Mercurial > hg > Members > kono > jpf-core

comparison src/main/gov/nasa/jpf/jvm/bytecode/InstructionFactory.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.bytecode;
20
21 import gov.nasa.jpf.JPFException;
22 import gov.nasa.jpf.jvm.JVMInstructionFactory;
23 import gov.nasa.jpf.util.Invocation;
24 import gov.nasa.jpf.vm.ClassInfo;
25 import gov.nasa.jpf.vm.Instruction;
26 import gov.nasa.jpf.vm.MethodInfo;
27 import gov.nasa.jpf.vm.NativeMethodInfo;
28
29 import java.util.List;
30
31 /**
32 * this is the new JVMInstructionFactory
33 */
34 public class InstructionFactory extends JVMInstructionFactory {
35
36 public InstructionFactory(){
37 // nothing here
38 }
39
40 @Override
41 public Object clone() {
42 try {
43 return super.clone();
44 } catch (CloneNotSupportedException cnsx){
45 throw new JPFException("InstructionFactory " + this.getClass().getName() + " does not support cloning");
46 }
47 }
48
49 //--- the factory methods
50 @Override
51 public Instruction aconst_null() {
52 return new ACONST_NULL();
53 }
54
55 @Override
56 public Instruction aload(int localVarIndex) {
57 return new ALOAD(localVarIndex);
58 }
59
60 @Override
61 public Instruction aload_0() {
62 return new ALOAD(0);
63 }
64
65 @Override
66 public Instruction aload_1() {
67 return new ALOAD(1);
68 }
69
70 @Override
71 public Instruction aload_2() {
72 return new ALOAD(2);
73 }
74
75 @Override
76 public Instruction aload_3() {
77 return new ALOAD(3);
78 }
79
80 @Override
81 public Instruction aaload() {
82 return new AALOAD();
83 }
84
85 @Override
86 public Instruction astore(int localVarIndex) {
87 return new ASTORE(localVarIndex);
88 }
89
90 @Override
91 public Instruction astore_0() {
92 return new ASTORE(0);
93 }
94
95 @Override
96 public Instruction astore_1() {
97 return new ASTORE(1);
98 }
99
100 @Override
101 public Instruction astore_2() {
102 return new ASTORE(2);
103 }
104
105 @Override
106 public Instruction astore_3() {
107 return new ASTORE(3);
108 }
109
110 @Override
111 public Instruction aastore() {
112 return new AASTORE();
113 }
114
115 @Override
116 public Instruction areturn() {
117 return new ARETURN();
118 }
119
120 @Override
121 public Instruction anewarray(String clsName){
122 return new ANEWARRAY(clsName);
123 }
124
125 @Override
126 public Instruction arraylength() {
127 return new ARRAYLENGTH();
128 }
129
130 @Override
131 public Instruction athrow() {
132 return new ATHROW();
133 }
134
135 @Override
136 public Instruction baload() {
137 return new BALOAD();
138 }
139
140 @Override
141 public Instruction bastore() {
142 return new BASTORE();
143 }
144
145 @Override
146 public Instruction bipush(int b) {
147 return new BIPUSH(b);
148 }
149
150 @Override
151 public Instruction caload() {
152 return new CALOAD();
153 }
154
155 @Override
156 public Instruction castore() {
157 return new CASTORE();
158 }
159
160 @Override
161 public Instruction checkcast(String clsName){
162 return new CHECKCAST(clsName);
163 }
164
165 @Override
166 public Instruction d2f() {
167 return new D2F();
168 }
169
170 @Override
171 public Instruction d2i() {
172 return new D2I();
173 }
174
175 @Override
176 public Instruction d2l() {
177 return new D2L();
178 }
179
180 @Override
181 public Instruction dadd() {
182 return new DADD();
183 }
184
185 @Override
186 public Instruction daload() {
187 return new DALOAD();
188 }
189
190 @Override
191 public Instruction dastore() {
192 return new DASTORE();
193 }
194
195 @Override
196 public Instruction dcmpg() {
197 return new DCMPG();
198 }
199
200 @Override
201 public Instruction dcmpl() {
202 return new DCMPL();
203 }
204
205 @Override
206 public Instruction dconst_0() {
207 return new DCONST(0.0);
208 }
209
210 @Override
211 public Instruction dconst_1() {
212 return new DCONST(1.0);
213 }
214
215 @Override
216 public Instruction ddiv() {
217 return new DDIV();
218 }
219
220 @Override
221 public Instruction dload(int localVarIndex) {
222 return new DLOAD(localVarIndex);
223 }
224
225 @Override
226 public Instruction dload_0() {
227 return new DLOAD(0);
228 }
229
230 @Override
231 public Instruction dload_1() {
232 return new DLOAD(1);
233 }
234
235 @Override
236 public Instruction dload_2() {
237 return new DLOAD(2);
238 }
239
240 @Override
241 public Instruction dload_3() {
242 return new DLOAD(3);
243 }
244
245 @Override
246 public Instruction dmul() {
247 return new DMUL();
248 }
249
250 @Override
251 public Instruction dneg() {
252 return new DNEG();
253 }
254
255 @Override
256 public Instruction drem() {
257 return new DREM();
258 }
259
260 @Override
261 public Instruction dreturn() {
262 return new DRETURN();
263 }
264
265 @Override
266 public Instruction dstore(int localVarIndex) {
267 return new DSTORE(localVarIndex);
268 }
269
270 @Override
271 public Instruction dstore_0() {
272 return new DSTORE(0);
273 }
274
275 @Override
276 public Instruction dstore_1() {
277 return new DSTORE(1);
278 }
279
280 @Override
281 public Instruction dstore_2() {
282 return new DSTORE(2);
283 }
284
285 @Override
286 public Instruction dstore_3() {
287 return new DSTORE(3);
288 }
289
290 @Override
291 public Instruction dsub() {
292 return new DSUB();
293 }
294
295 @Override
296 public Instruction dup() {
297 return new DUP();
298 }
299
300 @Override
301 public Instruction dup_x1() {
302 return new DUP_X1();
303 }
304
305 @Override
306 public Instruction dup_x2() {
307 return new DUP_X2();
308 }
309
310 @Override
311 public Instruction dup2() {
312 return new DUP2();
313 }
314
315 @Override
316 public Instruction dup2_x1() {
317 return new DUP2_X1();
318 }
319
320 @Override
321 public Instruction dup2_x2() {
322 return new DUP2_X2();
323 }
324
325 @Override
326 public Instruction f2d() {
327 return new F2D();
328 }
329
330 @Override
331 public Instruction f2i() {
332 return new F2I();
333 }
334
335 @Override
336 public Instruction f2l() {
337 return new F2L();
338 }
339
340 @Override
341 public Instruction fadd() {
342 return new FADD();
343 }
344
345 @Override
346 public Instruction faload() {
347 return new FALOAD();
348 }
349
350 @Override
351 public Instruction fastore() {
352 return new FASTORE();
353 }
354
355 @Override
356 public Instruction fcmpg() {
357 return new FCMPG();
358 }
359
360 @Override
361 public Instruction fcmpl() {
362 return new FCMPL();
363 }
364
365 @Override
366 public Instruction fconst_0() {
367 return new FCONST(0.0f);
368 }
369
370 @Override
371 public Instruction fconst_1() {
372 return new FCONST(1.0f);
373 }
374
375 @Override
376 public Instruction fconst_2() {
377 return new FCONST(2.0f);
378 }
379
380 @Override
381 public Instruction fdiv() {
382 return new FDIV();
383 }
384
385 @Override
386 public Instruction fload(int localVarIndex) {
387 return new FLOAD(localVarIndex);
388 }
389
390 @Override
391 public Instruction fload_0() {
392 return new FLOAD(0);
393 }
394
395 @Override
396 public Instruction fload_1() {
397 return new FLOAD(1);
398 }
399
400 @Override
401 public Instruction fload_2() {
402 return new FLOAD(2);
403 }
404
405 @Override
406 public Instruction fload_3() {
407 return new FLOAD(3);
408 }
409
410 @Override
411 public Instruction fmul() {
412 return new FMUL();
413 }
414
415 @Override
416 public Instruction fneg() {
417 return new FNEG();
418 }
419
420 @Override
421 public Instruction frem() {
422 return new FREM();
423 }
424
425 @Override
426 public Instruction freturn() {
427 return new FRETURN();
428 }
429
430 @Override
431 public Instruction fstore(int localVarIndex) {
432 return new FSTORE(localVarIndex);
433 }
434
435 @Override
436 public Instruction fstore_0() {
437 return new FSTORE(0);
438 }
439
440 @Override
441 public Instruction fstore_1() {
442 return new FSTORE(1);
443 }
444
445 @Override
446 public Instruction fstore_2() {
447 return new FSTORE(2);
448 }
449
450 @Override
451 public Instruction fstore_3() {
452 return new FSTORE(3);
453 }
454
455 @Override
456 public Instruction fsub() {
457 return new FSUB();
458 }
459
460 @Override
461 public Instruction getfield(String fieldName, String clsName, String fieldDescriptor){
462 return new GETFIELD(fieldName, clsName, fieldDescriptor);
463 }
464
465 @Override
466 public Instruction getstatic(String fieldName, String clsName, String fieldDescriptor){
467 return new GETSTATIC(fieldName, clsName, fieldDescriptor);
468 }
469
470
471 @Override
472 public Instruction goto_(int targetPc) {
473 return new GOTO(targetPc);
474 }
475
476 @Override
477 public Instruction goto_w(int targetPc) {
478 return new GOTO_W(targetPc);
479 }
480
481 @Override
482 public Instruction i2b() {
483 return new I2B();
484 }
485
486 @Override
487 public Instruction i2c() {
488 return new I2C();
489 }
490
491 @Override
492 public Instruction i2d() {
493 return new I2D();
494 }
495
496 @Override
497 public Instruction i2f() {
498 return new I2F();
499 }
500
501 @Override
502 public Instruction i2l() {
503 return new I2L();
504 }
505
506 @Override
507 public Instruction i2s() {
508 return new I2S();
509 }
510
511 @Override
512 public Instruction iadd() {
513 return new IADD();
514 }
515
516 @Override
517 public Instruction iaload() {
518 return new IALOAD();
519 }
520
521 @Override
522 public Instruction iand() {
523 return new IAND();
524 }
525
526 @Override
527 public Instruction iastore() {
528 return new IASTORE();
529 }
530
531 @Override
532 public Instruction iconst_m1() {
533 return new ICONST(-1);
534 }
535
536 @Override
537 public Instruction iconst_0() {
538 return new ICONST(0);
539 }
540
541 @Override
542 public Instruction iconst_1() {
543 return new ICONST(1);
544 }
545
546 @Override
547 public Instruction iconst_2() {
548 return new ICONST(2);
549 }
550
551 @Override
552 public Instruction iconst_3() {
553 return new ICONST(3);
554 }
555
556 @Override
557 public Instruction iconst_4() {
558 return new ICONST(4);
559 }
560
561 @Override
562 public Instruction iconst_5() {
563 return new ICONST(5);
564 }
565
566 @Override
567 public Instruction idiv() {
568 return new IDIV();
569 }
570
571 @Override
572 public Instruction if_acmpeq(int targetPc) {
573 return new IF_ACMPEQ(targetPc);
574 }
575
576 @Override
577 public Instruction if_acmpne(int targetPc) {
578 return new IF_ACMPNE(targetPc);
579 }
580
581 @Override
582 public Instruction if_icmpeq(int targetPc) {
583 return new IF_ICMPEQ(targetPc);
584 }
585
586 @Override
587 public Instruction if_icmpne(int targetPc) {
588 return new IF_ICMPNE(targetPc);
589 }
590
591 @Override
592 public Instruction if_icmplt(int targetPc) {
593 return new IF_ICMPLT(targetPc);
594 }
595
596 @Override
597 public Instruction if_icmpge(int targetPc) {
598 return new IF_ICMPGE(targetPc);
599 }
600
601 @Override
602 public Instruction if_icmpgt(int targetPc) {
603 return new IF_ICMPGT(targetPc);
604 }
605
606 @Override
607 public Instruction if_icmple(int targetPc) {
608 return new IF_ICMPLE(targetPc);
609 }
610
611 @Override
612 public Instruction ifeq(int targetPc) {
613 return new IFEQ(targetPc);
614 }
615
616 @Override
617 public Instruction ifne(int targetPc) {
618 return new IFNE(targetPc);
619 }
620
621 @Override
622 public Instruction iflt(int targetPc) {
623 return new IFLT(targetPc);
624 }
625
626 @Override
627 public Instruction ifge(int targetPc) {
628 return new IFGE(targetPc);
629 }
630
631 @Override
632 public Instruction ifgt(int targetPc) {
633 return new IFGT(targetPc);
634 }
635
636 @Override
637 public Instruction ifle(int targetPc) {
638 return new IFLE(targetPc);
639 }
640
641 @Override
642 public Instruction ifnonnull(int targetPc) {
643 return new IFNONNULL(targetPc);
644 }
645
646 @Override
647 public Instruction ifnull(int targetPc) {
648 return new IFNULL(targetPc);
649 }
650
651 @Override
652 public Instruction iinc(int localVarIndex, int incConstant) {
653 return new IINC(localVarIndex, incConstant);
654 }
655
656 @Override
657 public Instruction iload(int localVarIndex) {
658 return new ILOAD(localVarIndex);
659 }
660
661 @Override
662 public Instruction iload_0() {
663 return new ILOAD(0);
664 }
665
666 @Override
667 public Instruction iload_1() {
668 return new ILOAD(1);
669 }
670
671 @Override
672 public Instruction iload_2() {
673 return new ILOAD(2);
674 }
675
676 @Override
677 public Instruction iload_3() {
678 return new ILOAD(3);
679 }
680
681 @Override
682 public Instruction imul() {
683 return new IMUL();
684 }
685
686 @Override
687 public Instruction ineg() {
688 return new INEG();
689 }
690
691 @Override
692 public Instruction instanceof_(String clsName){
693 return new INSTANCEOF(clsName);
694 }
695
696 @Override
697 public Instruction invokeinterface(String clsName, String methodName, String methodSignature){
698 return new INVOKEINTERFACE(clsName, methodName, methodSignature);
699 }
700
701 @Override
702 public Instruction invokespecial(String clsName, String methodName, String methodSignature){
703 return new INVOKESPECIAL(clsName, methodName, methodSignature);
704 }
705
706 @Override
707 public Instruction invokestatic(String clsName, String methodName, String methodSignature){
708 return new INVOKESTATIC(clsName, methodName, methodSignature);
709 }
710
711 @Override
712 public Instruction invokevirtual(String clsName, String methodName, String methodSignature){
713 return new INVOKEVIRTUAL(clsName, methodName, methodSignature);
714 }
715
716 @Override
717 public Instruction invokedynamic(int bootstrapIndex, String samMethodName, String functionType){
718 return new INVOKEDYNAMIC(bootstrapIndex, samMethodName, functionType);
719 }
720
721 @Override
722 public Instruction ior() {
723 return new IOR();
724 }
725
726 @Override
727 public Instruction irem() {
728 return new IREM();
729 }
730
731 @Override
732 public Instruction ireturn() {
733 return new IRETURN();
734 }
735
736 @Override
737 public Instruction ishl() {
738 return new ISHL();
739 }
740
741 @Override
742 public Instruction ishr() {
743 return new ISHR();
744 }
745
746 @Override
747 public Instruction istore(int localVarIndex) {
748 return new ISTORE(localVarIndex);
749 }
750
751 @Override
752 public Instruction istore_0() {
753 return new ISTORE(0);
754 }
755
756 @Override
757 public Instruction istore_1() {
758 return new ISTORE(1);
759 }
760
761 @Override
762 public Instruction istore_2() {
763 return new ISTORE(2);
764 }
765
766 @Override
767 public Instruction istore_3() {
768 return new ISTORE(3);
769 }
770
771 @Override
772 public Instruction isub() {
773 return new ISUB();
774 }
775
776 @Override
777 public Instruction iushr() {
778 return new IUSHR();
779 }
780
781 @Override
782 public Instruction ixor() {
783 return new IXOR();
784 }
785
786 @Override
787 public Instruction jsr(int targetPc) {
788 return new JSR(targetPc);
789 }
790
791 @Override
792 public Instruction jsr_w(int targetPc) {
793 return new JSR_W(targetPc);
794 }
795
796 @Override
797 public Instruction l2d() {
798 return new L2D();
799 }
800
801 @Override
802 public Instruction l2f() {
803 return new L2F();
804 }
805
806 @Override
807 public Instruction l2i() {
808 return new L2I();
809 }
810
811 @Override
812 public Instruction ladd() {
813 return new LADD();
814 }
815
816 @Override
817 public Instruction laload() {
818 return new LALOAD();
819 }
820
821 @Override
822 public Instruction land() {
823 return new LAND();
824 }
825
826 @Override
827 public Instruction lastore() {
828 return new LASTORE();
829 }
830
831 @Override
832 public Instruction lcmp() {
833 return new LCMP();
834 }
835
836 @Override
837 public Instruction lconst_0() {
838 return new LCONST(0);
839 }
840
841 @Override
842 public Instruction lconst_1() {
843 return new LCONST(1L);
844 }
845
846 @Override
847 public Instruction ldc(int v){
848 return new LDC(v);
849 }
850 @Override
851 public Instruction ldc(float v){
852 return new LDC(v);
853 }
854 @Override
855 public Instruction ldc(String v, boolean isClass){
856 return new LDC(v, isClass);
857 }
858
859
860 @Override
861 public Instruction ldc_w(int v){
862 return new LDC_W(v);
863 }
864 @Override
865 public Instruction ldc_w(float v){
866 return new LDC_W(v);
867 }
868 @Override
869 public Instruction ldc_w(String v, boolean isClass){
870 return new LDC_W(v, isClass);
871 }
872
873 @Override
874 public Instruction ldc2_w(long v){
875 return new LDC2_W(v);
876 }
877 @Override
878 public Instruction ldc2_w(double v){
879 return new LDC2_W(v);
880 }
881
882 @Override
883 public Instruction ldiv() {
884 return new LDIV();
885 }
886
887 @Override
888 public Instruction lload(int localVarIndex) {
889 return new LLOAD(localVarIndex);
890 }
891
892 @Override
893 public Instruction lload_0() {
894 return new LLOAD(0);
895 }
896
897 @Override
898 public Instruction lload_1() {
899 return new LLOAD(1);
900 }
901
902 @Override
903 public Instruction lload_2() {
904 return new LLOAD(2);
905 }
906
907 @Override
908 public Instruction lload_3() {
909 return new LLOAD(3);
910 }
911
912 @Override
913 public Instruction lmul() {
914 return new LMUL();
915 }
916
917 @Override
918 public Instruction lneg() {
919 return new LNEG();
920 }
921
922 @Override
923 public Instruction lookupswitch(int defaultTargetPc, int nEntries) {
924 return new LOOKUPSWITCH(defaultTargetPc, nEntries);
925 }
926
927 @Override
928 public Instruction lor() {
929 return new LOR();
930 }
931
932 @Override
933 public Instruction lrem() {
934 return new LREM();
935 }
936
937 @Override
938 public Instruction lreturn() {
939 return new LRETURN();
940 }
941
942 @Override
943 public Instruction lshl() {
944 return new LSHL();
945 }
946
947 @Override
948 public Instruction lshr() {
949 return new LSHR();
950 }
951
952 @Override
953 public Instruction lstore(int localVarIndex) {
954 return new LSTORE(localVarIndex);
955 }
956
957 @Override
958 public Instruction lstore_0() {
959 return new LSTORE(0);
960 }
961
962 @Override
963 public Instruction lstore_1() {
964 return new LSTORE(1);
965 }
966
967 @Override
968 public Instruction lstore_2() {
969 return new LSTORE(2);
970 }
971
972 @Override
973 public Instruction lstore_3() {
974 return new LSTORE(3);
975 }
976
977 @Override
978 public Instruction lsub() {
979 return new LSUB();
980 }
981
982 @Override
983 public Instruction lushr() {
984 return new LUSHR();
985 }
986
987 @Override
988 public Instruction lxor() {
989 return new LXOR();
990 }
991
992 @Override
993 public Instruction monitorenter() {
994 return new MONITORENTER();
995 }
996
997 @Override
998 public Instruction monitorexit() {
999 return new MONITOREXIT();
1000 }
1001
1002 @Override
1003 public Instruction multianewarray(String clsName, int dimensions){
1004 return new MULTIANEWARRAY(clsName, dimensions);
1005 }
1006
1007 @Override
1008 public Instruction new_(String clsName) {
1009 return new NEW(clsName);
1010 }
1011
1012 @Override
1013 public Instruction newarray(int typeCode) {
1014 return new NEWARRAY(typeCode);
1015 }
1016
1017 @Override
1018 public Instruction nop() {
1019 return new NOP();
1020 }
1021
1022 @Override
1023 public Instruction pop() {
1024 return new POP();
1025 }
1026
1027 @Override
1028 public Instruction pop2() {
1029 return new POP2();
1030 }
1031
1032 @Override
1033 public Instruction putfield(String fieldName, String clsName, String fieldDescriptor){
1034 return new PUTFIELD(fieldName, clsName, fieldDescriptor);
1035 }
1036
1037 @Override
1038 public Instruction putstatic(String fieldName, String clsName, String fieldDescriptor){
1039 return new PUTSTATIC(fieldName, clsName, fieldDescriptor);
1040 }
1041
1042 @Override
1043 public Instruction ret(int localVarIndex) {
1044 return new RET(localVarIndex);
1045 }
1046
1047 @Override
1048 public Instruction return_() {
1049 return new RETURN();
1050 }
1051
1052 @Override
1053 public Instruction saload() {
1054 return new SALOAD();
1055 }
1056
1057 @Override
1058 public Instruction sastore() {
1059 return new SASTORE();
1060 }
1061
1062 @Override
1063 public Instruction sipush(int val) {
1064 return new SIPUSH(val);
1065 }
1066
1067 @Override
1068 public Instruction swap() {
1069 return new SWAP();
1070 }
1071
1072 @Override
1073 public Instruction tableswitch(int defaultTargetPc, int low, int high) {
1074 return new TABLESWITCH(defaultTargetPc, low, high);
1075 }
1076
1077 @Override
1078 public Instruction wide() {
1079 return new WIDE();
1080 }
1081
1082
1083 //--- the JPF specific ones (only used in synthetic methods)
1084 @Override
1085 public Instruction invokecg(List<Invocation> invokes) {
1086 return new INVOKECG(invokes);
1087 }
1088
1089 @Override
1090 public Instruction invokeclinit(ClassInfo ci) {
1091 return new INVOKECLINIT(ci);
1092 }
1093
1094 @Override
1095 public Instruction directcallreturn(){
1096 return new DIRECTCALLRETURN();
1097 }
1098
1099 @Override
1100 public Instruction executenative(NativeMethodInfo mi){
1101 return new EXECUTENATIVE(mi);
1102 }
1103
1104 @Override
1105 public Instruction nativereturn(){
1106 return new NATIVERETURN();
1107 }
1108
1109 // this is never part of MethodInfo stored code
1110 @Override
1111 public Instruction runstart(MethodInfo miRun){
1112 return new RUNSTART();
1113 }
1114
1115 }