graal-compiler: src/share/vm/runtime/sharedRuntime.cpp comparison

comparison src/share/vm/runtime/sharedRuntime.cpp @ 14518:d8041d695d19

Merged with jdk9/dev/hotspot changeset 3812c088b945

author	twisti
date	Tue, 11 Mar 2014 18:45:59 -0700
parents	02f27ecb4f3a 28f281e8de1d
children	d3225562f0d8

comparison

equal deleted inserted replaced

-:f97c5ec83832
+:d8041d695d19
 #endif // COMPILER2
 }
 #include <math.h>
-#ifndef USDT2
-HS_DTRACE_PROBE_DECL4(hotspot, object__alloc, Thread*, char*, int, size_t);
-HS_DTRACE_PROBE_DECL7(hotspot, method__entry, int,
-char*, int, char*, int, char*, int);
-HS_DTRACE_PROBE_DECL7(hotspot, method__return, int,
-char*, int, char*, int, char*, int);
-#endif /* !USDT2 */
 // Implementation of SharedRuntime
 #ifndef PRODUCT
 // For statistics
 int SharedRuntime::_ic_miss_ctr = 0;
 return (f <= (double)0.0) ? (double)0.0 - f : f;
 }
 #endif
-#if defined(__SOFTFP__) || defined(PPC)
+#if defined(__SOFTFP__) || defined(PPC32)
 double SharedRuntime::dsqrt(double f) {
 return sqrt(f);
 }
 #endif
 JRT_LEAF(jdouble, SharedRuntime::l2d(jlong x))
 return (jdouble)x;
 JRT_END
-// Exception handling accross interpreter/compiler boundaries
+// Exception handling across interpreter/compiler boundaries
 //
 // exception_handler_for_return_address(...) returns the continuation address.
 // The continuation address is the entry point of the exception handler of the
 // previous frame depending on the return address.
 thread->set_is_method_handle_return(nm->is_method_handle_return(return_address));
 // native nmethods don't have exception handlers
 assert(!nm->is_native_method(), "no exception handler");
 assert(nm->header_begin() != nm->exception_begin(), "no exception handler");
 if (nm->is_deopt_pc(return_address)) {
+// If we come here because of a stack overflow, the stack may be
+// unguarded. Reguard the stack otherwise if we return to the
+// deopt blob and the stack bang causes a stack overflow we
+// crash.
+bool guard_pages_enabled = thread->stack_yellow_zone_enabled();
+if (!guard_pages_enabled) guard_pages_enabled = thread->reguard_stack();
+assert(guard_pages_enabled, "stack banging in deopt blob may cause crash");
 return SharedRuntime::deopt_blob()->unpack_with_exception();
 } else {
 return nm->exception_begin();
 }
 }
 HandlerTableEntry *t = table.entry_for(catch_pco, handler_bci, scope_depth);
 if (t == NULL && (nm->is_compiled_by_c1() || handler_bci != -1)) {
 // Allow abbreviated catch tables.  The idea is to allow a method
 // to materialize its exceptions without committing to the exact
 // routing of exceptions.  In particular this is needed for adding
-// a synthethic handler to unlock monitors when inlining
+// a synthetic handler to unlock monitors when inlining
-// synchonized methods since the unlock path isn't represented in
+// synchronized methods since the unlock path isn't represented in
 // the bytecodes.
 t = table.entry_for(catch_pco, -1, 0);
 }
 #ifdef COMPILER1
 if (cb == NULL) return NULL;
 // Exception happened in CodeCache. Must be either:
 // 1. Inline-cache check in C2I handler blob,
 // 2. Inline-cache check in nmethod, or
-// 3. Implict null exception in nmethod
+// 3. Implicit null exception in nmethod
 if (!cb->is_nmethod()) {
 bool is_in_blob = cb->is_adapter_blob() || cb->is_method_handles_adapter_blob();
 if (!is_in_blob) {
 cb->print();
 int SharedRuntime::dtrace_object_alloc_base(Thread* thread, oopDesc* o) {
 assert(DTraceAllocProbes, "wrong call");
 Klass* klass = o->klass();
 int size = o->size();
 Symbol* name = klass->name();
-#ifndef USDT2
-HS_DTRACE_PROBE4(hotspot, object__alloc, get_java_tid(thread),
-name->bytes(), name->utf8_length(), size * HeapWordSize);
-#else /* USDT2 */
 HOTSPOT_OBJECT_ALLOC(
 get_java_tid(thread),
 (char *) name->bytes(), name->utf8_length(), size * HeapWordSize);
-#endif /* USDT2 */
 return 0;
 }
 JRT_LEAF(int, SharedRuntime::dtrace_method_entry(
 JavaThread* thread, Method* method))
 assert(DTraceMethodProbes, "wrong call");
 Symbol* kname = method->klass_name();
 Symbol* name = method->name();
 Symbol* sig = method->signature();
-#ifndef USDT2
-HS_DTRACE_PROBE7(hotspot, method__entry, get_java_tid(thread),
-kname->bytes(), kname->utf8_length(),
-name->bytes(), name->utf8_length(),
-sig->bytes(), sig->utf8_length());
-#else /* USDT2 */
 HOTSPOT_METHOD_ENTRY(
 get_java_tid(thread),
 (char *) kname->bytes(), kname->utf8_length(),
 (char *) name->bytes(), name->utf8_length(),
 (char *) sig->bytes(), sig->utf8_length());
-#endif /* USDT2 */
 return 0;
 JRT_END
 JRT_LEAF(int, SharedRuntime::dtrace_method_exit(
 JavaThread* thread, Method* method))
 assert(DTraceMethodProbes, "wrong call");
 Symbol* kname = method->klass_name();
 Symbol* name = method->name();
 Symbol* sig = method->signature();
-#ifndef USDT2
-HS_DTRACE_PROBE7(hotspot, method__return, get_java_tid(thread),
-kname->bytes(), kname->utf8_length(),
-name->bytes(), name->utf8_length(),
-sig->bytes(), sig->utf8_length());
-#else /* USDT2 */
 HOTSPOT_METHOD_RETURN(
 get_java_tid(thread),
 (char *) kname->bytes(), kname->utf8_length(),
 (char *) name->bytes(), name->utf8_length(),
 (char *) sig->bytes(), sig->utf8_length());
-#endif /* USDT2 */
 return 0;
 JRT_END
 // Finds receiver, CallInfo (i.e. receiver method), and calling bytecode)
 assert(ic_miss != NULL, "must have handler");
 ResourceMark rm;
 NOT_PRODUCT(int insts_size);
-AdapterBlob* B = NULL;
+AdapterBlob* new_adapter = NULL;
 AdapterHandlerEntry* entry = NULL;
 AdapterFingerPrint* fingerprint = NULL;
 {
 MutexLocker mu(AdapterHandlerLibrary_lock);
 // make sure data structure is initialized
 // Lookup method signature's fingerprint
 entry = _adapters->lookup(total_args_passed, sig_bt);
 #ifdef ASSERT
 AdapterHandlerEntry* shared_entry = NULL;
-if (VerifyAdapterSharing && entry != NULL) {
+// Start adapter sharing verification only after the VM is booted.
+if (VerifyAdapterSharing && (entry != NULL)) {
 shared_entry = entry;
 entry = NULL;
 }
 #endif
 int comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, false);
 // Make a C heap allocated version of the fingerprint to store in the adapter
 fingerprint = new AdapterFingerPrint(total_args_passed, sig_bt);
+// StubRoutines::code2() is initialized after this function can be called. As a result,
+// VerifyAdapterCalls and VerifyAdapterSharing can fail if we re-use code that generated
+// prior to StubRoutines::code2() being set. Checks refer to checks generated in an I2C
+// stub that ensure that an I2C stub is called from an interpreter frame.
+bool contains_all_checks = StubRoutines::code2() != NULL;
 // Create I2C & C2I handlers
 BufferBlob* buf = buffer_blob(); // the temporary code buffer in CodeCache
 if (buf != NULL) {
 CodeBuffer buffer(buf);
 short buffer_locs[20];
 buffer.insts()->initialize_shared_locs((relocInfo*)buffer_locs,
 sizeof(buffer_locs)/sizeof(relocInfo));
 MacroAssembler _masm(&buffer);
 entry = SharedRuntime::generate_i2c2i_adapters(&_masm,
 total_args_passed,
 comp_args_on_stack,
 sig_bt,
 regs,
 fingerprint);
 #ifdef ASSERT
 if (VerifyAdapterSharing) {
 if (shared_entry != NULL) {
-assert(shared_entry->compare_code(buf->code_begin(), buffer.insts_size(), total_args_passed, sig_bt),
+assert(shared_entry->compare_code(buf->code_begin(), buffer.insts_size()), "code must match");
-"code must match");
 // Release the one just created and return the original
 _adapters->free_entry(entry);
 return shared_entry;
 } else  {
-entry->save_code(buf->code_begin(), buffer.insts_size(), total_args_passed, sig_bt);
+entry->save_code(buf->code_begin(), buffer.insts_size());
 }
 }
 #endif
-B = AdapterBlob::create(&buffer);
+new_adapter = AdapterBlob::create(&buffer);
 NOT_PRODUCT(insts_size = buffer.insts_size());
 }
-if (B == NULL) {
+if (new_adapter == NULL) {
 // CodeCache is full, disable compilation
 // Ought to log this but compile log is only per compile thread
 // and we're some non descript Java thread.
 MutexUnlocker mu(AdapterHandlerLibrary_lock);
 CompileBroker::handle_full_code_cache();
 return NULL; // Out of CodeCache space
 }
-entry->relocate(B->content_begin());
+entry->relocate(new_adapter->content_begin());
 #ifndef PRODUCT
 // debugging suppport
 if (PrintAdapterHandlers || PrintStubCode) {
 ttyLocker ttyl;
 entry->print_adapter_on(tty);
 tty->cr();
 }
 }
 }
 #endif
+// Add the entry only if the entry contains all required checks (see sharedRuntime_xxx.cpp)
-_adapters->add(entry);
+// The checks are inserted only if -XX:+VerifyAdapterCalls is specified.
+if (contains_all_checks || !VerifyAdapterCalls) {
+_adapters->add(entry);
+}
 }
 // Outside of the lock
-if (B != NULL) {
+if (new_adapter != NULL) {
 char blob_id[256];
 jio_snprintf(blob_id,
 sizeof(blob_id),
 "%s(%s)@" PTR_FORMAT,
-B->name(),
+new_adapter->name(),
 fingerprint->as_string(),
-B->content_begin());
+new_adapter->content_begin());
-Forte::register_stub(blob_id, B->content_begin(), B->content_end());
+Forte::register_stub(blob_id, new_adapter->content_begin(),new_adapter->content_end());
 if (JvmtiExport::should_post_dynamic_code_generated()) {
-JvmtiExport::post_dynamic_code_generated(blob_id, B->content_begin(), B->content_end());
+JvmtiExport::post_dynamic_code_generated(blob_id, new_adapter->content_begin(), new_adapter->content_end());
 }
 }
 return entry;
 }
 void AdapterHandlerEntry::deallocate() {
 delete _fingerprint;
 #ifdef ASSERT
 if (_saved_code) FREE_C_HEAP_ARRAY(unsigned char, _saved_code, mtCode);
-if (_saved_sig)  FREE_C_HEAP_ARRAY(Basictype, _saved_sig, mtCode);
 #endif
 }
 #ifdef ASSERT
 // Capture the code before relocation so that it can be compared
 // against other versions.  If the code is captured after relocation
 // then relative instructions won't be equivalent.
-void AdapterHandlerEntry::save_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) {
+void AdapterHandlerEntry::save_code(unsigned char* buffer, int length) {
 _saved_code = NEW_C_HEAP_ARRAY(unsigned char, length, mtCode);
-_code_length = length;
+_saved_code_length = length;
 memcpy(_saved_code, buffer, length);
-_total_args_passed = total_args_passed;
+}
-_saved_sig = NEW_C_HEAP_ARRAY(BasicType, _total_args_passed, mtCode);
-memcpy(_saved_sig, sig_bt, _total_args_passed * sizeof(BasicType));
-}
+bool AdapterHandlerEntry::compare_code(unsigned char* buffer, int length) {
+if (length != _saved_code_length) {
-bool AdapterHandlerEntry::compare_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) {
-if (length != _code_length) {
 return false;
 }
-for (int i = 0; i < length; i++) {
-if (buffer[i] != _saved_code[i]) {
+return (memcmp(buffer, _saved_code, length) == 0) ? true : false;
-return false;
+}
-}
+#endif
-}
-return true;
-}
+/**
-#endif
+* Create a native wrapper for this native method.  The wrapper converts the
+* Java-compiled calling convention to the native convention, handles
+* arguments, and transitions to native.  On return from the native we transition
-// Create a native wrapper for this native method.  The wrapper converts the
+* back to java blocking if a safepoint is in progress.
-// java compiled calling convention to the native convention, handlizes
+*/
-// arguments, and transitions to native.  On return from the native we transition
+void AdapterHandlerLibrary::create_native_wrapper(methodHandle method) {
-// back to java blocking if a safepoint is in progress.
-nmethod *AdapterHandlerLibrary::create_native_wrapper(methodHandle method, int compile_id) {
 ResourceMark rm;
 nmethod* nm = NULL;
 assert(method->is_native(), "must be native");
 assert(method->is_method_handle_intrinsic() ||
 method->has_native_function(), "must have something valid to call!");
 {
-// perform the work while holding the lock, but perform any printing outside the lock
+// Perform the work while holding the lock, but perform any printing outside the lock
 MutexLocker mu(AdapterHandlerLibrary_lock);
 // See if somebody beat us to it
 nm = method->code();
-if (nm) {
+if (nm != NULL) {
-return nm;
+return;
 }
+const int compile_id = CompileBroker::assign_compile_id(method, CompileBroker::standard_entry_bci);
+assert(compile_id > 0, "Must generate native wrapper");
 ResourceMark rm;
 BufferBlob*  buf = buffer_blob(); // the temporary code buffer in CodeCache
 if (buf != NULL) {
 CodeBuffer buffer(buf);
 double locs_buf[20];
 buffer.insts()->initialize_shared_locs((relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo));
 // are just trampolines so the argument registers must be outgoing ones.
 const bool is_outgoing = method->is_method_handle_intrinsic();
 int comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, is_outgoing);
 // Generate the compiled-to-native wrapper code
-nm = SharedRuntime::generate_native_wrapper(&_masm,
+nm = SharedRuntime::generate_native_wrapper(&_masm, method, compile_id, sig_bt, regs, ret_type);
-method,
-compile_id,
+if (nm != NULL) {
-sig_bt,
+method->set_code(method, nm);
-regs,
+}
-ret_type);
+}
-}
+} // Unlock AdapterHandlerLibrary_lock
-}
-// Must unlock before calling set_code
 // Install the generated code.
 if (nm != NULL) {
 if (PrintCompilation) {
 ttyLocker ttyl;
 CompileTask::print_compilation(tty, nm, method->is_static() ? "(static)" : "");
 }
-method->set_code(method, nm);
 nm->post_compiled_method_load_event();
 } else {
 // CodeCache is full, disable compilation
 CompileBroker::handle_full_code_cache();
 }
-return nm;
 }
 JRT_ENTRY_NO_ASYNC(void, SharedRuntime::block_for_jni_critical(JavaThread* thread))
 assert(thread == JavaThread::current(), "must be");
 // The code is about to enter a JNI lazy critical native method and
 jlsValue->char_at_addr(jlsOffset);
 assert(TypeArrayKlass::cast(jlsValue->klass())->element_type() == T_CHAR, "compressed string");
 (void) UNICODE::as_utf8(jlsPos, jlsLen, (char *)dst, max_dtrace_string_size);
 }
 #endif // ndef HAVE_DTRACE_H
+int SharedRuntime::convert_ints_to_longints_argcnt(int in_args_count, BasicType* in_sig_bt) {
+int argcnt = in_args_count;
+if (CCallingConventionRequiresIntsAsLongs) {
+for (int in = 0; in < in_args_count; in++) {
+BasicType bt = in_sig_bt[in];
+switch (bt) {
+case T_BOOLEAN:
+case T_CHAR:
+case T_BYTE:
+case T_SHORT:
+case T_INT:
+argcnt++;
+break;
+default:
+break;
+}
+}
+} else {
+assert(0, "This should not be needed on this platform");
+}
+return argcnt;
+}
+void SharedRuntime::convert_ints_to_longints(int i2l_argcnt, int& in_args_count,
+BasicType*& in_sig_bt, VMRegPair*& in_regs) {
+if (CCallingConventionRequiresIntsAsLongs) {
+VMRegPair *new_in_regs   = NEW_RESOURCE_ARRAY(VMRegPair, i2l_argcnt);
+BasicType *new_in_sig_bt = NEW_RESOURCE_ARRAY(BasicType, i2l_argcnt);
+int argcnt = 0;
+for (int in = 0; in < in_args_count; in++, argcnt++) {
+BasicType bt  = in_sig_bt[in];
+VMRegPair reg = in_regs[in];
+switch (bt) {
+case T_BOOLEAN:
+case T_CHAR:
+case T_BYTE:
+case T_SHORT:
+case T_INT:
+// Convert (bt) to (T_LONG,bt).
+new_in_sig_bt[argcnt  ] = T_LONG;
+new_in_sig_bt[argcnt+1] = bt;
+assert(reg.first()->is_valid() && !reg.second()->is_valid(), "");
+new_in_regs[argcnt  ].set2(reg.first());
+new_in_regs[argcnt+1].set_bad();
+argcnt++;
+break;
+default:
+// No conversion needed.
+new_in_sig_bt[argcnt] = bt;
+new_in_regs[argcnt]   = reg;
+break;
+}
+}
+assert(argcnt == i2l_argcnt, "must match");
+in_regs = new_in_regs;
+in_sig_bt = new_in_sig_bt;
+in_args_count = i2l_argcnt;
+} else {
+assert(0, "This should not be needed on this platform");
+}
+}
 // -------------------------------------------------------------------------
 // Java-Java calling convention
 // (what you use when Java calls Java)
 //
 // This code is used convert interpreter frames into compiled frames.  It is
 // called from very start of a compiled OSR nmethod.  A temp array is
 // allocated to hold the interesting bits of the interpreter frame.  All
 // active locks are inflated to allow them to move.  The displaced headers and
-// active interpeter locals are copied into the temp buffer.  Then we return
+// active interpreter locals are copied into the temp buffer.  Then we return
 // back to the compiled code.  The compiled code then pops the current
 // interpreter frame off the stack and pushes a new compiled frame.  Then it
 // copies the interpreter locals and displaced headers where it wants.
 // Finally it calls back to free the temp buffer.
 //

Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/sharedRuntime.cpp @ 14518:d8041d695d19