Mercurial > hg > Members > kono > jpf-core

comparison src/main/gov/nasa/jpf/jvm/JVMCodeBuilder.java @ 0:61d41facf527

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial v8 import (history reset)
author Peter Mehlitz <Peter.C.Mehlitz@nasa.gov>
date Fri, 23 Jan 2015 10:14:01 -0800
parents
children 6774e2e08d37
comparison
equal deleted inserted replaced
-1:000000000000 0:61d41facf527
1 /*
2 * Copyright (C) 2014, United States Government, as represented by the
3 * Administrator of the National Aeronautics and Space Administration.
4 * All rights reserved.
5 *
6 * The Java Pathfinder core (jpf-core) platform is licensed under the
7 * Apache License, Version 2.0 (the "License"); you may not use this file except
8 * in compliance with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0.
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19 package gov.nasa.jpf.jvm;
20
21 import gov.nasa.jpf.JPFException;
22 import gov.nasa.jpf.util.Invocation;
23 import gov.nasa.jpf.vm.ClassInfo;
24 import gov.nasa.jpf.vm.Instruction;
25 import gov.nasa.jpf.vm.bytecode.LookupSwitchInstruction;
26 import gov.nasa.jpf.vm.MethodInfo;
27 import gov.nasa.jpf.vm.NativeMethodInfo;
28 import gov.nasa.jpf.vm.bytecode.TableSwitchInstruction;
29
30 import java.util.ArrayList;
31 import java.util.List;
32
33 /**
34 * a special JVMByteCodeReader implementation that builds code arrays for
35 * MethodInfos, setting index and pc on the fly
36 */
37 public class JVMCodeBuilder implements JVMByteCodeReader {
38
39 protected JVMInstructionFactory insnFactory;
40
41 protected ClassFile cf;
42 protected MethodInfo mi;
43
44 // have to cache these to set switch entries
45 // <2do> these should use interface types to avoid hardwiring our own instruction classes
46 protected TableSwitchInstruction tableswitchInsn;
47 protected LookupSwitchInstruction lookupswitchInsn;
48
49 protected ArrayList<Instruction> code;
50
51 protected int pc; // bytecode position within method code
52 protected int idx; // instruction index within MethodInfo
53
54 // flag to remember wide immediate operand modification
55 boolean isWide;
56
57 //--- for testing purposes
58 protected JVMCodeBuilder (JVMInstructionFactory ifact){
59 this.code = new ArrayList<Instruction>(64);
60 this.insnFactory = ifact;
61 }
62
63
64
65 // this is dangerous - it enables reuse of CodeBuilders, but
66 // you better make sure this does not get recursive or is used concurrently
67 public void reset (ClassFile classFile, MethodInfo targetMethod){
68 this.cf = classFile;
69 this.mi = targetMethod;
70
71 pc = 0;
72 idx = 0;
73 isWide = false;
74
75 tableswitchInsn = null;
76 lookupswitchInsn = null;
77
78 code.clear();
79 }
80
81 protected void add(Instruction insn){
82 insn.setMethodInfo(mi);
83 insn.setLocation(idx++, pc);
84 code.add(insn);
85 }
86
87 public void installCode(){
88 Instruction[] a = code.toArray( new Instruction[code.size()]);
89 mi.setCode(a);
90 }
91
92 //--- the factory methods
93
94 @Override public void aconst_null() {
95 add( insnFactory.aconst_null());
96 pc++;
97 }
98
99 @Override public void aload(int localVarIndex) {
100 add( insnFactory.aload(localVarIndex));
101 pc+=2;
102 if (isWide){
103 pc++;
104 isWide = false;
105 }
106 }
107
108 @Override public void aload_0() {
109 add( insnFactory.aload(0));
110 pc++;
111 }
112
113 @Override public void aload_1() {
114 add( insnFactory.aload(1));
115 pc++;
116 }
117
118 @Override public void aload_2() {
119 add( insnFactory.aload(2));
120 pc++;
121 }
122
123 @Override public void aload_3() {
124 add( insnFactory.aload(3));
125 pc++;
126 }
127
128 @Override public void aaload() {
129 add( insnFactory.aaload());
130 pc++;
131 }
132
133 @Override public void astore(int localVarIndex) {
134 add( insnFactory.astore(localVarIndex));
135 pc+=2;
136 if (isWide){
137 pc++;
138 isWide = false;
139 }
140 }
141
142 @Override public void astore_0() {
143 add( insnFactory.astore(0));
144 pc++;
145 }
146
147 @Override public void astore_1() {
148 add( insnFactory.astore(1));
149 pc++;
150 }
151
152 @Override public void astore_2() {
153 add( insnFactory.astore(2));
154 pc++;
155 }
156
157 @Override public void astore_3() {
158 add( insnFactory.astore(3));
159 pc++;
160 }
161
162 @Override public void aastore() {
163 add( insnFactory.aastore());
164 pc++;
165 }
166
167 @Override public void areturn() {
168 add( insnFactory.areturn());
169 pc++;
170 }
171
172 @Override public void anewarray(int cpClassIndex) {
173 String clsName = cf.classNameAt(cpClassIndex);
174 add( insnFactory.anewarray(clsName));
175 pc+=3;
176 }
177
178 @Override public void arraylength() {
179 add( insnFactory.arraylength());
180 pc++;
181 }
182
183 @Override public void athrow() {
184 add( insnFactory.athrow());
185 pc++;
186 }
187
188 @Override public void baload() {
189 add( insnFactory.baload());
190 pc++;
191 }
192
193 @Override public void bastore() {
194 add( insnFactory.bastore());
195 pc++;
196 }
197
198 @Override public void bipush(int b) {
199 add( insnFactory.bipush(b));
200 pc+=2;
201 }
202
203 @Override public void caload() {
204 add( insnFactory.caload());
205 pc++;
206 }
207
208 @Override public void castore() {
209 add( insnFactory.castore());
210 pc++;
211 }
212
213 @Override public void checkcast(int cpClassIndex) {
214 String clsName = cf.classNameAt(cpClassIndex);
215 add( insnFactory.checkcast(clsName));
216 pc+=3;
217 }
218
219 @Override public void d2f() {
220 add( insnFactory.d2f());
221 pc++;
222 }
223
224 @Override public void d2i() {
225 add( insnFactory.d2i());
226 pc++;
227 }
228
229 @Override public void d2l() {
230 add( insnFactory.d2l());
231 pc++;
232 }
233
234 @Override public void dadd() {
235 add( insnFactory.dadd());
236 pc++;
237 }
238
239 @Override public void daload() {
240 add( insnFactory.daload());
241 pc++;
242 }
243
244 @Override public void dastore() {
245 add( insnFactory.dastore());
246 pc++;
247 }
248
249 @Override public void dcmpg() {
250 add( insnFactory.dcmpg());
251 pc++;
252 }
253
254 @Override public void dcmpl() {
255 add( insnFactory.dcmpl());
256 pc++;
257 }
258
259 @Override public void dconst_0() {
260 add( insnFactory.dconst_0());
261 pc++;
262 }
263
264 @Override public void dconst_1() {
265 add( insnFactory.dconst_1());
266 pc++;
267 }
268
269 @Override public void ddiv() {
270 add( insnFactory.ddiv());
271 pc++;
272 }
273
274 @Override public void dload(int localVarIndex) {
275 add( insnFactory.dload(localVarIndex));
276 pc+=2;
277 if (isWide){
278 pc++;
279 isWide = false;
280 }
281 }
282
283 @Override public void dload_0() {
284 add( insnFactory.dload(0));
285 pc++;
286 }
287
288 @Override public void dload_1() {
289 add( insnFactory.dload(1));
290 pc++;
291 }
292
293 @Override public void dload_2() {
294 add( insnFactory.dload(2));
295 pc++;
296 }
297
298 @Override public void dload_3() {
299 add( insnFactory.dload(3));
300 pc++;
301 }
302
303 @Override public void dmul() {
304 add( insnFactory.dmul());
305 pc++;
306 }
307
308 @Override public void dneg() {
309 add( insnFactory.dneg());
310 pc++;
311 }
312
313 @Override public void drem() {
314 add( insnFactory.drem());
315 pc++;
316 }
317
318 @Override public void dreturn() {
319 add( insnFactory.dreturn());
320 pc++;
321 }
322
323 @Override public void dstore(int localVarIndex) {
324 add( insnFactory.dstore(localVarIndex));
325 pc+=2;
326 if (isWide){
327 pc++;
328 isWide = false;
329 }
330 }
331
332 @Override public void dstore_0() {
333 add( insnFactory.dstore(0));
334 pc++;
335 }
336
337 @Override public void dstore_1() {
338 add( insnFactory.dstore(1));
339 pc++;
340 }
341
342 @Override public void dstore_2() {
343 add( insnFactory.dstore(2));
344 pc++;
345 }
346
347 @Override public void dstore_3() {
348 add( insnFactory.dstore(3));
349 pc++;
350 }
351
352 @Override public void dsub() {
353 add( insnFactory.dsub());
354 pc++;
355 }
356
357 @Override public void dup() {
358 add( insnFactory.dup());
359 pc++;
360 }
361
362 @Override public void dup_x1() {
363 add( insnFactory.dup_x1());
364 pc++;
365 }
366
367 @Override public void dup_x2() {
368 add( insnFactory.dup_x2());
369 pc++;
370 }
371
372 @Override public void dup2() {
373 add( insnFactory.dup2());
374 pc++;
375 }
376
377 @Override public void dup2_x1() {
378 add( insnFactory.dup2_x1());
379 pc++;
380 }
381
382 @Override public void dup2_x2() {
383 add( insnFactory.dup2_x2());
384 pc++;
385 }
386
387 @Override public void f2d() {
388 add( insnFactory.f2d());
389 pc++;
390 }
391
392 @Override public void f2i() {
393 add( insnFactory.f2i());
394 pc++;
395 }
396
397 @Override public void f2l() {
398 add( insnFactory.f2l());
399 pc++;
400 }
401
402 @Override public void fadd() {
403 add( insnFactory.fadd());
404 pc++;
405 }
406
407 @Override public void faload() {
408 add( insnFactory.faload());
409 pc++;
410 }
411
412 @Override public void fastore() {
413 add( insnFactory.fastore());
414 pc++;
415 }
416
417 @Override public void fcmpg() {
418 add( insnFactory.fcmpg());
419 pc++;
420 }
421
422 @Override public void fcmpl() {
423 add( insnFactory.fcmpl());
424 pc++;
425 }
426
427 @Override public void fconst_0() {
428 add( insnFactory.fconst_0());
429 pc++;
430 }
431
432 @Override public void fconst_1() {
433 add( insnFactory.fconst_1());
434 pc++;
435 }
436
437 @Override public void fconst_2() {
438 add( insnFactory.fconst_2());
439 pc++;
440 }
441
442 @Override public void fdiv() {
443 add( insnFactory.fdiv());
444 pc++;
445 }
446
447 @Override public void fload(int localVarIndex) {
448 add( insnFactory.fload(localVarIndex));
449 pc+=2;
450 if (isWide){
451 pc++;
452 isWide = false;
453 }
454 }
455
456 @Override public void fload_0() {
457 add( insnFactory.fload(0));
458 pc++;
459 }
460
461 @Override public void fload_1() {
462 add( insnFactory.fload(1));
463 pc++;
464 }
465
466 @Override public void fload_2() {
467 add( insnFactory.fload(2));
468 pc++;
469 }
470
471 @Override public void fload_3() {
472 add( insnFactory.fload(3));
473 pc++;
474 }
475
476 @Override public void fmul() {
477 add( insnFactory.fmul());
478 pc++;
479 }
480
481 @Override public void fneg() {
482 add( insnFactory.fneg());
483 pc++;
484 }
485
486 @Override public void frem() {
487 add( insnFactory.frem());
488 pc++;
489 }
490
491 @Override public void freturn() {
492 add( insnFactory.freturn());
493 pc++;
494 }
495
496 @Override public void fstore(int localVarIndex) {
497 add( insnFactory.fstore(localVarIndex));
498 pc+=2;
499 if (isWide){
500 pc++;
501 isWide = false;
502 }
503 }
504
505 @Override public void fstore_0() {
506 add( insnFactory.fstore(0));
507 pc++;
508 }
509
510 @Override public void fstore_1() {
511 add( insnFactory.fstore(1));
512 pc++;
513 }
514
515 @Override public void fstore_2() {
516 add( insnFactory.fstore(2));
517 pc++;
518 }
519
520 @Override public void fstore_3() {
521 add( insnFactory.fstore(3));
522 pc++;
523 }
524
525 @Override public void fsub() {
526 add( insnFactory.fsub());
527 pc++;
528 }
529
530 @Override public void getfield(int cpFieldRefIndex) {
531 String fieldName = cf.fieldNameAt(cpFieldRefIndex);
532 String clsName = cf.fieldClassNameAt(cpFieldRefIndex);
533 String fieldDescriptor = cf.fieldDescriptorAt(cpFieldRefIndex);
534
535 add( insnFactory.getfield(fieldName, clsName, fieldDescriptor));
536 pc+=3;
537 }
538 public void getfield(String fieldName, String clsName, String fieldDescriptor){
539 add( insnFactory.getfield(fieldName, clsName, fieldDescriptor));
540 pc+=3;
541 }
542
543 @Override public void getstatic(int cpFieldRefIndex) {
544 String fieldName = cf.fieldNameAt(cpFieldRefIndex);
545 String clsName = cf.fieldClassNameAt(cpFieldRefIndex);
546 String fieldDescriptor = cf.fieldDescriptorAt(cpFieldRefIndex);
547
548 add( insnFactory.getstatic(fieldName, clsName, fieldDescriptor));
549 pc+=3;
550 }
551 public void getstatic(String fieldName, String clsName, String fieldDescriptor){
552 add( insnFactory.getstatic(fieldName, clsName, fieldDescriptor));
553 pc+=3;
554 }
555
556 @Override public void goto_(int pcOffset) {
557 add( insnFactory.goto_(pc + pcOffset));
558 pc+=3;
559 }
560
561 @Override public void goto_w(int pcOffset) {
562 add( insnFactory.goto_w(pc + pcOffset));
563 pc+=5;
564 }
565
566 @Override public void i2b() {
567 add( insnFactory.i2b());
568 pc++;
569 }
570
571 @Override public void i2c() {
572 add( insnFactory.i2c());
573 pc++;
574 }
575
576 @Override public void i2d() {
577 add( insnFactory.i2d());
578 pc++;
579 }
580
581 @Override public void i2f() {
582 add( insnFactory.i2f());
583 pc++;
584 }
585
586 @Override public void i2l() {
587 add( insnFactory.i2l());
588 pc++;
589 }
590
591 @Override public void i2s() {
592 add( insnFactory.i2s());
593 pc++;
594 }
595
596 @Override public void iadd() {
597 add( insnFactory.iadd());
598 pc++;
599 }
600
601 @Override public void iaload() {
602 add( insnFactory.iaload());
603 pc++;
604 }
605
606 @Override public void iand() {
607 add( insnFactory.iand());
608 pc++;
609 }
610
611 @Override public void iastore() {
612 add( insnFactory.iastore());
613 pc++;
614 }
615
616 @Override public void iconst_m1() {
617 add( insnFactory.iconst_m1());
618 pc++;
619 }
620
621 @Override public void iconst_0() {
622 add( insnFactory.iconst_0());
623 pc++;
624 }
625
626 @Override public void iconst_1() {
627 add( insnFactory.iconst_1());
628 pc++;
629 }
630
631 @Override public void iconst_2() {
632 add( insnFactory.iconst_2());
633 pc++;
634 }
635
636 @Override public void iconst_3() {
637 add( insnFactory.iconst_3());
638 pc++;
639 }
640
641 @Override public void iconst_4() {
642 add( insnFactory.iconst_4());
643 pc++;
644 }
645
646 @Override public void iconst_5() {
647 add( insnFactory.iconst_5());
648 pc++;
649 }
650
651 @Override public void idiv() {
652 add( insnFactory.idiv());
653 pc++;
654 }
655
656 @Override public void if_acmpeq(int pcOffset) {
657 add( insnFactory.if_acmpeq(pc + pcOffset));
658 pc+=3;
659 }
660
661 @Override public void if_acmpne(int pcOffset) {
662 add( insnFactory.if_acmpne(pc + pcOffset));
663 pc+=3;
664 }
665
666 @Override public void if_icmpeq(int pcOffset) {
667 add( insnFactory.if_icmpeq(pc + pcOffset));
668 pc+=3;
669 }
670
671 @Override public void if_icmpne(int pcOffset) {
672 add( insnFactory.if_icmpne(pc + pcOffset));
673 pc+=3;
674 }
675
676 @Override public void if_icmplt(int pcOffset) {
677 add( insnFactory.if_icmplt(pc + pcOffset));
678 pc+=3;
679 }
680
681 @Override public void if_icmpge(int pcOffset) {
682 add( insnFactory.if_icmpge(pc + pcOffset));
683 pc+=3;
684 }
685
686 @Override public void if_icmpgt(int pcOffset) {
687 add( insnFactory.if_icmpgt(pc + pcOffset));
688 pc+=3;
689 }
690
691 @Override public void if_icmple(int pcOffset) {
692 add( insnFactory.if_icmple(pc + pcOffset));
693 pc+=3;
694 }
695
696 @Override public void ifeq(int pcOffset) {
697 add( insnFactory.ifeq(pc + pcOffset));
698 pc+=3;
699 }
700
701 @Override public void ifne(int pcOffset) {
702 add( insnFactory.ifne(pc + pcOffset));
703 pc+=3;
704 }
705
706 @Override public void iflt(int pcOffset) {
707 add( insnFactory.iflt(pc + pcOffset));
708 pc+=3;
709 }
710
711 @Override public void ifge(int pcOffset) {
712 add( insnFactory.ifge(pc + pcOffset));
713 pc+=3;
714 }
715
716 @Override public void ifgt(int pcOffset) {
717 add( insnFactory.ifgt(pc + pcOffset));
718 pc+=3;
719 }
720
721 @Override public void ifle(int pcOffset) {
722 add( insnFactory.ifle(pc + pcOffset));
723 pc+=3;
724 }
725
726 @Override public void ifnonnull(int pcOffset) {
727 add( insnFactory.ifnonnull(pc + pcOffset));
728 pc+=3;
729 }
730
731 @Override public void ifnull(int pcOffset) {
732 add( insnFactory.ifnull(pc + pcOffset));
733 pc+=3;
734 }
735
736 @Override public void iinc(int localVarIndex, int incConstant) {
737 add( insnFactory.iinc(localVarIndex, incConstant));
738 pc+=3;
739 if (isWide){
740 pc+=2;
741 isWide = false;
742 }
743 }
744
745 @Override public void iload(int localVarIndex) {
746 add( insnFactory.iload(localVarIndex));
747 pc+=2;
748 if (isWide){
749 pc++;
750 isWide = false;
751 }
752 }
753
754 @Override public void iload_0() {
755 add( insnFactory.iload(0));
756 pc++;
757 }
758
759 @Override public void iload_1() {
760 add( insnFactory.iload(1));
761 pc++;
762 }
763
764 @Override public void iload_2() {
765 add( insnFactory.iload(2));
766 pc++;
767 }
768
769 @Override public void iload_3() {
770 add( insnFactory.iload(3));
771 pc++;
772 }
773
774 @Override public void imul() {
775 add( insnFactory.imul());
776 pc++;
777 }
778
779 @Override public void ineg() {
780 add( insnFactory.ineg());
781 pc++;
782 }
783
784 @Override public void instanceof_(int cpClassIndex) {
785 String clsName = cf.classNameAt(cpClassIndex);
786 add( insnFactory.instanceof_(clsName));
787 pc+=3;
788 }
789
790 @Override public void invokeinterface(int cpInterfaceMethodRefIndex, int count, int zero) {
791 String clsName = cf.interfaceMethodClassNameAt(cpInterfaceMethodRefIndex);
792 String methodName = cf.interfaceMethodNameAt(cpInterfaceMethodRefIndex);
793 String methodSignature = cf.interfaceMethodDescriptorAt(cpInterfaceMethodRefIndex);
794
795 add( insnFactory.invokeinterface(clsName, methodName, methodSignature));
796 pc+=5;
797 }
798 public void invokeinterface(String clsName, String methodName, String methodSignature){
799 add( insnFactory.invokeinterface(clsName, methodName, methodSignature));
800 pc+=5;
801 }
802
803 @Override
804 public void invokedynamic (int cpInvokeDynamicIndex){
805 int bootstrapMethodIndex = cf.bootstrapMethodIndex(cpInvokeDynamicIndex);
806 String samMethodName = cf.samMethodNameAt(cpInvokeDynamicIndex);
807 String callSiteDescriptor = cf.callSiteDescriptor(cpInvokeDynamicIndex);
808 add( insnFactory.invokedynamic(bootstrapMethodIndex, samMethodName, callSiteDescriptor));
809 pc+=5;
810 }
811
812 @Override public void invokespecial(int cpMethodRefIndex) {
813 String clsName = cf.methodClassNameAt(cpMethodRefIndex);
814 String methodName = cf.methodNameAt(cpMethodRefIndex);
815 String methodSignature = cf.methodDescriptorAt(cpMethodRefIndex);
816
817 add( insnFactory.invokespecial(clsName, methodName, methodSignature));
818 pc+=3;
819 }
820 public void invokespecial(String clsName, String methodName, String methodSignature){
821 add( insnFactory.invokespecial(clsName, methodName, methodSignature));
822 pc+=3;
823 }
824
825 @Override public void invokestatic(int cpMethodRefIndex) {
826 String clsName = cf.methodClassNameAt(cpMethodRefIndex);
827 String methodName = cf.methodNameAt(cpMethodRefIndex);
828 String methodSignature = cf.methodDescriptorAt(cpMethodRefIndex);
829
830 add( insnFactory.invokestatic(clsName, methodName, methodSignature));
831 pc+=3;
832 }
833 public void invokestatic(String clsName, String methodName, String methodSignature){
834 add( insnFactory.invokestatic(clsName, methodName, methodSignature));
835 pc+=3;
836 }
837
838 @Override public void invokevirtual(int cpMethodRefIndex) {
839 String clsName = cf.methodClassNameAt(cpMethodRefIndex);
840 String methodName = cf.methodNameAt(cpMethodRefIndex);
841 String methodSignature = cf.methodDescriptorAt(cpMethodRefIndex);
842
843 add( insnFactory.invokevirtual(clsName, methodName, methodSignature));
844 pc+=3;
845 }
846 public void invokevirtual(String clsName, String methodName, String methodSignature){
847 add( insnFactory.invokevirtual(clsName, methodName, methodSignature));
848 pc+=3;
849 }
850
851 @Override public void ior() {
852 add( insnFactory.ior());
853 pc++;
854 }
855
856 @Override public void irem() {
857 add( insnFactory.irem());
858 pc++;
859 }
860
861 @Override public void ireturn() {
862 add( insnFactory.ireturn());
863 pc++;
864 }
865
866 @Override public void ishl() {
867 add( insnFactory.ishl());
868 pc++;
869 }
870
871 @Override public void ishr() {
872 add( insnFactory.ishr());
873 pc++;
874 }
875
876 @Override public void istore(int localVarIndex) {
877 add( insnFactory.istore(localVarIndex));
878 pc+=2;
879 if (isWide){
880 pc++;
881 isWide = false;
882 }
883 }
884
885 @Override public void istore_0() {
886 add( insnFactory.istore(0));
887 pc++;
888 }
889
890 @Override public void istore_1() {
891 add( insnFactory.istore(1));
892 pc++;
893 }
894
895 @Override public void istore_2() {
896 add( insnFactory.istore(2));
897 pc++;
898 }
899
900 @Override public void istore_3() {
901 add( insnFactory.istore(3));
902 pc++;
903 }
904
905 @Override public void isub() {
906 add( insnFactory.isub());
907 pc++;
908 }
909
910 @Override public void iushr() {
911 add( insnFactory.iushr());
912 pc++;
913 }
914
915 @Override public void ixor() {
916 add( insnFactory.ixor());
917 pc++;
918 }
919
920 @Override public void jsr(int pcOffset) {
921 add( insnFactory.jsr(pc + pcOffset));
922 pc+=3;
923 }
924
925 @Override public void jsr_w(int pcOffset) {
926 add( insnFactory.jsr_w(pc + pcOffset));
927 pc+=5;
928 }
929
930 @Override public void l2d() {
931 add( insnFactory.l2d());
932 pc++;
933 }
934
935 @Override public void l2f() {
936 add( insnFactory.l2f());
937 pc++;
938 }
939
940 @Override public void l2i() {
941 add( insnFactory.l2i());
942 pc++;
943 }
944
945 @Override public void ladd() {
946 add( insnFactory.ladd());
947 pc++;
948 }
949
950 @Override public void laload() {
951 add( insnFactory.laload());
952 pc++;
953 }
954
955 @Override public void land() {
956 add( insnFactory.land());
957 pc++;
958 }
959
960 @Override public void lastore() {
961 add( insnFactory.lastore());
962 pc++;
963 }
964
965 @Override public void lcmp() {
966 add( insnFactory.lcmp());
967 pc++;
968 }
969
970 @Override public void lconst_0() {
971 add( insnFactory.lconst_0());
972 pc++;
973 }
974
975 @Override public void lconst_1() {
976 add( insnFactory.lconst_1());
977 pc++;
978 }
979
980 @Override public void ldc_(int cpIntOrFloatOrStringOrClassIndex) {
981 Object v = cf.getCpValue(cpIntOrFloatOrStringOrClassIndex);
982 switch (cf.getCpTag(cpIntOrFloatOrStringOrClassIndex)){
983 case ClassFile.CONSTANT_INTEGER:
984 add( insnFactory.ldc((Integer)v)); break;
985 case ClassFile.CONSTANT_FLOAT:
986 add( insnFactory.ldc((Float)v)); break;
987 case ClassFile.CONSTANT_STRING:
988 add( insnFactory.ldc((String)v, false)); break;
989 case ClassFile.CONSTANT_CLASS:
990 add( insnFactory.ldc((String)v, true)); break;
991 }
992 pc+=2;
993 }
994
995 @Override public void ldc_w_(int cpIntOrFloatOrStringOrClassIndex) {
996 Object v = cf.getCpValue(cpIntOrFloatOrStringOrClassIndex);
997 switch (cf.getCpTag(cpIntOrFloatOrStringOrClassIndex)){
998 case ClassFile.CONSTANT_INTEGER:
999 add( insnFactory.ldc_w((Integer)v)); break;
1000 case ClassFile.CONSTANT_FLOAT:
1001 add( insnFactory.ldc_w((Float)v)); break;
1002 case ClassFile.CONSTANT_STRING:
1003 add( insnFactory.ldc_w((String)v, false)); break;
1004 case ClassFile.CONSTANT_CLASS:
1005 add( insnFactory.ldc_w((String)v, true)); break;
1006 }
1007 pc+=3;
1008 }
1009
1010 @Override public void ldc2_w(int cpLongOrDoubleIndex) {
1011 Object v = cf.getCpValue(cpLongOrDoubleIndex);
1012 if (v instanceof Long){
1013 add( insnFactory.ldc2_w((Long)v));
1014 } else {
1015 add( insnFactory.ldc2_w((Double)v));
1016 }
1017 pc+=3;
1018 }
1019
1020 @Override public void ldiv() {
1021 add( insnFactory.ldiv());
1022 pc++;
1023 }
1024
1025 @Override public void lload(int localVarIndex) {
1026 add( insnFactory.lload(localVarIndex));
1027 pc+=2;
1028 if (isWide){
1029 pc++;
1030 isWide = false;
1031 }
1032 }
1033
1034 @Override public void lload_0() {
1035 add( insnFactory.lload(0));
1036 pc++;
1037 }
1038
1039 @Override public void lload_1() {
1040 add( insnFactory.lload(1));
1041 pc++;
1042 }
1043
1044 @Override public void lload_2() {
1045 add( insnFactory.lload(2));
1046 pc++;
1047 }
1048
1049 @Override public void lload_3() {
1050 add( insnFactory.lload(3));
1051 pc++;
1052 }
1053
1054 @Override public void lmul() {
1055 add( insnFactory.lmul());
1056 pc++;
1057 }
1058
1059 @Override public void lneg() {
1060 add( insnFactory.lneg());
1061 pc++;
1062 }
1063
1064
1065 @Override public void lookupswitch(int defaultPcOffset, int nEntries) {
1066 Instruction insn = insnFactory.lookupswitch(pc + defaultPcOffset, nEntries);
1067 add( insn);
1068
1069 lookupswitchInsn = (LookupSwitchInstruction)insn;
1070
1071 if (cf != null){
1072 cf.parseLookupSwitchEntries(this, nEntries);
1073 }
1074
1075 pc = ((pc+4)>>2)<<2; // opcode and padding
1076 pc += 8 + nEntries*8; // arguments and lookup table
1077 }
1078 @Override public void lookupswitchEntry(int index, int match, int pcOffset) {
1079 lookupswitchInsn.setTarget(index, match, pc + pcOffset);
1080 }
1081
1082 @Override public void lor() {
1083 add( insnFactory.lor());
1084 pc++;
1085 }
1086
1087 @Override public void lrem() {
1088 add( insnFactory.lrem());
1089 pc++;
1090 }
1091
1092 @Override public void lreturn() {
1093 add( insnFactory.lreturn());
1094 pc++;
1095 }
1096
1097 @Override public void lshl() {
1098 add( insnFactory.lshl());
1099 pc++;
1100 }
1101
1102 @Override public void lshr() {
1103 add( insnFactory.lshr());
1104 pc++;
1105 }
1106
1107 @Override public void lstore(int localVarIndex) {
1108 add( insnFactory.lstore(localVarIndex));
1109 pc+=2;
1110 if (isWide){
1111 pc++;
1112 isWide = false;
1113 }
1114 }
1115
1116 @Override public void lstore_0() {
1117 add( insnFactory.lstore(0));
1118 pc++;
1119 }
1120
1121 @Override public void lstore_1() {
1122 add( insnFactory.lstore(1));
1123 pc++;
1124 }
1125
1126 @Override public void lstore_2() {
1127 add( insnFactory.lstore(2));
1128 pc++;
1129 }
1130
1131 @Override public void lstore_3() {
1132 add( insnFactory.lstore(3));
1133 pc++;
1134 }
1135
1136 @Override public void lsub() {
1137 add( insnFactory.lsub());
1138 pc++;
1139 }
1140
1141 @Override public void lushr() {
1142 add( insnFactory.lushr());
1143 pc++;
1144 }
1145
1146 @Override public void lxor() {
1147 add( insnFactory.lxor());
1148 pc++;
1149 }
1150
1151 @Override public void monitorenter() {
1152 add( insnFactory.monitorenter());
1153 pc++;
1154 }
1155
1156 @Override public void monitorexit() {
1157 add( insnFactory.monitorexit());
1158 pc++;
1159 }
1160
1161 @Override public void multianewarray(int cpClassIndex, int dimensions) {
1162 add( insnFactory.multianewarray(cf.classNameAt(cpClassIndex), dimensions));
1163 pc+=4;
1164 }
1165
1166 @Override public void new_(int cpClassIndex) {
1167 add( insnFactory.new_(cf.classNameAt(cpClassIndex)));
1168 pc+=3;
1169 }
1170
1171 @Override public void newarray(int typeCode) {
1172 add( insnFactory.newarray(typeCode));
1173 pc+=2;
1174 }
1175
1176 @Override public void nop() {
1177 add( insnFactory.nop());
1178 pc++;
1179 }
1180
1181 @Override public void pop() {
1182 add( insnFactory.pop());
1183 pc++;
1184 }
1185
1186 @Override public void pop2() {
1187 add( insnFactory.pop2());
1188 pc++;
1189 }
1190
1191 @Override public void putfield(int cpFieldRefIndex) {
1192 String fieldName = cf.fieldNameAt(cpFieldRefIndex);
1193 String clsName = cf.fieldClassNameAt(cpFieldRefIndex);
1194 String fieldDescriptor = cf.fieldDescriptorAt(cpFieldRefIndex);
1195
1196 add( insnFactory.putfield(fieldName, clsName, fieldDescriptor));
1197 pc+=3;
1198 }
1199 public void putfield(String fieldName, String clsName, String fieldDescriptor){
1200 add( insnFactory.putfield(fieldName, clsName, fieldDescriptor));
1201 pc+=3;
1202 }
1203
1204
1205 @Override public void putstatic(int cpFieldRefIndex) {
1206 String fieldName = cf.fieldNameAt(cpFieldRefIndex);
1207 String clsName = cf.fieldClassNameAt(cpFieldRefIndex);
1208 String fieldDescriptor = cf.fieldDescriptorAt(cpFieldRefIndex);
1209
1210 add( insnFactory.putstatic(fieldName, clsName, fieldDescriptor));
1211 pc+=3;
1212 }
1213 public void putstatic(String fieldName, String clsName, String fieldDescriptor){
1214 add( insnFactory.putstatic(fieldName, clsName, fieldDescriptor));
1215 pc+=3;
1216 }
1217
1218
1219 @Override public void ret(int localVarIndex) {
1220 add( insnFactory.ret(localVarIndex));
1221 pc+=2;
1222 if (isWide){
1223 pc++;
1224 isWide = false;
1225 }
1226 }
1227
1228 @Override public void return_() {
1229 add( insnFactory.return_());
1230 pc++;
1231 }
1232
1233 @Override public void saload() {
1234 add( insnFactory.saload());
1235 pc++;
1236 }
1237
1238 @Override public void sastore() {
1239 add( insnFactory.sastore());
1240 pc++;
1241 }
1242
1243 @Override public void sipush(int val) {
1244 add( insnFactory.sipush(val));
1245 pc+=3;
1246 }
1247
1248 @Override public void swap() {
1249 add( insnFactory.swap());
1250 pc++;
1251 }
1252
1253 @Override public void tableswitch(int defaultPcOffset, int low, int high) {
1254 Instruction insn = insnFactory.tableswitch(pc + defaultPcOffset, low, high);
1255 add( insn);
1256
1257 tableswitchInsn = (TableSwitchInstruction)insn;
1258
1259 if (cf != null){
1260 cf.parseTableSwitchEntries(this, low, high);
1261 }
1262
1263 pc = ((pc+4)>>2)<<2; // opcode and padding
1264 pc+=12 + (high-low+1)*4; // the fixed args and jump table
1265 }
1266
1267 @Override public void tableswitchEntry(int value, int pcOffset) {
1268 tableswitchInsn.setTarget(value, pc + pcOffset);
1269 }
1270
1271 @Override public void wide() {
1272 add( insnFactory.wide());
1273 pc++;
1274 isWide = true;
1275 }
1276
1277 @Override public void unknown(int bytecode) {
1278 throw new JPFException("unknown bytecode: " + Integer.toHexString(bytecode));
1279 }
1280
1281
1282 //--- the JPF specific ones (only used in synthetic methods)
1283 public void invokecg(List<Invocation> invokes) {
1284 add (insnFactory.invokecg(invokes));
1285 pc++;
1286 }
1287
1288 public void invokeclinit(ClassInfo ci) {
1289 add( insnFactory.invokeclinit(ci));
1290 pc++;
1291 }
1292
1293 public void directcallreturn(){
1294 add( insnFactory.directcallreturn());
1295 pc++;
1296 }
1297
1298 public void executenative(NativeMethodInfo mi){
1299 add( insnFactory.executenative(mi));
1300 pc++;
1301 }
1302
1303 public void nativereturn(){
1304 add( insnFactory.nativereturn());
1305 pc++;
1306 }
1307
1308 public void runStart (MethodInfo mi){
1309 add( insnFactory.runstart(mi));
1310 pc++;
1311 }
1312
1313 }