1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
package org.checkerframework.dataflow.cfg;
/*>>>
import org.checkerframework.checker.nullness.qual.Nullable;
*/
import java.util.Map;
import org.checkerframework.dataflow.analysis.AbstractValue;
import org.checkerframework.dataflow.analysis.Analysis;
import org.checkerframework.dataflow.analysis.FlowExpressions;
import org.checkerframework.dataflow.analysis.Store;
import org.checkerframework.dataflow.analysis.TransferFunction;
import org.checkerframework.dataflow.cfg.block.Block;
import org.checkerframework.dataflow.cfg.block.SpecialBlock;
import org.checkerframework.dataflow.cfg.node.Node;
/**
* Perform some visualization on a control flow graph. The particular operations depend on the
* implementation.
*/
public interface CFGVisualizer<
A extends AbstractValue<A>, S extends Store<S>, T extends TransferFunction<A, S>> {
/**
* Initialization method guaranteed to be called once before the first invocation of {@link
* visualize}.
*
* @param args implementation-dependent options
*/
void init(Map<String, Object> args);
/**
* Output a visualization representing the control flow graph starting at {@code entry}. The
* concrete actions are implementation dependent.
*
* <p>An invocation {@code visualize(cfg, entry, null);} does not output stores at the beginning
* of basic blocks.
*
* @param cfg the CFG to visualize
* @param entry the entry node of the control flow graph to be represented
* @param analysis an analysis containing information about the program represented by the CFG.
* The information includes {@link Store}s that are valid at the beginning of basic blocks
* reachable from {@code entry} and per-node information for value producing {@link Node}s.
* Can also be {@code null} to indicate that this information should not be output.
* @return possible analysis results, e.g. generated file names.
*/
/*@Nullable*/ Map<String, Object> visualize(
ControlFlowGraph cfg, Block entry, /*@Nullable*/ Analysis<A, S, T> analysis);
/**
* Delegate the visualization responsibility to the passed {@link Store} instance, which will
* call back to this visualizer instance for sub-components.
*
* @param store the store to visualize
*/
void visualizeStore(S store);
/**
* Called by a {@code CFAbstractStore} to visualize the class name before calling the {@code
* CFAbstractStore#internalVisualize()} method.
*
* @param classCanonicalName the canonical name of the class
*/
void visualizeStoreHeader(String classCanonicalName);
/**
* Called by {@code CFAbstractStore#internalVisualize()} to visualize a local variable.
*
* @param localVar the local variable
* @param value the value of the local variable
*/
void visualizeStoreLocalVar(FlowExpressions.LocalVariable localVar, A value);
/**
* Called by {@code CFAbstractStore#internalVisualize()} to visualize the value of the current
* object {@code this} in this Store.
*
* @param value the value of the current object this
*/
void visualizeStoreThisVal(A value);
/**
* Called by {@code CFAbstractStore#internalVisualize()} to visualize the value of fields
* collected by this Store.
*
* @param fieldAccess the field
* @param value the value of the field
*/
void visualizeStoreFieldVals(FlowExpressions.FieldAccess fieldAccess, A value);
/**
* Called by {@code CFAbstractStore#internalVisualize()} to visualize the value of arrays
* collected by this Store.
*
* @param arrayValue the array
* @param value the value of the array
*/
void visualizeStoreArrayVal(FlowExpressions.ArrayAccess arrayValue, A value);
/**
* Called by {@code CFAbstractStore#internalVisualize()} to visualize the value of pure method
* calls collected by this Store.
*
* @param methodCall the pure method call
* @param value the value of the pure method call
*/
void visualizeStoreMethodVals(FlowExpressions.MethodCall methodCall, A value);
/**
* Called by {@code CFAbstractStore#internalVisualize()} to visualize the value of class names
* collected by this Store.
*
* @param className the class name
* @param value the value of the class name
*/
void visualizeStoreClassVals(FlowExpressions.ClassName className, A value);
/**
* Called by {@code CFAbstractStore#internalVisualize()} to visualize the specific information
* collected according to the specific kind of Store. Currently, these Stores call this method:
* {@code LockStore}, {@code NullnessStore}, and {@code InitializationStore} to visualize
* additional information.
*
* @param keyName the name of the specific information to be visualized
* @param value the value of the specific information to be visualized
*/
void visualizeStoreKeyVal(String keyName, Object value);
/**
* Called by {@code CFAbstractStore} to visualize any information after the invocation of {@code
* CFAbstractStore#internalVisualize()}.
*/
void visualizeStoreFooter();
/**
* Visualize a block based on the analysis.
*
* @param bb the block
* @param analysis the current analysis
*/
void visualizeBlock(Block bb, /*@Nullable*/ Analysis<A, S, T> analysis);
/**
* Visualize a SpecialBlock.
*
* @param sbb the special block
*/
void visualizeSpecialBlock(SpecialBlock sbb);
/**
* Visualize the transferInput of a Block based on the analysis.
*
* @param bb the block
* @param analysis the current analysis
*/
void visualizeBlockTransferInput(Block bb, Analysis<A, S, T> analysis);
/**
* Visualize a Node based on the analysis.
*
* @param t the node
* @param analysis the current analysis
*/
void visualizeBlockNode(Node t, /*@Nullable*/ Analysis<A, S, T> analysis);
/** Shutdown method called once from the shutdown hook of the {@code BaseTypeChecker}. */
void shutdown();
}
|
