*** old/src/share/vm/c1/c1_Runtime1.cpp	Wed Aug 21 16:07:21 2013
--- new/src/share/vm/c1/c1_Runtime1.cpp	Wed Aug 21 16:07:20 2013

*** 817,826 ****
--- 817,827 ----
    bool deoptimize_for_volatile = false;
    int patch_field_offset = -1;
    KlassHandle init_klass(THREAD, NULL); // klass needed by load_klass_patching code
    KlassHandle load_klass(THREAD, NULL); // klass needed by load_klass_patching code
    Handle mirror(THREAD, NULL);                    // oop needed by load_mirror_patching code
+   Handle appendix(THREAD, NULL);                  // oop needed by appendix_patching code
    bool load_klass_or_mirror_patch_id =
      (stub_id == Runtime1::load_klass_patching_id || stub_id == Runtime1::load_mirror_patching_id);
  
    if (stub_id == Runtime1::access_field_patching_id) {
  

*** 886,899 ****
--- 887,922 ----
            Bytecode_loadconstant cc(caller_method, bci);
            oop m = cc.resolve_constant(CHECK);
            mirror = Handle(THREAD, m);
          }
          break;
!       default: Unimplemented();
!       default: fatal("unexpected bytecode for load_klass_or_mirror_patch_id");
      }
      // convert to handle
      load_klass = KlassHandle(THREAD, k);
+   } else if (stub_id == load_appendix_patching_id) {
+     Bytecode_invoke bytecode(caller_method, bci);
+     Bytecodes::Code bc = bytecode.invoke_code();
+ 
+     CallInfo info;
+     constantPoolHandle pool(thread, caller_method->constants());
+     int index = bytecode.index();
+     LinkResolver::resolve_invoke(info, Handle(), pool, index, bc, CHECK);
+     appendix = info.resolved_appendix();
+     switch (bc) {
+       case Bytecodes::_invokehandle: {
+         int cache_index = ConstantPool::decode_cpcache_index(index, true);
+         assert(cache_index >= 0 && cache_index < pool->cache()->length(), "unexpected cache index");
+         pool->cache()->entry_at(cache_index)->set_method_handle(pool, info);
+         break;
+       }
+       case Bytecodes::_invokedynamic: {
+         pool->invokedynamic_cp_cache_entry_at(index)->set_dynamic_call(pool, info);
+         break;
+       }
+       default: fatal("unexpected bytecode for load_appendix_patching_id");
+     }
    } else {
      ShouldNotReachHere();
    }
  
    if (deoptimize_for_volatile) {

*** 915,925 ****
--- 938,949 ----
      // Return to the now deoptimized frame.
    }
  
    // If we are patching in a non-perm oop, make sure the nmethod
    // is on the right list.
!   if (ScavengeRootsInCode && mirror.not_null() && mirror()->is_scavengable()) {
!   if (ScavengeRootsInCode && ((mirror.not_null() && mirror()->is_scavengable()) ||
+                               (appendix.not_null() && appendix->is_scavengable()))) {
      MutexLockerEx ml_code (CodeCache_lock, Mutex::_no_safepoint_check_flag);
      nmethod* nm = CodeCache::find_nmethod(caller_frame.pc());
      guarantee(nm != NULL, "only nmethods can contain non-perm oops");
      if (!nm->on_scavenge_root_list())
        CodeCache::add_scavenge_root_nmethod(nm);

*** 1010,1021 ****
--- 1034,1061 ----
              }
  
              if (TracePatching) {
                Disassembler::decode(copy_buff, copy_buff + *byte_count, tty);
              }
+           }
+         } else if (stub_id == Runtime1::load_appendix_patching_id) {
+           NativeMovConstReg* n_copy = nativeMovConstReg_at(copy_buff);
+           assert(n_copy->data() == 0 ||
+                  n_copy->data() == (intptr_t)Universe::non_oop_word(),
+                  "illegal init value");
+           n_copy->set_data((intx) (appendix()));
+ 
+           if (TracePatching) {
+             Disassembler::decode(copy_buff, copy_buff + *byte_count, tty);
+           }
+         } else {
+           ShouldNotReachHere();
+         }
  
  #if defined(SPARC) || defined(PPC)
+         if (load_klass_or_mirror_patch_id ||
+             stub_id == Runtime1::load_appendix_patching_id) {
            // Update the location in the nmethod with the proper
            // metadata.  When the code was generated, a NULL was stuffed
            // in the metadata table and that table needs to be update to
            // have the right value.  On intel the value is kept
            // directly in the instruction instead of in the metadata

*** 1024,1037 ****
--- 1064,1078 ----
            assert(nm != NULL, "invalid nmethod_pc");
            RelocIterator mds(nm, copy_buff, copy_buff + 1);
            bool found = false;
            while (mds.next() && !found) {
              if (mds.type() == relocInfo::oop_type) {
                  assert(stub_id == Runtime1::load_mirror_patching_id, "wrong stub id");
+               assert(stub_id == Runtime1::load_mirror_patching_id ||
+                      stub_id == Runtime1::load_appendix_patching_id, "wrong stub id");
                oop_Relocation* r = mds.oop_reloc();
                oop* oop_adr = r->oop_addr();
!                 *oop_adr = mirror();
!               *oop_adr = stub_id == Runtime1::load_mirror_patching_id ? mirror() : appendix();
                r->fix_oop_relocation();
                found = true;
              } else if (mds.type() == relocInfo::metadata_type) {
                assert(stub_id == Runtime1::load_klass_patching_id, "wrong stub id");
                metadata_Relocation* r = mds.metadata_reloc();

*** 1040,1056 ****
--- 1081,1092 ----
                r->fix_metadata_relocation();
                found = true;
              }
            }
            assert(found, "the metadata must exist!");
  #endif
  
          }
          } else {
            ShouldNotReachHere();
          }
  
+ #endif
          if (do_patch) {
            // replace instructions
            // first replace the tail, then the call
  #ifdef ARM
            if(load_klass_or_mirror_patch_id && !VM_Version::supports_movw()) {

*** 1085,1095 ****
--- 1121,1132 ----
              *(unsigned char*)dst = (unsigned char) a_byte;
            }
            ICache::invalidate_range(instr_pc, *byte_count);
            NativeGeneralJump::replace_mt_safe(instr_pc, copy_buff);
  
!           if (load_klass_or_mirror_patch_id) {
!           if (load_klass_or_mirror_patch_id ||
+               stub_id == Runtime1::load_appendix_patching_id) {
              relocInfo::relocType rtype =
                (stub_id == Runtime1::load_klass_patching_id) ?
                                     relocInfo::metadata_type :
                                     relocInfo::oop_type;
              // update relocInfo to metadata

*** 1172,1181 ****
--- 1209,1236 ----
    // Return true if calling code is deoptimized
  
    return caller_is_deopted();
  }
  
+ int Runtime1::move_appendix_patching(JavaThread* thread) {
+ //
+ // NOTE: we are still in Java
+ //
+   Thread* THREAD = thread;
+   debug_only(NoHandleMark nhm;)
+   {
+     // Enter VM mode
+ 
+     ResetNoHandleMark rnhm;
+     patch_code(thread, load_appendix_patching_id);
+   }
+   // Back in JAVA, use no oops DON'T safepoint
+ 
+   // Return true if calling code is deoptimized
+ 
+   return caller_is_deopted();
+ }
  //
  // Entry point for compiled code. We want to patch a nmethod.
  // We don't do a normal VM transition here because we want to
  // know after the patching is complete and any safepoint(s) are taken
  // if the calling nmethod was deoptimized. We do this by calling a