--- /dev/null	2016-10-31 17:47:19.000000000 -0700
+++ new/src/share/vm/aot/aotCompiledMethod.cpp	2016-10-31 17:47:19.000000000 -0700
@@ -0,0 +1,454 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * 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.
+ *
+ * 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.
+ */
+
+#include "precompiled.hpp"
+
+#include "code/codeCache.hpp"
+#include "code/compiledIC.hpp"
+#include "code/nativeInst.hpp"
+#include "compiler/compilerOracle.hpp"
+#include "gc/shared/cardTableModRefBS.hpp"
+#include "gc/shared/collectedHeap.hpp"
+#include "gc/shared/gcLocker.hpp"
+#include "jvmci/compilerRuntime.hpp"
+#include "jvmci/jvmciRuntime.hpp"
+#include "oops/method.hpp"
+#include "aot/aotCompiledMethod.hpp"
+#include "aot/aotLoader.hpp"
+#include "aot/aotCodeHeap.hpp"
+#include "aot/compiledIC_aot.hpp"
+#include "runtime/java.hpp"
+#include "runtime/os.hpp"
+#include "runtime/sharedRuntime.hpp"
+#include "utilities/array.hpp"
+#include "utilities/xmlstream.hpp"
+
+#include <dlfcn.h>
+#include <stdio.h>
+
+#if 0
+static void metadata_oops_do(Metadata** metadata_begin, Metadata **metadata_end, OopClosure* f) {
+  // Visit the metadata/oops section
+  for (Metadata** p = metadata_begin; p < metadata_end; p++) {
+    Metadata* m = *p;
+
+    intptr_t meta = (intptr_t)m;
+    if ((meta & 1) == 1) {
+      // already resolved
+      m = (Metadata*)(meta & ~1);
+    } else {
+      continue;
+    }
+    assert(Metaspace::contains(m), "");
+    if (m->is_method()) {
+      m = ((Method*)m)->method_holder();
+    }
+    assert(m->is_klass(), "must be");
+    oop o = ((Klass*)m)->klass_holder();
+    if (o != NULL) {
+      f->do_oop(&o);
+    }
+  }
+}
+#endif
+
+void AOTCompiledMethod::oops_do(OopClosure* f) {
+  if (_oop != NULL) {
+    f->do_oop(&_oop);
+  }
+#if 0
+  metadata_oops_do(metadata_begin(), metadata_end(), f);
+#endif
+}
+
+bool AOTCompiledMethod::do_unloading_oops(address low_boundary, BoolObjectClosure* is_alive, bool unloading_occurred) {
+  return false;
+}
+
+oop AOTCompiledMethod::oop_at(int index) const {
+  if (index == 0) { // 0 is reserved
+    return NULL;
+  }
+  Metadata** entry = _metadata_got + (index - 1);
+  intptr_t meta = (intptr_t)*entry;
+  if ((meta & 1) == 1) {
+    // already resolved
+    Klass* k = (Klass*)(meta & ~1);
+    return k->java_mirror();
+  }
+  // The entry is string which we need to resolve.
+  const char* meta_name = _heap->get_name_at((int)meta);
+  int klass_len = build_u2_from((address)meta_name);
+  const char* klass_name = meta_name + 2;
+  // Quick check the current method's holder.
+  Klass* k = _method->method_holder();
+
+  ResourceMark rm; // for signature_name()
+  if (strncmp(k->signature_name(), klass_name, klass_len) != 0) { // Does not match?
+    // Search klass in got cells in DSO which have this compiled method.
+    k = _heap->get_klass_from_got(klass_name, klass_len, _method);
+  }
+  int method_name_len = build_u2_from((address)klass_name + klass_len);
+  guarantee(method_name_len == 0, "only klass is expected here");
+  meta = ((intptr_t)k) | 1;
+  *entry = (Metadata*)meta; // Should be atomic on x64
+  return k->java_mirror();
+}
+
+Metadata* AOTCompiledMethod::metadata_at(int index) const {
+  if (index == 0) { // 0 is reserved
+    return NULL;
+  }
+  assert(index - 1 < _metadata_size, "");
+  {
+    Metadata** entry = _metadata_got + (index - 1);
+    intptr_t meta = (intptr_t)*entry;
+    if ((meta & 1) == 1) {
+      // already resolved
+      Metadata *m = (Metadata*)(meta & ~1);
+      return m;
+    }
+    // The entry is string which we need to resolve.
+    const char* meta_name = _heap->get_name_at((int)meta);
+    int klass_len = build_u2_from((address)meta_name);
+    const char* klass_name = meta_name + 2;
+    // Quick check the current method's holder.
+    Klass* k = _method->method_holder();
+    bool klass_matched = true;
+
+    ResourceMark rm; // for signature_name() and find_method()
+    if (strncmp(k->signature_name(), klass_name, klass_len) != 0) { // Does not match?
+      // Search klass in got cells in DSO which have this compiled method.
+      k = _heap->get_klass_from_got(klass_name, klass_len, _method);
+      klass_matched = false;
+    }
+    int method_name_len = build_u2_from((address)klass_name + klass_len);
+    if (method_name_len == 0) { // Array or Klass name only?
+      meta = ((intptr_t)k) | 1;
+      *entry = (Metadata*)meta; // Should be atomic on x64
+      return (Metadata*)k;
+    } else { // Method
+      // Quick check the current method's name.
+      Method* m = _method;
+      int signature_len = build_u2_from((address)klass_name + klass_len + 2 + method_name_len);
+      int full_len = 2 + klass_len + 2 + method_name_len + 2 + signature_len;
+      if (!klass_matched || memcmp(_name, meta_name, full_len) != 0) { // Does not match?
+        Thread* thread = Thread::current();
+        KlassHandle klass = KlassHandle(thread, k);
+        const char* method_name = klass_name + klass_len;
+        m = AOTCodeHeap::find_method(klass, thread, method_name);
+      }
+      meta = ((intptr_t)m) | 1;
+      *entry = (Metadata*)meta; // Should be atomic on x64
+      return (Metadata*)m;
+    }
+    // need to resolve it here..., patching of GOT need to be CAS or atomic operation.
+    // FIXIT: need methods for debuginfo.
+    // return _method;
+  }
+  ShouldNotReachHere(); return NULL;
+}
+
+bool AOTCompiledMethod::make_not_entrant_helper(int new_state) {
+  // Make sure the method is not flushed in case of a safepoint in code below.
+  methodHandle the_method(method());
+  NoSafepointVerifier nsv;
+
+  {
+    // Enter critical section.  Does not block for safepoint.
+    MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
+
+    if (*_state_adr == new_state) {
+      // another thread already performed this transition so nothing
+      // to do, but return false to indicate this.
+      return false;
+    }
+
+    // Change state
+    OrderAccess::storestore();
+    *_state_adr = new_state;
+
+    // Log the transition once
+    log_state_change();
+
+#ifdef TIERED
+    // Remain non-entrant forever
+    if (new_state == not_entrant && method() != NULL) {
+        method()->set_aot_code(NULL);
+    }
+#endif
+
+    // Remove AOTCompiledMethod from method.
+    if (method() != NULL && (method()->code() == this ||
+                             method()->from_compiled_entry() == verified_entry_point())) {
+      HandleMark hm;
+      method()->clear_code(false /* already owns Patching_lock */);
+    }
+  } // leave critical region under Patching_lock
+
+
+  if (TraceCreateZombies) {
+    ResourceMark m;
+    const char *new_state_str = (new_state == not_entrant) ? "not entrant" : "not used";
+    tty->print_cr("aot method <" INTPTR_FORMAT "> %s code made %s", p2i(this), this->method() ? this->method()->name_and_sig_as_C_string() : "null", new_state_str);
+  }
+
+  return true;
+}
+
+bool AOTCompiledMethod::make_entrant() {
+  assert(!method()->is_old(), "reviving evolved method!");
+  assert(*_state_adr != not_entrant, "%s", method()->has_aot_code() ? "has_aot_code() not cleared" : "caller didn't check has_aot_code()");
+
+  // Make sure the method is not flushed in case of a safepoint in code below.
+  methodHandle the_method(method());
+  NoSafepointVerifier nsv;
+
+  {
+    // Enter critical section.  Does not block for safepoint.
+    MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
+
+    if (*_state_adr == in_use) {
+      // another thread already performed this transition so nothing
+      // to do, but return false to indicate this.
+      return false;
+    }
+
+    // Change state
+    OrderAccess::storestore();
+    *_state_adr = in_use;
+
+    // Log the transition once
+    log_state_change();
+  } // leave critical region under Patching_lock
+
+
+  if (TraceCreateZombies) {
+    ResourceMark m;
+    tty->print_cr("aot method <" INTPTR_FORMAT "> %s code made entrant", p2i(this), this->method() ? this->method()->name_and_sig_as_C_string() : "null");
+  }
+
+  return true;
+}
+
+// We don't have full dependencies for AOT methods, so flushing is
+// more conservative than for nmethods.
+void AOTCompiledMethod::flush_evol_dependents_on(instanceKlassHandle dependee) {
+  if (is_java_method()) {
+    cleanup_inline_caches();
+    mark_for_deoptimization();
+    make_not_entrant();
+  }
+}
+
+// Iterate over metadata calling this function.   Used by RedefineClasses
+// Copied from nmethod::metadata_do
+void AOTCompiledMethod::metadata_do(void f(Metadata*)) {
+  address low_boundary = verified_entry_point();
+  {
+    // Visit all immediate references that are embedded in the instruction stream.
+    RelocIterator iter(this, low_boundary);
+    while (iter.next()) {
+      if (iter.type() == relocInfo::metadata_type ) {
+        metadata_Relocation* r = iter.metadata_reloc();
+        // In this metadata, we must only follow those metadatas directly embedded in
+        // the code.  Other metadatas (oop_index>0) are seen as part of
+        // the metadata section below.
+        assert(1 == (r->metadata_is_immediate()) +
+               (r->metadata_addr() >= metadata_begin() && r->metadata_addr() < metadata_end()),
+               "metadata must be found in exactly one place");
+        if (r->metadata_is_immediate() && r->metadata_value() != NULL) {
+          Metadata* md = r->metadata_value();
+          if (md != _method) f(md);
+        }
+      } else if (iter.type() == relocInfo::virtual_call_type) {
+        // Check compiledIC holders associated with this nmethod
+        CompiledIC *ic = CompiledIC_at(&iter);
+        if (ic->is_icholder_call()) {
+          CompiledICHolder* cichk = ic->cached_icholder();
+          f(cichk->holder_method());
+          f(cichk->holder_klass());
+        } else {
+          Metadata* ic_oop = ic->cached_metadata();
+          if (ic_oop != NULL) {
+            f(ic_oop);
+          }
+        }
+      }
+    }
+  }
+
+  // Visit the metadata section
+  for (Metadata** p = metadata_begin(); p < metadata_end(); p++) {
+    Metadata* m = *p;
+
+    intptr_t meta = (intptr_t)m;
+    if ((meta & 1) == 1) {
+      // already resolved
+      m = (Metadata*)(meta & ~1);
+    } else {
+      continue;
+    }
+    assert(Metaspace::contains(m), "");
+    f(m);
+  }
+
+  // Visit metadata not embedded in the other places.
+  if (_method != NULL) f(_method);
+}
+
+void AOTCompiledMethod::print() const {
+  print_on(tty, "AOTCompiledMethod");
+}
+
+void AOTCompiledMethod::print_on(outputStream* st) const {
+  print_on(st, "AOTCompiledMethod");
+}
+
+// Print out more verbose output usually for a newly created aot method.
+void AOTCompiledMethod::print_on(outputStream* st, const char* msg) const {
+  if (st != NULL) {
+    ttyLocker ttyl;
+    st->print("%7d ", (int) st->time_stamp().milliseconds());
+    st->print("%4d ", _aot_id);    // print compilation number
+    st->print("    aot[%2d]", _heap->dso_id());
+    // Stubs have _method == NULL
+    st->print("   %s", (_method == NULL ? _name : _method->name_and_sig_as_C_string()));
+    if (Verbose) {
+      st->print(" entry at " INTPTR_FORMAT, p2i(_code));
+    }
+    if (msg != NULL) {
+      st->print("   %s", msg);
+    }
+    st->cr();
+  }
+}
+
+void AOTCompiledMethod::print_value_on(outputStream* st) const {
+  st->print("AOTCompiledMethod ");
+  print_on(st, NULL);
+}
+
+// Print a short set of xml attributes to identify this aot method.  The
+// output should be embedded in some other element.
+void AOTCompiledMethod::log_identity(xmlStream* log) const {
+  log->print(" aot_id='%d'", _aot_id);
+  log->print(" aot='%2d'", _heap->dso_id());
+}
+
+void AOTCompiledMethod::log_state_change() const {
+  if (LogCompilation) {
+    ResourceMark m;
+    if (xtty != NULL) {
+      ttyLocker ttyl;  // keep the following output all in one block
+      if (*_state_adr == not_entrant) {
+        xtty->begin_elem("make_not_entrant thread='" UINTX_FORMAT "'",
+                         os::current_thread_id());
+      } else if (*_state_adr == not_used) {
+        xtty->begin_elem("make_not_used thread='" UINTX_FORMAT "'",
+                         os::current_thread_id());
+      } else if (*_state_adr == in_use) {
+        xtty->begin_elem("make_entrant thread='" UINTX_FORMAT "'",
+                         os::current_thread_id());
+      }
+      log_identity(xtty);
+      xtty->stamp();
+      xtty->end_elem();
+    }
+  }
+  if (PrintCompilation) {
+    ResourceMark m;
+    if (*_state_adr == not_entrant) {
+      print_on(tty, "made not entrant");
+    } else if (*_state_adr == not_used) {
+      print_on(tty, "made not used");
+    } else if (*_state_adr == in_use) {
+      print_on(tty, "made entrant");
+    }
+  }
+}
+
+
+NativeInstruction* PltNativeCallWrapper::get_load_instruction(virtual_call_Relocation* r) const {
+  return nativeLoadGot_at(_call->plt_load_got());
+}
+
+void PltNativeCallWrapper::verify_resolve_call(address dest) const {
+  CodeBlob* db = CodeCache::find_blob_unsafe(dest);
+  if (db == NULL) {
+    assert(dest == _call->plt_resolve_call(), "sanity");
+  }
+}
+
+void PltNativeCallWrapper::set_to_interpreted(methodHandle method, CompiledICInfo& info) {
+  assert(!info.to_aot(), "only for nmethod");
+  CompiledPltStaticCall* csc = CompiledPltStaticCall::at(instruction_address());
+  csc->set_to_interpreted(method, info.entry());
+}
+
+NativeCallWrapper* AOTCompiledMethod::call_wrapper_at(address call) const {
+  return new PltNativeCallWrapper((NativePltCall*) call);
+}
+
+NativeCallWrapper* AOTCompiledMethod::call_wrapper_before(address return_pc) const {
+  return new PltNativeCallWrapper(nativePltCall_before(return_pc));
+}
+
+CompiledStaticCall* AOTCompiledMethod::compiledStaticCall_at(Relocation* call_site) const {
+  return CompiledPltStaticCall::at(call_site);
+}
+
+CompiledStaticCall* AOTCompiledMethod::compiledStaticCall_at(address call_site) const {
+  return CompiledPltStaticCall::at(call_site);
+}
+
+CompiledStaticCall* AOTCompiledMethod::compiledStaticCall_before(address return_addr) const {
+  return CompiledPltStaticCall::before(return_addr);
+}
+
+address AOTCompiledMethod::call_instruction_address(address pc) const {
+  NativePltCall* pltcall = nativePltCall_before(pc);
+  return pltcall->instruction_address();
+}
+
+bool AOTCompiledMethod::is_evol_dependent_on(Klass* dependee) {
+  return !is_aot_runtime_stub() && _heap->is_dependent_method(dependee, this);
+}
+
+void AOTCompiledMethod::clear_inline_caches() {
+  assert(SafepointSynchronize::is_at_safepoint(), "cleaning of IC's only allowed at safepoint");
+  if (is_zombie()) {
+    return;
+  }
+
+  RelocIterator iter(this);
+  while (iter.next()) {
+    iter.reloc()->clear_inline_cache();
+    if (iter.type() == relocInfo::opt_virtual_call_type) {
+      CompiledIC* cic = CompiledIC_at(&iter);
+      assert(cic->is_clean(), "!");
+      nativePltCall_at(iter.addr())->set_stub_to_clean();
+    }
+  }
+}
+