6 research outputs found

    Inferring Complete Initialization of Arrays

    Get PDF
    We define an automaton-based abstract interpretation of a trace semantics which identifies loops that definitely initialize all elements of an array to values satisfying a given property, a useful piece of information for the static analysis of Java-like languages. This results in a completely automatic and efficient analysis, that does not use manual code annotations. We give a formal proof of correctness that considers aspects such as side-effects of method calls. We show how the identification of those loops can be lifted to global invariants about the contents of elements of fields of array type, that hold everywhere in the code where those elements are accessed. This makes our work more significant and useful for the static analysis of real programs. The implementation of our analysis inside the Julia analyzer is both efficient and precise

    Automaton-Based Array Initialization Analysis

    Get PDF
    We define an automaton-based abstract interpretation of atrace semantics which identifies loops that definitely initialize all theelements of an array, a useful piece of information for the static analysis ofimperative languages. This results in a fully automatic and fast analysis, that does not use manual code annotations. Its implementation inside the Julia analyzer is efficient and precise

    Abstract Program Slicing: From theory towards an implementation

    No full text
    In this paper we extend the formal framework proposed by Binkley et al. for representing and comparing forms of program slicing. This framework describes many well-known forms of slicing in a unique formal structure based on (abstract) projections of state trajectories. We use this formal framework for defining a new technique of slicing, called abstract slicing, which aims to slice programs with respect to properties of variables. In this way we are able to extend the original work with three forms of abstract slicing, static, dynamic and conditioned, we show that all existing forms are instantiations of their corresponding abstract forms and we enrich the existing slicing technique hierarchy by inserting these abstract forms of slicing. Furthermore, we provide an algorithmic approach for extracting abstract slices. The algorithm is split into two modules: the simple approach, used for abstract static slicing, and the extended approach, composed of several applications of the simple one, which is used for abstract conditioned slicing

    Reachability Analysis of Program Variables

    No full text
    Reachability from a program variable v to a program variable w states that from v , it is possible to follow a path of memory locations that leads to the object bound to w . We present a new abstract domain for the static analysis of possible reachability between program variables or, equivalently, definite unreachability between them. This information is important for improving the precision of other static analyses, such as side-effects, field initialization, cyclicity and path-length analysis, as well as more complex analyses built upon them, such as nullness and termination analysis. We define and prove correct our reachability analysis for Java bytecode, defined as a constraint-based analysis, where the constraint is a graph whose nodes are the program points and whose arcs propagate reachability information in accordance to the abstract semantics of each bytecode instruction. For each program point p, our reachability analysis produces an overapproximation of the ordered pairs of variables v , w such that v might reach w at p. Seen the other way around, if a pair v , w is not present in the overapproximation at p, then v definitely does not reach w at p. We have implemented the analysis inside the Julia static analyzer. Our experiments of analysis of nontrivial Java and Android programs show the improvement of precision due to the presence of reachability information. Moreover, reachability analysis actually reduces the overall cost of nullness and termination analysis

    Definite Expression Aliasing Analysis for Java Bytecode

    No full text
    We define a novel static analysis for Java bytecode, called definite expression aliasing. It infers, for each variable v at each program point p, a set of expressions whose value at p is equal to the value of v at p, for every possible execution of the program. Namely, it determines which expressions must be aliased to local variables and stack elements of the Java Virtual Machine. This is a useful piece of information for a static analyzer, such as Julia, since it can be used to refine other analyses at conditional statements or assignments. We formalize and implement a constraint-based analysis, based and proved correct in the abstract interpretation framework. Moreover, we show the benefits of our definite expression aliasing analysis for nullness and termination analysis with Julia

    Investigating Students’ Difficulties and Approaches to Solving Buffer Related Problems

    No full text
    The subject of buffer solutions in chemistry is a challenging concept for students to learn due to its abstract nature. The difficulties that students face in learning about buffer solutions can lead to poor performance and alternative conceptions about the topic. The development of successful conceptual understanding to solve buffer solution problems requires that students have factual knowledge, procedural knowledge, and conceptual knowledge about the topic. This research project of the City College of New York (a minority-serving, public, urban, commuter institution) investigates difficulties that students experience in learning about buffer solutions and approaches that they rely on to solve buffer-related problems. The research method employed a survey comprised of a Likert-type and openended questions was used to assess the understanding of 102 participants. The research results indicate that the principal barrier to learning about buffer solutions is students’ dependence on formulaic problem solving and calculator use instead of reliance on conceptual understanding. Furthermore, students face difficulties memorizing a significant number of complicated formulas and equations necessary to solving buffer problems. The dominance of student strategies based on plug and chug problem solving likely hinders the development of conceptual understanding. We recommend that instructors need to be familiar with and address difficulties and alternative conceptions students have about buffer solutions
    corecore