jdk-sandbox: comparison hotspot/src/share/vm/runtime/sharedRuntime.cpp

equal deleted inserted replaced

-:82e8f98f22d8
+:6671edbd230e
 bool at_poll_return = ((nmethod*)cb)->is_at_poll_return(pc);
 if (at_poll_return) {
 assert(SharedRuntime::polling_page_return_handler_blob() != NULL,
 "polling page return stub not created yet");
-stub = SharedRuntime::polling_page_return_handler_blob()->instructions_begin();
+stub = SharedRuntime::polling_page_return_handler_blob()->entry_point();
 } else {
 assert(SharedRuntime::polling_page_safepoint_handler_blob() != NULL,
 "polling page safepoint stub not created yet");
-stub = SharedRuntime::polling_page_safepoint_handler_blob()->instructions_begin();
+stub = SharedRuntime::polling_page_safepoint_handler_blob()->entry_point();
 }
 #ifndef PRODUCT
 if( TraceSafepoint ) {
 char buf[256];
 jio_snprintf(buf, sizeof(buf),
 }
 } while (!top_frame_only && handler_bci < 0 && sd != NULL);
 }
 // found handling method => lookup exception handler
-int catch_pco = ret_pc - nm->instructions_begin();
+int catch_pco = ret_pc - nm->code_begin();
 ExceptionHandlerTable table(nm);
 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
 nm->print_code();
 guarantee(false, "missing exception handler");
 return NULL;
 }
-return nm->instructions_begin() + t->pco();
+return nm->code_begin() + t->pco();
 }
 JRT_ENTRY(void, SharedRuntime::throw_AbstractMethodError(JavaThread* thread))
 // These errors occur only at call sites
 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_AbstractMethodError());
 address ic_miss = SharedRuntime::get_ic_miss_stub();
 assert(ic_miss != NULL, "must have handler");
 ResourceMark rm;
-NOT_PRODUCT(int code_size);
+NOT_PRODUCT(int insts_size);
 AdapterBlob* B = NULL;
 AdapterHandlerEntry* entry = NULL;
 AdapterFingerPrint* fingerprint = NULL;
 {
 MutexLocker mu(AdapterHandlerLibrary_lock);
 // Create I2C & C2I handlers
 BufferBlob* buf = buffer_blob(); // the temporary code buffer in CodeCache
 if (buf != NULL) {
-CodeBuffer buffer(buf->instructions_begin(), buf->instructions_size());
+CodeBuffer buffer(buf);
 short buffer_locs[20];
 buffer.insts()->initialize_shared_locs((relocInfo*)buffer_locs,
 sizeof(buffer_locs)/sizeof(relocInfo));
 MacroAssembler _masm(&buffer);
 fingerprint);
 #ifdef ASSERT
 if (VerifyAdapterSharing) {
 if (shared_entry != NULL) {
-assert(shared_entry->compare_code(buf->instructions_begin(), buffer.code_size(), total_args_passed, sig_bt),
+assert(shared_entry->compare_code(buf->code_begin(), buffer.insts_size(), total_args_passed, sig_bt),
 "code must match");
 // Release the one just created and return the original
 _adapters->free_entry(entry);
 return shared_entry;
 } else  {
-entry->save_code(buf->instructions_begin(), buffer.code_size(), total_args_passed, sig_bt);
+entry->save_code(buf->code_begin(), buffer.insts_size(), total_args_passed, sig_bt);
 }
 }
 #endif
 B = AdapterBlob::create(&buffer);
-NOT_PRODUCT(code_size = buffer.code_size());
+NOT_PRODUCT(insts_size = buffer.insts_size());
 }
 if (B == 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->instructions_begin());
+entry->relocate(B->content_begin());
 #ifndef PRODUCT
 // debugging suppport
 if (PrintAdapterHandlers) {
 tty->cr();
 tty->print_cr("i2c argument handler #%d for: %s %s (fingerprint = %s, %d bytes generated)",
 _adapters->number_of_entries(), (method->is_static() ? "static" : "receiver"),
-method->signature()->as_C_string(), fingerprint->as_string(), code_size );
+method->signature()->as_C_string(), fingerprint->as_string(), insts_size );
 tty->print_cr("c2i argument handler starts at %p",entry->get_c2i_entry());
-Disassembler::decode(entry->get_i2c_entry(), entry->get_i2c_entry() + code_size);
+Disassembler::decode(entry->get_i2c_entry(), entry->get_i2c_entry() + insts_size);
 }
 #endif
 _adapters->add(entry);
 }
 jio_snprintf(blob_id,
 sizeof(blob_id),
 "%s(%s)@" PTR_FORMAT,
 B->name(),
 fingerprint->as_string(),
-B->instructions_begin());
+B->content_begin());
-Forte::register_stub(blob_id, B->instructions_begin(), B->instructions_end());
+Forte::register_stub(blob_id, B->content_begin(), B->content_end());
 if (JvmtiExport::should_post_dynamic_code_generated()) {
-JvmtiExport::post_dynamic_code_generated(blob_id,
+JvmtiExport::post_dynamic_code_generated(blob_id, B->content_begin(), B->content_end());
-B->instructions_begin(),
-B->instructions_end());
 }
 }
 return entry;
 }
 ResourceMark rm;
 BufferBlob*  buf = buffer_blob(); // the temporary code buffer in CodeCache
 if (buf != NULL) {
-CodeBuffer buffer(buf->instructions_begin(), buf->instructions_size());
+CodeBuffer buffer(buf);
 double locs_buf[20];
 buffer.insts()->initialize_shared_locs((relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo));
 MacroAssembler _masm(&buffer);
 // Fill in the signature array, for the calling-convention call.
 ResourceMark rm;
 BufferBlob*  buf = buffer_blob(); // the temporary code buffer in CodeCache
 if (buf != NULL) {
-CodeBuffer buffer(buf->instructions_begin(), buf->instructions_size());
+CodeBuffer buffer(buf);
 // Need a few relocation entries
 double locs_buf[20];
 buffer.insts()->initialize_shared_locs(
 (relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo));
 MacroAssembler _masm(&buffer);

changeset 6418	6671edbd230e
parent 6270	d628c75fbf48
child 6463	f4362c8da849