buildConfig.setNoWeave(true);
} else if (arg.equals("-XserializableAspects")) {
buildConfig.setXserializableAspects(true);
+ } else if (arg.equals("-XlazyTjp")) {
+ buildConfig.setXlazyTjp(true);
} else if (arg.equals("-XnoInline")) {
buildConfig.setXnoInline(true);
} else if (arg.equals("-Xlintfile")) {
private boolean emacsSymMode = false;
private boolean noWeave = false;
private boolean XserializableAspects = false;
+ private boolean XlazyTjp = false;
private boolean XnoInline = false;
private String lintMode = AJLINT_DEFAULT;
private File lintSpecFile = null;
public void doNotProceed() {
shouldProceed = false;
}
+
+ public boolean isXlazyTjp() {
+ return XlazyTjp;
+ }
+
+ public void setXlazyTjp(boolean b) {
+ XlazyTjp = b;
+ }
+
}
private void initBcelWorld(IMessageHandler handler) throws IOException {
bcelWorld = new BcelWorld(buildConfig.getClasspath(), handler, null);
bcelWorld.setXnoInline(buildConfig.isXnoInline());
+ bcelWorld.setXlazyTjp(buildConfig.isXlazyTjp());
bcelWeaver = new BcelWeaver(bcelWorld);
for (Iterator i = buildConfig.getAspectpath().iterator(); i.hasNext();) {
--- /dev/null
+public class LazyTjp {\r
+ \r
+ private static final int N = 10000000;\r
+ // if lazy tjp is working, then calling the advice that uses thisJoinPoint should\r
+ // take at least this much longer than using an if pcd to bypass the advice\r
+ private static final double minimumRatio = 8.0; \r
+ \r
+ public static void main(String[] args) {\r
+ Trace.enabled = false;\r
+ double tOff = timeIt(); // throw the first result out for warm-up\r
+ tOff = timeIt();\r
+ Trace.enabled = true;\r
+ double tOn = timeIt();\r
+ Trace.enabled = false;\r
+ double tEasy = timeIt0();\r
+ double tGone = timeIt1();\r
+ \r
+ System.out.println("tOff: " + tOff + ", tOn: " + tOn + ", tEasy: " + tEasy + ", tGone: " + tGone);\r
+ System.out.println("ratio: " + tOn/tOff);\r
+ \r
+ Trace.enabled = false;\r
+ double tOff2 = timeIt2();\r
+ tOff2 = timeIt2();\r
+ Trace.enabled = true;\r
+ double tOn2 = timeIt2();\r
+ \r
+ System.out.println("tOff2: " + tOff2 + ", tOn2: " + tOn2);\r
+ System.out.println("ratio2: " + tOn2/tOff2);\r
+\r
+ \r
+ if (tOn/tOff < minimumRatio) {\r
+ throw new IllegalStateException("tOn/tOff = " + tOn/tOff + " < " + minimumRatio);\r
+ }\r
+ }\r
+ \r
+ public static double timeIt() {\r
+ long start = System.currentTimeMillis();\r
+ \r
+ for (int i=0; i < N; i++) {\r
+ doit(i);\r
+ }\r
+ \r
+ long stop = System.currentTimeMillis(); \r
+ return (stop-start)/1000.0; \r
+ }\r
+ \r
+ private static int doit(int x) {\r
+ return x+1;\r
+ }\r
+ \r
+ public static double timeIt0() {\r
+ long start = System.currentTimeMillis();\r
+ \r
+ for (int i=0; i < N; i++) {\r
+ doit0(i);\r
+ }\r
+ \r
+ long stop = System.currentTimeMillis(); \r
+ return (stop-start)/1000.0; \r
+ }\r
+ \r
+ private static int doit0(int x) {\r
+ return x+1;\r
+ }\r
+ \r
+ public static double timeIt1() {\r
+ long start = System.currentTimeMillis();\r
+ \r
+ for (int i=0; i < N; i++) {\r
+ doit1(i);\r
+ }\r
+ \r
+ long stop = System.currentTimeMillis(); \r
+ return (stop-start)/1000.0; \r
+ }\r
+ \r
+ private static int doit1(int x) {\r
+ return x+1;\r
+ }\r
+ \r
+ public static double timeIt2() {\r
+ long start = System.currentTimeMillis();\r
+ \r
+ for (int i=0; i < N; i++) {\r
+ doit2(i);\r
+ }\r
+ \r
+ long stop = System.currentTimeMillis(); \r
+ return (stop-start)/1000.0; \r
+ }\r
+ \r
+ private static int doit2(int x) {\r
+ return x+1;\r
+ }\r
+ \r
+ private static int doit3(int x) {\r
+ return x+1;\r
+ }\r
+}\r
+\r
+aspect Trace {\r
+ public static boolean enabled = false;\r
+ \r
+ public static int counter = 0;\r
+ \r
+ pointcut traced(): if (enabled) && execution(* LazyTjp.doit(..));\r
+ \r
+ before(): traced() {\r
+ Object[] args = thisJoinPoint.getArgs();\r
+ counter += args.length;\r
+ }\r
+ \r
+ before(): execution(* LazyTjp.doit0(..)) {\r
+ counter += 1;\r
+ }\r
+ \r
+ pointcut traced2(): if (enabled) && execution(* LazyTjp.doit2(..));\r
+ \r
+ before(): traced2() {\r
+ Object[] args = thisJoinPoint.getArgs();\r
+ counter += args.length;\r
+ }\r
+\r
+ after() returning: traced2() {\r
+ Object[] args = thisJoinPoint.getArgs();\r
+ counter += args.length;\r
+ }\r
+\r
+\r
+ pointcut traced3(): if (enabled) && execution(* LazyTjp.doit3(..));\r
+ \r
+ before(): traced3() {\r
+ Object[] args = thisJoinPoint.getArgs();\r
+ counter += args.length;\r
+ }\r
+\r
+ Object around(): traced3() { // expect Xlint warning in -XlazyTjp mode\r
+ return proceed();\r
+ }\r
+\r
+\r
+}
\ No newline at end of file
//$JUnit-BEGIN$
suite.addTestSuite(BasicCommandTestCase.class);
suite.addTestSuite(BinaryFormsTestCase.class);
- suite.addTestSuite(CompileAndRunTestCase.class);
+ suite.addTestSuite(CompileAndRunTestCase.class);
+ suite.addTestSuite(PerformanceTestCase.class);
suite.addTestSuite(ImageTestCase.class);
suite.addTestSuite(MultipleCompileTestCase.class);
// XXX suite.addTestSuite(VerifyWeaveTestCase.class);
public static void checkCompile(String source, int[] expectedErrors) {
+ checkCompile(source, new String[0], expectedErrors);
+ }
+
+ public static void checkCompile(String source, String[] extraArgs, int[] expectedErrors) {
List args = new ArrayList();
args.add("-verbose");
args.add("-g"); //XXX need this to get sourcefile and line numbers, shouldn't
+ for (int i = 0; i < extraArgs.length; i++) {
+ args.add(extraArgs[i]);
+ }
+
args.add(AjdtAjcTests.TESTDATA_PATH + "/" + source);
runCompiler(args, expectedErrors);
--- /dev/null
+/* *******************************************************************
+ * 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 Common Public License v1.0
+ * which accompanies this distribution and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * PARC initial implementation
+ * ******************************************************************/
+
+package org.aspectj.ajdt.internal.compiler.batch;
+
+import java.io.IOException;
+
+import org.aspectj.testing.util.TestUtil;
+
+
+public class PerformanceTestCase extends CommandTestCase {
+
+ public PerformanceTestCase(String name) {
+ super(name);
+ }
+
+
+ // this is a nice test, but not strictly needed
+ public void xxx_testLazyTjpOff() throws IOException {
+ checkCompile("src1/LazyTjp.aj", NO_ERRORS);
+ try {
+ TestUtil.runMain("out", "LazyTjp");
+ fail("expected an exception when running without -XlazyTjp");
+ } catch (IllegalStateException e) {
+ // expected exception thrown when no -XlazyTjp
+ }
+ }
+
+ public void testLazyTjp() throws IOException {
+ checkCompile("src1/LazyTjp.aj", new String[] {"-XlazyTjp","-Xlint:error"}, new int[] {97});
+ TestUtil.runMain("out", "LazyTjp");
+ }
+}
return new JoinPointImpl.StaticPartImpl(kind, sig, makeSourceLoc(l, -1));
}
- public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
- Object _this, Object target, Object[] args)
- {
- return new JoinPointImpl(staticPart, _this, target, args);
- }
+ private static Object[] NO_ARGS = new Object[0];
+ public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
+ Object _this, Object target)
+ {
+ return new JoinPointImpl(staticPart, _this, target, NO_ARGS);
+ }
+
+ public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
+ Object _this, Object target, Object arg0)
+ {
+ return new JoinPointImpl(staticPart, _this, target, new Object[] {arg0});
+ }
+
+ public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
+ Object _this, Object target, Object arg0, Object arg1)
+ {
+ return new JoinPointImpl(staticPart, _this, target, new Object[] {arg0, arg1});
+ }
+
+
+ public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
+ Object _this, Object target, Object[] args)
+ {
+ return new JoinPointImpl(staticPart, _this, target, args);
+ }
public MethodSignature makeMethodSig(String stringRep) {
MethodSignatureImpl ret = new MethodSignatureImpl(stringRep);
public final Kind unmatchedSuperTypeInCall =
new Kind("unmatchedSuperTypeInCall", "does not match because declaring type is {0}, if match desired use target({1})");
+ public final Kind canNotImplementLazyTjp =
+ new Kind("canNotImplementLazyTjp", "can not implement lazyTjp on this joinpoint {0} because around advice is used");
+
public Lint(World world) {
this.world = world;
}
protected Lint lint = new Lint(this);
protected boolean XnoInline;
+ protected boolean XlazyTjp;
protected World() {
super();
public void setXnoInline(boolean xnoInline) {
XnoInline = xnoInline;
}
+
+ public boolean isXlazyTjp() {
+ return XlazyTjp;
+ }
+
+ public void setXlazyTjp(boolean b) {
+ XlazyTjp = b;
+ }
public ResolvedTypeX.Name lookupOrCreateName(TypeX ty) {
String signature = ty.getSignature();
return ret;
}
+
}
shadowNotInStructure = ignore
unmatchedSuperTypeInCall = warning
+
+canNotImplementLazyTjp = warning
\ No newline at end of file
}
if ((getExtraParameterFlags() & ThisJoinPoint) != 0) {
- ((BcelShadow)shadow).getThisJoinPointVar();
+ ((BcelShadow)shadow).requireThisJoinPoint(pointcutTest != Literal.TRUE && getKind() != AdviceKind.Around);
}
if ((getExtraParameterFlags() & ThisEnclosingJoinPointStaticPart) != 0) {
}
if ((getExtraParameterFlags() & ThisJoinPoint) != 0) {
- shadow.getThisJoinPointBcelVar().appendLoad(il, fact);
+ il.append(shadow.loadThisJoinPoint());
}
import org.apache.bcel.generic.TargetLostException;
import org.apache.bcel.generic.Type;
import org.aspectj.bridge.ISourceLocation;
+import org.aspectj.weaver.Advice;
import org.aspectj.weaver.AdviceKind;
import org.aspectj.weaver.AjcMemberMaker;
import org.aspectj.weaver.BCException;
}
// now we ask each munger to request our state
+ isThisJoinPointLazy = world.isXlazyTjp();
+
for (Iterator iter = mungers.iterator(); iter.hasNext();) {
ShadowMunger munger = (ShadowMunger) iter.next();
munger.specializeOn(this);
}
+ initializeThisJoinPoint();
+
// 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.
// reflective thisJoinPoint support
private BcelVar thisJoinPointVar = null;
+ private boolean isThisJoinPointLazy;
+ private int lazyTjpConsumers = 0;
private BcelVar thisJoinPointStaticPartVar = null;
// private BcelVar thisEnclosingJoinPointStaticPartVar = null;
- public final Var getThisJoinPointVar() {
- return getThisJoinPointBcelVar();
- }
public final Var getThisJoinPointStaticPartVar() {
return getThisJoinPointStaticPartBcelVar();
}
return getThisEnclosingJoinPointStaticPartBcelVar();
}
- public BcelVar getThisJoinPointBcelVar() {
+ public void requireThisJoinPoint(boolean hasGuardTest) {
+ if (!hasGuardTest) {
+ isThisJoinPointLazy = false;
+ } else {
+ lazyTjpConsumers++;
+ }
if (thisJoinPointVar == null) {
- thisJoinPointVar = genTempVar(TypeX.forName("org.aspectj.lang.JoinPoint"));
- InstructionFactory fact = getFactory();
- InstructionList il = new InstructionList();
- BcelVar staticPart = getThisJoinPointStaticPartBcelVar();
- staticPart.appendLoad(il, fact);
- if (hasThis()) {
- ((BcelVar)getThisVar()).appendLoad(il, fact);
- } else {
- il.append(new ACONST_NULL());
- }
- if (hasTarget()) {
- ((BcelVar)getTargetVar()).appendLoad(il, fact);
- } else {
- il.append(new ACONST_NULL());
- }
- il.append(makeArgsObjectArray());
-
- il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory",
- "makeJP", LazyClassGen.tjpType,
- new Type[] { LazyClassGen.staticTjpType,
- Type.OBJECT, Type.OBJECT, new ArrayType(Type.OBJECT, 1)},
- Constants.INVOKESTATIC));
- il.append(thisJoinPointVar.createStore(fact));
- range.insert(il, Range.OutsideBefore);
+ thisJoinPointVar = genTempVar(TypeX.forName("org.aspectj.lang.JoinPoint"));
}
+ }
+
+
+ public Var getThisJoinPointVar() {
+ requireThisJoinPoint(false);
return thisJoinPointVar;
}
+ void initializeThisJoinPoint() {
+ if (thisJoinPointVar == null) return;
+
+ if (isThisJoinPointLazy) {
+ isThisJoinPointLazy = checkLazyTjp();
+ }
+
+ if (isThisJoinPointLazy) {
+ createThisJoinPoint(); // make sure any state needed is initialized, but throw the instructions out
+
+ if (lazyTjpConsumers == 1) return; // special case only one lazyTjpUser
+
+ InstructionFactory fact = getFactory();
+ InstructionList il = new InstructionList();
+ il.append(InstructionConstants.ACONST_NULL);
+ il.append(thisJoinPointVar.createStore(fact));
+ range.insert(il, Range.OutsideBefore);
+ } else {
+ InstructionFactory fact = getFactory();
+ InstructionList il = createThisJoinPoint();
+ il.append(thisJoinPointVar.createStore(fact));
+ range.insert(il, Range.OutsideBefore);
+ }
+ }
+
+ private boolean checkLazyTjp() {
+ // check for around advice
+ for (Iterator i = mungers.iterator(); i.hasNext();) {
+ ShadowMunger munger = (ShadowMunger) i.next();
+ if (munger instanceof Advice) {
+ if ( ((Advice)munger).getKind() == AdviceKind.Around) {
+ world.getLint().canNotImplementLazyTjp.signal(
+ new String[] {toString()},
+ getSourceLocation(),
+ new ISourceLocation[] { munger.getSourceLocation() }
+ );
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ InstructionList loadThisJoinPoint() {
+ InstructionFactory fact = getFactory();
+ InstructionList il = new InstructionList();
+
+ if (isThisJoinPointLazy) {
+ il.append(createThisJoinPoint());
+
+ if (lazyTjpConsumers > 1) {
+ il.append(thisJoinPointVar.createStore(fact));
+
+ InstructionHandle end = il.append(thisJoinPointVar.createLoad(fact));
+
+ il.insert(InstructionFactory.createBranchInstruction(Constants.IFNONNULL, end));
+ il.insert(thisJoinPointVar.createLoad(fact));
+ }
+ } else {
+ thisJoinPointVar.appendLoad(il, fact);
+ }
+
+ return il;
+ }
+
+ InstructionList createThisJoinPoint() {
+ InstructionFactory fact = getFactory();
+ InstructionList il = new InstructionList();
+
+ BcelVar staticPart = getThisJoinPointStaticPartBcelVar();
+ staticPart.appendLoad(il, fact);
+ if (hasThis()) {
+ ((BcelVar)getThisVar()).appendLoad(il, fact);
+ } else {
+ il.append(new ACONST_NULL());
+ }
+ if (hasTarget()) {
+ ((BcelVar)getTargetVar()).appendLoad(il, fact);
+ } else {
+ il.append(new ACONST_NULL());
+ }
+
+ switch(getArgCount()) {
+ case 0:
+ il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory",
+ "makeJP", LazyClassGen.tjpType,
+ new Type[] { LazyClassGen.staticTjpType,
+ Type.OBJECT, Type.OBJECT},
+ Constants.INVOKESTATIC));
+ break;
+ case 1:
+ ((BcelVar)getArgVar(0)).appendLoadAndConvert(il, fact, world.resolve(ResolvedTypeX.OBJECT));
+ il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory",
+ "makeJP", LazyClassGen.tjpType,
+ new Type[] { LazyClassGen.staticTjpType,
+ Type.OBJECT, Type.OBJECT, Type.OBJECT},
+ Constants.INVOKESTATIC));
+ break;
+ case 2:
+ ((BcelVar)getArgVar(0)).appendLoadAndConvert(il, fact, world.resolve(ResolvedTypeX.OBJECT));
+ ((BcelVar)getArgVar(1)).appendLoadAndConvert(il, fact, world.resolve(ResolvedTypeX.OBJECT));
+ il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory",
+ "makeJP", LazyClassGen.tjpType,
+ new Type[] { LazyClassGen.staticTjpType,
+ Type.OBJECT, Type.OBJECT, Type.OBJECT, Type.OBJECT},
+ Constants.INVOKESTATIC));
+ break;
+ default:
+ il.append(makeArgsObjectArray());
+ il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory",
+ "makeJP", LazyClassGen.tjpType,
+ new Type[] { LazyClassGen.staticTjpType,
+ Type.OBJECT, Type.OBJECT, new ArrayType(Type.OBJECT, 1)},
+ Constants.INVOKESTATIC));
+ break;
+ }
+
+ return il;
+ }
+
public BcelVar getThisJoinPointStaticPartBcelVar() {
if (thisJoinPointStaticPartVar == null) {
Field field = getEnclosingClass().getTjpField(this);
GETSTATIC HelloWorld.ajc$tjp_0 Lorg/aspectj/lang/JoinPoint$StaticPart;
ALOAD_0
ALOAD_0
- BIPUSH 0
- ANEWARRAY java.lang.Object
- ASTORE_2
- ALOAD_2
- INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
+ INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
ASTORE_1
constructor-execution(void HelloWorld.<init>())
| BIPUSH 2
| ANEWARRAY java.lang.Object
- | ASTORE 4
- | ALOAD 4
+ | ASTORE_3
+ | ALOAD_3
| BIPUSH 0
| ALOAD_0
| AASTORE
- | ALOAD 4
+ | ALOAD_3
| BIPUSH 1
| ALOAD_1
| AASTORE
| NEW HelloWorld$AjcClosure3
| DUP
- | ALOAD 4
+ | ALOAD_3
| INVOKESPECIAL HelloWorld$AjcClosure3.<init> ([Ljava/lang/Object;)V
| ALOAD_1
| INVOKESTATIC Aspect.ajc_around (Lorg/aspectj/runtime/internal/AroundClosure;Lorg/aspectj/lang/JoinPoint;)Ljava/lang/Object;
public static void main(String[]):
ALOAD_0
- ASTORE 11
+ ASTORE 9
GETSTATIC HelloWorld.ajc$tjp_3 Lorg/aspectj/lang/JoinPoint$StaticPart;
ACONST_NULL
ACONST_NULL
- BIPUSH 1
- ANEWARRAY java.lang.Object
- ASTORE 13
- ALOAD 13
- BIPUSH 0
- ALOAD 11
- AASTORE
- ALOAD 13
- INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
- ASTORE 12
+ ALOAD 9
+ INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
+ ASTORE 10
method-execution(void HelloWorld.main(java.lang.String[]))
| BIPUSH 2
| ANEWARRAY java.lang.Object
- | ASTORE 15
- | ALOAD 15
+ | ASTORE 12
+ | ALOAD 12
| BIPUSH 0
- | ALOAD 11
+ | ALOAD 9
| AASTORE
- | ALOAD 15
- | BIPUSH 1
| ALOAD 12
+ | BIPUSH 1
+ | ALOAD 10
| AASTORE
| NEW HelloWorld$AjcClosure15
| DUP
- | ALOAD 15
- | INVOKESPECIAL HelloWorld$AjcClosure15.<init> ([Ljava/lang/Object;)V
| ALOAD 12
+ | INVOKESPECIAL HelloWorld$AjcClosure15.<init> ([Ljava/lang/Object;)V
+ | ALOAD 10
| INVOKESTATIC Aspect.ajc_around (Lorg/aspectj/runtime/internal/AroundClosure;Lorg/aspectj/lang/JoinPoint;)Ljava/lang/Object;
| POP
| RETURN
GETSTATIC HelloWorld.ajc$tjp_1 Lorg/aspectj/lang/JoinPoint$StaticPart;
ACONST_NULL
ACONST_NULL
- BIPUSH 0
- ANEWARRAY java.lang.Object
+ INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
ASTORE_2
- ALOAD_2
- INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
- ASTORE 4
field-get(java.io.PrintStream java.lang.System.out)
| BIPUSH 1
| ANEWARRAY java.lang.Object
- | ASTORE 6
- | ALOAD 6
- | BIPUSH 0
+ | ASTORE 4
| ALOAD 4
+ | BIPUSH 0
+ | ALOAD_2
| AASTORE
| NEW HelloWorld$AjcClosure7
| DUP
- | ALOAD 6
- | INVOKESPECIAL HelloWorld$AjcClosure7.<init> ([Ljava/lang/Object;)V
| ALOAD 4
+ | INVOKESPECIAL HelloWorld$AjcClosure7.<init> ([Ljava/lang/Object;)V
+ | ALOAD_2
| INVOKESTATIC Aspect.ajc_around (Lorg/aspectj/runtime/internal/AroundClosure;Lorg/aspectj/lang/JoinPoint;)Ljava/lang/Object;
| CHECKCAST java.io.PrintStream
field-get(java.io.PrintStream java.lang.System.out)
LDC "hello world" (line 9)
+ ASTORE 6
ASTORE 8
- ASTORE 10
GETSTATIC HelloWorld.ajc$tjp_2 Lorg/aspectj/lang/JoinPoint$StaticPart;
ACONST_NULL
- ALOAD 10
- BIPUSH 1
- ANEWARRAY java.lang.Object
- ASTORE 12
- ALOAD 12
- BIPUSH 0
ALOAD 8
- AASTORE
- ALOAD 12
- INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
- ASTORE 14
+ ALOAD 6
+ INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
+ ASTORE 10
method-call(void java.io.PrintStream.println(java.lang.String))
| BIPUSH 3
| ANEWARRAY java.lang.Object
- | ASTORE 16
- | ALOAD 16
+ | ASTORE 12
+ | ALOAD 12
| BIPUSH 0
- | ALOAD 10
+ | ALOAD 8
| AASTORE
- | ALOAD 16
+ | ALOAD 12
| BIPUSH 1
- | ALOAD 8
+ | ALOAD 6
| AASTORE
- | ALOAD 16
+ | ALOAD 12
| BIPUSH 2
- | ALOAD 14
+ | ALOAD 10
| AASTORE
| NEW HelloWorld$AjcClosure11
| DUP
- | ALOAD 16
+ | ALOAD 12
| INVOKESPECIAL HelloWorld$AjcClosure11.<init> ([Ljava/lang/Object;)V
- | ALOAD 14
+ | ALOAD 10
| INVOKESTATIC Aspect.ajc_around (Lorg/aspectj/runtime/internal/AroundClosure;Lorg/aspectj/lang/JoinPoint;)Ljava/lang/Object;
| POP
method-call(void java.io.PrintStream.println(java.lang.String))
GETSTATIC HelloWorld.ajc$tjp_0 Lorg/aspectj/lang/JoinPoint$StaticPart;
ALOAD_0
ALOAD_0
- BIPUSH 0
- ANEWARRAY java.lang.Object
- ASTORE_2
- ALOAD_2
- INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
+ INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
ASTORE_1
constructor-execution(void HelloWorld.<init>())
| BIPUSH 2
| ANEWARRAY java.lang.Object
- | ASTORE_3
- | ALOAD_3
+ | ASTORE_2
+ | ALOAD_2
| BIPUSH 0
| ALOAD_0
| AASTORE
- | ALOAD_3
+ | ALOAD_2
| BIPUSH 1
| ALOAD_1
| AASTORE
| NEW HelloWorld$AjcClosure1
| DUP
- | ALOAD_3
+ | ALOAD_2
| INVOKESPECIAL HelloWorld$AjcClosure1.<init> ([Ljava/lang/Object;)V
| ALOAD_1
| INVOKESTATIC Aspect.ajc_around (Lorg/aspectj/runtime/internal/AroundClosure;Lorg/aspectj/lang/JoinPoint;)Ljava/lang/Object;
public static void main(String[]):
ALOAD_0
- ASTORE 9
+ ASTORE 7
GETSTATIC HelloWorld.ajc$tjp_3 Lorg/aspectj/lang/JoinPoint$StaticPart;
ACONST_NULL
ACONST_NULL
- BIPUSH 1
- ANEWARRAY java.lang.Object
- ASTORE 11
- ALOAD 11
- BIPUSH 0
- ALOAD 9
- AASTORE
- ALOAD 11
- INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
- ASTORE 10
+ ALOAD 7
+ INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
+ ASTORE 8
method-execution(void HelloWorld.main(java.lang.String[]))
| BIPUSH 2
| ANEWARRAY java.lang.Object
- | ASTORE 12
- | ALOAD 12
- | BIPUSH 0
+ | ASTORE 9
| ALOAD 9
+ | BIPUSH 0
+ | ALOAD 7
| AASTORE
- | ALOAD 12
+ | ALOAD 9
| BIPUSH 1
- | ALOAD 10
+ | ALOAD 8
| AASTORE
| NEW HelloWorld$AjcClosure7
| DUP
- | ALOAD 12
+ | ALOAD 9
| INVOKESPECIAL HelloWorld$AjcClosure7.<init> ([Ljava/lang/Object;)V
- | ALOAD 10
+ | ALOAD 8
| INVOKESTATIC Aspect.ajc_around (Lorg/aspectj/runtime/internal/AroundClosure;Lorg/aspectj/lang/JoinPoint;)Ljava/lang/Object;
| POP
| RETURN
GETSTATIC HelloWorld.ajc$tjp_1 Lorg/aspectj/lang/JoinPoint$StaticPart;
ACONST_NULL
ACONST_NULL
- BIPUSH 0
- ANEWARRAY java.lang.Object
+ INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
ASTORE_2
- ALOAD_2
- INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
- ASTORE 4
field-get(java.io.PrintStream java.lang.System.out)
| BIPUSH 1
| ANEWARRAY java.lang.Object
- | ASTORE 6
- | ALOAD 6
- | BIPUSH 0
+ | ASTORE 4
| ALOAD 4
+ | BIPUSH 0
+ | ALOAD_2
| AASTORE
| NEW HelloWorld$AjcClosure3
| DUP
- | ALOAD 6
- | INVOKESPECIAL HelloWorld$AjcClosure3.<init> ([Ljava/lang/Object;)V
| ALOAD 4
+ | INVOKESPECIAL HelloWorld$AjcClosure3.<init> ([Ljava/lang/Object;)V
+ | ALOAD_2
| INVOKESTATIC Aspect.ajc_around (Lorg/aspectj/runtime/internal/AroundClosure;Lorg/aspectj/lang/JoinPoint;)Ljava/lang/Object;
| CHECKCAST java.io.PrintStream
field-get(java.io.PrintStream java.lang.System.out)
LDC "hello world" (line 9)
+ ASTORE 6
ASTORE 8
- ASTORE 10
GETSTATIC HelloWorld.ajc$tjp_2 Lorg/aspectj/lang/JoinPoint$StaticPart;
ACONST_NULL
- ALOAD 10
- BIPUSH 1
- ANEWARRAY java.lang.Object
- ASTORE 12
- ALOAD 12
- BIPUSH 0
ALOAD 8
- AASTORE
- ALOAD 12
- INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
- ASTORE 14
+ ALOAD 6
+ INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
+ ASTORE 10
method-call(void java.io.PrintStream.println(java.lang.String))
| BIPUSH 3
| ANEWARRAY java.lang.Object
- | ASTORE 16
- | ALOAD 16
+ | ASTORE 12
+ | ALOAD 12
| BIPUSH 0
- | ALOAD 10
+ | ALOAD 8
| AASTORE
- | ALOAD 16
+ | ALOAD 12
| BIPUSH 1
- | ALOAD 8
+ | ALOAD 6
| AASTORE
- | ALOAD 16
+ | ALOAD 12
| BIPUSH 2
- | ALOAD 14
+ | ALOAD 10
| AASTORE
| NEW HelloWorld$AjcClosure5
| DUP
- | ALOAD 16
+ | ALOAD 12
| INVOKESPECIAL HelloWorld$AjcClosure5.<init> ([Ljava/lang/Object;)V
- | ALOAD 14
+ | ALOAD 10
| INVOKESTATIC Aspect.ajc_around (Lorg/aspectj/runtime/internal/AroundClosure;Lorg/aspectj/lang/JoinPoint;)Ljava/lang/Object;
| POP
method-call(void java.io.PrintStream.println(java.lang.String))
GETSTATIC HelloWorld.ajc$tjp_0 Lorg/aspectj/lang/JoinPoint$StaticPart;
ALOAD_0
ALOAD_0
- BIPUSH 0
- ANEWARRAY java.lang.Object
- ASTORE_2
- ALOAD_2
- INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
+ INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
ASTORE_1
constructor-execution(void HelloWorld.<init>())
| ALOAD_1
public static void main(String[]):
ALOAD_0
- ASTORE 9
+ ASTORE 6
GETSTATIC HelloWorld.ajc$tjp_3 Lorg/aspectj/lang/JoinPoint$StaticPart;
ACONST_NULL
ACONST_NULL
- BIPUSH 1
- ANEWARRAY java.lang.Object
- ASTORE 8
- ALOAD 8
- BIPUSH 0
- ALOAD 9
- AASTORE
- ALOAD 8
- INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
- ASTORE 7
+ ALOAD 6
+ INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
+ ASTORE 5
method-execution(void HelloWorld.main(java.lang.String[]))
- | ALOAD 7
+ | ALOAD 5
| INVOKESTATIC Aspect.ajc_before (Lorg/aspectj/lang/JoinPoint;)V
| GETSTATIC HelloWorld.ajc$tjp_1 Lorg/aspectj/lang/JoinPoint$StaticPart;
| ACONST_NULL
| ACONST_NULL
- | BIPUSH 0
- | ANEWARRAY java.lang.Object
- | ASTORE_2
- | ALOAD_2
- | INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
+ | INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
| ASTORE_1
| field-get(java.io.PrintStream java.lang.System.out)
| | ALOAD_1
| | GETSTATIC java.lang.System.out Ljava/io/PrintStream; (line 8)
| field-get(java.io.PrintStream java.lang.System.out)
| LDC "hello world" (line 9)
+ | ASTORE_3
| ASTORE 4
- | ASTORE 5
| GETSTATIC HelloWorld.ajc$tjp_2 Lorg/aspectj/lang/JoinPoint$StaticPart;
| ACONST_NULL
- | ALOAD 5
- | BIPUSH 1
- | ANEWARRAY java.lang.Object
- | ASTORE 6
- | ALOAD 6
- | BIPUSH 0
| ALOAD 4
- | AASTORE
- | ALOAD 6
- | INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
- | ASTORE_3
+ | ALOAD_3
+ | INVOKESTATIC org.aspectj.runtime.reflect.Factory.makeJP (Lorg/aspectj/lang/JoinPoint$StaticPart;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Lorg/aspectj/lang/JoinPoint;
+ | ASTORE_2
| method-call(void java.io.PrintStream.println(java.lang.String))
- | | ALOAD_3
+ | | ALOAD_2
| | INVOKESTATIC Aspect.ajc_before (Lorg/aspectj/lang/JoinPoint;)V
- | | ALOAD 5
| | ALOAD 4
+ | | ALOAD_3
| | INVOKEVIRTUAL java.io.PrintStream.println (Ljava/lang/String;)V
| method-call(void java.io.PrintStream.println(java.lang.String))
| RETURN (line 11)
projects / aspectj.git / commitdiff