A Framework for SourceCode Level Interprocedural Dataflow Analysis

A Framework for Source-Code. Level Interprocedural Dataflow Analysis of Aspect. J Software Guoqing Xu and Atanas Rountev Ohio State University Supported by NSF under CAREER grant CCF-0546040 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Outline § Motivation § Program representation - Control flow representation - Data flow representation § Proof-of-concept analyses - Object effect analysis - Dependence-analysis-based slicing § Experimental evaluation 2 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Interprocedural Dataflow Analysis § Interprocedural dataflow analysis is important - For various software engineering and compiler construction tasks - e. g. performance optimization, static software verification, testing, software understanding and evolution § Powerful analyses for Aspect. J are needed - AOP becomes more and more popular - Need good program representation - Need new algorithms 3 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Program Representation for Aspect. J § Properties of a good representation - Should be easy to use for various clients ú Adapt existing Java analysis algorithm - Should provide clean separation between the base code and aspects ú Automated reasoning of aspects-base-code interaction § Advantages of source-code-level over bytecodelevel analysis - Produces more relevant results - Provides clean separation of base code and aspects - Faster running time 4 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Proposed representation § Has both properties - Take the large body of existing analysis algorithms for Java, and adapt them easily to Aspect. J - Define new analysis algorithms specifically for Aspect. J features § Control flow representation [ICSE’ 07] - Complex interactions of advices - Dynamic advices § Data flow representation [this paper] - Using calls and returns along chains of nested advice invocations - Expose the decision-making data for dynamic advices 5 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Running Example /* before 1 */ class Point { before(Point p, int x) : int x; setter. X(p) void set. X(int x) { this. x = x; } {…} static void main(String[] a) { Point p = new Point(); /* around 1 */ void around(Point p, int x) : p. set. X(10); } setter. X(p) { … proceed(p, x); … }} aspect Bound. Point { /* before 2 */ pointcut setter. X(Point p) : before(Point p) : setter. X(p) { … } call(void Point. set. X(*)) && /* after 1 */ target(p); after(Point p) : setter. X(p) { …advices } … // } 6 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Control-Flow Representation § Interprocedural Control Flow Graph (ICFG) - Java-like representation for “normal” calls ú No join points - New representation for interactions at join points ú Interaction graph § Multiple advices applicable at a join point - Calls to represent nesting relationships - Use ph_* placeholder method to represent call to proceed § Dynamic advices - Use ph_decision placeholder decision node to guard call sites of dynamic advices 7 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

root before 1 around 1 before 2 8 after 1 p. set. X PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Handling of Dynamic Advices ph_decision T F before 1 return around 1 return ph_decision T F ph_proceed 1 return exit 9 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Data-flow Representation for IG § Declarations for placeholder methods - Create a formal parameter for (1) the receiver object or (2) a formal parameter of the crosscut method - e. g. for shadow p. set. X(6), the entry method is declared as void ph_root(Point arg 0, int arg 1) § Declarations for non-around-advice - The original list of formal parameters is directly used - e. g. void before 1(int arg 0, Point arg 1) § Call sites for advices are built with appropriate actual parameters - void ph_root(Point arg 0, int arg 1) { before 1(arg 1, arg 0); } 10 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Handling of Around Advice § Handling of around advice is complicated - It must have all the necessary parameters of the shadow call site - Parameters needed by an around advice can be different for different shadows ú abc solution: replicate the body of an around advice for each shadow that the around advice matches ú Our solution: construct a globally valid list that includes parameters required at all matching shadows 11 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Example set. X(Point arg 0, int arg 1) set. Y(Point arg 2, float arg 3) set. Z(double arg 4, Point arg 5) around(Point p): call(void Point. set*(*)) && target(p) around(Point arg 0, int arg 1, Point arg 2, float arg 3, double arg 4, Point arg 5, int dv) 12 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Handling of Around Advice § Call to around advice - Non-trivial actual parameters are passed to the call site only for the formals corresponding to the currently-active shadow - A unique shadow ID is given for dv - e. g. set. X(Point arg 0, int arg 1) set. Y(Point arg 2, float arg 3) set. Z(double arg 4, Point arg 5) around(Point p): call(void Point. set*(*)) && target(p) around(Point arg 0, int arg 1, Point arg 2, float arg 3, double arg 4, Point arg 5, int dv) 13 for p. set. X(. . ), around(arg 0, arg 1, null, 0, 0, null, 0) for p. set. Y(. . ), around(null, 0, arg 2, arg 3, 0, null, 1) PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Handling of Around Advice (Cond. ) § Call to a placeholder method within an around advice - Use dv to select calls to placeholder methods - e. g. void around( Point arg 0, int arg 1, Point arg 2, float arg 3, double arg 4, Point arg 5, int dv){ switch(dv){ //corresponding to shadow set. X case 0: ph_proceed 0(arg 0, arg 1); break; //corresponding to shadow set. Y case 1: ph_proceed 1(arg 2, arg 3); break; //corresponding to shadow set. Z case 2: ph_proceed 2(arg 4, arg 5); } 14 } PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Data with ph_decision Nodes § For a dynamic advice, the data that contributes to dynamic decision making is associated with the ph_decision node that guards the call to the advice - E. g. before(Point p, int i): if(i > 0) && args(i) && target(p) both p and i are associated with the ph_decision node 15 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

So What? § Data flow is explicit with parameter passing § Advice nesting relationship is clear § Ready for data-flow analysis 16 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Object Effect Analysis § Compute for each object passed from the base code into an advice, a state machine encoding all events that must happen on the object - The state machine is represented by a regular expression - Can directly be used for program verification (e. g. checking typestate based properties) - E. g. (reset | ε) (( set. X | ε) | ( get. X (( set. X | ε ) |( set. Rectangular | ε )))) ((wx wy | ε)) ( ( (wx | ε) | ( rx ( ( wx | ε) | (( wx wy) | ε))))) - At the core of this analysis is a must-alias analysis § A typical example of interprocedural analysis for Aspect. J - Need to track the interprocedural flow of data - Need to be aware of the separation between base code and aspects 17 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Object Effect Analysis (Cond. ) § Data flow problem - We define a lattice element for each reference-typed formal parameter of a ph_root method - E. g. for void ph_root(Point arg 0, int arg 1) The lattice is {larg 0, ┴ , ┬ } - Transfer functions: v 1 = v 2: fn(S) = S[v 1 S(v 2)] v 1 = v 2. fld: fn(S) = S[v 1 ┴] v 1. fld = v 2: fn(S) = S v 1 = new X: fn(S) = S[v 1 ┴] other nodes: fn(S) = S - Compute meet-over-all-valid-paths soluction MVPn 18 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Analysis Algorithm § Phase 1: relate formals to variables - For each variable in a method, compute a set of formal parameters that the variable may alias - Bottom-up traverse call graph to compute a summary function that relates the return value of a method to its parameter(s) § Phase 2: Propagation of lattice elements - Top-down traverse the call graph starting from each ph_root method - For each variable, replace the formal parameter associated to it with the corresponding lattice element(s) § Phase 3: Effect graph construction - Prune ICFG by removing nodes that do not have a lattice element - Compute SCC in the graph, and bottom-up traverse the SCC-DAGs 19 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Dependence-based Slicing § Another typical example of interprocedural dataflow analysis § Given existing slicing algorithms for Java, adapting it to Aspect. J is very simple - Variables associated with ph_decision nodes are considered as used - The slice for a call to proceed in an around advice includes slices that are computed for the group of calls to ph_proceed methods in the advice 20 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Experimental Evaluation § Comparison of ICFG and SDG sizes between sourcecode analysis and bytecode analysis § Effect analysis results comparison between using must-alias analysis and may-alias analysis § Slice relevance comparison between source-code slicing and bytecode slicing § Implementation based on the abc compiler - Between static weaving and advice weaving - Intraprocedural representation based on Jimple from abc 21 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Numbers of Edges in ICFG and SDG ▲- SDG Edges ■- ICFG edges # ICFG edges 2 X smaller #SDG edges 3 X smaller 22 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Object Effect Analysis § The analysis has short running time - E. g. less than 3 sec for the largest program 23 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Slicing Relevance Ratio and Time 24 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University

Conclusions § We propose a program representation for Aspect. J software - A control flow representation and a data flow representation § Two proof-of-concepts analyses - Both are IDE (Interprocedural Distributive Environment) problems, which require context-sensitivity and flow-sensitivity - Representative of (1) a large class of existing Java analysis algorithms and (2) potentially new algorithms designed specifically for Aspect. J § Experimental results - Source-code-level analysis is superior to bytecode-level analysis - Program representation is easy to use and adapt existing algorithms - New algorithms can be easily designed 25 PRESTO: Program Analyses and Software Tools Research Group, Ohio State University