1 /*

     2  * Copyright (c) 2008, 2012, 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 

    25 #include "precompiled.hpp"

    26 #include "interpreter/rewriter.hpp"

    27 #include "memory/oopFactory.hpp"

    28 #include "prims/methodHandleWalk.hpp"

    29 

    30 /*

    31  * JSR 292 reference implementation: method handle structure analysis

    32  */

    33 

    34 #ifdef PRODUCT

    35 #define print_method_handle(mh) {}

    36 #else //PRODUCT

    37 extern "C" void print_method_handle(oop mh);

    38 #endif //PRODUCT

    39 

    40 // -----------------------------------------------------------------------------

    41 // MethodHandleChain

    42 

    43 void MethodHandleChain::set_method_handle(Handle mh, TRAPS) {

    44   if (!java_lang_invoke_MethodHandle::is_instance(mh()))  lose("bad method handle", CHECK);

    45 

    46   // set current method handle and unpack partially

    47   _method_handle = mh;

    48   _is_last       = false;

    49   _is_bound      = false;

    50   _arg_slot      = -1;

    51   _arg_type      = T_VOID;

    52   _conversion    = -1;

    53   _last_invoke   = Bytecodes::_nop;  //arbitrary non-garbage

    54 

    55   if (java_lang_invoke_DirectMethodHandle::is_instance(mh())) {

    56     set_last_method(mh(), THREAD);

    57     return;

    58   }

    59   if (java_lang_invoke_AdapterMethodHandle::is_instance(mh())) {

    60     _conversion = AdapterMethodHandle_conversion();

    61     assert(_conversion != -1, "bad conv value");

    62     assert(java_lang_invoke_BoundMethodHandle::is_instance(mh()), "also BMH");

    63   }

    64   if (java_lang_invoke_BoundMethodHandle::is_instance(mh())) {

    65     if (!is_adapter())          // keep AMH and BMH separate in this model

    66       _is_bound = true;

    67     _arg_slot = BoundMethodHandle_vmargslot();

    68     oop target = MethodHandle_vmtarget_oop();

    69     if (!is_bound() || java_lang_invoke_MethodHandle::is_instance(target)) {

    70       _arg_type = compute_bound_arg_type(target, NULL, _arg_slot, CHECK);

    71     } else if (target != NULL && target->is_method()) {

    72       methodOop m = (methodOop) target;

    73       _arg_type = compute_bound_arg_type(NULL, m, _arg_slot, CHECK);

    74       set_last_method(mh(), CHECK);

    75     } else {

    76       _is_bound = false;  // lose!

    77     }

    78   }

    79   if (is_bound() && _arg_type == T_VOID) {

    80     lose("bad vmargslot", CHECK);

    81   }

    82   if (!is_bound() && !is_adapter()) {

    83     lose("unrecognized MH type", CHECK);

    84   }

    85 }

    86 

    87 

    88 void MethodHandleChain::set_last_method(oop target, TRAPS) {

    89   _is_last = true;

    90   KlassHandle receiver_limit; int flags = 0;

    91   _last_method = MethodHandles::decode_method(target, receiver_limit, flags);

    92   if ((flags & MethodHandles::_dmf_has_receiver) == 0)

    93     _last_invoke = Bytecodes::_invokestatic;

    94   else if ((flags & MethodHandles::_dmf_does_dispatch) == 0)

    95     _last_invoke = Bytecodes::_invokespecial;

    96   else if ((flags & MethodHandles::_dmf_from_interface) != 0)

    97     _last_invoke = Bytecodes::_invokeinterface;

    98   else

    99     _last_invoke = Bytecodes::_invokevirtual;

   100 }

   101 

   102 

   103 BasicType MethodHandleChain::compute_bound_arg_type(oop target, methodOop m, int arg_slot, TRAPS) {

   104   // There is no direct indication of whether the argument is primitive or not.

   105   // It is implied by the _vmentry code, and by the MethodType of the target.

   106   BasicType arg_type = T_VOID;

   107   if (target != NULL) {

   108     oop mtype = java_lang_invoke_MethodHandle::type(target);

   109     int arg_num = MethodHandles::argument_slot_to_argnum(mtype, arg_slot);

   110     if (arg_num >= 0) {

   111       oop ptype = java_lang_invoke_MethodType::ptype(mtype, arg_num);

   112       arg_type = java_lang_Class::as_BasicType(ptype);

   113     }

   114   } else if (m != NULL) {

   115     // figure out the argument type from the slot

   116     // FIXME: make this explicit in the MH

   117     int cur_slot = m->size_of_parameters();

   118     if (arg_slot >= cur_slot)

   119       return T_VOID;

   120     if (!m->is_static()) {

   121       cur_slot -= type2size[T_OBJECT];

   122       if (cur_slot == arg_slot)

   123         return T_OBJECT;

   124     }

   125     ResourceMark rm(THREAD);

   126     for (SignatureStream ss(m->signature()); !ss.is_done(); ss.next()) {

   127       BasicType bt = ss.type();

   128       cur_slot -= type2size[bt];

   129       if (cur_slot <= arg_slot) {

   130         if (cur_slot == arg_slot)

   131           arg_type = bt;

   132         break;

   133       }

   134     }

   135   }

   136   if (arg_type == T_ARRAY)

   137     arg_type = T_OBJECT;

   138   return arg_type;

   139 }

   140 

   141 

   142 void MethodHandleChain::lose(const char* msg, TRAPS) {

   143   _lose_message = msg;

   144 #ifdef ASSERT

   145   if (Verbose) {

   146     tty->print_cr(INTPTR_FORMAT " lose: %s", _method_handle(), msg);

   147     print();

   148   }

   149 #endif

   150   if (!THREAD->is_Java_thread() || ((JavaThread*)THREAD)->thread_state() != _thread_in_vm) {

   151     // throw a preallocated exception

   152     THROW_OOP(Universe::virtual_machine_error_instance());

   153   }

   154   THROW_MSG(vmSymbols::java_lang_InternalError(), msg);

   155 }

   156 

   157 

   158 #ifdef ASSERT

   159 static const char* adapter_ops[] = {

   160   "retype_only"  ,

   161   "retype_raw"   ,

   162   "check_cast"   ,

   163   "prim_to_prim" ,

   164   "ref_to_prim"  ,

   165   "prim_to_ref"  ,

   166   "swap_args"    ,

   167   "rot_args"     ,

   168   "dup_args"     ,

   169   "drop_args"    ,

   170   "collect_args" ,

   171   "spread_args"  ,

   172   "fold_args"

   173 };

   174 

   175 static const char* adapter_op_to_string(int op) {

   176   if (op >= 0 && op < (int)ARRAY_SIZE(adapter_ops))

   177     return adapter_ops[op];

   178   return "unknown_op";

   179 }

   180 

   181 void MethodHandleChain::print(oopDesc* m) {

   182   HandleMark hm;

   183   ResourceMark rm;

   184   Handle mh(m);

   185   EXCEPTION_MARK;

   186   MethodHandleChain mhc(mh, THREAD);

   187   if (HAS_PENDING_EXCEPTION) {

   188     oop ex = THREAD->pending_exception();

   189     CLEAR_PENDING_EXCEPTION;

   190     ex->print();

   191     return;

   192   }

   193   mhc.print();

   194 }

   195 

   196 

   197 void MethodHandleChain::print() {

   198   EXCEPTION_MARK;

   199   print_impl(THREAD);

   200   if (HAS_PENDING_EXCEPTION) {

   201     oop ex = THREAD->pending_exception();

   202     CLEAR_PENDING_EXCEPTION;

   203     ex->print();

   204   }

   205 }

   206 

   207 void MethodHandleChain::print_impl(TRAPS) {

   208   ResourceMark rm;

   209 

   210   MethodHandleChain chain(_root, CHECK);

   211   for (;;) {

   212     tty->print(INTPTR_FORMAT ": ", chain.method_handle()());

   213     if (chain.is_bound()) {

   214       tty->print("bound: arg_type %s arg_slot %d",

   215                  type2name(chain.bound_arg_type()),

   216                  chain.bound_arg_slot());

   217       oop o = chain.bound_arg_oop();

   218       if (o != NULL) {

   219         if (o->is_instance()) {

   220           tty->print(" instance %s", o->klass()->klass_part()->internal_name());

   221           if (java_lang_invoke_CountingMethodHandle::is_instance(o)) {

   222             tty->print(" vmcount: %d", java_lang_invoke_CountingMethodHandle::vmcount(o));

   223           }

   224         } else {

   225           o->print();

   226         }

   227       }

   228       oop vmt = chain.vmtarget_oop();

   229       if (vmt != NULL) {

   230         if (vmt->is_method()) {

   231           tty->print(" ");

   232           methodOop(vmt)->print_short_name(tty);

   233         } else if (java_lang_invoke_MethodHandle::is_instance(vmt)) {

   234           tty->print(" method handle " INTPTR_FORMAT, vmt);

   235         } else {

   236           ShouldNotReachHere();

   237         }

   238       }

   239     } else if (chain.is_adapter()) {

   240       tty->print("adapter: arg_slot %d conversion op %s",

   241                  chain.adapter_arg_slot(),

   242                  adapter_op_to_string(chain.adapter_conversion_op()));

   243       switch (chain.adapter_conversion_op()) {

   244         case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY:

   245           if (java_lang_invoke_CountingMethodHandle::is_instance(chain.method_handle_oop())) {

   246             tty->print(" vmcount: %d", java_lang_invoke_CountingMethodHandle::vmcount(chain.method_handle_oop()));

   247           }

   248         case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW:

   249         case java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST:

   250         case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM:

   251         case java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM:

   252           break;

   253 

   254         case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_REF: {

   255           tty->print(" src_type = %s", type2name(chain.adapter_conversion_src_type()));

   256           break;

   257         }

   258 

   259         case java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS:

   260         case java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS: {

   261           int dest_arg_slot = chain.adapter_conversion_vminfo();

   262           tty->print(" dest_arg_slot %d type %s", dest_arg_slot, type2name(chain.adapter_conversion_src_type()));

   263           break;

   264         }

   265 

   266         case java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS:

   267         case java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS: {

   268           int dup_slots = chain.adapter_conversion_stack_pushes();

   269           tty->print(" pushes %d", dup_slots);

   270           break;

   271         }

   272 

   273         case java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS:

   274         case java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS: {

   275           int coll_slots = chain.MethodHandle_vmslots();

   276           tty->print(" coll_slots %d", coll_slots);

   277           break;

   278         }

   279 

   280         case java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS: {

   281           // Check the required length.

   282           int spread_slots = 1 + chain.adapter_conversion_stack_pushes();

   283           tty->print(" spread_slots %d", spread_slots);

   284           break;

   285         }

   286 

   287         default:

   288           tty->print_cr("bad adapter conversion");

   289           break;

   290       }

   291     } else {

   292       // DMH

   293       tty->print("direct: ");

   294       chain.last_method_oop()->print_short_name(tty);

   295     }

   296 

   297     tty->print(" (");

   298     objArrayOop ptypes = java_lang_invoke_MethodType::ptypes(chain.method_type_oop());

   299     for (int i = ptypes->length() - 1; i >= 0; i--) {

   300       BasicType t = java_lang_Class::as_BasicType(ptypes->obj_at(i));

   301       if (t == T_ARRAY) t = T_OBJECT;

   302       tty->print("%c", type2char(t));

   303       if (t == T_LONG || t == T_DOUBLE) tty->print("_");

   304     }

   305     tty->print(")");

   306     BasicType rtype = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(chain.method_type_oop()));

   307     if (rtype == T_ARRAY) rtype = T_OBJECT;

   308     tty->print("%c", type2char(rtype));

   309     tty->cr();

   310     if (!chain.is_last()) {

   311       chain.next(CHECK);

   312     } else {

   313       break;

   314     }

   315   }

   316 }

   317 #endif

   318 

   319 

   320 // -----------------------------------------------------------------------------

   321 // MethodHandleWalker

   322 

   323 Bytecodes::Code MethodHandleWalker::conversion_code(BasicType src, BasicType dest) {

   324   if (is_subword_type(src)) {

   325     src = T_INT;          // all subword src types act like int

   326   }

   327   if (src == dest) {

   328     return Bytecodes::_nop;

   329   }

   330 

   331 #define SRC_DEST(s,d) (((int)(s) << 4) + (int)(d))

   332   switch (SRC_DEST(src, dest)) {

   333   case SRC_DEST(T_INT, T_LONG):           return Bytecodes::_i2l;

   334   case SRC_DEST(T_INT, T_FLOAT):          return Bytecodes::_i2f;

   335   case SRC_DEST(T_INT, T_DOUBLE):         return Bytecodes::_i2d;

   336   case SRC_DEST(T_INT, T_BYTE):           return Bytecodes::_i2b;

   337   case SRC_DEST(T_INT, T_CHAR):           return Bytecodes::_i2c;

   338   case SRC_DEST(T_INT, T_SHORT):          return Bytecodes::_i2s;

   339 

   340   case SRC_DEST(T_LONG, T_INT):           return Bytecodes::_l2i;

   341   case SRC_DEST(T_LONG, T_FLOAT):         return Bytecodes::_l2f;

   342   case SRC_DEST(T_LONG, T_DOUBLE):        return Bytecodes::_l2d;

   343 

   344   case SRC_DEST(T_FLOAT, T_INT):          return Bytecodes::_f2i;

   345   case SRC_DEST(T_FLOAT, T_LONG):         return Bytecodes::_f2l;

   346   case SRC_DEST(T_FLOAT, T_DOUBLE):       return Bytecodes::_f2d;

   347 

   348   case SRC_DEST(T_DOUBLE, T_INT):         return Bytecodes::_d2i;

   349   case SRC_DEST(T_DOUBLE, T_LONG):        return Bytecodes::_d2l;

   350   case SRC_DEST(T_DOUBLE, T_FLOAT):       return Bytecodes::_d2f;

   351   }

   352 #undef SRC_DEST

   353 

   354   // cannot do it in one step, or at all

   355   return Bytecodes::_illegal;

   356 }

   357 

   358 

   359 // -----------------------------------------------------------------------------

   360 // MethodHandleWalker::walk

   361 //

   362 MethodHandleWalker::ArgToken

   363 MethodHandleWalker::walk(TRAPS) {

   364   ArgToken empty = ArgToken();  // Empty return value.

   365 

   366   walk_incoming_state(CHECK_(empty));

   367 

   368   for (;;) {

   369     set_method_handle(chain().method_handle_oop());

   370 

   371     assert(_outgoing_argc == argument_count_slow(), "empty slots under control");

   372 

   373     if (chain().is_adapter()) {

   374       int conv_op = chain().adapter_conversion_op();

   375       int arg_slot = chain().adapter_arg_slot();

   376 

   377       // Check that the arg_slot is valid.  In most cases it must be

   378       // within range of the current arguments but there are some

   379       // exceptions.  Those are sanity checked in their implemention

   380       // below.

   381       if ((arg_slot < 0 || arg_slot >= _outgoing.length()) &&

   382           conv_op > java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW &&

   383           conv_op != java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS &&

   384           conv_op != java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS) {

   385         lose(err_msg("bad argument index %d", arg_slot), CHECK_(empty));

   386       }

   387 

   388       bool retain_original_args = false;  // used by fold/collect logic

   389 

   390       // perform the adapter action

   391       switch (conv_op) {

   392       case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY:

   393         // No changes to arguments; pass the bits through.

   394         break;

   395 

   396       case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW: {

   397         // To keep the verifier happy, emit bitwise ("raw") conversions as needed.

   398         // See MethodHandles::same_basic_type_for_arguments for allowed conversions.

   399         Handle incoming_mtype(THREAD, chain().method_type_oop());

   400         Handle outgoing_mtype;

   401         {

   402           oop outgoing_mh_oop = chain().vmtarget_oop();

   403           if (!java_lang_invoke_MethodHandle::is_instance(outgoing_mh_oop))

   404             lose("outgoing target not a MethodHandle", CHECK_(empty));

   405           outgoing_mtype = Handle(THREAD, java_lang_invoke_MethodHandle::type(outgoing_mh_oop));

   406         }

   407 

   408         int nptypes = java_lang_invoke_MethodType::ptype_count(outgoing_mtype());

   409         if (nptypes != java_lang_invoke_MethodType::ptype_count(incoming_mtype()))

   410           lose("incoming and outgoing parameter count do not agree", CHECK_(empty));

   411 

   412         // Argument types.

   413         for (int i = 0, slot = _outgoing.length() - 1; slot >= 0; slot--) {

   414           if (arg_type(slot) == T_VOID)  continue;

   415 

   416           klassOop  src_klass = NULL;

   417           klassOop  dst_klass = NULL;

   418           BasicType src = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::ptype(incoming_mtype(), i), &src_klass);

   419           BasicType dst = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::ptype(outgoing_mtype(), i), &dst_klass);

   420           retype_raw_argument_type(src, dst, slot, CHECK_(empty));

   421           i++;  // We need to skip void slots at the top of the loop.

   422         }

   423 

   424         // Return type.

   425         {

   426           BasicType src = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(incoming_mtype()));

   427           BasicType dst = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(outgoing_mtype()));

   428           retype_raw_return_type(src, dst, CHECK_(empty));

   429         }

   430         break;

   431       }

   432 

   433       case java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST: {

   434         // checkcast the Nth outgoing argument in place

   435         klassOop dest_klass = NULL;

   436         BasicType dest = java_lang_Class::as_BasicType(chain().adapter_arg_oop(), &dest_klass);

   437         assert(dest == T_OBJECT, "");

   438         ArgToken arg = _outgoing.at(arg_slot);

   439         assert(dest == arg.basic_type(), "");

   440         arg = make_conversion(T_OBJECT, dest_klass, Bytecodes::_checkcast, arg, CHECK_(empty));

   441         // replace the object by the result of the cast, to make the compiler happy:

   442         change_argument(T_OBJECT, arg_slot, T_OBJECT, arg);

   443         debug_only(dest_klass = (klassOop)badOop);

   444         break;

   445       }

   446 

   447       case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM: {

   448         // i2l, etc., on the Nth outgoing argument in place

   449         BasicType src = chain().adapter_conversion_src_type(),

   450                   dest = chain().adapter_conversion_dest_type();

   451         ArgToken arg = _outgoing.at(arg_slot);

   452         Bytecodes::Code bc = conversion_code(src, dest);

   453         if (bc == Bytecodes::_nop) {

   454           break;

   455         } else if (bc != Bytecodes::_illegal) {

   456           arg = make_conversion(dest, NULL, bc, arg, CHECK_(empty));

   457         } else if (is_subword_type(dest)) {

   458           bc = conversion_code(src, T_INT);

   459           if (bc != Bytecodes::_illegal) {

   460             arg = make_conversion(dest, NULL, bc, arg, CHECK_(empty));

   461             bc = conversion_code(T_INT, dest);

   462             arg = make_conversion(dest, NULL, bc, arg, CHECK_(empty));

   463           }

   464         }

   465         if (bc == Bytecodes::_illegal) {

   466           lose(err_msg("bad primitive conversion for %s -> %s", type2name(src), type2name(dest)), CHECK_(empty));

   467         }

   468         change_argument(src, arg_slot, dest, arg);

   469         break;

   470       }

   471 

   472       case java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM: {

   473         // checkcast to wrapper type & call intValue, etc.

   474         BasicType dest = chain().adapter_conversion_dest_type();

   475         ArgToken arg = _outgoing.at(arg_slot);

   476         arg = make_conversion(T_OBJECT, SystemDictionary::box_klass(dest),

   477                               Bytecodes::_checkcast, arg, CHECK_(empty));

   478         vmIntrinsics::ID unboxer = vmIntrinsics::for_unboxing(dest);

   479         if (unboxer == vmIntrinsics::_none) {

   480           lose("no unboxing method", CHECK_(empty));

   481         }

   482         ArgToken arglist[2];

   483         arglist[0] = arg;         // outgoing 'this'

   484         arglist[1] = ArgToken();  // sentinel

   485         arg = make_invoke(methodHandle(), unboxer, Bytecodes::_invokevirtual, false, 1, &arglist[0], CHECK_(empty));

   486         change_argument(T_OBJECT, arg_slot, dest, arg);

   487         break;

   488       }

   489 

   490       case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_REF: {

   491         // call wrapper type.valueOf

   492         BasicType src = chain().adapter_conversion_src_type();

   493         vmIntrinsics::ID boxer = vmIntrinsics::for_boxing(src);

   494         if (boxer == vmIntrinsics::_none) {

   495           lose("no boxing method", CHECK_(empty));

   496         }

   497         ArgToken arg = _outgoing.at(arg_slot);

   498         ArgToken arglist[2];

   499         arglist[0] = arg;         // outgoing value

   500         arglist[1] = ArgToken();  // sentinel

   501         arg = make_invoke(methodHandle(), boxer, Bytecodes::_invokestatic, false, 1, &arglist[0], CHECK_(empty));

   502         change_argument(src, arg_slot, T_OBJECT, arg);

   503         break;

   504       }

   505 

   506       case java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS: {

   507         int dest_arg_slot = chain().adapter_conversion_vminfo();

   508         if (!has_argument(dest_arg_slot)) {

   509           lose("bad swap index", CHECK_(empty));

   510         }

   511         // a simple swap between two arguments

   512         if (arg_slot > dest_arg_slot) {

   513           int tmp = arg_slot;

   514           arg_slot = dest_arg_slot;

   515           dest_arg_slot = tmp;

   516         }

   517         ArgToken a1 = _outgoing.at(arg_slot);

   518         ArgToken a2 = _outgoing.at(dest_arg_slot);

   519         change_argument(a2.basic_type(), dest_arg_slot, a1);

   520         change_argument(a1.basic_type(), arg_slot, a2);

   521         break;

   522       }

   523 

   524       case java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS: {

   525         int limit_raw  = chain().adapter_conversion_vminfo();

   526         bool rot_down  = (arg_slot < limit_raw);

   527         int limit_bias = (rot_down ? MethodHandles::OP_ROT_ARGS_DOWN_LIMIT_BIAS : 0);

   528         int limit_slot = limit_raw - limit_bias;

   529         if ((uint)limit_slot > (uint)_outgoing.length()) {

   530           lose("bad rotate index", CHECK_(empty));

   531         }

   532         // Rotate the source argument (plus following N slots) into the

   533         // position occupied by the dest argument (plus following N slots).

   534         int rotate_count = type2size[chain().adapter_conversion_src_type()];

   535         // (no other rotate counts are currently supported)

   536         if (rot_down) {

   537           for (int i = 0; i < rotate_count; i++) {

   538             ArgToken temp = _outgoing.at(arg_slot);

   539             _outgoing.remove_at(arg_slot);

   540             _outgoing.insert_before(limit_slot - 1, temp);

   541           }

   542         } else { // arg_slot > limit_slot => rotate_up

   543           for (int i = 0; i < rotate_count; i++) {

   544             ArgToken temp = _outgoing.at(arg_slot + rotate_count - 1);

   545             _outgoing.remove_at(arg_slot + rotate_count - 1);

   546             _outgoing.insert_before(limit_slot, temp);

   547           }

   548         }

   549         assert(_outgoing_argc == argument_count_slow(), "empty slots under control");

   550         break;

   551       }

   552 

   553       case java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS: {

   554         int dup_slots = chain().adapter_conversion_stack_pushes();

   555         if (dup_slots <= 0) {

   556           lose("bad dup count", CHECK_(empty));

   557         }

   558         for (int i = 0; i < dup_slots; i++) {

   559           ArgToken dup = _outgoing.at(arg_slot + 2*i);

   560           if (dup.basic_type() != T_VOID)     _outgoing_argc += 1;

   561           _outgoing.insert_before(i, dup);

   562         }

   563         assert(_outgoing_argc == argument_count_slow(), "empty slots under control");

   564         break;

   565       }

   566 

   567       case java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS: {

   568         int drop_slots = -chain().adapter_conversion_stack_pushes();

   569         if (drop_slots <= 0) {

   570           lose("bad drop count", CHECK_(empty));

   571         }

   572         for (int i = 0; i < drop_slots; i++) {

   573           ArgToken drop = _outgoing.at(arg_slot);

   574           if (drop.basic_type() != T_VOID)    _outgoing_argc -= 1;

   575           _outgoing.remove_at(arg_slot);

   576         }

   577         assert(_outgoing_argc == argument_count_slow(), "empty slots under control");

   578         break;

   579       }

   580 

   581       case java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS:

   582         retain_original_args = true;   // and fall through:

   583       case java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS: {

   584         // call argument MH recursively

   585         //{static int x; if (!x++) print_method_handle(chain().method_handle_oop()); --x;}

   586         Handle recursive_mh(THREAD, chain().adapter_arg_oop());

   587         if (!java_lang_invoke_MethodHandle::is_instance(recursive_mh())) {

   588           lose("recursive target not a MethodHandle", CHECK_(empty));

   589         }

   590         Handle recursive_mtype(THREAD, java_lang_invoke_MethodHandle::type(recursive_mh()));

   591         int argc = java_lang_invoke_MethodType::ptype_count(recursive_mtype());

   592         int coll_slots = java_lang_invoke_MethodHandle::vmslots(recursive_mh());

   593         BasicType rtype = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(recursive_mtype()));

   594         ArgToken* arglist = NEW_RESOURCE_ARRAY(ArgToken, 1 + argc + 1);  // 1+: mh, +1: sentinel

   595         arglist[0] = make_oop_constant(recursive_mh(), CHECK_(empty));

   596         if (arg_slot < 0 || coll_slots < 0 || arg_slot + coll_slots > _outgoing.length()) {

   597           lose("bad fold/collect arg slot", CHECK_(empty));

   598         }

   599         for (int i = 0, slot = arg_slot + coll_slots - 1; slot >= arg_slot; slot--) {

   600           ArgToken arg_state = _outgoing.at(slot);

   601           BasicType  arg_type  = arg_state.basic_type();

   602           if (arg_type == T_VOID)  continue;

   603           ArgToken arg = _outgoing.at(slot);

   604           if (i >= argc) { lose("bad fold/collect arg", CHECK_(empty)); }

   605           arglist[1+i] = arg;

   606           if (!retain_original_args)

   607             change_argument(arg_type, slot, T_VOID, ArgToken(tt_void));

   608           i++;

   609         }

   610         arglist[1+argc] = ArgToken();  // sentinel

   611         oop invoker = java_lang_invoke_MethodTypeForm::vmlayout(

   612                           java_lang_invoke_MethodType::form(recursive_mtype()) );

   613         if (invoker == NULL || !invoker->is_method()) {

   614           lose("bad vmlayout slot", CHECK_(empty));

   615         }

   616         // FIXME: consider inlining the invokee at the bytecode level

   617         ArgToken ret = make_invoke(methodHandle(THREAD, methodOop(invoker)), vmIntrinsics::_invokeGeneric,

   618                                    Bytecodes::_invokevirtual, false, 1+argc, &arglist[0], CHECK_(empty));

   619         // The iid = _invokeGeneric really means to adjust reference types as needed.

   620         DEBUG_ONLY(invoker = NULL);

   621         if (rtype == T_OBJECT) {

   622           klassOop rklass = java_lang_Class::as_klassOop( java_lang_invoke_MethodType::rtype(recursive_mtype()) );

   623           if (rklass != SystemDictionary::Object_klass() &&

   624               !Klass::cast(rklass)->is_interface()) {

   625             // preserve type safety

   626             ret = make_conversion(T_OBJECT, rklass, Bytecodes::_checkcast, ret, CHECK_(empty));

   627           }

   628         }

   629         if (rtype != T_VOID) {

   630           int ret_slot = arg_slot + (retain_original_args ? coll_slots : 0);

   631           change_argument(T_VOID, ret_slot, rtype, ret);

   632         }

   633         break;

   634       }

   635 

   636       case java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS: {

   637         klassOop array_klass_oop = NULL;

   638         BasicType array_type = java_lang_Class::as_BasicType(chain().adapter_arg_oop(),

   639                                                              &array_klass_oop);

   640         assert(array_type == T_OBJECT, "");

   641         assert(Klass::cast(array_klass_oop)->oop_is_array(), "");

   642         arrayKlassHandle array_klass(THREAD, array_klass_oop);

   643         debug_only(array_klass_oop = (klassOop)badOop);

   644 

   645         klassOop element_klass_oop = NULL;

   646         BasicType element_type = java_lang_Class::as_BasicType(array_klass->component_mirror(),

   647                                                                &element_klass_oop);

   648         KlassHandle element_klass(THREAD, element_klass_oop);

   649         debug_only(element_klass_oop = (klassOop)badOop);

   650 

   651         // Fetch the argument, which we will cast to the required array type.

   652         ArgToken arg = _outgoing.at(arg_slot);

   653         assert(arg.basic_type() == T_OBJECT, "");

   654         ArgToken array_arg = arg;

   655         array_arg = make_conversion(T_OBJECT, array_klass(), Bytecodes::_checkcast, array_arg, CHECK_(empty));

   656         change_argument(T_OBJECT, arg_slot, T_VOID, ArgToken(tt_void));

   657 

   658         // Check the required length.

   659         int spread_slots = 1 + chain().adapter_conversion_stack_pushes();

   660         int spread_length = spread_slots;

   661         if (type2size[element_type] == 2) {

   662           if (spread_slots % 2 != 0)  spread_slots = -1;  // force error

   663           spread_length = spread_slots / 2;

   664         }

   665         if (spread_slots < 0) {

   666           lose("bad spread length", CHECK_(empty));

   667         }

   668 

   669         jvalue   length_jvalue;  length_jvalue.i = spread_length;

   670         ArgToken length_arg = make_prim_constant(T_INT, &length_jvalue, CHECK_(empty));

   671         // Call a built-in method known to the JVM to validate the length.

   672         ArgToken arglist[3];

   673         arglist[0] = array_arg;   // value to check

   674         arglist[1] = length_arg;  // length to check

   675         arglist[2] = ArgToken();  // sentinel

   676         make_invoke(methodHandle(), vmIntrinsics::_checkSpreadArgument,

   677                     Bytecodes::_invokestatic, false, 2, &arglist[0], CHECK_(empty));

   678 

   679         // Spread out the array elements.

   680         Bytecodes::Code aload_op = Bytecodes::_nop;

   681         switch (element_type) {

   682         case T_INT:       aload_op = Bytecodes::_iaload; break;

   683         case T_LONG:      aload_op = Bytecodes::_laload; break;

   684         case T_FLOAT:     aload_op = Bytecodes::_faload; break;

   685         case T_DOUBLE:    aload_op = Bytecodes::_daload; break;

   686         case T_OBJECT:    aload_op = Bytecodes::_aaload; break;

   687         case T_BOOLEAN:   // fall through:

   688         case T_BYTE:      aload_op = Bytecodes::_baload; break;

   689         case T_CHAR:      aload_op = Bytecodes::_caload; break;

   690         case T_SHORT:     aload_op = Bytecodes::_saload; break;

   691         default:          lose("primitive array NYI", CHECK_(empty));

   692         }

   693         int ap = arg_slot;

   694         for (int i = 0; i < spread_length; i++) {

   695           jvalue   offset_jvalue;  offset_jvalue.i = i;

   696           ArgToken offset_arg = make_prim_constant(T_INT, &offset_jvalue, CHECK_(empty));

   697           ArgToken element_arg = make_fetch(element_type, element_klass(), aload_op, array_arg, offset_arg, CHECK_(empty));

   698           change_argument(T_VOID, ap, element_type, element_arg);

   699           //ap += type2size[element_type];  // don't do this; insert next arg to *right* of previous

   700         }

   701         break;

   702       }

   703 

   704       default:

   705         lose("bad adapter conversion", CHECK_(empty));

   706         break;

   707       }

   708     }

   709 

   710     if (chain().is_bound()) {

   711       // push a new argument

   712       BasicType arg_type  = chain().bound_arg_type();

   713       jint      arg_slot  = chain().bound_arg_slot();

   714       oop       arg_oop   = chain().bound_arg_oop();

   715       ArgToken  arg;

   716       if (arg_type == T_OBJECT) {

   717         arg = make_oop_constant(arg_oop, CHECK_(empty));

   718       } else {

   719         jvalue arg_value;

   720         BasicType bt = java_lang_boxing_object::get_value(arg_oop, &arg_value);

   721         if (bt == arg_type || (bt == T_INT && is_subword_type(arg_type))) {

   722           arg = make_prim_constant(arg_type, &arg_value, CHECK_(empty));

   723         } else {

   724           lose(err_msg("bad bound value: arg_type %s boxing %s", type2name(arg_type), type2name(bt)), CHECK_(empty));

   725         }

   726       }

   727       DEBUG_ONLY(arg_oop = badOop);

   728       change_argument(T_VOID, arg_slot, arg_type, arg);

   729     }

   730 

   731     // this test must come after the body of the loop

   732     if (!chain().is_last()) {

   733       chain().next(CHECK_(empty));

   734     } else {

   735       break;

   736     }

   737   }

   738 

   739   // finish the sequence with a tail-call to the ultimate target

   740   // parameters are passed in logical order (recv 1st), not slot order

   741   ArgToken* arglist = NEW_RESOURCE_ARRAY(ArgToken, _outgoing.length() + 1);

   742   int ap = 0;

   743   for (int i = _outgoing.length() - 1; i >= 0; i--) {

   744     ArgToken arg_state = _outgoing.at(i);

   745     if (arg_state.basic_type() == T_VOID)  continue;

   746     arglist[ap++] = _outgoing.at(i);

   747   }

   748   assert(ap == _outgoing_argc, "");

   749   arglist[ap] = ArgToken();  // add a sentinel, for the sake of asserts

   750   return make_invoke(chain().last_method(),

   751                      vmIntrinsics::_none,

   752                      chain().last_invoke_code(), true,

   753                      ap, arglist, THREAD);

   754 }

   755 

   756 

   757 // -----------------------------------------------------------------------------

   758 // MethodHandleWalker::walk_incoming_state

   759 //

   760 void MethodHandleWalker::walk_incoming_state(TRAPS) {

   761   Handle mtype(THREAD, chain().method_type_oop());

   762   int nptypes = java_lang_invoke_MethodType::ptype_count(mtype());

   763   _outgoing_argc = nptypes;

   764   int argp = nptypes - 1;

   765   if (argp >= 0) {

   766     _outgoing.at_grow(argp, ArgToken(tt_void)); // presize

   767   }

   768   for (int i = 0; i < nptypes; i++) {

   769     klassOop  arg_type_klass = NULL;

   770     BasicType arg_type = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::ptype(mtype(), i), &arg_type_klass);

   771     int index = new_local_index(arg_type);

   772     ArgToken arg = make_parameter(arg_type, arg_type_klass, index, CHECK);

   773     DEBUG_ONLY(arg_type_klass = (klassOop) NULL);

   774     _outgoing.at_put(argp, arg);

   775     if (type2size[arg_type] == 2) {

   776       // add the extra slot, so we can model the JVM stack

   777       _outgoing.insert_before(argp+1, ArgToken(tt_void));

   778     }

   779     --argp;

   780   }

   781   // call make_parameter at the end of the list for the return type

   782   klassOop  ret_type_klass = NULL;

   783   BasicType ret_type = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(mtype()), &ret_type_klass);

   784   ArgToken  ret = make_parameter(ret_type, ret_type_klass, -1, CHECK);

   785   // ignore ret; client can catch it if needed

   786 

   787   assert(_outgoing_argc == argument_count_slow(), "empty slots under control");

   788 

   789   verify_args_and_signature(CHECK);

   790 }

   791 

   792 

   793 #ifdef ASSERT

   794 void MethodHandleWalker::verify_args_and_signature(TRAPS) {

   795   int index = _outgoing.length() - 1;

   796   objArrayOop ptypes = java_lang_invoke_MethodType::ptypes(chain().method_type_oop());

   797   for (int i = 0, limit = ptypes->length(); i < limit; i++) {

   798     BasicType t = java_lang_Class::as_BasicType(ptypes->obj_at(i));

   799     if (t == T_ARRAY) t = T_OBJECT;

   800     if (t == T_LONG || t == T_DOUBLE) {

   801       assert(T_VOID == _outgoing.at(index).basic_type(), "types must match");

   802       index--;

   803     }

   804     assert(t == _outgoing.at(index).basic_type(), "types must match");

   805     index--;

   806   }

   807 }

   808 #endif

   809 

   810 

   811 // -----------------------------------------------------------------------------

   812 // MethodHandleWalker::change_argument

   813 //

   814 // This is messy because some kinds of arguments are paired with

   815 // companion slots containing an empty value.

   816 void MethodHandleWalker::change_argument(BasicType old_type, int slot, const ArgToken& new_arg) {

   817   BasicType new_type = new_arg.basic_type();

   818   int old_size = type2size[old_type];

   819   int new_size = type2size[new_type];

   820   if (old_size == new_size) {

   821     // simple case first

   822     _outgoing.at_put(slot, new_arg);

   823   } else if (old_size > new_size) {

   824     for (int i = old_size - 1; i >= new_size; i--) {

   825       assert((i != 0) == (_outgoing.at(slot + i).basic_type() == T_VOID), "");

   826       _outgoing.remove_at(slot + i);

   827     }

   828     if (new_size > 0)

   829       _outgoing.at_put(slot, new_arg);

   830     else

   831       _outgoing_argc -= 1;      // deleted a real argument

   832   } else {

   833     for (int i = old_size; i < new_size; i++) {

   834       _outgoing.insert_before(slot + i, ArgToken(tt_void));

   835     }

   836     _outgoing.at_put(slot, new_arg);

   837     if (old_size == 0)

   838       _outgoing_argc += 1;      // inserted a real argument

   839   }

   840   assert(_outgoing_argc == argument_count_slow(), "empty slots under control");

   841 }

   842 

   843 

   844 #ifdef ASSERT

   845 int MethodHandleWalker::argument_count_slow() {

   846   int args_seen = 0;

   847   for (int i = _outgoing.length() - 1; i >= 0; i--) {

   848     if (_outgoing.at(i).basic_type() != T_VOID) {

   849       ++args_seen;

   850       if (_outgoing.at(i).basic_type() == T_LONG ||

   851           _outgoing.at(i).basic_type() == T_DOUBLE) {

   852         assert(_outgoing.at(i + 1).basic_type() == T_VOID, "should only follow two word");

   853       }

   854     } else {

   855       assert(_outgoing.at(i - 1).basic_type() == T_LONG ||

   856              _outgoing.at(i - 1).basic_type() == T_DOUBLE, "should only follow two word");

   857     }

   858   }

   859   return args_seen;

   860 }

   861 #endif

   862 

   863 

   864 // -----------------------------------------------------------------------------

   865 // MethodHandleWalker::retype_raw_conversion

   866 //

   867 // Do the raw retype conversions for OP_RETYPE_RAW.

   868 void MethodHandleWalker::retype_raw_conversion(BasicType src, BasicType dst, bool for_return, int slot, TRAPS) {

   869   if (src != dst) {

   870     if (MethodHandles::same_basic_type_for_returns(src, dst, /*raw*/ true)) {

   871       if (MethodHandles::is_float_fixed_reinterpretation_cast(src, dst)) {

   872         vmIntrinsics::ID iid = vmIntrinsics::for_raw_conversion(src, dst);

   873         if (iid == vmIntrinsics::_none) {

   874           lose("no raw conversion method", CHECK);

   875         }

   876         ArgToken arglist[2];

   877         if (!for_return) {

   878           // argument type conversion

   879           ArgToken arg = _outgoing.at(slot);

   880           assert(arg.token_type() >= tt_symbolic || src == arg.basic_type(), "sanity");

   881           arglist[0] = arg;         // outgoing 'this'

   882           arglist[1] = ArgToken();  // sentinel

   883           arg = make_invoke(methodHandle(), iid, Bytecodes::_invokestatic, false, 1, &arglist[0], CHECK);

   884           change_argument(src, slot, dst, arg);

   885         } else {

   886           // return type conversion

   887           if (_return_conv == vmIntrinsics::_none) {

   888             _return_conv = iid;

   889           } else if (_return_conv == vmIntrinsics::for_raw_conversion(dst, src)) {

   890             _return_conv = vmIntrinsics::_none;

   891           } else if (_return_conv != zero_return_conv()) {

   892             lose(err_msg("requested raw return conversion not allowed: %s -> %s (before %s)", type2name(src), type2name(dst), vmIntrinsics::name_at(_return_conv)), CHECK);

   893           }

   894         }

   895       } else {

   896         // Nothing to do.

   897       }

   898     } else if (for_return && (!is_subword_type(src) || !is_subword_type(dst))) {

   899       // This can occur in exception-throwing MHs, which have a fictitious return value encoded as Void or Empty.

   900       _return_conv = zero_return_conv();

   901     } else if (src == T_OBJECT && is_java_primitive(dst)) {

   902       // ref-to-prim: discard ref, push zero

   903       lose("requested ref-to-prim conversion not expected", CHECK);

   904     } else {

   905       lose(err_msg("requested raw conversion not allowed: %s -> %s", type2name(src), type2name(dst)), CHECK);

   906     }

   907   }

   908 }

   909 

   910 

   911 // -----------------------------------------------------------------------------

   912 // MethodHandleCompiler

   913 

   914 MethodHandleCompiler::MethodHandleCompiler(Handle root, Symbol* name, Symbol* signature, int invoke_count, bool is_invokedynamic, TRAPS)

   915   : MethodHandleWalker(root, is_invokedynamic, THREAD),

   916     _invoke_count(invoke_count),

   917     _thread(THREAD),

   918     _bytecode(THREAD, 50),

   919     _constants(THREAD, 10),

   920     _non_bcp_klasses(THREAD, 5),

   921     _cur_stack(0),

   922     _max_stack(0),

   923     _rtype(T_ILLEGAL),

   924     _selectAlternative_bci(-1),

   925     _taken_count(0),

   926     _not_taken_count(0)

   927 {

   928 

   929   // Element zero is always the null constant.

   930   (void) _constants.append(NULL);

   931 

   932   // Set name and signature index.

   933   _name_index      = cpool_symbol_put(name);

   934   _signature_index = cpool_symbol_put(signature);

   935 

   936   // To make the resulting methods more recognizable by

   937   // stack walkers and compiler heuristics,

   938   // we put them in holder class MethodHandle.

   939   // See klass_is_method_handle_adapter_holder

   940   // and methodOopDesc::is_method_handle_adapter.

   941   _target_klass = SystemDictionaryHandles::MethodHandle_klass();

   942 

   943   check_non_bcp_klasses(java_lang_invoke_MethodHandle::type(root()), CHECK);

   944 

   945   // Get return type klass.

   946   Handle first_mtype(THREAD, chain().method_type_oop());

   947   // _rklass is NULL for primitives.

   948   _rtype = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(first_mtype()), &_rklass);

   949   if (_rtype == T_ARRAY)  _rtype = T_OBJECT;

   950 

   951   ArgumentSizeComputer args(signature);

   952   int params = args.size() + 1;  // Incoming arguments plus receiver.

   953   _num_params = for_invokedynamic() ? params - 1 : params;  // XXX Check if callee is static?

   954 }

   955 

   956 

   957 // -----------------------------------------------------------------------------

   958 // MethodHandleCompiler::compile

   959 //

   960 // Compile this MethodHandle into a bytecode adapter and return a

   961 // methodOop.

   962 methodHandle MethodHandleCompiler::compile(TRAPS) {

   963   assert(_thread == THREAD, "must be same thread");

   964   methodHandle nullHandle;

   965   (void) walk(CHECK_(nullHandle));

   966   record_non_bcp_klasses();

   967   return get_method_oop(CHECK_(nullHandle));

   968 }

   969 

   970 

   971 void MethodHandleCompiler::emit_bc(Bytecodes::Code op, int index, int args_size) {

   972   Bytecodes::check(op);  // Are we legal?

   973 

   974   switch (op) {

   975   // b

   976   case Bytecodes::_aconst_null:

   977   case Bytecodes::_iconst_m1:

   978   case Bytecodes::_iconst_0:

   979   case Bytecodes::_iconst_1:

   980   case Bytecodes::_iconst_2:

   981   case Bytecodes::_iconst_3:

   982   case Bytecodes::_iconst_4:

   983   case Bytecodes::_iconst_5:

   984   case Bytecodes::_lconst_0:

   985   case Bytecodes::_lconst_1:

   986   case Bytecodes::_fconst_0:

   987   case Bytecodes::_fconst_1:

   988   case Bytecodes::_fconst_2:

   989   case Bytecodes::_dconst_0:

   990   case Bytecodes::_dconst_1:

   991   case Bytecodes::_iload_0:

   992   case Bytecodes::_iload_1:

   993   case Bytecodes::_iload_2:

   994   case Bytecodes::_iload_3:

   995   case Bytecodes::_lload_0:

   996   case Bytecodes::_lload_1:

   997   case Bytecodes::_lload_2:

   998   case Bytecodes::_lload_3:

   999   case Bytecodes::_fload_0:

  1000   case Bytecodes::_fload_1:

  1001   case Bytecodes::_fload_2:

  1002   case Bytecodes::_fload_3:

  1003   case Bytecodes::_dload_0:

  1004   case Bytecodes::_dload_1:

  1005   case Bytecodes::_dload_2:

  1006   case Bytecodes::_dload_3:

  1007   case Bytecodes::_aload_0:

  1008   case Bytecodes::_aload_1:

  1009   case Bytecodes::_aload_2:

  1010   case Bytecodes::_aload_3:

  1011   case Bytecodes::_istore_0:

  1012   case Bytecodes::_istore_1:

  1013   case Bytecodes::_istore_2:

  1014   case Bytecodes::_istore_3:

  1015   case Bytecodes::_lstore_0:

  1016   case Bytecodes::_lstore_1:

  1017   case Bytecodes::_lstore_2:

  1018   case Bytecodes::_lstore_3:

  1019   case Bytecodes::_fstore_0:

  1020   case Bytecodes::_fstore_1:

  1021   case Bytecodes::_fstore_2:

  1022   case Bytecodes::_fstore_3:

  1023   case Bytecodes::_dstore_0:

  1024   case Bytecodes::_dstore_1:

  1025   case Bytecodes::_dstore_2:

  1026   case Bytecodes::_dstore_3:

  1027   case Bytecodes::_astore_0:

  1028   case Bytecodes::_astore_1:

  1029   case Bytecodes::_astore_2:

  1030   case Bytecodes::_astore_3:

  1031   case Bytecodes::_iand:

  1032   case Bytecodes::_i2l:

  1033   case Bytecodes::_i2f:

  1034   case Bytecodes::_i2d:

  1035   case Bytecodes::_i2b:

  1036   case Bytecodes::_i2c:

  1037   case Bytecodes::_i2s:

  1038   case Bytecodes::_l2i:

  1039   case Bytecodes::_l2f:

  1040   case Bytecodes::_l2d:

  1041   case Bytecodes::_f2i:

  1042   case Bytecodes::_f2l:

  1043   case Bytecodes::_f2d:

  1044   case Bytecodes::_d2i:

  1045   case Bytecodes::_d2l:

  1046   case Bytecodes::_d2f:

  1047   case Bytecodes::_iaload:

  1048   case Bytecodes::_laload:

  1049   case Bytecodes::_faload:

  1050   case Bytecodes::_daload:

  1051   case Bytecodes::_aaload:

  1052   case Bytecodes::_baload:

  1053   case Bytecodes::_caload:

  1054   case Bytecodes::_saload:

  1055   case Bytecodes::_ireturn:

  1056   case Bytecodes::_lreturn:

  1057   case Bytecodes::_freturn:

  1058   case Bytecodes::_dreturn:

  1059   case Bytecodes::_areturn:

  1060   case Bytecodes::_return:

  1061     assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_b, "wrong bytecode format");

  1062     _bytecode.push(op);

  1063     break;

  1064 

  1065   // bi

  1066   case Bytecodes::_ldc:

  1067     assert(Bytecodes::format_bits(op, false) == (Bytecodes::_fmt_b|Bytecodes::_fmt_has_k), "wrong bytecode format");

  1068     if (index == (index & 0xff)) {

  1069       _bytecode.push(op);

  1070       _bytecode.push(index);

  1071     } else {

  1072       _bytecode.push(Bytecodes::_ldc_w);

  1073       _bytecode.push(index >> 8);

  1074       _bytecode.push(index);

  1075     }

  1076     break;

  1077 

  1078   case Bytecodes::_iload:

  1079   case Bytecodes::_lload:

  1080   case Bytecodes::_fload:

  1081   case Bytecodes::_dload:

  1082   case Bytecodes::_aload:

  1083   case Bytecodes::_istore:

  1084   case Bytecodes::_lstore:

  1085   case Bytecodes::_fstore:

  1086   case Bytecodes::_dstore:

  1087   case Bytecodes::_astore:

  1088     assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_bi, "wrong bytecode format");

  1089     if (index == (index & 0xff)) {

  1090       _bytecode.push(op);

  1091       _bytecode.push(index);

  1092     } else {

  1093       // doesn't fit in a u2

  1094       _bytecode.push(Bytecodes::_wide);

  1095       _bytecode.push(op);

  1096       _bytecode.push(index >> 8);

  1097       _bytecode.push(index);

  1098     }

  1099     break;

  1100 

  1101   // bkk

  1102   case Bytecodes::_ldc_w:

  1103   case Bytecodes::_ldc2_w:

  1104   case Bytecodes::_checkcast:

  1105     assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_bkk, "wrong bytecode format");

  1106     assert((unsigned short) index == index, "index does not fit in 16-bit");

  1107     _bytecode.push(op);

  1108     _bytecode.push(index >> 8);

  1109     _bytecode.push(index);

  1110     break;

  1111 

  1112   // bJJ

  1113   case Bytecodes::_invokestatic:

  1114   case Bytecodes::_invokespecial:

  1115   case Bytecodes::_invokevirtual:

  1116     assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_bJJ, "wrong bytecode format");

  1117     assert((unsigned short) index == index, "index does not fit in 16-bit");

  1118     _bytecode.push(op);

  1119     _bytecode.push(index >> 8);

  1120     _bytecode.push(index);

  1121     break;

  1122 

  1123   case Bytecodes::_invokeinterface:

  1124     assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_bJJ, "wrong bytecode format");

  1125     assert((unsigned short) index == index, "index does not fit in 16-bit");

  1126     assert(args_size > 0, "valid args_size");

  1127     _bytecode.push(op);

  1128     _bytecode.push(index >> 8);

  1129     _bytecode.push(index);

  1130     _bytecode.push(args_size);

  1131     _bytecode.push(0);

  1132     break;

  1133 

  1134   case Bytecodes::_ifeq: