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