【南大静态代码分析】作业 5：非上下文敏感指针分析
作业 5：非上下文敏感指针分析
题目链接：https://tai-e.pascal-lab.net/pa5.html
评测链接：https://oj.pascal-lab.net/problem
作业出品：南京大学《软件分析》课程，谭添、李樾
代码讲解
addReachable
这个函数的作用是遇到可达方法的时候构造调用图，同时对方法中的 NEW ，COPY，STATIC LOAD FIELD，STATIC STORE FIELD，和 STATIC INVOKE 语句进行处理。
这里有一个难理解的点，伪代码中有 \(S \cup= S_m\) ，用来添加新可达方法中的语句，后面对这些语句再遍历，但是可达方法中的语句一定也是可达的，所以标记方法可达和添加方法中的可达语句本质是一样的，可以通过遍历所有可达方法再获得其中的所有语句来实现，method.getIR().getStmts() ，不需要额外的空间来存储。
使用访问者模式来实现，避免不同类型的语句使用多个 if-else 的情况。一些具体的 Stmt 子类中提供了 accept 的具体实现，传递 this ，调用 visitor 中重载的 visit 函数来执行相应函数。
public <T> T accept(StmtVisitor<T> visitor) {
return visitor.visit(this);
}
而 visitor 中重载的 visit 函数需要根据传递进来的 this 的具体类型，提供不同的实现。
StmtVisitor 接口中提供了对所有类型语句重载的默认 visit 函数。
/**
* Processes new reachable method.
*/
private void addReachable(JMethod method) {
// TODO - finish me
if (!callGraph.contains(method)) { // 当前调用图中该方法是否可达
callGraph.addReachableMethod(method); // 添加可达方法到调用图
for (Stmt stmt : method.getIR().getStmts()) { // 遍历方法中所有语句，调用accept
stmt.accept(stmtProcessor);
}
}
}
StmtProcessor
这是一个实现了 StmtVisitor 接口的内部私有类，负责针对不同语句实现具体的 visit 函数。
这里特别注意一下 STATIC INVOKE 情况，对于静态方法调用，处理流程和实例方法调用差不多，但是更简单，因为不需要传递 this 参数，获取目标方法的时候也不用 Dispatch ，即函数 resolveCallee 的第一个参数传递 null 即可。
/**
* Processes statements in new reachable methods.
*/
private class StmtProcessor implements StmtVisitor<Void> {
// TODO - if you choose to implement addReachable()
// via visitor pattern, then finish me
@Override
public Void visit(New stmt) { // 对于NEW语句，例如 x = new X()
Obj obj = heapModel.getObj(stmt); // 从模拟堆中获取当前语句的allocation site
VarPtr varPtr = pointerFlowGraph.getVarPtr(stmt.getLValue()); // 获取左值变量指针
workList.addEntry(varPtr, new PointsToSet(obj)); // 添加(x,o)到worklist
return null;
}
@Override
public Void visit(Copy stmt) { // 对于COPY语句，例如 x = y，左右值都是变量
VarPtr lVar = pointerFlowGraph.getVarPtr(stmt.getLValue()); // 获取左值变量指针
VarPtr rVar = pointerFlowGraph.getVarPtr(stmt.getRValue()); // 获取右值变量指针
addPFGEdge(rVar, lVar); // 添加边到pfg
return null;
}
@Override
public Void visit(LoadArray stmt) { // 对于LOAD ARRAY语句，不处理
return StmtVisitor.super.visit(stmt);
}
@Override
public Void visit(StoreArray stmt) { // 对于STORY ARRAY语句，不处理
return StmtVisitor.super.visit(stmt);
}
@Override
public Void visit(LoadField stmt) { // 对于LOAD FIELD语句
JField loadField = stmt.getFieldRef().resolve(); // 获取要被load的字段
if (loadField.isStatic()) { // 只处理STATIC LOAD FIELD语句
VarPtr lVar = pointerFlowGraph.getVarPtr(stmt.getLValue()); // 获取左值变量指针
StaticField rStaticField = pointerFlowGraph.getStaticField(loadField); // 获取静态字段指针
addPFGEdge(rStaticField, lVar); // 添加边到pfg
}
return null;
}
@Override
public Void visit(StoreField stmt) { // 对于STORE FIELD语句
JField loadField = stmt.getFieldRef().resolve(); // 获取要被store的字段
if (loadField.isStatic()) { // 只处理STATIC STORE FIELD语句
VarPtr rVar = pointerFlowGraph.getVarPtr(stmt.getRValue()); // 获取右值变量指针
StaticField staticField = pointerFlowGraph.getStaticField(loadField); // 获取静态字段指针
addPFGEdge(rVar, staticField); // 添加边到pfg
}
return null;
}
@Override
public Void visit(Invoke stmt) { // 对于STATIC INVOKE语句
if (stmt.isStatic()) {
Var lVar = stmt.getLValue(); // 获取左值变量
JMethod callee = resolveCallee(null, stmt); // 获取调用的函数
Edge<Invoke, JMethod> edge = new Edge(CallKind.STATIC, stmt, callee); // 构造静态类型函数调用边
if (callGraph.addEdge(edge)) { // 如果调用图中没有该边
addReachable(callee); // 添加该边到调用图
InvokeExp invokeExp = stmt.getInvokeExp(); // 获取调用函数表达式
for (int i = 0; i < invokeExp.getArgCount(); i++) { // 按位置在实参和形参之间添加边到pfg
Var actual = invokeExp.getArg(i);
VarPtr actualPtr = pointerFlowGraph.getVarPtr(actual);
Var form = callee.getIR().getParam(i);
VarPtr formPtr = pointerFlowGraph.getVarPtr(form);
addPFGEdge(actualPtr, formPtr);
}
if (lVar != null) { // 在所有返回值和接收参数之间添加边到pfg
for (Var returnVar : callee.getIR().getReturnVars()) {
VarPtr returnVarPtr = pointerFlowGraph.getVarPtr(returnVar);
VarPtr lVarPtr = pointerFlowGraph.getVarPtr(lVar);
addPFGEdge(returnVarPtr, lVarPtr);
}
}
}
}
return null;
}
}
addPFGEdge
这个函数的作用是在 PFG 中添加一条指针传递边。
/**
* Adds an edge "source -> target" to the PFG.
*/
private void addPFGEdge(Pointer source, Pointer target) {
// TODO - finish me
if (pointerFlowGraph.addEdge(source, target)) {
if (!source.getPointsToSet().isEmpty()) {
workList.addEntry(target, source.getPointsToSet());
}
}
}
analyze
这个函数的作用是实现 worklist 工作流程。
/**
* Processes work-list entries until the work-list is empty.
*/
private void analyze() {
// TODO - finish me
while (!workList.isEmpty()) {
WorkList.Entry entry = workList.pollEntry();
Pointer pointer = entry.pointer();
PointsToSet pts = entry.pointsToSet();
PointsToSet difference = propagate(pointer, pts);
if (pointer instanceof VarPtr varPtr) { // 如果是变量指针才可能继续更新Allocation Site
Var var = varPtr.getVar(); // 获取变量
for (Obj obj : difference) { // 遍历所有新的Allocation Site
for (StoreField storeField : var.getStoreFields()) { // 如果是实例StoreFields
JField field = storeField.getFieldRef().resolve();
InstanceField instanceField = pointerFlowGraph.getInstanceField(obj, field);
Var rVar = storeField.getRValue();
VarPtr rVarPtr = pointerFlowGraph.getVarPtr(rVar);
addPFGEdge(rVarPtr, instanceField);
}
for (LoadField loadField : var.getLoadFields()) { // 如果是实例LoadFields
JField field = loadField.getFieldRef().resolve();
InstanceField instanceField = pointerFlowGraph.getInstanceField(obj, field);
Var lVar = loadField.getLValue();
VarPtr lVarPtr = pointerFlowGraph.getVarPtr(lVar);
addPFGEdge(instanceField, lVarPtr);
}
for (StoreArray storeArray : var.getStoreArrays()) { // 如果是StoreArrays
Var rVar = storeArray.getRValue();
VarPtr rVarPtr = pointerFlowGraph.getVarPtr(rVar);
ArrayIndex arrayIndex = pointerFlowGraph.getArrayIndex(obj);
addPFGEdge(rVarPtr, arrayIndex);
}
for (LoadArray loadArray : var.getLoadArrays()) { // 如果是LoadArrays
Var lVar = loadArray.getLValue();
VarPtr lVarPtr = pointerFlowGraph.getVarPtr(lVar);
ArrayIndex arrayIndex = pointerFlowGraph.getArrayIndex(obj);
addPFGEdge(arrayIndex, lVarPtr);
}
processCall(var, obj); // 处理该变量调用的实例方法
}
}
}
}
propagate
这个函数有两个作用，一是求 pointsToSet 和 pt(pointer) 的差集，二是传递 pointsToSet 到 pt(pointer)。
其中 if (!difference.isEmpty()) 这个判断非常重要，如果差集是空，说明pointer 的指针集中已经包含了 pointsToSet ，pointer 的指针集并没有被更新，不需要执行后面的传递差集到 pointer 后继指针的操作。否则在循环引用的情况下会出现死循环，worklist 中始终添加新的元素。测试用例 Assign2.java 将无法通过。
/**
* Propagates pointsToSet to pt(pointer) and its PFG successors,
* returns the difference set of pointsToSet and pt(pointer).
*/
private PointsToSet propagate(Pointer pointer, PointsToSet pointsToSet) {
// TODO - finish me
PointsToSet difference = new PointsToSet();
PointsToSet ptn = pointer.getPointsToSet();
for (Obj obj : pointsToSet) {
if (!ptn.contains(obj)) {
ptn.addObject(obj);
difference.addObject(obj);
}
}
if (!difference.isEmpty()) {
for (Pointer s : pointerFlowGraph.getSuccsOf(pointer)) {
workList.addEntry(s, pointsToSet);
}
}
return difference;
}
processCall
这个函数的作用是处理实例方法调用，与静态方法调用的差异就是多了 this 到 receiver object 的 Allocation Site 的传递（并没有添加 PFG 边）。
注意构造调用图边的时候要考虑所有非静态方法调用的情况（INTERFACE，DYNAMIC，SPECIAL，VIRTUAL）。
/**
* Processes instance calls when points-to set of the receiver variable changes.
*
* @param var the variable that holds receiver objects
* @param recv a new discovered object pointed by the variable.
*/
private void processCall(Var var, Obj recv) { // 仅仅是非静态方法调用（静态方法调用在addReachable中已经调用了）
// TODO - finish me
for (Invoke invoke : var.getInvokes()) {
JMethod callee = resolveCallee(recv, invoke);
Var thisVar = callee.getIR().getThis();
VarPtr thisVarPtr = pointerFlowGraph.getVarPtr(thisVar);
workList.addEntry(thisVarPtr, new PointsToSet(recv));
Edge edge = null;
if (invoke.isInterface()) {
edge = new Edge(CallKind.INTERFACE, invoke, callee);
} else if (invoke.isDynamic()) {
edge = new Edge(CallKind.DYNAMIC, invoke, callee);
} else if (invoke.isSpecial()) {
edge = new Edge(CallKind.SPECIAL, invoke, callee);
} else if (invoke.isVirtual()) {
edge = new Edge(CallKind.VIRTUAL, invoke, callee);
} else {
edge = new Edge(CallKind.OTHER, invoke, callee);
}
if (callGraph.addEdge(edge)) {
addReachable(callee);
InvokeExp invokeExp = invoke.getInvokeExp();
for (int i = 0; i < invokeExp.getArgCount(); i++) {
Var actual = invokeExp.getArg(i);
VarPtr actualPtr = pointerFlowGraph.getVarPtr(actual);
Var form = callee.getIR().getParam(i);
VarPtr formPtr = pointerFlowGraph.getVarPtr(form);
addPFGEdge(actualPtr, formPtr);
}
Var lVar = invoke.getLValue();
if (lVar != null) {
for (Var returnVar : callee.getIR().getReturnVars()) {
VarPtr returnVarPtr = pointerFlowGraph.getVarPtr(returnVar);
VarPtr lVarPtr = pointerFlowGraph.getVarPtr(lVar);
addPFGEdge(returnVarPtr, lVarPtr);
}
}
}
}
}
评测结果
