src/main/gov/nasa/jpf/jvm/bytecode/InstructionFactory.java

   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   @Override
1116   public Instruction finishclinit(ClassInfo ci) {
1117     return new FINISHCLINIT(ci);
1118   }
1119
1120 }