12,656 research outputs found
Definite Reference Mutability
Get PDFReference immutability type systems such as Javari and ReIm ensure that a given reference cannot be used to mutate the referenced object. These systems are conservative in the sense that a mutable reference may be mutable due to approximation.
In this paper, we present ReM (for definite Re[ference] M[utability]). It separates mutable references into (1) definitely mutable, and (2) maybe mutable, i.e., references whose mutability is due to inherent approximation. In addition, we propose a CFL-reachability system for reference immutability, and prove that it is equivalent to ReIm/ReM, thus building a novel framework for reasoning about correctness of reference immutability type systems. We have implemented ReM and applied it on a large benchmark suite. Our results show that approximately 86.5% of all mutable references are definitely mutable
Definite Reference Mutability (Artifact)
Get PDFRelated paper "Definite Reference Mutability" presents
ReM (Re[ference] M[utability]), a type system
that separates mutable references into (1) definitely mutable,
and (2) maybe mutable, i.e., references whose mutability is due to inherent
approximation. We have implemented ReM and applied it on a large benchmark
suite. Results show that ~ 86\% of mutable references
are definitely mutable.
This article describes the tool artifact from the related paper. The purpose of
the article and artifact is to allow researchers to reproduce our results, as well as build new type systems upon our code
Differential stability of 2'F-ANA*RNA and ANA*RNA hybrid duplexes: roles of structure, pseudohydrogen bonding, hydration, ion uptake and flexibility
No full text14 pags., 7 figs., 3 tabs.Hybrids of RNA with arabinonucleic acids 2′F-ANA and ANA have very similar structures but strikingly different thermal stabilities. We now present a thorough study combining NMR and other biophysical methods together with state-of-the-art theoretical calculations on a fully modified 10-mer hybrid duplex. Comparison between the solution structure of 2′F-ANA•RNA and ANA•RNA hybrids indicates that the increased binding affinity of 2′F-ANA is related to several subtle differences, most importantly a favorable pseudohydrogen bond (2′F-purine H8) which contrasts with unfavorable 2′-OH-nucleobase steric interactions in the case of ANA. While both 2′F-ANA and ANA strands maintained conformations in the southern/eastern sugar pucker range, the 2′F-ANA strand's structure was more compatible with the A-like structure of a hybrid duplex. No dramatic differences are found in terms of relative hydration for the two hybrids, but the ANA•RNA duplex showed lower uptake of counterions than its 2′F-ANA•RNA counterpart. Finally, while the two hybrid duplexes are of similar rigidities, 2′F-ANA single strands may be more suitably preorganized for duplex formation. Thus the dramatically increased stability of 2′F-ANA•RNA and ANA•RNA duplexes is caused by differencesin at least four areas, of which structure and pseudohydrogen bonding are the most important. © The Author(s) 2010. Published by Oxford University Press.Spanish Ministerio de Ciencia e Innovacion (grants
CTQ2007-68014-C02-02 to CG and BIO2009-10964 to
MO); Fundacion Marcelino Botin (grant to MO);
Canadian Institutes for Health Research (grant to
M.J.D.); Natural Sciences and Engineering Research
Council of Canada (postgraduate scholarship to
J.K.W.). Funding for open access charge: Canadian
Institutes for Health Research
Representações da sexualidade na obra de Ana Saldanha
Get PDFMestrado em Línguas, Literaturas e CulturasA presente dissertação analisa as diferentes representações da sexualidade na obra literária para jovens de Ana Saldanha. A leitura analítica incide sobre as narrativas da autora que abordam a temática da sexualidade juvenil e as suas problemáticas, com o objetivo de estudar a forma como as mesmas contribuem para a construção da identidade pessoal e sexual do potencial recetor juvenil. Desta forma, pretende-se detetar os conflitos psicológicos dos protagonistas, os seus valores e problemas, assim como os novos valores, problemas e preocupações sociais que emergem das narrativas; compreender de que forma a autora exprime a sua capacidade em observar o quotidiano e as relações humanas; identificar os pilares em que se apoia o universo social em estudo (família, escola, grupo de amigos); enquadrar as personagens numa sociedade pós-industrial e de informação que exige ao adolescente uma superação de desafios e de novos problemas.This dissertation analyzes the different representations of sexuality in Ana Saldanha’s literary work for youth. The analytical reading focuses on the author's narratives that address the issue of teenage sexuality and its problems, aiming to study their contribution in the construction of personal and sexual identity of the potential juvenile receiver. Thus, it is intended to detect the psychological conflicts of the protagonists, their values and problems, as well as the new values, social concerns and problems that emerge from the narratives; understand how the author expresses her ability to observe daily life and human relations; identify the pillars on which relies the social universe under study (family, school, friends); framing the characters in a post-industrial and information society which requires the teenager to relentlessly surmount challenges and new problems
Precise Call Graph Construction in the Presence of Function Pointers
No full textThe use of pointers creates serious problems for optimizing compilers and software engineering tools. Pointers enable indirect memory accesses through pointer dereferences, as well as indirect procedure calls (e.g., through function pointers in C). Such indirect accesses and calls can be disambiguated with pointer analysis. In this paper we evaluate the precision of a pointer analysis by Zhang et al. [17] for the purposes of call graph construction for C programs with function pointers. The analysis uses an inexpensive, almost-linear, flow- and context-insensitive algorithm. To measure analysis precision, we compare the call graph computed by the analysis with the most precise call graph obtainable by a large category of pointer analyses. Surprisingly, for all our data programs the analysis from [17] achieves the best possible precision. This result indicates that for the purposes of call graph construction, even inexpensive analyses can provide very good precision, and therefore the use of more expensive analyses may not be justified.Technical report DCS-TR-44
PoTo: A Hybrid Andersen’s Points-To Analysis for Python
Get PDFAs Python is increasingly being adopted for large and complex programs, the importance of static analysis for Python (such as type inference) grows. Unfortunately, static analysis for Python remains a challenging task due to its dynamic language features and its abundant external libraries. To help fill this gap, this paper presents PoTo, an Andersen-style context-insensitive and flow-insensitive points-to analysis for Python. PoTo addresses Python-specific challenges and works for large programs via a novel hybrid evaluation, integrating traditional static points-to analysis with concrete evaluation in the Python interpreter for external library calls. We evaluate the analysis with two clients: type inference and call graph construction. This paper presents PoTo+, a static type inference for Python built on PoTo. We evaluate PoTo+ and compare it to two state-of-the-art Python type inference techniques: (1) the static rule-based Pytype and (2) the deep-learning based DLInfer. Our results show that PoTo+ outperforms both Pytype and DLInfer on existing Python packages. This paper also presents PoToCG, a call-graph construction analysis for Python built on PoTo. We compare PoToCG to PyCG, the state of the art for this problem, and show that PoTo produces more complete and more precise call graphs
Points-to analysis for Java using annotated inclusion constraints
No full textThe goal of points-to analysis for Java is to determine the set of objects pointed to by a reference variable or a reference object field. In this paper we define and evaluate a points-to analysis for Java which extends Andersen’s points-to analysis for C [4]. Andersen’s analysis for C can be implemented efficiently by using systems of set-inclusion constraints and by employing several techniques for constraint representation and resolution. We extend these techniques to efficiently represent and solve systems of annotated inclusion constraints. The annotations play two roles in our analysis. Method annotations are used to model precisely and efficiently the semantics of virtual calls. Field annotations allow us to distinguish the flow of values through different fields of an object. In addition, our analysis keeps track of all methods reachable from the entry point of the program, and avoids analyzing dead library code. We evaluate the performance of the analysis on a large set of realistic Java programs. Our results show that the analysis is practical and therefore will be useful as a relatively precise general-purpose points-to analysis for Java. The experiments also show that the points-to solution has significant impact on call graph construction, virtual call resolution, elimination of unnecessary synchronization, and stack-based object allocation.Technical report DCS-TR-41
Parameterized object sensitivity for points-to and side-effect analyses for Java
No full textThe goal of points-to analysis for Java is to determine the set of objects pointed to by a reference variable or a reference object field. Improving the precision of practical points-to analysis is important because points-to information has a wide variety of client applications in optimizing compilers and software engineering tools. In this paper we present object sensitivity, a new approach to context-sensitive flow insensitive points-to analysis for Java. The key idea of our approach is to analyze a method separately for each of the objects on which this method is invoked. To ensure flexibility and practicality, we propose a parameterization framework which allows analysis designers to control the cost precision tradeoffs of the object-sensitive analysis. Side-effect analysis determines the memory locations that can be modified by the execution of a program statement. This information is needed for various compiler optimizations and software engineering tools. We present a new form of side-effect analysis for Java which is based on object sensitive points-to analysis. We have implemented one instantiation of our parameterized object-sensitive points-to analysis. We compare this instantiation with a context-insensitive points-to analysis for Java which is based on Andersen’s analysis for C [4]. On a set of 23 realistic Java programs, our experiments show that the two analyses have comparable cost. In some cases the object-sensitive analysis is actually faster than the context sensitive analysis. Our results also show that object sensitivity significantly improves the precision of side-effect analysis, call graph construction, and virtual call resolution. Our empirical results demonstrate that object-sensitive analyses are capable of achieving significantly better precision than context-insensitive ones, while at the same time remaining efficient and practical. Thus, object-sensitive analysis is a better candidate for a relatively precise, practical, general-purpose points-to analysis for Java.Technical report DCS-TR-47
Fragment class analysis for testing of polymorphism in Java software
No full textAdequate testing of polymorphism in object-oriented software requires coverage of all possible bindings of receiver classes and target methods at call sites. Tools that measure this coverage need to use class analysis to compute the coverage requirements. However, traditional whole-program class analysis cannot be used when testing partial programs. To solve this problem, we present a general approach for adapting whole-program class analyses to operate on program fragments. Furthermore, since analysis precision is critical for coverage tools, we provide precision measurements for several analyses by determining which of the computed coverage requirements are actually feasible. Our work enables the use of whole-program class analyses for testing of polymorphism in partial programs, and identifies analyses that compute precise coverage requirements and therefore are good candidates for use in coverage tools.Technical report DCS-TR-50
Precise and practical flow analysis of object-oriented software
No full textProgram flow analysis is a technique which determines properties about the run-time behavior of a program by analyzing its source code. Flow information has a wide variety of uses in optimizing compilers and software tools for software understanding, testing and maintenance. There are two important requirements for a flow analysis to be successfully applied in optimizing compilers and software tools: (i) first the analysis needs to be relatively precise and (ii) the analysis needs to be practical. However, typically there is a tradeoff between analysis precision and analysis practicality. Many existing practical flow analyses are based on inclusion constraints. However, these analyses do not model dimensions of analysis precision that are of crucial importance for the analysis of object-oriented languages and its usability in software tools and compilers. The first contribution of this thesis is the development of annotated inclusion constraints— a general framework that allows relatively precise and at the same time practical analysis of large programs. The annotated constraint system is parameterized by an annotation language and operations on the annotations. The key idea is to take a relatively imprecise flow analysis that can be expressed using non-annotated inclusion constraints, and add a dimension of precision by choosing appropriate annotations and operations on the annotations. Using this approach results in analyses that are substantially more precise while remaining efficient and practical. The second contribution is the formulation and implementation of a field-sensitive points-to analysis for Java in the context of this framework. Points-to analysis for Java is a fundamental flow analysis with a wide variety of uses in optimizing compilers and software tools. Extensive experiments show that our analysis has practical cost and achieves substantial impact on various client applications. Another contribution is the development of object sensitivity, a new form of context sensitivity for object-oriented languages. We have formulated and implemented several object-sensitive points-to analyses for Java as instances of the framework for annotated constraints. The empirical results show that object sensitivity substantially improves the precision of points-to and side-effect analyses over context-insensitive analyses. At the same time, the annotations model context sensitivity efficiently, achieving practical cost, comparable to the cost of context-insensitive analysis. The last contribution is the application of relatively precise flow analysis for the construction of interclass dependence diagrams (to be used in integration and regression testing, impact analysis, reverse engineering, etc.). We have developed a general algorithm for diagram construction, and have shown empirically that using field-sensitive points-to analysis improves diagram precision substantially compared to earlier work. The enhanced precision improves the usability of the diagrams in software tools.Technical report DCS-TR-53
- …
