Examples of com.google.dexmaker.Code

com.google.dexmaker.Code
Builds a sequence of instructions.
Locals
All data manipulation takes place in local variables. Each parameter gets its own local by default; access these using {@link #getParameter getParameter()}. Non-static methods and constructors also have a {@code this}parameter; it's available as {@link #getThis getThis()}. Allocate a new local variable using {@link #newLocal newLocal()}, and assign a default value to it with {@link #loadConstant loadConstant()}. Copy a value from one local to another with {@link #move move()}.
Every local variable has a fixed type. This is either a primitive type (of any size) or a reference type. This class emits instructions appropriate to the types they operate on. Not all operations are local on all types; attempting to emit such an operation will fail with an unchecked exception.
Math and Bit Operations
Transform a single value into another related value using {@link #op(UnaryOp,Local,Local) op(UnaryOp, Local, Local)}. Transform two values into a third value using {@link #op(BinaryOp,Local,Local,Local) op(BinaryOp,Local, Local, Local)}. In either overload the first {@code Local} parameteris where the result will be sent; the other {@code Local} parameters are theinputs.
Comparisons
There are three different comparison operations each with different constraints:
- {@link #compareLongs compareLongs()} compares two locals eachcontaining a {@code long} primitive. This is the only operation thatcan compare longs. The result of the comparison is written to another {@code int} local.
- {@link #compareFloatingPoint compareFloatingPoint()} compares twolocals; both {@code float} primitives or both {@code double}primitives. This is the only operation that can compare floating point values. This comparison takes an extra parameter that sets the desired result if either parameter is {@code NaN}. The result of the comparison is wrtten to another {@code int} local.
- {@link #compare compare()} compares two locals. The {@link Comparison#EQ} and {@link Comparison#NE} options compare either{@code int} primitives or references. The other options compare only{@code int} primitives. This comparison takes a {@link Label} thatwill be jumped to if the comparison is true. If the comparison is false the next instruction in sequence will be executed.
There's no single operation to compare longs and jump, or to compare ints and store the result in a local. Accomplish these goals by chaining multiple operations together.
Branches, Labels and Returns
Basic control flow is expressed using jumps and labels. Each label must be marked exactly once and may be jumped to any number of times. Create a label using its constructor: {@code new Label()}, and mark it using {@link #mark mark(Label)}. All jumps to a label will execute instructions starting from that label. You can jump to a label that hasn't yet been marked (jumping forward) or to a label that has already been marked (jumping backward). Jump unconditionally with {@link #jump jump(Label)} or conditionally based on acomparison using {@link #compare compare()}.
Most methods should contain a return instruction. Void methods should use {@link #returnVoid()}; non-void methods should use {@link #returnValue returnValue()} with a local whose return type matches themethod's return type. Constructors are considered void methods and should call {@link #returnVoid()}. Methods may make multiple returns. Methods containing no return statements must either loop infinitely or throw unconditionally; it is not legal to end a sequence of instructions without a jump, return or throw.
Throwing and Catching
This API uses labels to handle thrown exceptions, errors and throwables. Call {@link #addCatchClause addCatchClause()} to register the target label andthrowable class. All statements that follow will jump to that catch clause if they throw a {@link Throwable} assignable to that type. Use {@link #removeCatchClause removeCatchClause()} to unregister the throwable class.
Throw an throwable by first assigning it to a local and then calling {@link #throwValue throwValue()}. Control flow will jump to the nearest label assigned to a type assignable to the thrown type. In this context, "nearest" means the label requiring the fewest stack frames to be popped.
Calling methods
A method's caller must know its return type, name, parameters, and invoke kind. Lookup a method on a type using {@link TypeId#getMethod TypeId.getMethod()}. This is more onerous than Java language invokes, which can infer the target method using the target object and parameters. There are four invoke kinds:
- {@link #invokeStatic invokeStatic()} is used for static methods.
- {@link #invokeDirect invokeDirect()} is used for private instancemethods and for constructors to call their superclass's constructor.
- {@link #invokeInterface invokeInterface()} is used to invoke a methodwhose declaring type is an interface.
- {@link #invokeVirtual invokeVirtual()} is used to invoke any othermethod. The target must not be static, private, a constructor, or an interface method.
- {@link #invokeSuper invokeSuper()} is used to invoke the closestsuperclass's virtual method. The target must not be static, private, a constructor method, or an interface method.
- {@link #newInstance newInstance()} is used to invoke aconstructor.
All invoke methods take a local for the return value. For void methods this local is unused and may be null.
Field Access
Read static fields using {@link #sget sget()}; write them using {@link #sput sput()}. For instance values you'll need to specify the declaring instance; use {@link #getThis getThis()} in an instance method to use {@code this}. Read instance values using {@link #iget iget()} and write them with{@link #iput iput()}.
Array Access
Allocate an array using {@link #newArray newArray()}. Read an array's length with {@link #arrayLength arrayLength()} and its elements with {@link #aget aget()}. Write an array's elements with {@link #aput aput()}.
Types
Use {@link #cast cast()} to perform either a numeric cast ora type cast. Interrogate the type of a value in a local using {@link #instanceOfType instanceOfType()}.
Synchronization
Acquire a monitor using {@link #monitorEnter monitorEnter()}; release it with {@link #monitorExit monitorExit()}. It is the caller's responsibility to guarantee that enter and exit calls are balanced, even in the presence of exceptions thrown. Warning: Even if a method has the {@code synchronized} flag,dex requires instructions to acquire and release monitors manually. A method declared with {@link java.lang.reflect.Modifier#SYNCHRONIZED SYNCHRONIZED}but without manual calls to {@code monitorEnter()} and {@code monitorExit()}will not be synchronized when executed.

            }
            Class<?> returnType = method.getReturnType();
            TypeId<?> resultType = TypeId.get(returnType);
            MethodId<T, ?> superMethod = superclassType.getMethod(resultType, name, argTypes);
            MethodId<?, ?> methodId = generatedType.getMethod(resultType, name, argTypes);
            Code code = dexMaker.declare(methodId, PUBLIC);
            Local<G> localThis = code.getThis(generatedType);
            Local<InvocationHandler> localHandler = code.newLocal(handlerType);
            Local<Object> invokeResult = code.newLocal(TypeId.OBJECT);
            Local<Integer> intValue = code.newLocal(TypeId.INT);
            Local<Object[]> args = code.newLocal(objectArrayType);
            Local<Integer> argsLength = code.newLocal(TypeId.INT);
            Local<Object> temp = code.newLocal(TypeId.OBJECT);
            Local<?> resultHolder = code.newLocal(resultType);
            Local<Method[]> methodArray = code.newLocal(methodArrayType);
            Local<Method> thisMethod = code.newLocal(methodType);
            Local<Integer> methodIndex = code.newLocal(TypeId.INT);
            Class<?> aBoxedClass = PRIMITIVE_TO_BOXED.get(returnType);
            Local<?> aBoxedResult = null;
            if (aBoxedClass != null) {
                aBoxedResult = code.newLocal(TypeId.get(aBoxedClass));
            }
            Local<?>[] superArgs2 = new Local<?>[argClasses.length];
            Local<?> superResult2 = code.newLocal(resultType);
            Local<InvocationHandler> nullHandler = code.newLocal(handlerType);


            code.loadConstant(methodIndex, m);
            code.sget(allMethods, methodArray);
            code.aget(thisMethod, methodArray, methodIndex);
            code.loadConstant(argsLength, argTypes.length);
            code.newArray(args, argsLength);
            code.iget(handlerField, localHandler, localThis);


            // if (proxy == null)
            code.loadConstant(nullHandler, null);
            Label handlerNullCase = new Label();
            code.compare(Comparison.EQ, handlerNullCase, nullHandler, localHandler);


            // This code is what we execute when we have a valid proxy: delegate to invocation
            // handler.
            for (int p = 0; p < argTypes.length; ++p) {
                code.loadConstant(intValue, p);
                Local<?> parameter = code.getParameter(p, argTypes[p]);
                Local<?> unboxedIfNecessary = boxIfRequired(code, parameter, temp);
                code.aput(args, intValue, unboxedIfNecessary);
            }
            code.invokeInterface(methodInvoke, invokeResult, localHandler,
                    localThis, thisMethod, args);
            generateCodeForReturnStatement(code, returnType, invokeResult, resultHolder,
                    aBoxedResult);


            // This code is executed if proxy is null: call the original super method.
            // This is required to handle the case of construction of an object which leaks the
            // "this" pointer.
            code.mark(handlerNullCase);
            for (int i = 0; i < superArgs2.length; ++i) {
                superArgs2[i] = code.getParameter(i, argTypes[i]);
            }
            if (void.class.equals(returnType)) {
                code.invokeSuper(superMethod, null, localThis, superArgs2);
                code.returnVoid();
            } else {
                invokeSuper(superMethod, code, localThis, superArgs2, superResult2);
                code.returnValue(superResult2);
            }


            /*
             * And to allow calling the original super method, the following is also generated:
             *
             *     public String super$doSomething$java_lang_String(Bar param0, int param1) {
             *          int result = super.doSomething(param0, param1);
             *          return result;
             *     }
             */
            // TODO: don't include a super_ method if the target is abstract!
            MethodId<G, ?> callsSuperMethod = generatedType.getMethod(
                    resultType, superMethodName(method), argTypes);
            Code superCode = dexMaker.declare(callsSuperMethod, PUBLIC);
            Local<G> superThis = superCode.getThis(generatedType);
            Local<?>[] superArgs = new Local<?>[argClasses.length];
            for (int i = 0; i < superArgs.length; ++i) {
                superArgs[i] = superCode.getParameter(i, argTypes[i]);
            }
            if (void.class.equals(returnType)) {
                superCode.invokeSuper(superMethod, null, superThis, superArgs);
                superCode.returnVoid();
            } else {
                Local<?> superResult = superCode.newLocal(resultType);
                invokeSuper(superMethod, superCode, superThis, superArgs, superResult);
                superCode.returnValue(superResult);
            }
        }
    }

View Full Code Here

            if (constructor.getModifiers() == Modifier.FINAL) {
                continue;
            }
            TypeId<?>[] types = classArrayToTypeArray(constructor.getParameterTypes());
            MethodId<?, ?> method = generatedType.getConstructor(types);
            Code constructorCode = dexMaker.declare(method, PUBLIC);
            Local<G> thisRef = constructorCode.getThis(generatedType);
            Local<?>[] params = new Local[types.length];
            for (int i = 0; i < params.length; ++i) {
                params[i] = constructorCode.getParameter(i, types[i]);
            }
            MethodId<T, ?> superConstructor = superType.getConstructor(types);
            constructorCode.invokeDirect(superConstructor, null, thisRef, params);
            constructorCode.returnVoid();
        }
    }

View Full Code Here

        // Identify the 'hello()' method on declaringType.
        MethodId hello = declaringType.getMethod(TypeId.VOID, "hello");


        // Declare that method on the dexMaker. Use the returned Code instance
        // as a builder that we can append instructions to.
        Code code = dexMaker.declare(hello, Modifier.STATIC | Modifier.PUBLIC);


        // Declare all the locals we'll need up front. The API requires this.
        Local<Integer> a = code.newLocal(TypeId.INT);
        Local<Integer> b = code.newLocal(TypeId.INT);
        Local<Integer> c = code.newLocal(TypeId.INT);
        Local<String> s = code.newLocal(TypeId.STRING);
        Local<PrintStream> localSystemOut = code.newLocal(printStreamType);


        // int a = 0xabcd;
        code.loadConstant(a, 0xabcd);


        // int b = 0xaaaa;
        code.loadConstant(b, 0xaaaa);


        // int c = a - b;
        code.op(BinaryOp.SUBTRACT, c, a, b);


        // String s = Integer.toHexString(c);
        MethodId<Integer, String> toHexString
                = TypeId.get(Integer.class).getMethod(TypeId.STRING, "toHexString", TypeId.INT);
        code.invokeStatic(toHexString, s, c);


        // System.out.println(s);
        FieldId<System, PrintStream> systemOutField = systemType.getField(printStreamType, "out");
        code.sget(systemOutField, localSystemOut);
        MethodId<PrintStream, Void> printlnMethod = printStreamType.getMethod(
                TypeId.VOID, "println", TypeId.STRING);
        code.invokeVirtual(printlnMethod, null, localSystemOut, s);


        // return;
        code.returnVoid();
    }

View Full Code Here

        String fileName = "Fibonacci.generated";
        DexMaker dexMaker = new DexMaker();
        dexMaker.declare(fibonacci, fileName, Modifier.PUBLIC, TypeId.OBJECT);


        MethodId<?, Integer> fib = fibonacci.getMethod(TypeId.INT, "fib", TypeId.INT);
        Code code = dexMaker.declare(fib, Modifier.PUBLIC | Modifier.STATIC);


        Local<Integer> i = code.getParameter(0, TypeId.INT);
        Local<Integer> constant1 = code.newLocal(TypeId.INT);
        Local<Integer> constant2 = code.newLocal(TypeId.INT);
        Local<Integer> a = code.newLocal(TypeId.INT);
        Local<Integer> b = code.newLocal(TypeId.INT);
        Local<Integer> c = code.newLocal(TypeId.INT);
        Local<Integer> d = code.newLocal(TypeId.INT);
        Local<Integer> result = code.newLocal(TypeId.INT);


        code.loadConstant(constant1, 1);
        code.loadConstant(constant2, 2);
        Label baseCase = new Label();
        code.compare(Comparison.LT, baseCase, i, constant2);
        code.op(BinaryOp.SUBTRACT, a, i, constant1);
        code.op(BinaryOp.SUBTRACT, b, i, constant2);
        code.invokeStatic(fib, c, a);
        code.invokeStatic(fib, d, b);
        code.op(BinaryOp.ADD, result, c, d);
        code.returnValue(result);
        code.mark(baseCase);
        code.returnValue(i);


        ClassLoader loader = dexMaker.generateAndLoad(
                FibonacciMaker.class.getClassLoader(), getDataDirectory());


        Class<?> fibonacciClass = loader.loadClass("com.google.dexmaker.examples.Fibonacci");

View Full Code Here

TOP

Related Classes of com.google.dexmaker.Code

com.android.dx.rop.code.BasicBlockList

com.android.dx.rop.code.PlainCstInsn

com.android.dx.rop.code.PlainInsn

com.android.dx.rop.code.RegisterSpecList

com.android.dx.rop.code.Rop

com.android.dx.rop.code.ThrowingCstInsn

com.android.dx.rop.code.ThrowingInsn

com.android.dx.rop.cst.CstInteger

com.android.dx.rop.type.StdTypeList

com.google.dexmaker.examples.FibonacciMaker

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of com.google.dexmaker.Code

Locals

Math and Bit Operations

Comparisons

Branches, Labels and Returns

Throwing and Catching

Calling methods

Field Access

Array Access

Types

Synchronization

Related Classes of com.google.dexmaker.Code