rewriter.cpp 20.6 KB
Newer Older
D
duke 已提交
1
/*
2
 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
D
duke 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
19 20 21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
D
duke 已提交
22 23 24
 *
 */

25 26 27 28 29 30 31
#include "precompiled.hpp"
#include "interpreter/bytecodes.hpp"
#include "interpreter/interpreter.hpp"
#include "interpreter/rewriter.hpp"
#include "memory/gcLocker.hpp"
#include "memory/resourceArea.hpp"
#include "oops/generateOopMap.hpp"
32
#include "prims/methodHandles.hpp"
D
duke 已提交
33

34
// Computes a CPC map (new_index -> original_index) for constant pool entries
D
duke 已提交
35
// that are referred to by the interpreter at runtime via the constant pool cache.
36 37 38 39
// Also computes a CP map (original_index -> new_index).
// Marks entries in CP which require additional processing.
void Rewriter::compute_index_maps() {
  const int length  = _pool->length();
40
  init_maps(length);
41
  bool saw_mh_symbol = false;
D
duke 已提交
42
  for (int i = 0; i < length; i++) {
43 44 45
    int tag = _pool->tag_at(i).value();
    switch (tag) {
      case JVM_CONSTANT_InterfaceMethodref:
D
duke 已提交
46 47
      case JVM_CONSTANT_Fieldref          : // fall through
      case JVM_CONSTANT_Methodref         : // fall through
48 49 50
        add_cp_cache_entry(i);
        break;
      case JVM_CONSTANT_String:
51 52
      case JVM_CONSTANT_MethodHandle      : // fall through
      case JVM_CONSTANT_MethodType        : // fall through
53
        add_resolved_references_entry(i);
54
        break;
55 56 57 58
      case JVM_CONSTANT_Utf8:
        if (_pool->symbol_at(i) == vmSymbols::java_lang_invoke_MethodHandle())
          saw_mh_symbol = true;
        break;
D
duke 已提交
59 60
    }
  }
61

62 63 64
  // Record limits of resolved reference map for constant pool cache indices
  record_map_limits();

65 66
  guarantee((int)_cp_cache_map.length()-1 <= (int)((u2)-1),
            "all cp cache indexes fit in a u2");
67

68 69
  if (saw_mh_symbol)
    _method_handle_invokers.initialize(length, (int)0);
D
duke 已提交
70 71
}

72
// Unrewrite the bytecodes if an error occurs.
73
void Rewriter::restore_bytecodes(TRAPS) {
74 75 76
  int len = _methods->length();

  for (int i = len-1; i >= 0; i--) {
77
    Method* method = _methods->at(i);
78
    scan_method(method, true, CHECK);
79 80
  }
}
D
duke 已提交
81

82 83
// Creates a constant pool cache given a CPC map
void Rewriter::make_constant_pool_cache(TRAPS) {
84 85
  ClassLoaderData* loader_data = _pool->pool_holder()->class_loader_data();
  ConstantPoolCache* cache =
86 87
      ConstantPoolCache::allocate(loader_data, _cp_cache_map,
                                  _invokedynamic_cp_cache_map,
88
                                  _invokedynamic_references_map, CHECK);
89 90 91 92 93

  // initialize object cache in constant pool
  _pool->initialize_resolved_references(loader_data, _resolved_references_map,
                                        _resolved_reference_limit,
                                        CHECK);
94 95
  _pool->set_cache(cache);
  cache->set_constant_pool(_pool());
D
duke 已提交
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
}



// The new finalization semantics says that registration of
// finalizable objects must be performed on successful return from the
// Object.<init> constructor.  We could implement this trivially if
// <init> were never rewritten but since JVMTI allows this to occur, a
// more complicated solution is required.  A special return bytecode
// is used only by Object.<init> to signal the finalization
// registration point.  Additionally local 0 must be preserved so it's
// available to pass to the registration function.  For simplicty we
// require that local 0 is never overwritten so it's available as an
// argument for registration.

void Rewriter::rewrite_Object_init(methodHandle method, TRAPS) {
  RawBytecodeStream bcs(method);
  while (!bcs.is_last_bytecode()) {
    Bytecodes::Code opcode = bcs.raw_next();
    switch (opcode) {
      case Bytecodes::_return: *bcs.bcp() = Bytecodes::_return_register_finalizer; break;

      case Bytecodes::_istore:
      case Bytecodes::_lstore:
      case Bytecodes::_fstore:
      case Bytecodes::_dstore:
      case Bytecodes::_astore:
        if (bcs.get_index() != 0) continue;

        // fall through
      case Bytecodes::_istore_0:
      case Bytecodes::_lstore_0:
      case Bytecodes::_fstore_0:
      case Bytecodes::_dstore_0:
      case Bytecodes::_astore_0:
        THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(),
                  "can't overwrite local 0 in Object.<init>");
        break;
    }
  }
}


139
// Rewrite a classfile-order CP index into a native-order CPC index.
140
void Rewriter::rewrite_member_reference(address bcp, int offset, bool reverse) {
141
  address p = bcp + offset;
142 143 144 145
  if (!reverse) {
    int  cp_index    = Bytes::get_Java_u2(p);
    int  cache_index = cp_entry_to_cp_cache(cp_index);
    Bytes::put_native_u2(p, cache_index);
146
    if (!_method_handle_invokers.is_empty())
147
      maybe_rewrite_invokehandle(p - 1, cp_index, cache_index, reverse);
148 149 150 151
  } else {
    int cache_index = Bytes::get_native_u2(p);
    int pool_index = cp_cache_entry_pool_index(cache_index);
    Bytes::put_Java_u2(p, pool_index);
152
    if (!_method_handle_invokers.is_empty())
153
      maybe_rewrite_invokehandle(p - 1, pool_index, cache_index, reverse);
154 155 156
  }
}

157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
// If the constant pool entry for invokespecial is InterfaceMethodref,
// we need to add a separate cpCache entry for its resolution, because it is
// different than the resolution for invokeinterface with InterfaceMethodref.
// These cannot share cpCache entries.  It's unclear if all invokespecial to
// InterfaceMethodrefs would resolve to the same thing so a new cpCache entry
// is created for each one.  This was added with lambda.
void Rewriter::rewrite_invokespecial(address bcp, int offset, bool reverse, TRAPS) {
  static int count = 0;
  address p = bcp + offset;
  if (!reverse) {
    int cp_index = Bytes::get_Java_u2(p);
    int cache_index = add_invokespecial_cp_cache_entry(cp_index);
    if (cache_index != (int)(jushort) cache_index) {
      THROW_MSG(vmSymbols::java_lang_InternalError(),
                "This classfile overflows invokespecial for interfaces "
                "and cannot be loaded");
    }
    Bytes::put_native_u2(p, cache_index);
  } else {
    int cache_index = Bytes::get_native_u2(p);
    int cp_index = cp_cache_entry_pool_index(cache_index);
    Bytes::put_Java_u2(p, cp_index);
  }
}

182 183

// Adjust the invocation bytecode for a signature-polymorphic method (MethodHandle.invoke, etc.)
184
void Rewriter::maybe_rewrite_invokehandle(address opc, int cp_index, int cache_index, bool reverse) {
185 186 187 188 189 190 191 192 193 194 195 196
  if (!reverse) {
    if ((*opc) == (u1)Bytecodes::_invokevirtual ||
        // allow invokespecial as an alias, although it would be very odd:
        (*opc) == (u1)Bytecodes::_invokespecial) {
      assert(_pool->tag_at(cp_index).is_method(), "wrong index");
      // Determine whether this is a signature-polymorphic method.
      if (cp_index >= _method_handle_invokers.length())  return;
      int status = _method_handle_invokers[cp_index];
      assert(status >= -1 && status <= 1, "oob tri-state");
      if (status == 0) {
        if (_pool->klass_ref_at_noresolve(cp_index) == vmSymbols::java_lang_invoke_MethodHandle() &&
            MethodHandles::is_signature_polymorphic_name(SystemDictionary::MethodHandle_klass(),
197 198
                                                         _pool->name_ref_at(cp_index))) {
          // we may need a resolved_refs entry for the appendix
199
          add_invokedynamic_resolved_references_entries(cp_index, cache_index);
200
          status = +1;
201
        } else {
202
          status = -1;
203
        }
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
        _method_handle_invokers[cp_index] = status;
      }
      // We use a special internal bytecode for such methods (if non-static).
      // The basic reason for this is that such methods need an extra "appendix" argument
      // to transmit the call site's intended call type.
      if (status > 0) {
        (*opc) = (u1)Bytecodes::_invokehandle;
      }
    }
  } else {
    // Do not need to look at cp_index.
    if ((*opc) == (u1)Bytecodes::_invokehandle) {
      (*opc) = (u1)Bytecodes::_invokevirtual;
      // Ignore corner case of original _invokespecial instruction.
      // This is safe because (a) the signature polymorphic method was final, and
      // (b) the implementation of MethodHandle will not call invokespecial on it.
    }
221
  }
222 223 224
}


225
void Rewriter::rewrite_invokedynamic(address bcp, int offset, bool reverse) {
226
  address p = bcp + offset;
227 228 229
  assert(p[-1] == Bytecodes::_invokedynamic, "not invokedynamic bytecode");
  if (!reverse) {
    int cp_index = Bytes::get_Java_u2(p);
230
    int cache_index = add_invokedynamic_cp_cache_entry(cp_index);
231
    int resolved_index = add_invokedynamic_resolved_references_entries(cp_index, cache_index);
232 233 234 235 236 237 238 239 240
    // Replace the trailing four bytes with a CPC index for the dynamic
    // call site.  Unlike other CPC entries, there is one per bytecode,
    // not just one per distinct CP entry.  In other words, the
    // CPC-to-CP relation is many-to-one for invokedynamic entries.
    // This means we must use a larger index size than u2 to address
    // all these entries.  That is the main reason invokedynamic
    // must have a five-byte instruction format.  (Of course, other JVM
    // implementations can use the bytes for other purposes.)
    // Note: We use native_u4 format exclusively for 4-byte indexes.
241 242 243 244 245
    Bytes::put_native_u4(p, ConstantPool::encode_invokedynamic_index(cache_index));
    // add the bcp in case we need to patch this bytecode if we also find a
    // invokespecial/InterfaceMethodref in the bytecode stream
    _patch_invokedynamic_bcps->push(p);
    _patch_invokedynamic_refs->push(resolved_index);
246
  } else {
247
    int cache_index = ConstantPool::decode_invokedynamic_index(
248
                        Bytes::get_native_u4(p));
249 250 251 252 253
    // We will reverse the bytecode rewriting _after_ adjusting them.
    // Adjust the cache index by offset to the invokedynamic entries in the
    // cpCache plus the delta if the invokedynamic bytecodes were adjusted.
    cache_index = cp_cache_delta() + _first_iteration_cp_cache_limit;
    int cp_index = invokedynamic_cp_cache_entry_pool_index(cache_index);
254
    assert(_pool->tag_at(cp_index).is_invoke_dynamic(), "wrong index");
255 256
    // zero out 4 bytes
    Bytes::put_Java_u4(p, 0);
257
    Bytes::put_Java_u2(p, cp_index);
258
  }
259 260
}

261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
void Rewriter::patch_invokedynamic_bytecodes() {
  // If the end of the cp_cache is the same as after initializing with the
  // cpool, nothing needs to be done.  Invokedynamic bytecodes are at the
  // correct offsets. ie. no invokespecials added
  int delta = cp_cache_delta();
  if (delta > 0) {
    int length = _patch_invokedynamic_bcps->length();
    assert(length == _patch_invokedynamic_refs->length(),
           "lengths should match");
    for (int i = 0; i < length; i++) {
      address p = _patch_invokedynamic_bcps->at(i);
      int cache_index = ConstantPool::decode_invokedynamic_index(
                          Bytes::get_native_u4(p));
      Bytes::put_native_u4(p, ConstantPool::encode_invokedynamic_index(cache_index + delta));

      // invokedynamic resolved references map also points to cp cache and must
      // add delta to each.
      int resolved_index = _patch_invokedynamic_refs->at(i);
      for (int entry = 0; entry < ConstantPoolCacheEntry::_indy_resolved_references_entries; entry++) {
        assert(_invokedynamic_references_map[resolved_index+entry] == cache_index,
             "should be the same index");
        _invokedynamic_references_map.at_put(resolved_index+entry,
                                             cache_index + delta);
      }
    }
  }
}

289

290
// Rewrite some ldc bytecodes to _fast_aldc
291 292 293 294 295 296 297
void Rewriter::maybe_rewrite_ldc(address bcp, int offset, bool is_wide,
                                 bool reverse) {
  if (!reverse) {
    assert((*bcp) == (is_wide ? Bytecodes::_ldc_w : Bytecodes::_ldc), "not ldc bytecode");
    address p = bcp + offset;
    int cp_index = is_wide ? Bytes::get_Java_u2(p) : (u1)(*p);
    constantTag tag = _pool->tag_at(cp_index).value();
298
    if (tag.is_method_handle() || tag.is_method_type() || tag.is_string()) {
299
      int ref_index = cp_entry_to_resolved_references(cp_index);
300 301
      if (is_wide) {
        (*bcp) = Bytecodes::_fast_aldc_w;
302 303
        assert(ref_index == (u2)ref_index, "index overflow");
        Bytes::put_native_u2(p, ref_index);
304 305
      } else {
        (*bcp) = Bytecodes::_fast_aldc;
306 307
        assert(ref_index == (u1)ref_index, "index overflow");
        (*p) = (u1)ref_index;
308 309 310 311 312 313 314
      }
    }
  } else {
    Bytecodes::Code rewritten_bc =
              (is_wide ? Bytecodes::_fast_aldc_w : Bytecodes::_fast_aldc);
    if ((*bcp) == rewritten_bc) {
      address p = bcp + offset;
315 316
      int ref_index = is_wide ? Bytes::get_native_u2(p) : (u1)(*p);
      int pool_index = resolved_references_entry_to_pool_index(ref_index);
317 318 319 320 321 322 323 324 325
      if (is_wide) {
        (*bcp) = Bytecodes::_ldc_w;
        assert(pool_index == (u2)pool_index, "index overflow");
        Bytes::put_Java_u2(p, pool_index);
      } else {
        (*bcp) = Bytecodes::_ldc;
        assert(pool_index == (u1)pool_index, "index overflow");
        (*p) = (u1)pool_index;
      }
326 327 328 329 330
    }
  }
}


D
duke 已提交
331
// Rewrites a method given the index_map information
332
void Rewriter::scan_method(Method* method, bool reverse, TRAPS) {
D
duke 已提交
333 334 335 336 337 338

  int nof_jsrs = 0;
  bool has_monitor_bytecodes = false;

  {
    // We cannot tolerate a GC in this block, because we've
339
    // cached the bytecodes in 'code_base'. If the Method*
D
duke 已提交
340 341 342 343 344 345 346 347 348 349 350
    // moves, the bytecodes will also move.
    No_Safepoint_Verifier nsv;
    Bytecodes::Code c;

    // Bytecodes and their length
    const address code_base = method->code_base();
    const int code_length = method->code_size();

    int bc_length;
    for (int bci = 0; bci < code_length; bci += bc_length) {
      address bcp = code_base + bci;
351
      int prefix_length = 0;
D
duke 已提交
352 353 354 355 356 357 358 359
      c = (Bytecodes::Code)(*bcp);

      // Since we have the code, see if we can get the length
      // directly. Some more complicated bytecodes will report
      // a length of zero, meaning we need to make another method
      // call to calculate the length.
      bc_length = Bytecodes::length_for(c);
      if (bc_length == 0) {
360
        bc_length = Bytecodes::length_at(method, bcp);
D
duke 已提交
361 362 363 364 365

        // length_at will put us at the bytecode after the one modified
        // by 'wide'. We don't currently examine any of the bytecodes
        // modified by wide, but in case we do in the future...
        if (c == Bytecodes::_wide) {
366
          prefix_length = 1;
D
duke 已提交
367 368 369 370 371 372 373 374 375
          c = (Bytecodes::Code)bcp[1];
        }
      }

      assert(bc_length != 0, "impossible bytecode length");

      switch (c) {
        case Bytecodes::_lookupswitch   : {
#ifndef CC_INTERP
376
          Bytecode_lookupswitch bc(method, bcp);
377
          (*bcp) = (
378
            bc.number_of_pairs() < BinarySwitchThreshold
D
duke 已提交
379 380 381
            ? Bytecodes::_fast_linearswitch
            : Bytecodes::_fast_binaryswitch
          );
382 383 384 385 386 387 388
#endif
          break;
        }
        case Bytecodes::_fast_linearswitch:
        case Bytecodes::_fast_binaryswitch: {
#ifndef CC_INTERP
          (*bcp) = Bytecodes::_lookupswitch;
D
duke 已提交
389 390 391
#endif
          break;
        }
392 393 394 395 396 397 398 399 400 401 402 403 404 405

        case Bytecodes::_invokespecial  : {
          int offset = prefix_length + 1;
          address p = bcp + offset;
          int cp_index = Bytes::get_Java_u2(p);
          // InterfaceMethodref
          if (_pool->tag_at(cp_index).is_interface_method()) {
            rewrite_invokespecial(bcp, offset, reverse, CHECK);
          } else {
            rewrite_member_reference(bcp, offset, reverse);
          }
          break;
        }

D
duke 已提交
406 407 408 409 410
        case Bytecodes::_getstatic      : // fall through
        case Bytecodes::_putstatic      : // fall through
        case Bytecodes::_getfield       : // fall through
        case Bytecodes::_putfield       : // fall through
        case Bytecodes::_invokevirtual  : // fall through
411 412
        case Bytecodes::_invokestatic   :
        case Bytecodes::_invokeinterface:
413
        case Bytecodes::_invokehandle   : // if reverse=true
414
          rewrite_member_reference(bcp, prefix_length+1, reverse);
415 416
          break;
        case Bytecodes::_invokedynamic:
417
          rewrite_invokedynamic(bcp, prefix_length+1, reverse);
D
duke 已提交
418
          break;
419
        case Bytecodes::_ldc:
420
        case Bytecodes::_fast_aldc:  // if reverse=true
421
          maybe_rewrite_ldc(bcp, prefix_length+1, false, reverse);
422 423
          break;
        case Bytecodes::_ldc_w:
424
        case Bytecodes::_fast_aldc_w:  // if reverse=true
425
          maybe_rewrite_ldc(bcp, prefix_length+1, true, reverse);
426
          break;
D
duke 已提交
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
        case Bytecodes::_jsr            : // fall through
        case Bytecodes::_jsr_w          : nof_jsrs++;                   break;
        case Bytecodes::_monitorenter   : // fall through
        case Bytecodes::_monitorexit    : has_monitor_bytecodes = true; break;
      }
    }
  }

  // Update access flags
  if (has_monitor_bytecodes) {
    method->set_has_monitor_bytecodes();
  }

  // The present of a jsr bytecode implies that the method might potentially
  // have to be rewritten, so we run the oopMapGenerator on the method
  if (nof_jsrs > 0) {
    method->set_has_jsrs();
444
    // Second pass will revisit this method.
445
    assert(method->has_jsrs(), "didn't we just set this?");
446 447
  }
}
D
duke 已提交
448

449 450
// After constant pool is created, revisit methods containing jsrs.
methodHandle Rewriter::rewrite_jsrs(methodHandle method, TRAPS) {
451
  ResourceMark rm(THREAD);
452 453 454 455 456 457 458
  ResolveOopMapConflicts romc(method);
  methodHandle original_method = method;
  method = romc.do_potential_rewrite(CHECK_(methodHandle()));
  // Update monitor matching info.
  if (romc.monitor_safe()) {
    method->set_guaranteed_monitor_matching();
  }
D
duke 已提交
459 460 461 462 463 464

  return method;
}

void Rewriter::rewrite(instanceKlassHandle klass, TRAPS) {
  ResourceMark rm(THREAD);
465
  Rewriter     rw(klass, klass->constants(), klass->methods(), CHECK);
466 467
  // (That's all, folks.)
}
D
duke 已提交
468

469

470
Rewriter::Rewriter(instanceKlassHandle klass, constantPoolHandle cpool, Array<Method*>* methods, TRAPS)
471
  : _klass(klass),
472 473
    _pool(cpool),
    _methods(methods)
474 475
{
  assert(_pool->cache() == NULL, "constant pool cache must not be set yet");
D
duke 已提交
476

477
  // determine index maps for Method* rewriting
478
  compute_index_maps();
D
duke 已提交
479

480
  if (RegisterFinalizersAtInit && _klass->name() == vmSymbols::java_lang_Object()) {
481
    bool did_rewrite = false;
482
    int i = _methods->length();
D
duke 已提交
483
    while (i-- > 0) {
484
      Method* method = _methods->at(i);
D
duke 已提交
485 486 487 488 489
      if (method->intrinsic_id() == vmIntrinsics::_Object_init) {
        // rewrite the return bytecodes of Object.<init> to register the
        // object for finalization if needed.
        methodHandle m(THREAD, method);
        rewrite_Object_init(m, CHECK);
490
        did_rewrite = true;
D
duke 已提交
491 492 493
        break;
      }
    }
494
    assert(did_rewrite, "must find Object::<init> to rewrite it");
D
duke 已提交
495 496
  }

497
  // rewrite methods, in two passes
498
  int len = _methods->length();
499

500
  for (int i = len-1; i >= 0; i--) {
501
    Method* method = _methods->at(i);
502 503
    scan_method(method, false, CHECK);  // If you get an error here,
                                        // there is no reversing bytecodes
504 505
  }

506 507 508 509
  // May have to fix invokedynamic bytecodes if invokestatic/InterfaceMethodref
  // entries had to be added.
  patch_invokedynamic_bytecodes();

510
  // allocate constant pool cache, now that we've seen all the bytecodes
511 512 513 514 515
  make_constant_pool_cache(THREAD);

  // Restore bytecodes to their unrewritten state if there are exceptions
  // rewriting bytecodes or allocating the cpCache
  if (HAS_PENDING_EXCEPTION) {
516
    restore_bytecodes(CATCH);
517 518 519
    return;
  }

520 521 522 523
  // Relocate after everything, but still do this under the is_rewritten flag,
  // so methods with jsrs in custom class lists in aren't attempted to be
  // rewritten in the RO section of the shared archive.
  // Relocated bytecodes don't have to be restored, only the cp cache entries
524
  for (int i = len-1; i >= 0; i--) {
525
    methodHandle m(THREAD, _methods->at(i));
526 527

    if (m->has_jsrs()) {
528 529 530 531 532
      m = rewrite_jsrs(m, THREAD);
      // Restore bytecodes to their unrewritten state if there are exceptions
      // relocating bytecodes.  If some are relocated, that is ok because that
      // doesn't affect constant pool to cpCache rewriting.
      if (HAS_PENDING_EXCEPTION) {
533
        restore_bytecodes(CATCH);
534 535
        return;
      }
D
duke 已提交
536
      // Method might have gotten rewritten.
537
      methods->at_put(i, m());
D
duke 已提交
538 539 540
    }
  }
}