/* *******************************************************************
* Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
* All rights reserved.
* This program and the accompanying materials are made available
* under the terms of the Eclipse Public License v1.0
* which accompanies this distribution and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* PARC initial implementation
* ******************************************************************/
package org.aspectj.weaver.bcel;
import java.util.Iterator;
import org.aspectj.apache.bcel.generic.Instruction;
import org.aspectj.apache.bcel.generic.InstructionBranch;
import org.aspectj.apache.bcel.generic.InstructionFactory;
import org.aspectj.apache.bcel.generic.InstructionHandle;
import org.aspectj.apache.bcel.generic.InstructionLV;
import org.aspectj.apache.bcel.generic.InstructionList;
import org.aspectj.apache.bcel.generic.InstructionSelect;
import org.aspectj.apache.bcel.generic.InstructionTargeter;
import org.aspectj.apache.bcel.generic.LocalVariableTag;
import org.aspectj.apache.bcel.generic.RET;
import org.aspectj.apache.bcel.generic.TargetLostException;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.IntMap;
import org.aspectj.weaver.Shadow;
final class ShadowRange extends Range {
private BcelShadow shadow;
// ---- initialization
/**
* After this constructor is called, this range is not well situated unless both {@link #associateWithTargets} and
* {@link #associateWithShadow} are called.
*/
public ShadowRange(InstructionList body) {
super(body);
}
protected void associateWithTargets(InstructionHandle start, InstructionHandle end) {
// assert body.contains(start) && body.contains(end);
this.start = start;
this.end = end;
start.addTargeter(this);
end.addTargeter(this);
}
public void associateWithShadow(BcelShadow shadow) {
this.shadow = shadow;
shadow.setRange(this);
}
// ----
public Shadow.Kind getKind() {
return shadow.getKind();
}
@Override
public String toString() {
return shadow.toString();
}
void extractInstructionsInto(LazyMethodGen freshMethod, IntMap remap, boolean addReturn) {
LazyMethodGen.assertGoodBody(getBody(), toString());
freshMethod.assertGoodBody();
InstructionList freshBody = freshMethod.getBody();
for (InstructionHandle oldIh = start.getNext(); oldIh != end; oldIh = oldIh.getNext()) {
// first we copy the instruction itself.
Instruction oldI = oldIh.getInstruction();
Instruction freshI = (oldI == RANGEINSTRUCTION) ? oldI : Utility.copyInstruction(oldI);
// Now we add it to the new instruction list.
InstructionHandle freshIh;
if (freshI instanceof InstructionBranch) {
// If it's a targeting instruction,
// update the target(s) to point to the new copy instead of the old copy.
InstructionBranch oldBranch = (InstructionBranch) oldI;
InstructionBranch freshBranch = (InstructionBranch) freshI;
InstructionHandle oldTarget = oldBranch.getTarget();
oldTarget.removeTargeter(oldBranch);
oldTarget.addTargeter(freshBranch);
if (freshBranch instanceof InstructionSelect) {
InstructionSelect oldSelect = (InstructionSelect) oldI;
InstructionSelect freshSelect = (InstructionSelect) freshI;
InstructionHandle[] oldTargets = freshSelect.getTargets();
for (int k = oldTargets.length - 1; k >= 0; k--) {
oldTargets[k].removeTargeter(oldSelect);
oldTargets[k].addTargeter(freshSelect);
}
}
freshIh = freshBody.append(freshBranch);
} else {
freshIh = freshBody.append(freshI);
}
// if source comes before target:
// source <--> target
// --> [process: target.removeTargeter(source); target.addTargeter(sourcecopy)]
// source ---------\
// v
// sourcecopy <--> target
// --> [ process: sourcecopy.updateTarget(target, targetcopy) ]
// source ----> target
// sourcecopy <--> targetcopy
// if target comes before source
// target <--> source
// --> [process: source.updateTarget(target, targetcopy) ]
// target
// targetcopy <--> source
// --> [process: targetcopy.removeTargeter(source); targetcopy.addTargeter(sourcecopy)]
// target source
// v
// targetcopy <--> sourcecopy
// now deal with the old instruction's targeters. Update them all to point to us
// instead of the old instruction. We use updateTarget to do this. One goal is
// to make sure we remove all targeters from the old guy, so we can successfully
// delete it.
for (InstructionTargeter source : oldIh.getTargetersCopy()) {
if (source instanceof LocalVariableTag) {
Shadow.Kind kind = getKind();
if (kind == Shadow.AdviceExecution || kind == Shadow.ConstructorExecution || kind == Shadow.MethodExecution
|| kind == Shadow.PreInitialization || kind == Shadow.Initialization
|| kind == Shadow.StaticInitialization) {
LocalVariableTag sourceLocalVariableTag = (LocalVariableTag) source;
if (sourceLocalVariableTag.getSlot() == 0) {
// might be 'this' so should be renamed if being dumped in a static method 277616
if (sourceLocalVariableTag.getName().equals("this")) {
sourceLocalVariableTag.setName("ajc$this");
}
}
// if we're extracting a whole block we can do this...
source.updateTarget(oldIh, freshIh);
} else {
// XXX destroying local variable info
// but only for a call or get join point, so no big deal
source.updateTarget(oldIh, null);
}
} else if (source instanceof Range) {
// exceptions and shadows are just moved
((Range) source).updateTarget(oldIh, freshIh, freshBody);
} else {
// line numbers can be shared,
// branches will be copied along with us.
source.updateTarget(oldIh, freshIh);
}
}
// we're now done with the old instruction entirely, and will ignore them through
// the rest of this loop. The only time we'll see them again is a second pass to
// delete them.
// now deal with local variable instructions. If this points to a remapped
// frame location, update the instruction's index. If this doesn't,
// do compaction/expansion: allocate a new local variable, and modify the remap
// to handle it. XXX We're doing the safe thing and allocating ALL these local variables
// as double-wides, in case the location is found to hold a double-wide later.
if (freshI.isLocalVariableInstruction() || freshI instanceof RET) {
// IndexedInstruction indexedI = (IndexedInstruction) freshI;
int oldIndex = freshI.getIndex();
int freshIndex;
if (!remap.hasKey(oldIndex)) {
freshIndex = freshMethod.allocateLocal(2);
remap.put(oldIndex, freshIndex);
} else {
freshIndex = remap.get(oldIndex);
}
if (freshI instanceof RET) {
freshI.setIndex(freshIndex);
} else {
freshI = ((InstructionLV) freshI).setIndexAndCopyIfNecessary(freshIndex);
freshIh.setInstruction(freshI);
}
}
// System.err.println("JUST COPIED: " +
// oldIh.getInstruction().toString(freshMethod.getEnclosingClass().getConstantPoolGen().getConstantPool())
// + " INTO " +
// freshIh.getInstruction().toString(freshMethod.getEnclosingClass().getConstantPoolGen().getConstantPool()));
}
// now go through again and update variable slots that have been altered as a result
// of remapping...
for (InstructionHandle newIh = freshBody.getStart(); newIh != freshBody.getEnd(); newIh = newIh.getNext()) {
Iterator<InstructionTargeter> tIter = newIh.getTargeters().iterator();
while (tIter.hasNext()) {
InstructionTargeter source = tIter.next();
if (source instanceof LocalVariableTag) {
LocalVariableTag lvt = (LocalVariableTag) source;
if (!lvt.isRemapped() && remap.hasKey(lvt.getSlot())) {
lvt.updateSlot(remap.get(lvt.getSlot()));
}
}
}
}
// we've now copied out all the instructions.
// now delete the instructions... we've already taken care of the damn
// targets, but since TargetLostException is checked, we have to do this stuff.
try {
for (InstructionHandle oldIh = start.getNext(); oldIh != end;) {
InstructionHandle next = oldIh.getNext();
body.delete(oldIh);
oldIh = next;
}
} catch (TargetLostException e) {
throw new BCException("shouldn't have gotten a target lost");
}
// now add the return, if one is warranted.
InstructionHandle ret = null;
if (addReturn) {
// we really should pull this out somewhere...
ret = freshBody.append(InstructionFactory.createReturn(freshMethod.getReturnType()));
}
// and remap all the old targeters of the end handle of the range to the return.
for (InstructionTargeter t : end.getTargetersCopy()) {
if (t == this) {
continue;
}
if (!addReturn) {
throw new BCException("range has target, but we aren't adding a return");
} else {
t.updateTarget(end, ret);
}
}
LazyMethodGen.assertGoodBody(getBody(), toString());
freshMethod.assertGoodBody();
}
public BcelShadow getShadow() {
return shadow;
}
}