List of usage examples for org.objectweb.asm Opcodes DUP
int DUP
To view the source code for org.objectweb.asm Opcodes DUP.
Click Source Link
From source file:com.google.gwt.jvm.asm.NativeMethodDelegatingVisitor.java
License:Apache License
private void assertThisNotNull() { delegate.visitVarInsn(Opcodes.ALOAD, 0); Label notNull = new Label(); delegate.visitJumpInsn(Opcodes.IFNONNULL, notNull); delegate.visitTypeInsn(Opcodes.NEW, NULL_POINTER_EXCEPTION); delegate.visitInsn(Opcodes.DUP); delegate.visitMethodInsn(Opcodes.INVOKESPECIAL, NULL_POINTER_EXCEPTION, "<init>", "()V"); delegate.visitInsn(Opcodes.ATHROW);/* w ww .ja va 2 s.c o m*/ delegate.visitLabel(notNull); }
From source file:com.google.gwt.jvm.asm.NativeMethodDelegatingVisitor.java
License:Apache License
private int nativeDelegate_addArgument(String parameter, int index) { int size = 1; delegate.visitInsn(Opcodes.DUP); switch (parameter.charAt(0)) { case 'L': case '[': parameter = "Ljava/lang/Object;"; delegate.visitVarInsn(Opcodes.ALOAD, index); break;//from ww w . j a v a2 s. c o m case 'Z': case 'B': case 'C': case 'S': case 'I': delegate.visitVarInsn(Opcodes.ILOAD, index); break; case 'J': delegate.visitVarInsn(Opcodes.LLOAD, index); size = 2; break; case 'F': delegate.visitVarInsn(Opcodes.FLOAD, index); break; case 'D': delegate.visitVarInsn(Opcodes.DLOAD, index); size = 2; break; default: throw new IllegalStateException(parameter); } delegate.visitMethodInsn(Opcodes.INVOKEVIRTUAL, InvocationDelegate, "addArg", "(" + parameter + ")V"); return size; }
From source file:com.google.monitoring.runtime.instrumentation.adapters.AllocationMethodAdapter.java
License:Apache License
/** * newarray shows up as an instruction taking an int operand (the primitive * element type of the array) so we hook it here. *///from ww w. ja va2s . c o m @Override public void visitIntInsn(final int opcode, final int operand) { if (opcode == Opcodes.NEWARRAY) { // instack: ... count // outstack: ... aref if (operand >= 4 && operand <= 11) { super.visitInsn(Opcodes.DUP); // -> stack: ... count count super.visitIntInsn(opcode, operand); // -> stack: ... count aref invokeRecordAllocation(primitiveTypeNames[operand]); // -> stack: ... aref } else { AllocationInstrumenter.logger.severe("NEWARRAY called with an invalid operand " + operand + ". Not instrumenting this allocation!"); super.visitIntInsn(opcode, operand); } } else { super.visitIntInsn(opcode, operand); } }
From source file:com.google.monitoring.runtime.instrumentation.adapters.AllocationMethodAdapter.java
License:Apache License
private void pushProductOfIntArrayOnStack() { final Label beginScopeLabel = new Label(); final Label endScopeLabel = new Label(); final int dimsArrayIndex = newLocal("[I", beginScopeLabel, endScopeLabel); final int counterIndex = newLocal("I", beginScopeLabel, endScopeLabel); final int productIndex = newLocal("I", beginScopeLabel, endScopeLabel); final Label loopLabel = new Label(); final Label endLabel = new Label(); super.visitLabel(beginScopeLabel); // stack: ... intArray super.visitVarInsn(Opcodes.ASTORE, dimsArrayIndex); // -> stack: ... // counter = 0 super.visitInsn(Opcodes.ICONST_0); super.visitVarInsn(Opcodes.ISTORE, counterIndex); // product = 1 super.visitInsn(Opcodes.ICONST_1); super.visitVarInsn(Opcodes.ISTORE, productIndex); // loop:/*from w ww .ja va 2 s . c o m*/ super.visitLabel(loopLabel); // if index >= arraylength goto end: super.visitVarInsn(Opcodes.ILOAD, counterIndex); super.visitVarInsn(Opcodes.ALOAD, dimsArrayIndex); super.visitInsn(Opcodes.ARRAYLENGTH); super.visitJumpInsn(Opcodes.IF_ICMPGE, endLabel); // product = product * max(array[counter],1) super.visitVarInsn(Opcodes.ALOAD, dimsArrayIndex); super.visitVarInsn(Opcodes.ILOAD, counterIndex); super.visitInsn(Opcodes.IALOAD); super.visitInsn(Opcodes.DUP); final Label nonZeroDimension = new Label(); super.visitJumpInsn(Opcodes.IFNE, nonZeroDimension); super.visitInsn(Opcodes.POP); super.visitInsn(Opcodes.ICONST_1); super.visitLabel(nonZeroDimension); super.visitVarInsn(Opcodes.ILOAD, productIndex); super.visitInsn(Opcodes.IMUL); // if overflow happens it happens. super.visitVarInsn(Opcodes.ISTORE, productIndex); // iinc counter 1 super.visitIincInsn(counterIndex, 1); // goto loop super.visitJumpInsn(Opcodes.GOTO, loopLabel); // end: super.visitLabel(endLabel); // re-push dimensions array super.visitVarInsn(Opcodes.ALOAD, dimsArrayIndex); // push product super.visitVarInsn(Opcodes.ILOAD, productIndex); super.visitLabel(endScopeLabel); }
From source file:com.google.monitoring.runtime.instrumentation.adapters.AllocationMethodAdapter.java
License:Apache License
/** * Reflection-based allocation (@see java.lang.reflect.Array#newInstance) is * triggered with a static method call (INVOKESTATIC), so we hook it here. * Class initialization is triggered with a constructor call (INVOKESPECIAL) * so we hook that here too as a proxy for the new bytecode which leaves an * uninitialized object on the stack that we're not allowed to touch. * {@link java.lang.Object#clone} is also a call to INVOKESPECIAL, * and is hooked here. {@link java.lang.Class#newInstance} and * {@link java.lang.reflect.Constructor#newInstance} are both * INVOKEVIRTUAL calls, so they are hooked here, as well. *///from w ww . j ava 2 s .c om @Override public void visitMethodInsn(final int opcode, final String owner, final String name, final String signature, final boolean itf) { if (opcode == Opcodes.INVOKESTATIC && // Array does its own native allocation. Grr. owner.equals("java/lang/reflect/Array") && name.equals("newInstance")) { if (signature.equals("(Ljava/lang/Class;I)Ljava/lang/Object;")) { final Label beginScopeLabel = new Label(); final Label endScopeLabel = new Label(); super.visitLabel(beginScopeLabel); // stack: ... class count final int countIndex = newLocal("I", beginScopeLabel, endScopeLabel); super.visitVarInsn(Opcodes.ISTORE, countIndex); // -> stack: ... class pushClassNameOnStack(); // -> stack: ... class className final int typeNameIndex = newLocal("Ljava/lang/String;", beginScopeLabel, endScopeLabel); super.visitVarInsn(Opcodes.ASTORE, typeNameIndex); // -> stack: ... class super.visitVarInsn(Opcodes.ILOAD, countIndex); // -> stack: ... class count super.visitMethodInsn(opcode, owner, name, signature, itf); // -> stack: ... newobj super.visitInsn(Opcodes.DUP); // -> stack: ... newobj newobj super.visitVarInsn(Opcodes.ILOAD, countIndex); // -> stack: ... newobj newobj count super.visitInsn(Opcodes.SWAP); // -> stack: ... newobj count newobj super.visitVarInsn(Opcodes.ALOAD, typeNameIndex); super.visitLabel(endScopeLabel); // -> stack: ... newobj count newobj className super.visitInsn(Opcodes.SWAP); // -> stack: ... newobj count className newobj super.visitMethodInsn(Opcodes.INVOKESTATIC, recorderClass, recorderMethod, RECORDER_SIGNATURE, false); // -> stack: ... newobj return; } else if (signature.equals("(Ljava/lang/Class;[I)Ljava/lang/Object;")) { final Label beginScopeLabel = new Label(); final Label endScopeLabel = new Label(); super.visitLabel(beginScopeLabel); final int dimsArrayIndex = newLocal("[I", beginScopeLabel, endScopeLabel); // stack: ... class dimsArray pushProductOfIntArrayOnStack(); // -> stack: ... class dimsArray product final int productIndex = newLocal("I", beginScopeLabel, endScopeLabel); super.visitVarInsn(Opcodes.ISTORE, productIndex); // -> stack: ... class dimsArray super.visitVarInsn(Opcodes.ASTORE, dimsArrayIndex); // -> stack: ... class pushClassNameOnStack(); // -> stack: ... class className final int typeNameIndex = newLocal("Ljava/lang/String;", beginScopeLabel, endScopeLabel); super.visitVarInsn(Opcodes.ASTORE, typeNameIndex); // -> stack: ... class super.visitVarInsn(Opcodes.ALOAD, dimsArrayIndex); // -> stack: ... class dimsArray super.visitMethodInsn(opcode, owner, name, signature, itf); // -> stack: ... newobj super.visitInsn(Opcodes.DUP); // -> stack: ... newobj newobj super.visitVarInsn(Opcodes.ILOAD, productIndex); // -> stack: ... newobj newobj product super.visitInsn(Opcodes.SWAP); // -> stack: ... newobj product newobj super.visitVarInsn(Opcodes.ALOAD, typeNameIndex); super.visitLabel(endScopeLabel); // -> stack: ... newobj product newobj className super.visitInsn(Opcodes.SWAP); // -> stack: ... newobj product className newobj super.visitMethodInsn(Opcodes.INVOKESTATIC, recorderClass, recorderMethod, RECORDER_SIGNATURE, false); // -> stack: ... newobj return; } } if (opcode == Opcodes.INVOKEVIRTUAL) { if ("clone".equals(name) && owner.startsWith("[")) { super.visitMethodInsn(opcode, owner, name, signature, itf); int i = 0; while (i < owner.length()) { if (owner.charAt(i) != '[') { break; } i++; } if (i > 1) { // -> stack: ... newobj super.visitTypeInsn(Opcodes.CHECKCAST, owner); // -> stack: ... arrayref calculateArrayLengthAndDispatch(owner.substring(i), i); } else { // -> stack: ... newobj super.visitInsn(Opcodes.DUP); // -> stack: ... newobj newobj super.visitTypeInsn(Opcodes.CHECKCAST, owner); // -> stack: ... newobj arrayref super.visitInsn(Opcodes.ARRAYLENGTH); // -> stack: ... newobj length super.visitInsn(Opcodes.SWAP); // -> stack: ... length newobj invokeRecordAllocation(owner.substring(i)); } return; } else if ("newInstance".equals(name)) { if ("java/lang/Class".equals(owner) && "()Ljava/lang/Object;".equals(signature)) { super.visitInsn(Opcodes.DUP); // -> stack: ... Class Class super.visitMethodInsn(opcode, owner, name, signature, itf); // -> stack: ... Class newobj super.visitInsn(Opcodes.DUP_X1); // -> stack: ... newobj Class newobj super.visitMethodInsn(Opcodes.INVOKESTATIC, recorderClass, recorderMethod, CLASS_RECORDER_SIG, false); // -> stack: ... newobj return; } else if ("java/lang/reflect/Constructor".equals(owner) && "([Ljava/lang/Object;)Ljava/lang/Object;".equals(signature)) { buildRecorderFromObject(opcode, owner, name, signature, itf); return; } } } if (opcode == Opcodes.INVOKESPECIAL) { if ("clone".equals(name) && "java/lang/Object".equals(owner)) { buildRecorderFromObject(opcode, owner, name, signature, itf); return; } else if ("<init>".equals(name) && outstandingAllocs > 0) { // Tricky because superclass initializers mean there can be more calls // to <init> than calls to NEW; hence outstandingAllocs. --outstandingAllocs; // Most of the time (i.e. in bytecode generated by javac) it is the case // that following an <init> call the top of the stack has a reference ot // the newly-initialized object. But nothing in the JVM Spec requires // this, so we need to play games with the stack to make an explicit // extra copy (and then discard it). dupStackElementBeforeSignatureArgs(signature); super.visitMethodInsn(opcode, owner, name, signature, itf); super.visitLdcInsn(-1); super.visitInsn(Opcodes.SWAP); invokeRecordAllocation(owner); super.visitInsn(Opcodes.POP); return; } } super.visitMethodInsn(opcode, owner, name, signature, itf); }
From source file:com.google.monitoring.runtime.instrumentation.adapters.AllocationMethodAdapter.java
License:Apache License
private void buildRecorderFromObject(final int opcode, final String owner, final String name, final String signature, final boolean itf) { super.visitMethodInsn(opcode, owner, name, signature, itf); // -> stack: ... newobj super.visitInsn(Opcodes.DUP); // -> stack: ... newobj newobj super.visitInsn(Opcodes.DUP); // -> stack: ... newobj newobj newobj // We could be instantiating this class or a subclass, so we // have to get the class the hard way. super.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Object", "getClass", "()Ljava/lang/Class;", false); // -> stack: ... newobj newobj Class super.visitInsn(Opcodes.SWAP); // -> stack: ... newobj Class newobj super.visitMethodInsn(Opcodes.INVOKESTATIC, recorderClass, recorderMethod, CLASS_RECORDER_SIG, false); // -> stack: ... newobj }
From source file:com.google.monitoring.runtime.instrumentation.adapters.AllocationMethodAdapter.java
License:Apache License
private void dupStackElementBeforeSignatureArgs(final String sig) { final Label beginScopeLabel = new Label(); final Label endScopeLabel = new Label(); super.visitLabel(beginScopeLabel); final Type[] argTypes = Type.getArgumentTypes(sig); final int[] args = new int[argTypes.length]; for (int i = argTypes.length - 1; i >= 0; --i) { args[i] = newLocal(argTypes[i], beginScopeLabel, endScopeLabel); super.visitVarInsn(argTypes[i].getOpcode(Opcodes.ISTORE), args[i]); }/*ww w. ja v a 2 s .com*/ super.visitInsn(Opcodes.DUP); for (int i = 0; i < argTypes.length; ++i) { final int op = argTypes[i].getOpcode(Opcodes.ILOAD); super.visitVarInsn(op, args[i]); if (op == Opcodes.ALOAD) { super.visitInsn(Opcodes.ACONST_NULL); super.visitVarInsn(Opcodes.ASTORE, args[i]); } } super.visitLabel(endScopeLabel); }
From source file:com.google.monitoring.runtime.instrumentation.adapters.AllocationMethodAdapter.java
License:Apache License
/** * new and anewarray bytecodes take a String operand for the type of * the object or array element so we hook them here. Note that new doesn't * actually result in any instrumentation here; we just do a bit of * book-keeping and do the instrumentation following the constructor call * (because we're not allowed to touch the object until it is initialized). */// w w w .j av a2s .c o m @Override public void visitTypeInsn(final int opcode, final String typeName) { if (opcode == Opcodes.NEW) { // We can't actually tag this object right after allocation because it // must be initialized with a ctor before we can touch it (Verifier // enforces this). Instead, we just note it and tag following // initialization. super.visitTypeInsn(opcode, typeName); ++outstandingAllocs; } else if (opcode == Opcodes.ANEWARRAY) { super.visitInsn(Opcodes.DUP); super.visitTypeInsn(opcode, typeName); invokeRecordAllocation(typeName); } else { super.visitTypeInsn(opcode, typeName); } }
From source file:com.google.monitoring.runtime.instrumentation.adapters.AllocationMethodAdapter.java
License:Apache License
void calculateArrayLengthAndDispatch(final String typeName, final int dimCount) { // Since the dimensions of the array are not known at instrumentation // time, we take the created multi-dimensional array and peel off nesting // levels from the left. For each nesting layer we probe the array length // and accumulate a partial product which we can then feed the recording // function.//from w ww. j av a2 s . c o m // below we note the partial product of dimensions 1 to X-1 as productToX // (so productTo1 == 1 == no dimensions yet). We denote by aref0 the // array reference at the current nesting level (the containing aref's [0] // element). If we hit a level whose arraylength is 0 there's no point // continuing so we shortcut out. final Label zeroDimension = new Label(); super.visitInsn(Opcodes.DUP); // -> stack: ... origaref aref0 super.visitLdcInsn(1); // -> stack: ... origaref aref0 productTo1 for (int i = 0; i < dimCount; ++i) { // pre: stack: ... origaref aref0 productToI super.visitInsn(Opcodes.SWAP); // -> stack: ... origaref productToI aref super.visitInsn(Opcodes.DUP_X1); // -> stack: ... origaref aref0 productToI aref super.visitInsn(Opcodes.ARRAYLENGTH); // -> stack: ... origaref aref0 productToI dimI final Label nonZeroDimension = new Label(); super.visitInsn(Opcodes.DUP); // -> stack: ... origaref aref0 productToI dimI dimI super.visitJumpInsn(Opcodes.IFNE, nonZeroDimension); // -> stack: ... origaref aref0 productToI dimI super.visitInsn(Opcodes.POP); // -> stack: ... origaref aref0 productToI super.visitJumpInsn(Opcodes.GOTO, zeroDimension); super.visitLabel(nonZeroDimension); // -> stack: ... origaref aref0 productToI max(dimI,1) super.visitInsn(Opcodes.IMUL); // -> stack: ... origaref aref0 productTo{I+1} if (i < dimCount - 1) { super.visitInsn(Opcodes.SWAP); // -> stack: ... origaref productTo{I+1} aref0 super.visitInsn(Opcodes.ICONST_0); // -> stack: ... origaref productTo{I+1} aref0 0 super.visitInsn(Opcodes.AALOAD); // -> stack: ... origaref productTo{I+1} aref0' super.visitInsn(Opcodes.SWAP); } // post: stack: ... origaref aref0 productTo{I+1} } super.visitLabel(zeroDimension); super.visitInsn(Opcodes.SWAP); // -> stack: ... origaref product aref0 super.visitInsn(Opcodes.POP); // -> stack: ... origaref product super.visitInsn(Opcodes.SWAP); // -> stack: ... product origaref invokeRecordAllocation(typeName); }
From source file:com.google.monitoring.runtime.instrumentation.adapters.EscapeMethodAdapter.java
License:Apache License
/** * newarray shows up as an instruction taking an int operand (the primitive * element type of the array) so we hook it here. *///w w w .java 2 s.com @Override public void visitIntInsn(int opcode, int operand) { if (opcode == Opcodes.NEWARRAY) { // instack: ... count // outstack: ... aref if (operand >= 4 && operand <= 11) { invokeStart(); super.visitInsn(Opcodes.DUP); // -> stack: ... count count super.visitIntInsn(opcode, operand); // -> stack: ... count aref invokeRecordAllocation(primitiveTypeNames[operand]); // -> stack: ... aref } else { AllocationInstrumenter.logger.severe("NEWARRAY called with an invalid operand " + operand + ". Not instrumenting this allocation!"); super.visitIntInsn(opcode, operand); } } else { super.visitIntInsn(opcode, operand); } }