/* *******************************************************************
 * 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 associateWithTargets and associateWithShadow are called.
/** * 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; } }