1 /*
   2  * Copyright (c) 1999, 2018, 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 "ci/ciCallSite.hpp"
  27 #include "ci/ciConstant.hpp"
  28 #include "ci/ciField.hpp"
  29 #include "ci/ciStreams.hpp"
  30 #include "ci/ciUtilities.inline.hpp"
  31 #include "runtime/handles.inline.hpp"
  32 
  33 // ciExceptionHandlerStream
  34 //
  35 // Walk over some selected set of a methods exception handlers.
  36 
  37 // ------------------------------------------------------------------
  38 // ciExceptionHandlerStream::count
  39 //
  40 // How many exception handlers are there in this stream?
  41 //
  42 // Implementation note: Compiler2 needs this functionality, so I had
  43 int ciExceptionHandlerStream::count() {
  44   int save_pos = _pos;
  45   int save_end = _end;
  46 
  47   int count = 0;
  48 
  49   _pos = -1;
  50   _end = _method->_handler_count;
  51 
  52 
  53   next();
  54   while (!is_done()) {
  55     count++;
  56     next();
  57   }
  58 
  59   _pos = save_pos;
  60   _end = save_end;
  61 
  62   return count;
  63 }
  64 
  65 int ciExceptionHandlerStream::count_remaining() {
  66   int save_pos = _pos;
  67   int save_end = _end;
  68 
  69   int count = 0;
  70 
  71   while (!is_done()) {
  72     count++;
  73     next();
  74   }
  75 
  76   _pos = save_pos;
  77   _end = save_end;
  78 
  79   return count;
  80 }
  81 
  82 // ciBytecodeStream
  83 //
  84 // The class is used to iterate over the bytecodes of a method.
  85 // It hides the details of constant pool structure/access by
  86 // providing accessors for constant pool items.
  87 
  88 // ------------------------------------------------------------------
  89 // ciBytecodeStream::next_wide_or_table
  90 //
  91 // Special handling for switch ops
  92 Bytecodes::Code ciBytecodeStream::next_wide_or_table(Bytecodes::Code bc) {
  93   switch (bc) {                // Check for special bytecode handling
  94   case Bytecodes::_wide:
  95     // Special handling for the wide bytcode
  96     // Get following bytecode; do not return wide
  97     assert(Bytecodes::Code(_pc[0]) == Bytecodes::_wide, "");
  98     bc = Bytecodes::java_code(_raw_bc = (Bytecodes::Code)_pc[1]);
  99     assert(Bytecodes::wide_length_for(bc) > 2, "must make progress");
 100     _pc += Bytecodes::wide_length_for(bc);
 101     _was_wide = _pc;              // Flag last wide bytecode found
 102     assert(is_wide(), "accessor works right");
 103     break;
 104 
 105   case Bytecodes::_lookupswitch:
 106     _pc++;                      // Skip wide bytecode
 107     _pc += (_start-_pc)&3;      // Word align
 108     _table_base = (jint*)_pc;   // Capture for later usage
 109                                 // table_base[0] is default far_dest
 110     // Table has 2 lead elements (default, length), then pairs of u4 values.
 111     // So load table length, and compute address at end of table
 112     _pc = (address)&_table_base[2+ 2*Bytes::get_Java_u4((address)&_table_base[1])];
 113     break;
 114 
 115   case Bytecodes::_tableswitch: {
 116     _pc++;                      // Skip wide bytecode
 117     _pc += (_start-_pc)&3;      // Word align
 118     _table_base = (jint*)_pc;   // Capture for later usage
 119                                 // table_base[0] is default far_dest
 120     int lo = Bytes::get_Java_u4((address)&_table_base[1]);// Low bound
 121     int hi = Bytes::get_Java_u4((address)&_table_base[2]);// High bound
 122     int len = hi - lo + 1;      // Dense table size
 123     _pc = (address)&_table_base[3+len]; // Skip past table
 124     break;
 125   }
 126 
 127   default:
 128     fatal("unhandled bytecode");
 129   }
 130   return bc;
 131 }
 132 
 133 // ------------------------------------------------------------------
 134 // ciBytecodeStream::reset_to_bci
 135 void ciBytecodeStream::reset_to_bci( int bci ) {
 136   _bc_start=_was_wide=0;
 137   _pc = _start+bci;
 138 }
 139 
 140 // ------------------------------------------------------------------
 141 // ciBytecodeStream::force_bci
 142 void ciBytecodeStream::force_bci(int bci) {
 143   if (bci < 0) {
 144     reset_to_bci(0);
 145     _bc_start = _start + bci;
 146     _bc = EOBC();
 147   } else {
 148     reset_to_bci(bci);
 149     next();
 150   }
 151 }
 152 
 153 
 154 // ------------------------------------------------------------------
 155 // Constant pool access
 156 // ------------------------------------------------------------------
 157 
 158 // ------------------------------------------------------------------
 159 // ciBytecodeStream::get_klass_index
 160 //
 161 // If this bytecodes references a klass, return the index of the
 162 // referenced klass.
 163 int ciBytecodeStream::get_klass_index() const {
 164   switch(cur_bc()) {
 165   case Bytecodes::_ldc:
 166     return get_index_u1();
 167   case Bytecodes::_ldc_w:
 168   case Bytecodes::_ldc2_w:
 169   case Bytecodes::_checkcast:
 170   case Bytecodes::_instanceof:
 171   case Bytecodes::_anewarray:
 172   case Bytecodes::_multianewarray:
 173   case Bytecodes::_new:
 174   case Bytecodes::_defaultvalue:
 175   case Bytecodes::_newarray:
 176     return get_index_u2();
 177   default:
 178     ShouldNotReachHere();
 179     return 0;
 180   }
 181 }
 182 
 183 // ------------------------------------------------------------------
 184 // ciBytecodeStream::get_klass
 185 //
 186 // If this bytecode is a new, newarray, multianewarray, instanceof,
 187 // or checkcast, get the referenced klass.
 188 ciKlass* ciBytecodeStream::get_klass(bool& will_link) {
 189   VM_ENTRY_MARK;
 190   constantPoolHandle cpool(_method->get_Method()->constants());
 191   return CURRENT_ENV->get_klass_by_index(cpool, get_klass_index(), will_link, _holder);
 192 }
 193 
 194 // ------------------------------------------------------------------
 195 // ciBytecodeStream::is_klass_never_null
 196 //
 197 // Get information about nullability from the constant pool.
 198 bool ciBytecodeStream::is_klass_never_null() const {
 199   VM_ENTRY_MARK;
 200   constantPoolHandle cpool(_method->get_Method()->constants());
 201   return CURRENT_ENV->is_klass_never_null(cpool, get_klass_index());
 202 }
 203 
 204 // ------------------------------------------------------------------
 205 // ciBytecodeStream::get_constant_raw_index
 206 //
 207 // If this bytecode is one of the ldc variants, get the index of the
 208 // referenced constant.
 209 int ciBytecodeStream::get_constant_raw_index() const {
 210   // work-alike for Bytecode_loadconstant::raw_index()
 211   switch (cur_bc()) {
 212   case Bytecodes::_ldc:
 213     return get_index_u1();
 214   case Bytecodes::_ldc_w:
 215   case Bytecodes::_ldc2_w:
 216     return get_index_u2();
 217   default:
 218     ShouldNotReachHere();
 219     return 0;
 220   }
 221 }
 222 
 223 // ------------------------------------------------------------------
 224 // ciBytecodeStream::get_constant_pool_index
 225 // Decode any reference index into a regular pool index.
 226 int ciBytecodeStream::get_constant_pool_index() const {
 227   // work-alike for Bytecode_loadconstant::pool_index()
 228   int index = get_constant_raw_index();
 229   if (has_cache_index()) {
 230     VM_ENTRY_MARK;
 231     constantPoolHandle cpool(_method->get_Method()->constants());
 232     return cpool->object_to_cp_index(index);
 233   }
 234   return index;
 235 }
 236 
 237 // ------------------------------------------------------------------
 238 // ciBytecodeStream::get_constant_cache_index
 239 // Return the CP cache index, or -1 if there isn't any.
 240 int ciBytecodeStream::get_constant_cache_index() const {
 241   // work-alike for Bytecode_loadconstant::cache_index()
 242   return has_cache_index() ? get_constant_raw_index() : -1;
 243 }
 244 
 245 // ------------------------------------------------------------------
 246 // ciBytecodeStream::get_constant
 247 //
 248 // If this bytecode is one of the ldc variants, get the referenced
 249 // constant.
 250 ciConstant ciBytecodeStream::get_constant() {
 251   int pool_index = get_constant_raw_index();
 252   int cache_index = -1;
 253   if (has_cache_index()) {
 254     cache_index = pool_index;
 255     pool_index = -1;
 256   }
 257   VM_ENTRY_MARK;
 258   constantPoolHandle cpool(_method->get_Method()->constants());
 259   return CURRENT_ENV->get_constant_by_index(cpool, pool_index, cache_index, _holder);
 260 }
 261 
 262 // ------------------------------------------------------------------
 263 // ciBytecodeStream::get_constant_pool_tag
 264 //
 265 // If this bytecode is one of the ldc variants, get the referenced
 266 // constant.
 267 constantTag ciBytecodeStream::get_constant_pool_tag(int index) const {
 268   VM_ENTRY_MARK;
 269   return _method->get_Method()->constants()->constant_tag_at(index);
 270 }
 271 
 272 // ------------------------------------------------------------------
 273 // ciBytecodeStream::get_field_index
 274 //
 275 // If this is a field access bytecode, get the constant pool
 276 // index of the referenced field.
 277 int ciBytecodeStream::get_field_index() {
 278   assert(cur_bc() == Bytecodes::_getfield ||
 279          cur_bc() == Bytecodes::_putfield ||
 280          cur_bc() == Bytecodes::_getstatic ||
 281          cur_bc() == Bytecodes::_putstatic ||
 282          cur_bc() == Bytecodes::_withfield, "wrong bc");
 283   return get_index_u2_cpcache();
 284 }
 285 
 286 
 287 // ------------------------------------------------------------------
 288 // ciBytecodeStream::get_field
 289 //
 290 // If this bytecode is one of get_field, get_static, put_field,
 291 // or put_static, get the referenced field.
 292 ciField* ciBytecodeStream::get_field(bool& will_link) {
 293   ciField* f = CURRENT_ENV->get_field_by_index(_holder, get_field_index());
 294   will_link = f->will_link(_method, _bc);
 295   return f;
 296 }
 297 
 298 
 299 // ------------------------------------------------------------------
 300 // ciBytecodeStream::get_declared_field_holder
 301 //
 302 // Get the declared holder of the currently referenced field.
 303 //
 304 // Usage note: the holder() of a ciField class returns the canonical
 305 // holder of the field, rather than the holder declared in the
 306 // bytecodes.
 307 //
 308 // There is no "will_link" result passed back.  The user is responsible
 309 // for checking linkability when retrieving the associated field.
 310 ciInstanceKlass* ciBytecodeStream::get_declared_field_holder() {
 311   VM_ENTRY_MARK;
 312   constantPoolHandle cpool(_method->get_Method()->constants());
 313   int holder_index = get_field_holder_index();
 314   bool ignore;
 315   return CURRENT_ENV->get_klass_by_index(cpool, holder_index, ignore, _holder)
 316       ->as_instance_klass();
 317 }
 318 
 319 // ------------------------------------------------------------------
 320 // ciBytecodeStream::get_field_holder_index
 321 //
 322 // Get the constant pool index of the declared holder of the field
 323 // referenced by the current bytecode.  Used for generating
 324 // deoptimization information.
 325 int ciBytecodeStream::get_field_holder_index() {
 326   GUARDED_VM_ENTRY(
 327     ConstantPool* cpool = _holder->get_instanceKlass()->constants();
 328     return cpool->klass_ref_index_at(get_field_index());
 329   )
 330 }
 331 
 332 // ------------------------------------------------------------------
 333 // ciBytecodeStream::get_field_signature_index
 334 //
 335 // Get the constant pool index of the signature of the field
 336 // referenced by the current bytecode.  Used for generating
 337 // deoptimization information.
 338 int ciBytecodeStream::get_field_signature_index() {
 339   VM_ENTRY_MARK;
 340   ConstantPool* cpool = _holder->get_instanceKlass()->constants();
 341   int nt_index = cpool->name_and_type_ref_index_at(get_field_index());
 342   return cpool->signature_ref_index_at(nt_index);
 343 }
 344 
 345 // ------------------------------------------------------------------
 346 // ciBytecodeStream::get_method_index
 347 //
 348 // If this is a method invocation bytecode, get the constant pool
 349 // index of the invoked method.
 350 int ciBytecodeStream::get_method_index() {
 351 #ifdef ASSERT
 352   switch (cur_bc()) {
 353   case Bytecodes::_invokeinterface:
 354   case Bytecodes::_invokevirtual:
 355   case Bytecodes::_invokespecial:
 356   case Bytecodes::_invokestatic:
 357   case Bytecodes::_invokedynamic:
 358     break;
 359   default:
 360     ShouldNotReachHere();
 361   }
 362 #endif
 363   if (has_index_u4())
 364     return get_index_u4();  // invokedynamic
 365   return get_index_u2_cpcache();
 366 }
 367 
 368 // ------------------------------------------------------------------
 369 // ciBytecodeStream::get_method
 370 //
 371 // If this is a method invocation bytecode, get the invoked method.
 372 // Additionally return the declared signature to get more concrete
 373 // type information if required (Cf. invokedynamic and invokehandle).
 374 ciMethod* ciBytecodeStream::get_method(bool& will_link, ciSignature* *declared_signature_result) {
 375   VM_ENTRY_MARK;
 376   ciEnv* env = CURRENT_ENV;
 377   constantPoolHandle cpool(THREAD, _method->get_Method()->constants());
 378   ciMethod* m = env->get_method_by_index(cpool, get_method_index(), cur_bc(), _holder);
 379   will_link = m->is_loaded();
 380 
 381   // Use the MethodType stored in the CP cache to create a signature
 382   // with correct types (in respect to class loaders).
 383   if (has_method_type()) {
 384     ciSymbol*     sig_sym     = env->get_symbol(cpool->symbol_at(get_method_signature_index(cpool)));
 385     ciKlass*      pool_holder = env->get_klass(cpool->pool_holder());
 386     ciMethodType* method_type = get_method_type();
 387     ciSignature* declared_signature = new (env->arena()) ciSignature(pool_holder, sig_sym, method_type);
 388     (*declared_signature_result) = declared_signature;
 389   } else {
 390     (*declared_signature_result) = m->signature();
 391   }
 392   return m;
 393 }
 394 
 395 // ------------------------------------------------------------------
 396 // ciBytecodeStream::has_appendix
 397 //
 398 // Returns true if there is an appendix argument stored in the
 399 // constant pool cache at the current bci.
 400 bool ciBytecodeStream::has_appendix() {
 401   VM_ENTRY_MARK;
 402   constantPoolHandle cpool(_method->get_Method()->constants());
 403   return ConstantPool::has_appendix_at_if_loaded(cpool, get_method_index());
 404 }
 405 
 406 // ------------------------------------------------------------------
 407 // ciBytecodeStream::get_appendix
 408 //
 409 // Return the appendix argument stored in the constant pool cache at
 410 // the current bci.
 411 ciObject* ciBytecodeStream::get_appendix() {
 412   VM_ENTRY_MARK;
 413   constantPoolHandle cpool(_method->get_Method()->constants());
 414   oop appendix_oop = ConstantPool::appendix_at_if_loaded(cpool, get_method_index());
 415   return CURRENT_ENV->get_object(appendix_oop);
 416 }
 417 
 418 // ------------------------------------------------------------------
 419 // ciBytecodeStream::has_method_type
 420 //
 421 // Returns true if there is a MethodType argument stored in the
 422 // constant pool cache at the current bci.
 423 bool ciBytecodeStream::has_method_type() {
 424   GUARDED_VM_ENTRY(
 425     constantPoolHandle cpool(_method->get_Method()->constants());
 426     return ConstantPool::has_method_type_at_if_loaded(cpool, get_method_index());
 427   )
 428 }
 429 
 430 // ------------------------------------------------------------------
 431 // ciBytecodeStream::get_method_type
 432 //
 433 // Return the MethodType stored in the constant pool cache at
 434 // the current bci.
 435 ciMethodType* ciBytecodeStream::get_method_type() {
 436   GUARDED_VM_ENTRY(
 437     constantPoolHandle cpool(_method->get_Method()->constants());
 438     oop method_type_oop = ConstantPool::method_type_at_if_loaded(cpool, get_method_index());
 439     return CURRENT_ENV->get_object(method_type_oop)->as_method_type();
 440   )
 441 }
 442 
 443 // ------------------------------------------------------------------
 444 // ciBytecodeStream::get_declared_method_holder
 445 //
 446 // Get the declared holder of the currently referenced method.
 447 //
 448 // Usage note: the holder() of a ciMethod class returns the canonical
 449 // holder of the method, rather than the holder declared in the
 450 // bytecodes.
 451 //
 452 // There is no "will_link" result passed back.  The user is responsible
 453 // for checking linkability when retrieving the associated method.
 454 ciKlass* ciBytecodeStream::get_declared_method_holder() {
 455   VM_ENTRY_MARK;
 456   constantPoolHandle cpool(_method->get_Method()->constants());
 457   bool ignore;
 458   // report as MethodHandle for invokedynamic, which is syntactically classless
 459   if (cur_bc() == Bytecodes::_invokedynamic)
 460     return CURRENT_ENV->get_klass_by_name(_holder, ciSymbol::java_lang_invoke_MethodHandle(), false);
 461   return CURRENT_ENV->get_klass_by_index(cpool, get_method_holder_index(), ignore, _holder);
 462 }
 463 
 464 // ------------------------------------------------------------------
 465 // ciBytecodeStream::get_method_holder_index
 466 //
 467 // Get the constant pool index of the declared holder of the method
 468 // referenced by the current bytecode.  Used for generating
 469 // deoptimization information.
 470 int ciBytecodeStream::get_method_holder_index() {
 471   ConstantPool* cpool = _method->get_Method()->constants();
 472   return cpool->klass_ref_index_at(get_method_index());
 473 }
 474 
 475 // ------------------------------------------------------------------
 476 // ciBytecodeStream::get_method_signature_index
 477 //
 478 // Get the constant pool index of the signature of the method
 479 // referenced by the current bytecode.  Used for generating
 480 // deoptimization information.
 481 int ciBytecodeStream::get_method_signature_index(const constantPoolHandle& cpool) {
 482   GUARDED_VM_ENTRY(
 483     const int method_index = get_method_index();
 484     const int name_and_type_index = cpool->name_and_type_ref_index_at(method_index);
 485     return cpool->signature_ref_index_at(name_and_type_index);
 486   )
 487 }
 488 
 489 // ------------------------------------------------------------------
 490 // ciBytecodeStream::get_resolved_references
 491 ciObjArray* ciBytecodeStream::get_resolved_references() {
 492     VM_ENTRY_MARK;
 493     // Get the constant pool.
 494   ConstantPool*        cpool   = _holder->get_instanceKlass()->constants();
 495 
 496   // Create a resolved references array and return it.
 497   return CURRENT_ENV->get_object(cpool->resolved_references())->as_obj_array();
 498   }