* 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

*     Alexandre Vasseur    support for @AJ aspects

* ******************************************************************/

* Some fun implementation stuff:

*

*   * expressionKind advice is non-execution advice

*     * may have a target.

*     * if the body is extracted, it will be extracted into

*       a static method.  The first argument to the static

*       method is the target

*     * advice may expose a this object, but that's the advice's

*       consideration, not ours.  This object will NOT be cached in another

*       local, but will always come from frame zero.

*

*   * non-expressionKind advice is execution advice

*     * may have a this.

*     * target is same as this, and is exposed that way to advice

*       (i.e., target will not be cached, will always come from frame zero)

*     * if the body is extracted, it will be extracted into a method

*       with same static/dynamic modifier as enclosing method.  If non-static,

*       target of callback call will be this.

*

*   * because of these two facts, the setup of the actual arguments (including

*     possible target) callback method is the same for both kinds of advice:

*     push the targetVar, if it exists (it will not exist for advice on static

*     things), then push all the argVars. 

*

* Protected things:

*

*   * the above is sufficient for non-expressionKind advice for protected things,

*     since the target will always be this.

*

*   * For expressionKind things, we have to modify the signature of the callback

*     method slightly.  For non-static expressionKind things, we modify

*     the first argument of the callback method NOT to be the type specified

*     by the method/field signature (the owner), but rather we type it to

*     the currentlyEnclosing type. We are guaranteed this will be fine,

*     since the verifier verifies that the target is a subtype of the currently

*     enclosingType.

*

* Worries:

*

*    * ConstructorCalls will be weirder than all of these, since they

*      supposedly don't have a target (according to AspectJ), but they clearly

*      do have a target of sorts, just one that needs to be pushed on the stack,

*      dupped, and not touched otherwise until the constructor runs.

* 

* @author Jim Hugunin

* @author Erik Hilsdale

*

*/

  private static final String[] NoDeclaredExceptions = new String[0];

  private ShadowRange range;

  private final BcelWorld world;

  private final LazyMethodGen enclosingMethod;

  // TESTING this will tell us if the optimisation succeeded *on the last shadow processed*

  public static boolean appliedLazyTjpOptimization;

  // Some instructions have a target type that will vary

  // from the signature (pr109728) (1.4 declaring type issue)

  private String actualInstructionTargetType;

  /**

   * This generates an unassociated shadow, rooted in a particular method but not rooted to any particular point in the code. It

   * should be given to a rooted ShadowRange in the {@link ShadowRange#associateWithShadow(BcelShadow)} method.

   */

  public BcelShadow(BcelWorld world, Kind kind, Member signature, LazyMethodGen enclosingMethod, BcelShadow enclosingShadow) {

    super(kind, signature, enclosingShadow);

    this.world = world;

    this.enclosingMethod = enclosingMethod;

  }

  // ---- copies all state, including Shadow's mungers...

  public BcelShadow copyInto(LazyMethodGen recipient, BcelShadow enclosing) {

    BcelShadow s = new BcelShadow(world, getKind(), getSignature(), recipient, enclosing);

    if (mungers.size() > 0) {

      List<ShadowMunger> src = mungers;

      if (s.mungers == Collections.EMPTY_LIST) {

        s.mungers = new ArrayList<ShadowMunger>();

      }

      List<ShadowMunger> dest = s.mungers;

      for (Iterator<ShadowMunger> i = src.iterator(); i.hasNext();) {

        dest.add(i.next());

      }

    }

    return s;

  }

  // ---- overridden behaviour

  @Override

  public World getIWorld() {

    return world;

  }

  // see comment in deleteNewAndDup

  // } else if (inst.opcode == Constants.DUP_X2) {

  // // This code seen in the wild (by Brad):

  // // 40: new #12; //class java/lang/StringBuffer

  // // STACK: STRINGBUFFER

  // // 43: dup

  // // STACK: STRINGBUFFER/STRINGBUFFER

  // // 44: aload_0

  // // STACK: STRINGBUFFER/STRINGBUFFER/THIS

  // // 45: dup_x2

  // // STACK: THIS/STRINGBUFFER/STRINGBUFFER/THIS

  // // 46: getfield #36; //Field value:Ljava/lang/String;

  // // STACK: THIS/STRINGBUFFER/STRINGBUFFER/STRING<value>

  // // 49: invokestatic #37; //Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;

  // // STACK: THIS/STRINGBUFFER/STRINGBUFFER/STRING

  // // 52: invokespecial #19; //Method java/lang/StringBuffer."<init>":(Ljava/lang/String;)V

  // // STACK: THIS/STRINGBUFFER

  // // 55: aload_1

  // // STACK: THIS/STRINGBUFFER/LOCAL1

  // // 56: invokevirtual #22; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;

  // // STACK: THIS/STRINGBUFFER

  // // 59: invokevirtual #34; //Method java/lang/StringBuffer.toString:()Ljava/lang/String;

  // // STACK: THIS/STRING

  // // 62: putfield #36; //Field value:Ljava/lang/String;

  // // STACK: <empty>

  // // 65: return

  //

  // // if we attempt to match on the ctor call to StringBuffer.<init> then we get into trouble.

  // // if we simply delete the new/dup pair without fixing up the dup_x2 then the dup_x2 will fail due to there

  // // not being 3 elements on the stack for it to work with. The fix *in this situation* is to change it to

  // // a simple 'dup'

  //

  // // this fix is *not* very clean - but a general purpose decent solution will take much longer and this

  // // bytecode sequence has only been seen once in the wild.

  // ih.setInstruction(InstructionConstants.DUP);

  /**

   * The new/dup (or new/dup_x1/swap) are removed and will be readded later (after the advice call) by the caller of this method.

   * The groovy compiler produces unusual code where the new/dup isn't visible (when making a this() call from an existing ctor),

   * an aload_0 is used to load the uninitialized object (as an example see the ctors in grails.util.BuildSettings).

   *

   * @return true if managed to remove them

   */

  private boolean deleteNewAndDup() {

    final ConstantPool cpool = getEnclosingClass().getConstantPool();

    int depth = 1;

    InstructionHandle ih = range.getStart();

    // Go back from where we are looking for 'NEW' that takes us to a stack depth of 0. INVOKESPECIAL <init>

    while (ih != null) {

      Instruction inst = ih.getInstruction();

      if (inst.opcode == Constants.INVOKESPECIAL && ((InvokeInstruction) inst).getName(cpool).equals("<init>")) {

        depth++;

      } else if (inst.opcode == Constants.NEW) {

        depth--;

        if (depth == 0) {

          break;

        }

        // need a testcase to show this can really happen in a modern compiler - removed due to 315398 - moved this out to

        // comment proceeding this method:

      }

      ih = ih.getPrev();

    }

    if (ih == null) {

      return false;

    }

    // now IH points to the NEW. We're followed by the DUP, and that is followed

    // by the actual instruction we care about.

    InstructionHandle newHandle = ih;

    InstructionHandle endHandle = newHandle.getNext();

    InstructionHandle nextHandle;

    if (endHandle.getInstruction().opcode == Constants.DUP) {

      nextHandle = endHandle.getNext();

      retargetFrom(newHandle, nextHandle);

      retargetFrom(endHandle, nextHandle);

    } else if (endHandle.getInstruction().opcode == Constants.DUP_X1) {

      InstructionHandle dupHandle = endHandle;

      endHandle = endHandle.getNext();

      nextHandle = endHandle.getNext();

      boolean skipEndRepositioning = false;

      if (endHandle.getInstruction().opcode == Constants.SWAP) {

      } else if (endHandle.getInstruction().opcode == Constants.IMPDEP1) {

        skipEndRepositioning = true; // pr186884

      } else {

        // XXX see next XXX comment

        throw new RuntimeException("Unhandled kind of new " + endHandle);

      }

      // Now make any jumps to the 'new', the 'dup' or the 'end' now target the nextHandle

      retargetFrom(newHandle, nextHandle);

      retargetFrom(dupHandle, nextHandle);

      if (!skipEndRepositioning) {

        retargetFrom(endHandle, nextHandle);

      }

    } else {

      endHandle = newHandle;

      nextHandle = endHandle.getNext();

      retargetFrom(newHandle, nextHandle);

      // add a POP here... we found a NEW w/o a dup or anything else, so

      // we must be in statement context.

      getRange().insert(InstructionConstants.POP, Range.OutsideAfter);

    }

    // assert (dupHandle.getInstruction() instanceof DUP);

    try {

      range.getBody().delete(newHandle, endHandle);

    } catch (TargetLostException e) {

      throw new BCException("shouldn't happen");

    }

    return true;

  }

  private void retargetFrom(InstructionHandle old, InstructionHandle fresh) {

    for (InstructionTargeter targeter : old.getTargetersCopy()) {

      if (targeter instanceof ExceptionRange) {

        ExceptionRange it = (ExceptionRange) targeter;

        it.updateTarget(old, fresh, it.getBody());

      } else {

        targeter.updateTarget(old, fresh);

      }

    }

  }

  // records advice that is stopping us doing the lazyTjp optimization

  private List<BcelAdvice> badAdvice = null;

  public void addAdvicePreventingLazyTjp(BcelAdvice advice) {

    if (badAdvice == null) {

      badAdvice = new ArrayList<BcelAdvice>();

    }

    badAdvice.add(advice);

  }

  @Override

  protected void prepareForMungers() {

    // if we're a constructor call, we need to remove the new:dup or the new:dup_x1:swap,

    // and store all our arguments on the frame.

    // ??? This is a bit of a hack (for the Java langauge). We do this because

    // we sometime add code "outsideBefore" when dealing with weaving join points. We only

    // do this for exposing state that is on the stack. It turns out to just work for

    // everything except for constructor calls and exception handlers. If we were to clean

    // this up, every ShadowRange would have three instructionHandle points, the start of

    // the arg-setup code, the start of the running code, and the end of the running code.

    boolean deletedNewAndDup = true;

    if (getKind() == ConstructorCall) {

      if (!world.isJoinpointArrayConstructionEnabled() || !this.getSignature().getDeclaringType().isArray()) {

        deletedNewAndDup = deleteNewAndDup(); // no new/dup for new array construction

      }

      initializeArgVars();

    } else if (getKind() == PreInitialization) { // pr74952

      ShadowRange range = getRange();

      range.insert(InstructionConstants.NOP, Range.InsideAfter);

    } else if (getKind() == ExceptionHandler) {

      ShadowRange range = getRange();

      InstructionList body = range.getBody();

      InstructionHandle start = range.getStart();

      // Create a store instruction to put the value from the top of the

      // stack into a local variable slot. This is a trimmed version of

      // what is in initializeArgVars() (since there is only one argument

      // at a handler jp and only before advice is supported) (pr46298)

      argVars = new BcelVar[1];

      // int positionOffset = (hasTarget() ? 1 : 0) + ((hasThis() && !getKind().isTargetSameAsThis()) ? 1 : 0);

      UnresolvedType tx = getArgType(0);

      argVars[0] = genTempVar(tx, "ajc$arg0");

      InstructionHandle insertedInstruction = range.insert(argVars[0].createStore(getFactory()), Range.OutsideBefore);

      // Now the exception range starts just after our new instruction.

      // The next bit of code changes the exception range to point at

      // the store instruction

      for (InstructionTargeter t : start.getTargetersCopy()) {

        if (t instanceof ExceptionRange) {

          ExceptionRange er = (ExceptionRange) t;

          er.updateTarget(start, insertedInstruction, body);

        }

      }

    }

    // now we ask each munger to request our state

    isThisJoinPointLazy = true;// world.isXlazyTjp(); // lazy is default now

    badAdvice = null;

    for (ShadowMunger munger : mungers) {

      munger.specializeOn(this);

    }

    initializeThisJoinPoint();

    if (thisJoinPointVar != null && !isThisJoinPointLazy && badAdvice != null && badAdvice.size() > 1) {

      // something stopped us making it a lazy tjp

      // can't build tjp lazily, no suitable test...

      int valid = 0;

      for (Iterator<BcelAdvice> iter = badAdvice.iterator(); iter.hasNext();) {

        BcelAdvice element = iter.next();

        ISourceLocation sLoc = element.getSourceLocation();

        if (sLoc != null && sLoc.getLine() > 0) {

          valid++;

        }

      }

      if (valid != 0) {

        ISourceLocation[] badLocs = new ISourceLocation[valid];

        int i = 0;

        for (Iterator<BcelAdvice> iter = badAdvice.iterator(); iter.hasNext();) {

          BcelAdvice element = iter.next();

          ISourceLocation sLoc = element.getSourceLocation();

          if (sLoc != null) {

            badLocs[i++] = sLoc;

          }

        }

        world.getLint().multipleAdviceStoppingLazyTjp

            .signal(new String[] { this.toString() }, getSourceLocation(), badLocs);

      }

    }

    badAdvice = null;

    // If we are an expression kind, we require our target/arguments on the stack

    // before we do our actual thing. However, they may have been removed

    // from the stack as the shadowMungers have requested state.

    // if any of our shadowMungers requested either the arguments or target,