import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
final LocalVariableGen getLocal(MethodGen m, LocalVariableInstruction curr,
    int pos) {
int localNr = curr.getIndex();
LocalVariableGen[] lt = getLocalTable(m);

for (int i = 0; i < lt.length; i++) {
    // Watch out. The first initialization seems not to be included in
    // the range given in the local variable table!

    if (localNr == lt[i].getIndex()) {
	// System.err.println("Looking for local " + localNr
	// + " on position " + pos);
	// System.err.println("found one with range "
	// + lt[i].getStart().getPrev().getPosition() + ", "
	// + lt[i].getEnd().getPosition());

	if (pos >= lt[i].getStart().getPrev().getPosition()
		&& pos < (lt[i].getEnd().getPosition())) {
	    return lt[i];
	}
    }
}

return null;
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
private void getIndicesStores(InstructionHandle start,
    InstructionHandle end, ArrayList<LocalVariableGen> resultIndices) {

for (InstructionHandle current = start.getNext() ;current != end.getNext(); current = current.getNext()) {
    try {
	LocalVariableGen l = getIndexStore(current);
	if (! resultIndices.contains(l)) {
	    resultIndices.add(l);
	}
	for (LocalVariableGen ll : this.getLocalVariables()) {
	    if (ll != l && l.getIndex() == ll.getIndex() && l.getName().equals(ll.getName())) {
		if (! resultIndices.contains(ll)) {
		    resultIndices.add(ll);
		}
	    }		    
	}
    }
    catch (ClassCastException e) {
	// no problem, just not a store 
    }
}
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
private SpawnableCall getSpawnableCallWithException(InstructionHandle invokeInstruction, 
    ArrayList<CodeExceptionGen> exceptionHandlers) {

ArrayList<LocalVariableGen> resultIndices = new ArrayList<LocalVariableGen>();
for (CodeExceptionGen exceptionHandler : exceptionHandlers) {
    InstructionHandle start = exceptionHandler.getHandlerPC(); 
    InstructionHandle end = getEndExceptionHandler(exceptionHandler);
    getIndicesStores(start, end, resultIndices);
}

LocalVariableGen[] dummy = new LocalVariableGen[resultIndices.size()];

return new SpawnableCall(invokeInstruction,
	getObjectReferenceLoadInstruction(invokeInstruction),
	resultIndices.toArray(dummy));
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
/** Tests whether this spawnable call stores in variables with index index.
    *
    * @param index The index which is tested.
    * @return true if the spawnable call stores in a variable with index
    * index; false otherwise.
    */
   public boolean storesIn(int index, InstructionHandle ih) {
int insNo = ih.getPosition();
       for (LocalVariableGen g : indicesStores) {
           if (g.getIndex() == index) {
       	InstructionHandle end = g.getEnd();
       	InstructionHandle start = g.getStart();
       	if (start.getPrev() != null) {
       	    start = start.getPrev();
       	}
       	if (insNo >= start.getPosition() && insNo <= end.getPosition()) {
       	    return true;
       	}
           }
       }
return false;
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
/** Returns a string representation.
    */
   public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(invokeInstruction.toString());
sb.append(", resultIndices: ");
if (indicesStores == null) {
    sb.append("(none), exceptions are not handled");
}
else {
    for (LocalVariableGen i : indicesStores) {
	sb.append(i);
	sb.append(", ");
    }
    sb.delete(sb.length()-2, sb.length());
}
return sb.toString();
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
/** Returns the end of an exception handler.
    *
    * @param codeException The codeException which end is returned.
    * @return The instructionHandle that is the end of the exception handler.
    */
   public InstructionHandle getEndExceptionHandler(CodeExceptionGen codeException) {
LocalVariableGen[] localVars = getLocalVariables();
InstructionHandle startHandler = codeException.getHandlerPC();

for (LocalVariableGen localVar : localVars) {
    InstructionHandle startScope = localVar.getStart();
    InstructionHandle endScope = localVar.getEnd();

    if (startScope == startHandler || startScope == startHandler.getNext() || 
	    startScope == startHandler.getNext().getNext() &&
	    localVar.getType().equals(codeException.getCatchType()))
	return endScope.getPrev();
}
throw new Error("no end exceptionhandler...");
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
boolean noAliasesLoadWithIndexBefore(InstructionHandle ih, LocalVariableGen lg) {
      for (InstructionContext ic : instructions) {
          InstructionHandle current = ic.getInstruction();
          if (current.equals(ih)) {
              break;
          }
          LocalVariableGen l = methodGen.findLocalVar(current, lg.getIndex(), false);
          if (l == lg && methodGen.instructionLoadsTo(current, lg.getIndex())) {
// OK, there is a load, but maybe it does not create an alias?
if (! methodGen.isUsedForArrayLoad(current) && ! methodGen.isUsedForArrayLength(current)
	&& ! methodGen.isUsedForArrayStore(current) && ! methodGen.isUsedForPutField(current)
	&& ! methodGen.isUsedForGetField(current)) {
    return false;
}
          }
      }
      return true;
  }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
private boolean containsLoadWithIndexAfter(InstructionHandle ih, boolean ignoreInstructions, LocalVariableGen lg) {
       InstructionHandle start = lg.getStart();
       InstructionHandle prev = start.getPrev();
       // The initial store is not included in the start/end range, so include the previous
       // instruction if it exists.
       InstructionHandle end = lg.getEnd();
       int startPosition = prev != null ? prev.getPosition() : start.getPosition();
       int endPosition = end.getPosition();
for (InstructionContext ic : instructions) {
    InstructionHandle current = ic.getInstruction();
    if (ignoreInstructions) { 
        ignoreInstructions = !current.equals(ih);
    } else if (current.getPosition() >= startPosition && current.getPosition() <= endPosition
	    && methodGen.instructionLoadsTo(current, lg.getIndex())) {
        return true;
    }
}
return false;
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
private boolean noAliasesLoadWithIndex(InstructionHandle ih, boolean ignoreInstructions, LocalVariableGen lg) {
       InstructionHandle start = lg.getStart();
       InstructionHandle prev = start.getPrev();
       // The initial store is not included in the start/end range, so include the previous
       // instruction if it exists.
       InstructionHandle end = lg.getEnd();
       int startPosition = prev != null ? prev.getPosition() : start.getPosition();
       int endPosition = end.getPosition();
for (InstructionContext ic : instructions) {
    InstructionHandle current = ic.getInstruction();
    if (ignoreInstructions) { 
        ignoreInstructions = !current.equals(ih);
    } else if (current.getPosition() >= startPosition && current.getPosition() <= endPosition
	    && methodGen.instructionLoadsTo(current, lg.getIndex())) {
	// OK, there is a load, but maybe it does not create an alias?
	if (! methodGen.isUsedForArrayLoad(current) && ! methodGen.isUsedForArrayLength(current)
		&& ! methodGen.isUsedForArrayStore(current) && ! methodGen.isUsedForPutField(current)
		&& ! methodGen.isUsedForGetField(current)) {
	    return false;
	}
    }
}
return true;
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
private void fillStoreLoadPaths(ArrayList<StoreLoadPath> storeLoadPaths, Path path, SpawnableCall spawnableCall) {
LocalVariableGen[] indicesStores = spawnableCall.getIndicesStores();
InstructionHandle invokeInstruction = spawnableCall.getInvokeInstruction();

if (!spawnableCall.exceptionsHandled()) {
    return;
}
else {
    StoreLoadPath storeLoadPath = null;
    try {
	storeLoadPath = new StoreLoadPath(invokeInstruction, path, indicesStores);
    }
    catch (NeverReadException e) {
    }
    if (storeLoadPath != null && !storeLoadPaths.contains(storeLoadPath)) {
	storeLoadPaths.add(storeLoadPath);
    }
}
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
private int getIndexEarliestBasicBlock(LocalVariableGen[] localVariableIndices, InstructionHandle storeInstruction) throws NeverReadException {
for (int i = 0; i < size(); i++) {
    LoadAwareBasicBlock basicBlock = new LoadAwareBasicBlock(get(i));
    if (i == 0) {
	if (containsLoadWithIndexAfter(basicBlock, localVariableIndices, storeInstruction)) {
	    return i;
	}
    }
    else {
	if (containsLoadWithIndex(basicBlock, localVariableIndices)) {
	    return i;
	}
    }
}
throw new NeverReadException();
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
public String toString(MethodGen method) {
    String[] variables = new String[method.getLocalVariables().length];
    LocalVariableGen[] variablesGen = method.getLocalVariables();
    for(int i=0; i<variablesGen.length ;i++) {
        variables[i] = variablesGen[i].getName();
    }
    return toString(variables);
}
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
static InstructionHandle getEndOfCatchBlock(MethodGen m,
    CodeExceptionGen catchBlock) {

if (catchBlock.getCatchType() == null) {
    // finally clause, no local variable!
    return null;
}

LocalVariableGen[] lt = m.getLocalVariables();

InstructionHandle handler = catchBlock.getHandlerPC();

for (int i = 0; i < lt.length; i++) {
    InstructionHandle start = lt[i].getStart();
    InstructionHandle end = lt[i].getEnd();

    // dangerous, javac is one instruction further...
    if ((start == handler || start == handler.getNext() || start == handler
	    .getNext().getNext())
	    && lt[i].getType().equals(catchBlock.getCatchType())) {
	// System.out.println("found range of catch block: "
	// + handler + " - " + end);
	return end.getPrev();
    }
}

System.err
	.println("Could not find end of catch block, did you compile "
		+ "with the '-g' option?");
System.exit(1);
return null;
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
private final LocalVariableGen[] getLocalTable(MethodGen m) {
LocalVariableGen[] lt = m.getLocalVariables();

if (lt == null) {
    System.err.println("Could not get local variable table, did you "
	    + "compile with the '-g' option?");
    System.exit(1);
}

return lt;
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
String getLocalName(MethodGen m, LocalVariableInstruction curr, int pos) {
LocalVariableGen a = getLocal(m, curr, pos);

if (a == null) {
    return null;
}

return a.getName();
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
Type getLocalType(MethodGen m, LocalVariableInstruction curr, int pos) {
LocalVariableGen a = getLocal(m, curr, pos);

if (a == null) {
    return null;
}

return a.getType();
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
private LocalVariableGen[] findIndexStore(InstructionHandle spawnableMethodInvoke) throws ResultNotStored {
InstructionHandle[] stackConsumers = findInstructionConsumers(spawnableMethodInvoke);
if (stackConsumers.length != 1) {
    /*
    throw new Error("Uncovered situation, invoke instruction's " + 
	    "result is consumed by multiple instructions. " + 
	    "Is there controlflow right after the spawnable invoke???");
	    */
    throw new ResultNotStored();
    // I think this is a better solution. Controlflow right after the
    // invoke is something that is hard to analyze and rare. Better to
    // just mark it as a result that isn't stored.
}
try {
    ArrayList<LocalVariableGen> resultIndices = new ArrayList<LocalVariableGen>();
    LocalVariableGen l = getIndexStore(stackConsumers[0]);
    resultIndices.add(l);
    for (LocalVariableGen ll : this.getLocalVariables()) {
	if (ll != l && l.getIndex() == ll.getIndex() && l.getName().equals(ll.getName())) {
	    if (! resultIndices.contains(ll)) {
		resultIndices.add(ll);
	    }
	}		    
    }
    return resultIndices.toArray(new LocalVariableGen[resultIndices.size()]);
}
catch (ClassCastException e) {
    throw new ResultNotStored();
}
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
SpawnableCall(InstructionHandle invokeInstruction, 
    InstructionHandle objectReference, LocalVariableGen[] indicesStores) {
this.invokeInstruction = invokeInstruction;
this.objectReference = objectReference;
this.indicesStores = indicesStores;
this.type = Type.NORMAL;
   }
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
boolean containsLoadWithIndexBefore(InstructionHandle ih, LocalVariableGen lg) {
    for (InstructionContext ic : instructions) {
        InstructionHandle current = ic.getInstruction();
        if (current.equals(ih)) {
            break;
        }
        LocalVariableGen l = methodGen.findLocalVar(current, lg.getIndex(), false);
        if (l == lg && methodGen.instructionLoadsTo(current, lg.getIndex())) {
            return true;
        }
    }
    return false;
}
 

import org.apache.bcel.generic.LocalVariableGen; //导入依赖的package包/类
StoreLoadPath(InstructionHandle storeInstruction, BasicBlock block, LocalVariableGen[] localVariableIndices) {
    super(new Path());
    add(block);
    this.storeInstruction = storeInstruction;
    this.localVariableIndices = localVariableIndices;
    aliasProblem = true;
}