Java IR类代码示例

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
private ObjectArrayMapping makeInitialFieldNumbers(IR ir) {
   Set fields = new LinkedHashSet();
   for(Iterator is = iterateInstructions(ir); is.hasNext(); ) {
     SSAInstruction i = (SSAInstruction)is.next();
     if (i == null) continue;

     PointerKey[] defs = fieldAccesses.getDefs(i);
     for(int f = 0; f < defs.length; f++) {
fields.add( defs[f] );
     }

     PointerKey[] uses = fieldAccesses.getUses(i);
     for(int f = 0; f < uses.length; f++) {
fields.add( uses[f] );
     }
   }

   return new ObjectArrayMapping(
     fields.toArray(new PointerKey[ fields.size() ])
   );
 }
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
private Map makeValueNumbers(IR ir) {
   Map vns = new LinkedHashMap();
   for(Iterator is = iterateInstructions(ir); is.hasNext(); ) {
     SSAInstruction inst = (SSAInstruction)is.next();
     if (inst == null) continue;

     PointerKey[] uses = fieldAccesses.getUses(inst);
     int[] useValueNumbers = new int[ uses.length ];
     for(int j = 0; j < uses.length; j++) {
useValueNumbers[j] = getInitialFieldNumber( uses[j] );
     }
     vns.put(Pair.make(inst, USES), useValueNumbers);
     
     PointerKey[] defs = fieldAccesses.getDefs(inst);
     int[] defValueNumbers = new int[ defs.length ];
     for(int j = 0; j < defs.length; j++) {
defValueNumbers[j] = getInitialFieldNumber( defs[j] );
     }
     vns.put(Pair.make(inst, DEFS), defValueNumbers);
   }
   
   return vns;
 }
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
public String toString() {
  StringBuffer buf = new StringBuffer("types for " + node + "\n");
  IR ir = node.getIR();
  SymbolTable st = ir.getSymbolTable();
  for(int vn = 1; vn <= st.getMaxValueNumber(); vn++) {
    if (st.isNullConstant(vn)) {
 buf.append(vn + " --> <null constant>\n");
    }
   
    PointerKey pk = new LocalPointerKey(node, vn);
    OrdinalSet<? extends InstanceKey> types = PA.getPointsToSet( pk );

    buf.append(vn + " --> " + types + "\n");
  }

  return buf.toString();
}
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
protected Iterator getInstructions(final CGNode node) {
	final PDG pdg = sdg.getPDG(node);
	final IR ir = node.getIR();
	final Map indicesMap = PDG.computeInstructionIndices(ir);
	return new FilterIterator(
			node.getIR().iterateAllInstructions(), new Predicate() {
				private boolean sliceContainsInstruction(
						SSAInstruction s) {
					return slice.contains(PDG
							.ssaInstruction2Statement(node, s,
									indicesMap, ir));
				}

				public boolean test(Object o) {
					return sliceContainsInstruction((SSAInstruction) o);
				}
			});
}
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
public static Map<SSAInstruction, Integer> createInstructionToIndexMap(IR ir) {

		Map<SSAInstruction, Integer> map = Maps.newHashMap();

		for (int i = 0; i < ir.getInstructions().length; i++) {
			SSAInstruction instruction = ir.getInstructions()[i];
			if (instruction != null) {
				Integer old = map.put(instruction, i);
				if (old != null) {
					throw new IllegalStateException("instruction was set before: actual index = " + i +
							"; old index = " + old + "; instruction = " + instruction);
				}
			}
		}

		return map;
	}
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
public static SSACFG getSSACFG(String methodSignature, CallGraph cg) {
	logger.debug("Retrieve SSACFG for " + methodSignature);

	IR ir = getIR(methodSignature, cg);
	if (ir == null && !methodSignature.startsWith(WALA_FAKE_ROOT_CLASS))
		logger.warn("Could not retrieve IR for " + methodSignature);		
	
	return ir == null? null : ir.getControlFlowGraph();
}
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
public static Expr getExprForCondition(ValidityChecker vc, BasicBlock basicBlock, IR entryIR) {
    // According to WALA documentation these blocks contain exactly one instruction
    SSAConditionalBranchInstruction inst = (SSAConditionalBranchInstruction) basicBlock.getLastInstruction();
    int var = inst.getUse(0); // This Instruction contains exactly two uses (0, 1) and use 1 is always 0.
    Expr expr = getExprForInstruction(vc, var, entryIR, null);

    return expr;
}
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
public static Expr getExprForConditionalBranchInstruction(ValidityChecker vc, SSAInstruction inst, IR entryIR) {
    // According to WALA documentation these blocks contain exactly one instruction
    SSAConditionalBranchInstruction condInst = (SSAConditionalBranchInstruction) inst;
    int var = condInst.getUse(0); // This Instruction contains exactly two uses (0, 1) and use 1 is always 0.
    Expr expr = getExprForInstruction(vc, var, entryIR, BinaryOpInstruction.Operator.AND); // The AND operator identifies the expression as a boolean type

    return expr;
}
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
/**
 * Display different values from Nodes maybe interesting for further
 * Analyzing
 *
 * @param nodes
 *            A collection of nodes from a callgraph
 */
public static ArrayList<String> printSSA(Collection<CGNode> nodes) {
    ArrayList<String> liste = new ArrayList<String>();
    for (CGNode cgNode : nodes) {
        // get intermediate representation
        IR ir = cgNode.getIR();

        liste.add("Instruction: " + (ir.getInstructions().toString()));
        System.out.println("Instruction: " + ir.getInstructions());
        liste.add("Methode: " + ir.getMethod());
        System.out.println("Methode: " + ir.getMethod());

        // System.out.println("Flow Graph of Node="+ir.getControlFlowGraph());
        SSACFG cfg = ir.getControlFlowGraph();

        // Iterate over the Basic Blocks of CFG
        Iterator<ISSABasicBlock> cfgIt = cfg.iterator();
        SSAInstruction ssaInstr = null;
        while (cfgIt.hasNext()) {
            ISSABasicBlock ssaBb = cfgIt.next();

            // Iterate over SSA Instructions for a Basic Block
            Iterator<SSAInstruction> ssaIt = ssaBb.iterator();

            while (ssaIt.hasNext()) {
                ssaInstr = ssaIt.next();

                printSSAInstruction(ssaInstr);
                liste.add("  " + ssaInstr.toString() + " |Count Defs="
                          + ssaInstr.getNumberOfDefs() + " |count uses="
                          + ssaInstr.getNumberOfUses());
                System.out.println("  " + ssaInstr.toString()
                                   + " |Count Defs=" + ssaInstr.getNumberOfDefs()
                                   + " |count uses=" + ssaInstr.getNumberOfUses());

            }
        }
    }
    return liste;
}
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
public Map<IMethod, IR> createIR() throws java.io.IOException {
   Map<IMethod, IR> result = new HashMap<IMethod, IR>();
   
   engine.buildAnalysisScope();

   IClassHierarchy cha = engine.getClassHierarchy();

   SSAOptions options = new SSAOptions();
   IRFactory<IMethod> F = AstIRFactory.makeDefaultFactory();
   
   for(Iterator<IClass> clss = cha.iterator(); clss.hasNext(); ) {
     IClass cls = clss.next();
     ClassLoaderReference clr = cls.getClassLoader().getReference(); 
     if ( !(clr.equals(ClassLoaderReference.Primordial)  
                    || 
     clr.equals(ClassLoaderReference.Extension)))
     {		
for (Iterator<IMethod> ms = cls.getDeclaredMethods().iterator(); 
     ms.hasNext(); ) 
{
  IMethod m = ms.next();
  IR ir = F.makeIR(m, Everywhere.EVERYWHERE, options);
  result.put(m, ir);
}
     }
   }
   
   return result;
 }
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
public FieldNameSSAConversion(IR ir, FieldAccesses fieldAccesses) {
  super(ir, new SSAOptions());
  this.ir = ir;
  this.fieldAccesses = fieldAccesses;
  fieldPhiSet = new LinkedHashSet();
  fieldPhiNodes = new LinkedHashMap();
  initialFieldNumbers = makeInitialFieldNumbers(ir);
  valueNumbers = makeValueNumbers(ir);
  nextFreeNumber = getMaxValueNumber() + 1;
}
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
public byte evaluate(IVariable lhs, IVariable rhs) {
     FieldAccessesVariable lv = (FieldAccessesVariable)lhs;
     FieldAccessesVariable rv = (FieldAccessesVariable)rhs;

     IR ir = node.getIR();
     Set localReads = new HashSet();
     Set localWrites = new HashSet();
     if (ir != null) {
   	FieldAccesses accesses = localAccesses.get(node);
for(Iterator insts = getInstructions(node); insts.hasNext();) {
  SSAInstruction inst = (SSAInstruction) insts.next();

  PointerKey[] defs = accesses.getDefs(inst);
  for(int f = 0; f < defs.length; f++) {
    localWrites.add( defs[f] );
  }

  PointerKey[] uses = accesses.getUses(inst);
  for(int f = 0; f < uses.length; f++) {
    localReads.add( uses[f] );
  }
}
     }

     boolean changed = false;
     changed |= lv.addReads( rv.readReferences );
     changed |= lv.addReads( localReads );
     changed |= lv.addWrites( rv.writeReferences );
     changed |= lv.addWrites( localWrites );
     if (changed)
return CHANGED;
     else
return NOT_CHANGED;      
   }
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
/**
 * Constructs a new warning for the given ir, instruction and reason.
 */
TranslationWarning(IR ir, SSAInstruction inst, String reason) {
	super(CLIENT_MODERATE);
	this.ir = ir;
	this.inst = inst;
	this.reason = reason;
}
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
public AnalyzedMethod(IR ir, DefUse defUse) {
	Preconditions.checkNotNull(ir, "ir is null");
	Preconditions.checkNotNull(defUse, "defUse is null");

	this.ir = ir;
	this.defUse = defUse;
}
 

import com.ibm.wala.ssa.IR; //导入依赖的package包/类
public IR findIRForMethod(IMethod m) {
	try {
		IInstruction[] instructions = ((IBytecodeMethod) m).getInstructions();
		if (instructions != null) {
			return cache.getSSACache().findOrCreateIR(m, Everywhere.EVERYWHERE,
				options.getSSAOptions());
		}
	} catch (InvalidClassFileException e) {
		e.printStackTrace();
	}
	return null;
}