Package alt.jiapi.reflect

Examples of alt.jiapi.reflect.InstructionList

525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
        JiapiClass c = JiapiClass.createClass("HelloWorld");

        // No API to set SourceFile!

        JiapiMethod method = c.addMethod(Modifier.PUBLIC, "<init>", emptySig);
        InstructionList il = method.getInstructionList();
        InstructionFactory iFactory = il.getInstructionFactory();
        il.add(iFactory.aload(0));
        il.add(iFactory.invoke(0, "java/lang/Object", "<init>", emptySig));
        il.add(iFactory.returnMethod(method));

        method = c.addMethod(Modifier.PUBLIC | Modifier.STATIC, "main", mainSig);
        il = method.getInstructionList();
        iFactory = il.getInstructionFactory();
        il.add(iFactory.getField(Modifier.STATIC,
                "java/lang/System",
                "out",
                "Ljava/io/PrintStream;"));
        il.add(iFactory.pushConstant("Hello world!"));
        il.add(iFactory.invoke(0, "java/io/PrintStream", "println", printlnSig));
        il.add(iFactory.returnMethod(method));

        return c.getByteCode();
    }
View Full Code Here
104
105
106
107
108
109
110
111
112
113
114
                // Case: start==0, end==0
                // Should we continue here or not.
                end = start;
            }

            InstructionList view = il.createView(start, end);

            forward(view);

            start = boundary.getEnd() + 1; // Just after hotspot
        }
View Full Code Here
93
94
95
96
97
98
99
100
101
102
103
        List hotSpots = strategy.findHotSpots(il);

        Iterator iter = hotSpots.iterator();
        while (iter.hasNext()) {
            HotSpot hs = (HotSpot)iter.next();
            InstructionList view = il.createView(hs.getStart(), hs.getEnd());
//             System.out.println("Grep:" + hs.getStart() + "-" + hs.getEnd() +
//                                ":" + view);

            forward(view);
        }
View Full Code Here
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
        JiapiMethod method = clazz.addMethod(Modifier.PUBLIC, "helloWorld",
                                             signature);
       
        // Then create the method body. The body will make a call to
        // System.out.println and then just return.
        InstructionList il = method.getInstructionList();
        InstructionFactory iFactory = method.getInstructionFactory();

        JiapiMethod println = clazz.getDeclaredMethod("println", new String[]
                                                      {"java.lang.Object"});

//         il.add(iFactory.getField(loader.loadClass("java.lang.System").getField("out")));
//         JiapiMethod println = loader.loadClass(System.out.getClass().getName()).getMethod("println", new String[] { "java.lang.String" } );

        il.add(iFactory.pushConstant("hello world!"));

        il.add(iFactory.invoke(println));
        il.add(iFactory.returnMethod(method));

        // Finalize the modified class and dump it to the file:

        clazz.dump(new FileOutputStream("Test.class"));
    }
View Full Code Here
77
78
79
80
81
82
83
84
85
86
87
     */
    public void instrument(InstructionList il) {
        log.info("Instrumenting " + getCurrentClass().getName() + "." +
                 il.getDeclaringMethod().getName());

        InstructionList view;

        if (instructionCount > il.size()) {
            log.warn("List size exceeded: instructions needed : " +
                     instructionCount + ", available " + il.size() +
                     ". Using all that is available.");
View Full Code Here
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
    FieldEventInstrumentor(FieldEventProducer fep) {
        super(fep);
    }

    public void instrument(JiapiMethod jm) {
        InstructionList il = jm.getInstructionList();
        InstructionFactory factory = il.getInstructionFactory();
        JiapiClass fep = getEventProducer();
        JiapiMethod fieldGet = null;
        JiapiMethod fieldSet = null;
        JiapiField jiapiField = getEventProducerField();

        try {
            fieldGet =
                fep.getDeclaredMethod("fieldGet",
                                      new String[] { "java.lang.Object",
                                                     "java.lang.String" });
            fieldSet =
                fep.getDeclaredMethod("fieldSet",
                                      new String[] { "java.lang.Object",
                                                     "java.lang.String" });
        }
        catch(Exception e) {
            System.out.println("ERROR: " + e);
        }

        //System.out.println("Instrumenting " + il.getDeclaringMethod());

        int idx = -1;
        while ((idx = il.indexOf(OpcodeGroups.FIELD_ACCESS_INSTRUCTIONS, idx+1)) != -1) {
            FieldAccess ins = (FieldAccess)il.get(idx);
            // Do not instrument on __jiapi_fields
            if (ins.getName().startsWith("__jiapi_field")) {
                continue;
            }

            //System.out.println("  found " + ins);
            InstructionList invokeList = il.createEmptyList();

            switch(ins.getOpcode()) {
            case Opcodes.PUTFIELD:
            case Opcodes.GETFIELD:
                invokeList.add(factory.getField(jiapiField));
                invokeList.add(factory.pushThis());
                invokeList.add(factory.pushConstant(ins.getFieldName()));
                if (ins.getOpcode() == Opcodes.GETFIELD) {
                    invokeList.add(factory.invoke(fieldGet));
                }
                else {
                    invokeList.add(factory.invoke(fieldSet));
                }
                break;
            case Opcodes.PUTSTATIC:
            case Opcodes.GETSTATIC:
                invokeList.add(factory.getField(jiapiField));
                invokeList.add(factory.getField(jiapiField)); // BUG: Class
                invokeList.add(factory.pushConstant(ins.getFieldName()));
                if (ins.getOpcode() == Opcodes.GETSTATIC) {
                    invokeList.add(factory.invoke(fieldGet));
                }
                else {
                    invokeList.add(factory.invoke(fieldSet));
                }
                break;
            }

            // Insert list after field access operation
            il.insert(idx + 1, invokeList);

            // Next index. Skip Instructions created above.
            idx += invokeList.size();
        }
    }
View Full Code Here
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
    MethodEventInstrumentor(MethodEventProducer mep) {
        super(mep);
    }

    public void instrument(JiapiMethod jm) {
        InstructionList il = jm.getInstructionList();
        InstructionFactory factory = il.getInstructionFactory();
        JiapiClass mep = getEventProducer();
        JiapiMethod methodEntered = null;
        JiapiMethod methodExited = null;
        JiapiField jiapiField = getEventProducerField();

        // a flag, that tells whether or not InstructionList being
        // processed is in a static method.
        boolean isStatic = Modifier.isStatic(il.getDeclaringMethod().getModifiers());

        try {
            methodEntered =
                mep.getDeclaredMethod("methodEntered",
                                      new String[] { "java.lang.Object",
                                                     "java.lang.String" });
            methodExited =
                mep.getDeclaredMethod("methodExited",
                                      new String[] { "java.lang.Object",
                                                     "java.lang.String" });
        }
        catch(Exception e) {
            System.out.println("ERROR: " + e);
        }

        // Create instructions for method entrance
        InstructionList entryList = il.createEmptyList();
        entryList.add(factory.getField(jiapiField));
        if (isStatic) {
            entryList.add(factory.pushConstant(il.getDeclaringMethod().getDeclaringClass().getName())); // BUG: we should pass a Class
        }
        else {
            entryList.add(factory.pushThis());
        }
        entryList.add(factory.pushConstant(il.getDeclaringMethod().getName()));
        entryList.add(factory.invoke(methodEntered));

        // Skip super(....) call, if in <init> method
        int superIdx = il.indexOf(Opcodes.INVOKESPECIAL);

        // BUG: we should insert entrylist on <clinit> pass the
        //      __jiapi_field initialization
        if (!"<clinit>".equals(il.getDeclaringMethod().getName())) {
            // FIXME: See bug above
            il.insert(superIdx+1, entryList);
        }
        else {
            int idx = findFieldInitIndex(il, jiapiField);
            if (idx != -1) {
                il.insert(idx + 1, entryList);
            }
        }

        // Create instructions for method exits
        InstructionList exitList = il.createEmptyList();
        exitList.add(factory.getField(jiapiField));
        if (isStatic) {
            exitList.add(factory.pushConstant(il.getDeclaringMethod().getDeclaringClass().getName())); // BUG: we should pass a Class
        }
        else {
            exitList.add(factory.pushThis());
        }

        exitList.add(factory.pushConstant(il.getDeclaringMethod().getName()));
        exitList.add(factory.invoke(methodExited));

        // Find all method exits
        int idx = il.indexOf(OpcodeGroups.RETURN_INSTRUCTIONS, 0);
        while (idx != -1) {
            Instruction ins = il.get(idx);
            il.insert(idx, exitList);

            // Next index. Skip Instructions created above.
            idx = il.indexOf(OpcodeGroups.RETURN_INSTRUCTIONS,
                             idx + exitList.size() + 1);
        }
    }
View Full Code Here
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
            catch(MethodExistsException mee) {
                mee.printStackTrace();
            }
        }

        InstructionList il = clinit.getInstructionList();
        InstructionFactory factory = il.getInstructionFactory();
        InstructionList initializer = il.createEmptyList();

        try {
            JiapiClass er = currentClass.getLoader().loadClass("alt.jiapi.event.EventRuntime");
            JiapiMethod gfv =
                er.getDeclaredMethod("getFieldValue",
                                     new String[] {"java.lang.String"});

            // Get the field value from runtime
            initializer.add(factory.pushConstant(fieldName));
            initializer.add(factory.invoke(gfv));


            // put the returned event producer to __jiapi_field
            initializer.add(factory.cast(ep.getClass().getName()));
            initializer.add(factory.setField(eventProducerField));
        }
        catch(NoSuchMethodException nsme) {
            nsme.printStackTrace();
        }
        catch(ClassNotFoundException cnfe) {
View Full Code Here
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
                int idx = il.indexOf(inv);

                // Following assumes, that trigger call is
                // void-void method.
                // First, we remove a call to Advice class...
                InstructionList view = il.createView(idx-1, idx + 1);
    view.clear();

                // ...then we replace, that call with trigger action
                // instructions.
                if ("getHotSpotName".equals(inv.getMethodName())) {
                    view.add(factory.pushConstant(hs.getName()));
                }
                else if ("getArguments".equals(inv.getMethodName())) {
                    // NOT IMPLEMENTED
                    // This needs some further thinking before implementing
                }
                else if ("getInstrumentedObject".equals(inv.getMethodName())) {
        JiapiMethod jm = il.getDeclaringMethod();
        int modifiers = jm.getModifiers();
        if (Modifier.isStatic(modifiers)) {
      // Static methods do not have reference to 'this'
      //view.add(factory.pushNull());
      view.add(factory.pushConstant(jm.getDeclaringClass().getName()));
      view.add(factory.invoke(Modifier.STATIC, "java.lang.Class", "forName", new Signature("java.lang.Class", new String[] {"java.lang.String"})));
        }
        else {
      view.add(factory.aload(0));
        }
                    // NOT IMPLEMENTED
                    // This needs some further thinking before implementing
                }
            }
View Full Code Here
225
226
227
228
229
230
231
232
233
234
235
                il.add(factory.pushConstant(targetName));
            }
            else if (hookParams[i].equals(Object.class)) {
                // ---  target Object  ---
                InstructionList targetCode = instrumentation.getTargetCode();
                if (targetCode != null) {
                    log.debug("Got target code: " + targetCode);
                    il.add(targetCode);
                }
                else {
View Full Code Here
TOP

Related Classes of alt.jiapi.reflect.InstructionList

  • alt.jiapi.event.EventInstrumentor
  • alt.jiapi.event.FieldEventInstrumentor
  • alt.jiapi.event.MethodEventInstrumentor
  • alt.jiapi.file.ConstantPool
  • alt.jiapi.instrumentor.CatchInstrumentor
  • alt.jiapi.instrumentor.GrepInstrumentor
  • alt.jiapi.instrumentor.HeadInstrumentor
  • alt.jiapi.instrumentor.MethodCallInstrumentor
  • alt.jiapi.instrumentor.MethodDispatcherInstrumentor
  • alt.jiapi.instrumentor.SplitInstrumentor
    • Copyright © 2018 www.massapicom. All rights reserved.
    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.