1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 package jdk.experimental.bytecode;
  25 
  26 import java.util.ArrayList;
  27 import java.util.HashMap;
  28 import java.util.Iterator;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.Map.Entry;
  32 import java.util.Vector;
  33 import java.util.function.Consumer;
  34 import java.util.function.Supplier;
  35 import java.util.function.ToIntFunction;
  36 
  37 public class TypedCodeBuilder<S, T, E, C extends TypedCodeBuilder<S, T, E, C>> extends MacroCodeBuilder<S, T, E, C> {
  38 
  39     State lastStackMapState;
  40     int lastStackMapPc = -1;
  41     Map<CharSequence, LocalVarInfo> lvarOffsets = new HashMap<>();
  42     protected State state;
  43     int depth = 0;
  44     int currLocalOffset = 0;
  45 
  46     class StatefulPendingJump extends PendingJump {
  47 
  48         State state;
  49 
  50         StatefulPendingJump(CharSequence label, int pc, State state) {
  51             super(label, pc);
  52             this.state = state;
  53         }
  54 
  55         @Override
  56         boolean resolve(CharSequence label, int pc) {
  57             boolean b = super.resolve(label, pc);
  58             if (b) {
  59                 TypedCodeBuilder.this.state = TypedCodeBuilder.this.state.merge(state);
  60             }
  61             return b;
  62         }
  63     }
  64 
  65     class LocalVarInfo {
  66         CharSequence name;
  67         int offset;
  68         int depth;
  69         TypeTag type;
  70 
  71         LocalVarInfo(CharSequence name, int offset, int depth, TypeTag type) {
  72             this.name = name;
  73             this.offset = offset;
  74             this.depth = depth;
  75             this.type = type;
  76         }
  77     }
  78 
  79     public TypedCodeBuilder(MethodBuilder<S, T, E> methodBuilder) {
  80         super(methodBuilder);
  81         T t = methodBuilder.desc;
  82         state = new State();
  83         if ((methodBuilder.flags & Flag.ACC_STATIC.flag) == 0) {
  84             T clazz = typeHelper.type(methodBuilder.thisClass);
  85             state.load(clazz, currLocalOffset++); //TODO: uninit??
  86         }
  87         Iterator<T> paramsIt = typeHelper.parameterTypes(t);
  88         while (paramsIt.hasNext()) {
  89             T p = paramsIt.next();
  90             state.load(p, currLocalOffset);
  91             currLocalOffset += typeHelper.tag(p).width;
  92         }
  93         lastStackMapState = state.dup();
  94         stacksize = state.stack.size();
  95         localsize = state.locals.size();
  96     }
  97 
  98     @Override
  99     protected C emitOp(Opcode opcode, Object optPoolValue) {
 100         updateState(opcode, optPoolValue);
 101         return super.emitOp(opcode, optPoolValue);
 102     }
 103 
 104     @Override
 105     protected SwitchBuilder makeSwitchBuilder() {
 106         return new TypedSwitchBuilder();
 107     }
 108 
 109     class TypedSwitchBuilder extends SwitchBuilder {
 110 
 111         @Override
 112         public SwitchBuilder withCase(int value, Consumer<? super C> case_, boolean fallthrough) {
 113             super.withCase(value, c -> {
 114                 withLocalScope(() -> {
 115                     State prevState = state;
 116                     state = prevState.dup();
 117                     emitStackMap(c.offset());
 118                     case_.accept(c);
 119                     state = prevState;
 120                 });
 121             }, fallthrough);
 122             return this;
 123         }
 124 
 125         @Override
 126         public SwitchBuilder withDefault(Consumer<? super C> defaultCase) {
 127             super.withDefault(c -> {
 128                 withLocalScope(() -> {
 129                     State prevState = state;
 130                     state = prevState.dup();
 131                     emitStackMap(c.offset());
 132                     defaultCase.accept(c);
 133                     state = prevState;
 134                 });
 135             });
 136             return this;
 137         }
 138     }
 139 

























































































 140     public class State {
 141         public final ArrayList<T> stack;
 142         public final Vector<T> locals;
 143         boolean alive;
 144 
 145         State(ArrayList<T> stack, Vector<T> locals) {
 146             this.stack = stack;
 147             this.locals = locals;
 148         }
 149 
 150         State() {
 151             this(new ArrayList<>(), new Vector<>());
 152         }
 153 
 154         void push(TypeTag tag) {
 155             switch (tag) {
 156                 case A:
 157                 case V:
 158                     throw new IllegalStateException("Bad type tag");
 159                 default:
 160                     push(typeHelper.fromTag(tag));
 161             }
 162         }
 163 
 164         void push(T t) {
 165             stack.add(t);
 166             if (width(t) == 2) {
 167                 stack.add(null);
 168             }
 169             if (stack.size() > stacksize) {
 170                 stacksize = stack.size();
 171             }
 172         }
 173 
 174         T peek() {
 175             return stack.get(stack.size() - 1);
 176         }
 177 
 178         T tosType() {
 179             T tos = peek();
 180             if (tos == null) {
 181                 //double slot
 182                 tos = stack.get(stack.size() - 2);
 183             }
 184             return tos;
 185         }
 186 
 187         T popInternal() {
 188             return stack.remove(stack.size() - 1);
 189         }
 190 
 191         @SuppressWarnings("unchecked")
 192         T pop() {
 193             if (stack.size() == 0 || peek() == null) throw new IllegalStateException();
 194             return popInternal();
 195         }
 196 
 197         T pop2() {
 198             T o = stack.get(stack.size() - 2);
 199             TypeTag t = typeHelper.tag(o);
 200             if (t.width != 2) throw new IllegalStateException();
 201             popInternal();
 202             popInternal();
 203             return o;
 204         }
 205 
 206         T pop(TypeTag t) {
 207             return (t.width() == 2) ?
 208                 pop2() : pop();
 209         }
 210 
 211         void load(TypeTag tag, int index) {
 212             if (tag == TypeTag.A) throw new IllegalStateException("Bad type tag");
 213             load(typeHelper.fromTag(tag), index);
 214         }
 215 
 216         void load(T t, int index) {
 217             ensureDefined(index);
 218             locals.set(index, t);
 219             if (width(t) == 2) {
 220                 locals.add(null);
 221             }
 222             if (locals.size() > localsize) {
 223                 localsize = locals.size();
 224             }
 225         }
 226 
 227         void ensureDefined(int index) {
 228             if (index >= locals.size()) {
 229                 locals.setSize(index + 1);
 230             }
 231         }
 232 
 233         State dup() {
 234             State newState = new State(new ArrayList<>(stack), new Vector<>(locals));
 235             return newState;
 236         }
 237 
 238         State merge(State that) {
 239             if (!alive) { return that; }
 240             if (that.stack.size() != stack.size()) {
 241                 throw new IllegalStateException("Bad stack size at merge point");
 242             }
 243             for (int i = 0; i < stack.size(); i++) {
 244                 T t1 = stack.get(i);
 245                 T t2 = that.stack.get(i);
 246                 stack.set(i, merge(t1, t2, "Bad stack type at merge point"));
 247             }
 248             int nlocals = locals.size() > that.locals.size() ? that.locals.size() : locals.size();
 249             for (int i = 0; i < nlocals; i++) {
 250                 T t1 = locals.get(i);
 251                 T t2 = that.locals.get(i);
 252                 locals.set(i, merge(t1, t2, "Bad local type at merge point"));
 253             }
 254             if (locals.size() > nlocals) {
 255                 for (int i = nlocals; i < locals.size(); i++) {
 256                     locals.remove(i);
 257                 }
 258             }
 259             return this;
 260         }
 261 
 262         T merge(T t1, T t2, String msg) {
 263             if (t1 == null && t2 == null) {
 264                 return t1;
 265             }
 266             T res;
 267             TypeTag tag1 = typeHelper.tag(t1);
 268             TypeTag tag2 = typeHelper.tag(t2);
 269             if (tag1 != TypeTag.A && tag2 != TypeTag.A &&
 270                     tag1 != TypeTag.Q && tag2 != TypeTag.Q) {
 271                 res = typeHelper.fromTag(TypeTag.commonSupertype(tag1, tag2));
 272             } else if (t1 == typeHelper.nullType()) {
 273                 res = t2;
 274             } else if (t2 == typeHelper.nullType()) {
 275                 res = t1;
 276             } else {
 277                 res = typeHelper.commonSupertype(t1, t2);
 278             }
 279             if (res == null) {
 280                 throw new IllegalStateException(msg);
 281             }
 282             return res;
 283         }
 284 
 285         @Override
 286         public String toString() {
 287             return String.format("[locals = %s, stack = %s]", locals, stack);
 288         }
 289     }
 290 
 291     int width(T o) {
 292         return o == typeHelper.nullType() ?
 293                 TypeTag.A.width() :
 294                 typeHelper.tag(o).width;
 295     }
 296 
 297     @SuppressWarnings("unchecked")
 298     public void updateState(Opcode op, Object optValue) {
 299         switch (op) {

 300             case AALOAD:
 301                 state.pop();
 302                 state.push(typeHelper.elemtype(state.pop()));
 303                 break;
 304             case GOTO_:
 305                 state.alive = false;
 306                 break;
 307             case NOP:
 308             case IINC:
 309             case INEG:
 310             case LNEG:
 311             case FNEG:
 312             case DNEG:
 313                 break;
 314             case ACONST_NULL:
 315                 state.push(typeHelper.nullType());
 316                 break;
 317             case ICONST_M1:
 318             case ICONST_0:
 319             case ICONST_1:
 320             case ICONST_2:
 321             case ICONST_3:
 322             case ICONST_4:
 323             case ICONST_5:
 324                 state.push(TypeTag.I);
 325                 break;
 326             case LCONST_0:
 327             case LCONST_1:
 328                 state.push(TypeTag.J);
 329                 break;
 330             case FCONST_0:
 331             case FCONST_1:
 332             case FCONST_2:
 333                 state.push(TypeTag.F);
 334                 break;
 335             case DCONST_0:
 336             case DCONST_1:
 337                 state.push(TypeTag.D);
 338                 break;
 339             case ILOAD_0:
 340             case FLOAD_0:
 341             case ALOAD_0:
 342             case LLOAD_0:
 343             case DLOAD_0:
 344                 state.push(state.locals.get(0));
 345                 break;
 346             case ILOAD_1:
 347             case FLOAD_1:
 348             case ALOAD_1:
 349             case LLOAD_1:
 350             case DLOAD_1:
 351                 state.push(state.locals.get(1));
 352                 break;
 353             case ILOAD_2:
 354             case FLOAD_2:
 355             case ALOAD_2:
 356             case LLOAD_2:
 357             case DLOAD_2:
 358                 state.push(state.locals.get(2));
 359                 break;
 360             case ILOAD_3:
 361             case FLOAD_3:
 362             case ALOAD_3:
 363             case LLOAD_3:
 364             case DLOAD_3:
 365                 state.push(state.locals.get(3));
 366                 break;
 367             case ILOAD:
 368             case FLOAD:
 369             case ALOAD:
 370             case LLOAD:
 371             case DLOAD:

 372                 state.push(state.locals.get((Integer) optValue));
 373                 break;
 374             case IALOAD:
 375             case BALOAD:
 376             case CALOAD:
 377             case SALOAD:
 378                 state.pop();
 379                 state.pop();
 380                 state.push(TypeTag.I);
 381                 break;
 382             case LALOAD:
 383                 state.pop();
 384                 state.pop();
 385                 state.push(TypeTag.J);
 386                 break;
 387             case FALOAD:
 388                 state.pop();
 389                 state.pop();
 390                 state.push(TypeTag.F);
 391                 break;
 392             case DALOAD:
 393                 state.pop();
 394                 state.pop();
 395                 state.push(TypeTag.D);
 396                 break;
 397             case ISTORE_0:
 398             case FSTORE_0:
 399             case ASTORE_0:
 400                 state.load(state.pop(), 0);
 401                 break;
 402             case ISTORE_1:
 403             case FSTORE_1:
 404             case ASTORE_1:
 405                 state.load(state.pop(), 1);
 406                 break;
 407             case ISTORE_2:
 408             case FSTORE_2:
 409             case ASTORE_2:
 410                 state.load(state.pop(), 2);
 411                 break;
 412             case ISTORE_3:
 413             case FSTORE_3:
 414             case ASTORE_3:
 415                 state.load(state.pop(), 3);
 416                 break;
 417             case ISTORE:
 418             case FSTORE:
 419             case ASTORE:

 420                 state.load(state.pop(), (int) optValue);
 421                 break;
 422             case LSTORE_0:
 423             case DSTORE_0:
 424                 state.load(state.pop2(), 0);
 425                 break;
 426             case LSTORE_1:
 427             case DSTORE_1:
 428                 state.load(state.pop2(), 1);
 429                 break;
 430             case LSTORE_2:
 431             case DSTORE_2:
 432                 state.load(state.pop2(), 2);
 433                 break;
 434             case LSTORE_3:
 435             case DSTORE_3:
 436                 state.load(state.pop2(), 3);
 437                 break;
 438             case LSTORE:
 439             case DSTORE:
 440                 state.load(state.pop2(), (int) optValue);
 441                 break;
 442             case POP:
 443             case LSHR:
 444             case LSHL:
 445             case LUSHR:
 446                 state.pop();
 447                 break;

 448             case ARETURN:
 449             case IRETURN:
 450             case FRETURN:
 451                 state.pop();
 452                 break;
 453             case ATHROW:
 454                 state.pop();
 455                 break;
 456             case POP2:
 457                 state.pop2();
 458                 break;
 459             case LRETURN:
 460             case DRETURN:
 461                 state.pop2();
 462                 break;
 463             case DUP:
 464                 state.push(state.peek());
 465                 break;
 466             case RETURN:
 467                 break;
 468             case ARRAYLENGTH:
 469                 state.pop();
 470                 state.push(TypeTag.I);
 471                 break;
 472             case ISUB:
 473             case IADD:
 474             case IMUL:
 475             case IDIV:
 476             case IREM:
 477             case ISHL:
 478             case ISHR:
 479             case IUSHR:
 480             case IAND:
 481             case IOR:
 482             case IXOR:
 483                 state.pop();
 484                 state.pop();
 485                 state.push(TypeTag.I);
 486                 break;

 487             case AASTORE:
 488                 state.pop();
 489                 state.pop();
 490                 state.pop();
 491                 break;
 492             case LAND:
 493             case LOR:
 494             case LXOR:
 495             case LREM:
 496             case LDIV:
 497             case LMUL:
 498             case LSUB:
 499             case LADD:
 500                 state.pop2();
 501                 state.pop2();
 502                 state.push(TypeTag.J);
 503                 break;
 504             case LCMP:
 505                 state.pop2();
 506                 state.pop2();
 507                 state.push(TypeTag.I);
 508                 break;
 509             case L2I:
 510                 state.pop2();
 511                 state.push(TypeTag.I);
 512                 break;
 513             case I2L:
 514                 state.pop();
 515                 state.push(TypeTag.J);
 516                 break;
 517             case I2F:
 518                 state.pop();
 519                 state.push(TypeTag.F);
 520                 break;
 521             case I2D:
 522                 state.pop();
 523                 state.push(TypeTag.D);
 524                 break;
 525             case L2F:
 526                 state.pop2();
 527                 state.push(TypeTag.F);
 528                 break;
 529             case L2D:
 530                 state.pop2();
 531                 state.push(TypeTag.D);
 532                 break;
 533             case F2I:
 534                 state.pop();
 535                 state.push(TypeTag.I);
 536                 break;
 537             case F2L:
 538                 state.pop();
 539                 state.push(TypeTag.J);
 540                 break;
 541             case F2D:
 542                 state.pop();
 543                 state.push(TypeTag.D);
 544                 break;
 545             case D2I:
 546                 state.pop2();
 547                 state.push(TypeTag.I);
 548                 break;
 549             case D2L:
 550                 state.pop2();
 551                 state.push(TypeTag.J);
 552                 break;
 553             case D2F:
 554                 state.pop2();
 555                 state.push(TypeTag.F);
 556                 break;
 557             case TABLESWITCH:
 558             case LOOKUPSWITCH:
 559                 state.pop();
 560                 break;
 561             case DUP_X1: {
 562                 T val1 = state.pop();
 563                 T val2 = state.pop();
 564                 state.push(val1);
 565                 state.push(val2);
 566                 state.push(val1);
 567                 break;
 568             }
 569             case BASTORE:
 570                 state.pop();
 571                 state.pop();
 572                 state.pop();
 573                 break;
 574             case I2B:
 575             case I2C:
 576             case I2S:
 577                 break;
 578             case FMUL:
 579             case FADD:
 580             case FSUB:
 581             case FDIV:
 582             case FREM:
 583                 state.pop();
 584                 state.pop();
 585                 state.push(TypeTag.F);
 586                 break;
 587             case CASTORE:
 588             case IASTORE:
 589             case FASTORE:
 590             case SASTORE:
 591                 state.pop();
 592                 state.pop();
 593                 state.pop();
 594                 break;
 595             case LASTORE:
 596             case DASTORE:
 597                 state.pop2();
 598                 state.pop();
 599                 state.pop();
 600                 break;
 601             case DUP2:
 602                 if (state.peek() != null) {
 603                     //form 1
 604                     T value1 = state.pop();
 605                     T value2 = state.pop();
 606                     state.push(value2);
 607                     state.push(value1);
 608                     state.push(value2);
 609                     state.push(value1);
 610                 } else {
 611                     //form 2
 612                     T value = state.pop2();
 613                     state.push(value);
 614                     state.push(value);
 615                 }
 616                 break;
 617             case DUP2_X1:
 618                 if (state.peek() != null) {
 619                     T value1 = state.pop();
 620                     T value2 = state.pop();
 621                     T value3 = state.pop();
 622                     state.push(value2);
 623                     state.push(value1);
 624                     state.push(value3);
 625                     state.push(value2);
 626                     state.push(value1);
 627                 } else {
 628                     T value1 = state.pop2();
 629                     T value2 = state.pop();
 630                     state.push(value1);
 631                     state.push(value2);
 632                     state.push(value1);
 633                 }
 634                 break;
 635             case DUP2_X2:
 636                 if (state.peek() != null) {
 637                     T value1 = state.pop();
 638                     T value2 = state.pop();
 639                     if (state.peek() != null) {
 640                         // form 1
 641                         T value3 = state.pop();
 642                         T value4 = state.pop();
 643                         state.push(value2);
 644                         state.push(value1);
 645                         state.push(value4);
 646                         state.push(value3);
 647                         state.push(value2);
 648                         state.push(value1);
 649                     } else {
 650                         // form 3
 651                         T value3 = state.pop2();
 652                         state.push(value2);
 653                         state.push(value1);
 654                         state.push(value3);
 655                         state.push(value2);
 656                         state.push(value1);
 657                     }
 658                 } else {
 659                     T value1 = state.pop2();
 660                     if (state.peek() != null) {
 661                         // form 2
 662                         T value2 = state.pop();
 663                         T value3 = state.pop();
 664                         state.push(value1);
 665                         state.push(value3);
 666                         state.push(value2);
 667                         state.push(value1);
 668                     } else {
 669                         // form 4
 670                         T value2 = state.pop2();
 671                         state.push(value1);
 672                         state.push(value2);
 673                         state.push(value1);
 674                     }
 675                 }
 676                 break;
 677             case DUP_X2: {
 678                 T value1 = state.pop();
 679                 if (state.peek() != null) {
 680                     // form 1
 681                     T value2 = state.pop();
 682                     T value3 = state.pop();
 683                     state.push(value1);
 684                     state.push(value3);
 685                     state.push(value2);
 686                     state.push(value1);
 687                 } else {
 688                     // form 2
 689                     T value2 = state.pop2();
 690                     state.push(value1);
 691                     state.push(value2);
 692                     state.push(value1);
 693                 }
 694             }
 695             break;
 696             case FCMPL:
 697             case FCMPG:
 698                 state.pop();
 699                 state.pop();
 700                 state.push(TypeTag.I);
 701                 break;
 702             case DCMPL:
 703             case DCMPG:
 704                 state.pop2();
 705                 state.pop2();
 706                 state.push(TypeTag.I);
 707                 break;
 708             case SWAP: {
 709                 T value1 = state.pop();
 710                 T value2 = state.pop();
 711                 state.push(value1);
 712                 state.push(value2);
 713                 break;
 714             }
 715             case DADD:
 716             case DSUB:
 717             case DMUL:
 718             case DDIV:
 719             case DREM:
 720                 state.pop2();
 721                 state.pop2();
 722                 state.push(TypeTag.D);
 723                 break;
 724             case RET:
 725                 break;
 726             case WIDE:
 727                 // must be handled by the caller.
 728                 return;
 729             case MONITORENTER:
 730             case MONITOREXIT:
 731                 state.pop();
 732                 break;

 733             case NEW:
 734             case ACONST_INIT:
 735                 state.push(typeHelper.type((S) optValue));
 736                 break;
 737             case NEWARRAY:
 738                 state.pop();
 739                 state.push(typeHelper.arrayOf(typeHelper.fromTag((TypeTag) optValue)));
 740                 break;
 741             case ANEWARRAY:
 742                 state.pop();
 743                 state.push(typeHelper.arrayOf(typeHelper.arrayOf(typeHelper.type((S)optValue))));
 744                 break;







 745             case MULTIANEWARRAY:
 746                 for (int i = 0; i < (byte) ((Object[]) optValue)[1]; i++) {
 747                     state.pop();
 748                 }
 749                 state.push(typeHelper.type((S) ((Object[]) optValue)[0]));
 750                 break;
 751             case INVOKEINTERFACE:
 752             case INVOKEVIRTUAL:
 753             case INVOKESPECIAL:
 754             case INVOKESTATIC:
 755             case INVOKEDYNAMIC:
 756                 processInvoke(op, (T) optValue);
 757                 break;
 758             case GETSTATIC:
 759                 state.push((T) optValue);
 760                 break;

 761             case GETFIELD:
 762                 state.pop();
 763                 state.push((T) optValue);
 764                 break;
 765             case PUTSTATIC: {
 766                 TypeTag tag = typeHelper.tag((T) optValue);
 767                 if (tag.width == 1) {
 768                     state.pop();
 769                 } else {
 770                     state.pop2();
 771                 }
 772                 break;
 773             }
 774             case PUTFIELD: {
 775                 TypeTag tag = typeHelper.tag((T) optValue);
 776                 if (tag.width == 1) {
 777                     state.pop();
 778                 } else {
 779                     state.pop2();
 780                 }
 781                 state.pop();
 782                 break;
 783             }
 784             case WITHFIELD: {
 785                 TypeTag tag = typeHelper.tag((T) optValue);
 786                 if (tag.width == 1) {
 787                     state.pop();
 788                 } else {
 789                     state.pop2();
 790                 }
 791                 break;
 792             }
 793             case BIPUSH:
 794             case SIPUSH:
 795                 state.push(TypeTag.I);
 796                 break;
 797             case LDC:
 798             case LDC_W:
 799             case LDC2_W:
 800                 state.push((T)optValue);
 801                 break;
 802             case IF_ACMPEQ:
 803             case IF_ICMPEQ:
 804             case IF_ACMPNE:
 805             case IF_ICMPGE:
 806             case IF_ICMPGT:
 807             case IF_ICMPLE:
 808             case IF_ICMPLT:
 809             case IF_ICMPNE:
 810                 state.pop();
 811                 state.pop();
 812                 break;
 813             case IF_NONNULL:
 814             case IF_NULL:
 815             case IFEQ:
 816             case IFGE:
 817             case IFGT:
 818             case IFLE:
 819             case IFLT:
 820             case IFNE:
 821                 state.pop();
 822                 break;
 823             case INSTANCEOF:
 824                 state.pop();
 825                 state.push(TypeTag.Z);
 826                 break;

 827             case CHECKCAST:
 828                 break;
 829 
 830             default:
 831                 throw new UnsupportedOperationException("Unsupported opcode: " + op);
 832         }
 833     }
 834 
 835     void processInvoke(Opcode opcode, T invokedType) {
 836         Iterator<T> paramsIt = typeHelper.parameterTypes(invokedType);
 837         while (paramsIt.hasNext()) {
 838             T t = paramsIt.next();
 839             TypeTag tag = typeHelper.tag(t);
 840             if (tag.width == 2) {
 841                 state.popInternal();
 842                 state.popInternal();
 843             } else {
 844                 state.popInternal();
 845             }
 846         }
 847         if (opcode != Opcode.INVOKESTATIC && opcode != Opcode.INVOKEDYNAMIC) {
 848             state.pop(); //receiver
 849         }
 850         T retType = typeHelper.returnType(invokedType);
 851         TypeTag retTag = typeHelper.tag(retType);
 852         if (retTag != TypeTag.V)
 853             state.push(retType);
 854     }
 855 
 856     @Override
 857     protected C ldc(ToIntFunction<PoolHelper<S, T, E>> indexFunc, boolean fat) {
 858         LdcPoolHelper ldcPoolHelper = new LdcPoolHelper();
 859         int index = indexFunc.applyAsInt(ldcPoolHelper);
 860         fat = typeHelper.tag(ldcPoolHelper.type).width() == 2;
 861         return super.ldc(index, ldcPoolHelper.type, fat);
 862     }
 863     //where
 864         class LdcPoolHelper implements PoolHelper<S, T, E> {
 865 
 866             T type;
 867 
 868             @Override
 869             public int putClass(S symbol) {
 870                 type = typeHelper.type(symbol);
 871                 return poolHelper.putClass(symbol);
 872             }
 873 
 874             @Override
 875             public int putInlineClass(S symbol) {
 876                 throw new IllegalStateException();
 877             }
 878 
 879             @Override
 880             public int putInt(int i) {
 881                 type = typeHelper.fromTag(TypeTag.I);
 882                 return poolHelper.putInt(i);
 883             }
 884 
 885             @Override
 886             public int putFloat(float f) {
 887                 type = typeHelper.fromTag(TypeTag.F);
 888                 return poolHelper.putFloat(f);
 889             }
 890 
 891             @Override
 892             public int putLong(long l) {
 893                 type = typeHelper.fromTag(TypeTag.J);
 894                 return poolHelper.putLong(l);
 895             }
 896 
 897             @Override
 898             public int putDouble(double d) {
 899                 type = typeHelper.fromTag(TypeTag.D);
 900                 return poolHelper.putDouble(d);
 901             }
 902 
 903             @Override
 904             public int putString(String s) {
 905                 type = typeHelper.type(typeHelper.symbolFrom("java/lang/String"));
 906                 return poolHelper.putString(s);
 907             }
 908 
 909             @Override
 910             public int putDynamicConstant(CharSequence constName, T constType, S bsmClass, CharSequence bsmName, T bsmType, Consumer<StaticArgListBuilder<S, T, E>> staticArgs) {
 911                 type = constType;
 912                 return poolHelper.putDynamicConstant(constName, constType, bsmClass, bsmName, bsmType, staticArgs);
 913             }
 914 
 915             @Override
 916             public int putFieldRef(S owner, CharSequence name, T type) {
 917                 throw new IllegalStateException();
 918             }
 919 
 920             @Override
 921             public int putMethodRef(S owner, CharSequence name, T type, boolean isInterface) {
 922                 throw new IllegalStateException();
 923             }
 924 
 925             @Override
 926             public int putUtf8(CharSequence s) {
 927                 throw new IllegalStateException();
 928             }
 929 
 930             @Override
 931             public int putType(T t) {
 932                 throw new IllegalStateException();
 933             }
 934 
 935             @Override
 936             public int putMethodType(T t) {
 937                 type = typeHelper.type(typeHelper.symbolFrom("java/lang/invoke/MethodType"));
 938                 return poolHelper.putMethodType(t);
 939             }
 940 
 941             @Override
 942             public int putHandle(int refKind, S owner, CharSequence name, T t) {
 943                 type = typeHelper.type(typeHelper.symbolFrom("java/lang/invoke/MethodHandle"));
 944                 return poolHelper.putHandle(refKind, owner, name, t);
 945             }
 946 
 947             @Override
 948             public int putHandle(int refKind, S owner, CharSequence name, T t, boolean isInterface) {
 949                 type = typeHelper.type(typeHelper.symbolFrom("java/lang/invoke/MethodHandle"));
 950                 return poolHelper.putHandle(refKind, owner, name, t, isInterface);
 951             }
 952 
 953             @Override
 954             public int putInvokeDynamic(CharSequence invokedName, T invokedType, S bsmClass, CharSequence bsmName, T bsmType, Consumer<StaticArgListBuilder<S, T, E>> staticArgs) {
 955                 throw new IllegalStateException();
 956             }
 957 
 958             @Override
 959             public int size() {
 960                 throw new IllegalStateException();
 961             }
 962 
 963             @Override
 964             public E entries() {
 965                 throw new IllegalStateException();
 966             }
 967     }
 968 
 969     public C load(int index) {
 970         return load(typeHelper.tag(state.locals.get(index)), index);
 971     }
 972 
 973     public C store(int index) {
 974         return store(typeHelper.tag(state.tosType()), index);
 975     }
 976 
 977     @Override
 978     public C withLocalSize(int localsize) {
 979         throw new IllegalStateException("Local size automatically computed");
 980     }
 981 
 982     @Override
 983     public C withStackSize(int stacksize) {
 984         throw new IllegalStateException("Stack size automatically computed");
 985     }
 986 
 987     public C withLocal(CharSequence name, T type) {
 988         int offset = currLocalOffset;
 989         TypeTag tag = typeHelper.tag(type);
 990         lvarOffsets.put(name, new LocalVarInfo(name, offset, depth, tag));
 991         state.load(type, offset);
 992         currLocalOffset += tag.width;
 993         return thisBuilder();
 994     }
 995 
 996     public C load(CharSequence local) {
 997         return load(lvarOffsets.get(local).offset);
 998     }
 999 
1000     public C store(CharSequence local) {
1001         return store(lvarOffsets.get(local).offset);
1002     }
1003 
1004     @Override
1005     public C withTry(Consumer<? super C> tryBlock, Consumer<? super CatchBuilder> catchBlocks) {
1006         return super.withTry(c -> {
1007             withLocalScope(() -> {
1008                 tryBlock.accept(c);
1009             });
1010         }, catchBlocks);
1011     }
1012 
1013     @Override
1014     protected CatchBuilder makeCatchBuilder(int start, int end) {
1015         return new TypedCatchBuilder(start, end);
1016     }
1017 
1018     class TypedCatchBuilder extends CatchBuilder {
1019 
1020         State initialState = state.dup();
1021 
1022         TypedCatchBuilder(int start, int end) {
1023             super(start, end);
1024         }
1025 
1026         @Override
1027         protected void emitCatch(S exc, Consumer<? super C> catcher) {
1028             withLocalScope(() -> {
1029                 state.push(typeHelper.type(exc));
1030                 emitStackMap(code.offset);
1031                 super.emitCatch(exc, catcher);
1032                 state = initialState;
1033             });
1034         }
1035 
1036         @Override
1037         protected void emitFinalizer() {
1038             withLocalScope(() -> {
1039                 state.push(typeHelper.type(typeHelper.symbolFrom("java/lang/Throwable")));
1040                 emitStackMap(code.offset);
1041                 super.emitFinalizer();
1042             });
1043         }
1044     }
1045 
1046     protected void withLocalScope(Runnable runnable) {
1047         int prevDepth = depth;
1048         try {
1049             depth++;
1050             runnable.run();
1051         } finally {
1052             Iterator<Entry<CharSequence, LocalVarInfo>> lvarIt = lvarOffsets.entrySet().iterator();
1053             while (lvarIt.hasNext()) {
1054                 LocalVarInfo lvi = lvarIt.next().getValue();
1055                 if (lvi.depth == depth) {
1056                     int width = lvi.type.width;
1057                     currLocalOffset -= width;
1058                     lvarIt.remove();
1059                 }
1060             }
1061             depth = prevDepth;
1062         }
1063     }
1064 
1065     @Override
1066     void addPendingJump(CharSequence label, int pc) {
1067         pendingJumps.add(new StatefulPendingJump(label, pc, state.dup()));
1068     }
1069 
1070     @Override
1071     void resolveJumps(CharSequence label, int pc) {
1072         super.resolveJumps(label, pc);
1073         emitStackMap(pc);
1074     }
1075 
1076     //TODO: optimize stackmap generation by avoiding intermediate classes
1077     protected void emitStackMap(int pc) {
1078         //stack map generation
1079         if (pc > lastStackMapPc) {
1080             writeStackMapFrame(pc);
1081             lastStackMapState = state.dup();
1082             lastStackMapPc = pc;
1083             nstackmaps++;
1084         }
1085     }
1086 
1087     @Override
1088     void build(GrowableByteBuffer buf) {
1089         if (stacksize == -1) {
1090             throw new IllegalStateException("Bad stack size");
1091         }
1092         if (localsize == -1) {
1093             throw new IllegalStateException("Bad locals size");
1094         }
1095         if (nstackmaps > 0) {
1096             GrowableByteBuffer stackmapsAttr = new GrowableByteBuffer();
1097             stackmapsAttr.writeChar(nstackmaps);
1098             stackmapsAttr.writeBytes(stackmaps);
1099             withAttribute("StackMapTable", stackmapsAttr.bytes());
1100         }
1101         super.build(buf);
1102     }
1103 
1104     /**
1105      * Compare this frame with the previous frame and produce
1106      * an entry of compressed stack map frame.
1107      */
1108     void writeStackMapFrame(int pc) {
1109         List<T> locals = state.locals;
1110         List<T> stack = state.stack;
1111         List<T> prev_locals = lastStackMapState.locals;
1112         int offset_delta = lastStackMapPc == -1 ? pc : pc - lastStackMapPc - 1;
1113         if (stack.size() == 1) {
1114             if (locals.size() == prev_locals.size() && prev_locals.equals(locals)) {
1115                 sameLocals1StackItemFrame(offset_delta, stack.get(stack.size() - 1));
1116                 return;
1117             }
1118         } else if (stack.size() == 0) {
1119             int diff_length = prev_locals.size() - locals.size();
1120             if (diff_length == 0) {
1121                 sameFrame(offset_delta);
1122                 return;
1123             } else if (-MAX_LOCAL_LENGTH_DIFF < diff_length && diff_length < 0) {
1124                 appendFrame(offset_delta, prev_locals.size(), locals);
1125                 return;
1126             } else if (0 < diff_length && diff_length < MAX_LOCAL_LENGTH_DIFF) {
1127                 chopFrame(offset_delta, diff_length);
1128                 return;
1129             }
1130         }
1131         fullFrame(offset_delta, locals, stack);
1132     }
1133 }
--- EOF ---