0N/A

1879N/A#include "precompiled.hpp"

1879N/A#include "code/codeBlob.hpp"

1879N/A#include "code/codeCache.hpp"

1879N/A#include "code/relocInfo.hpp"

1879N/A#include "compiler/disassembler.hpp"

1879N/A#include "interpreter/bytecode.hpp"

1879N/A#include "memory/allocation.inline.hpp"

1879N/A#include "memory/heap.hpp"

1879N/A#include "oops/oop.inline.hpp"

1879N/A#include "prims/forte.hpp"

1879N/A#include "runtime/handles.inline.hpp"

1879N/A#include "runtime/interfaceSupport.hpp"

1879N/A#include "runtime/mutexLocker.hpp"

1879N/A#include "runtime/safepoint.hpp"

1879N/A#include "runtime/sharedRuntime.hpp"

1879N/A#include "runtime/vframe.hpp"

1879N/A#include "services/memoryService.hpp"

1879N/A#ifdef TARGET_ARCH_x86

1879N/A# include "nativeInst_x86.hpp"

1879N/A#endif

1879N/A#ifdef TARGET_ARCH_sparc

1879N/A# include "nativeInst_sparc.hpp"

1879N/A#endif

1879N/A#ifdef TARGET_ARCH_zero

1879N/A# include "nativeInst_zero.hpp"

1879N/A#endif

2073N/A#ifdef TARGET_ARCH_arm

2073N/A# include "nativeInst_arm.hpp"

2073N/A#endif

2073N/A#ifdef TARGET_ARCH_ppc

2073N/A# include "nativeInst_ppc.hpp"

2073N/A#endif

1879N/A#ifdef COMPILER1

1879N/A#include "c1/c1_Runtime1.hpp"

1879N/A#endif

0N/A

0N/Aunsigned int align_code_offset(int offset) {

0N/A // align the size to CodeEntryAlignment

0N/A return

0N/A ((offset + (int)CodeHeap::header_size() + (CodeEntryAlignment-1)) & ~(CodeEntryAlignment-1))

0N/A - (int)CodeHeap::header_size();

0N/A}

0N/A

0N/A

0N/Aunsigned int CodeBlob::allocation_size(CodeBuffer* cb, int header_size) {

0N/A unsigned int size = header_size;

0N/A size += round_to(cb->total_relocation_size(), oopSize);

0N/A // align the size to CodeEntryAlignment

0N/A size = align_code_offset(size);

1668N/A size += round_to(cb->total_content_size(), oopSize);

0N/A size += round_to(cb->total_oop_size(), oopSize);

0N/A return size;

0N/A}

0N/A

0N/A

0N/ACodeBlob::CodeBlob(const char* name, int header_size, int size, int frame_complete, int locs_size) {

1668N/A assert(size == round_to(size, oopSize), "unaligned size");

1668N/A assert(locs_size == round_to(locs_size, oopSize), "unaligned size");

0N/A assert(header_size == round_to(header_size, oopSize), "unaligned size");

0N/A assert(!UseRelocIndex, "no space allocated for reloc index yet");

0N/A

0N/A // Note: If UseRelocIndex is enabled, there needs to be (at least) one

0N/A // extra word for the relocation information, containing the reloc

0N/A // index table length. Unfortunately, the reloc index table imple-

0N/A // mentation is not easily understandable and thus it is not clear

0N/A // what exactly the format is supposed to be. For now, we just turn

0N/A // off the use of this table (gri 7/6/2000).

0N/A

0N/A _name = name;

0N/A _size = size;

0N/A _frame_complete_offset = frame_complete;

0N/A _header_size = header_size;

0N/A _relocation_size = locs_size;

1668N/A _content_offset = align_code_offset(header_size + _relocation_size);

1668N/A _code_offset = _content_offset;

0N/A _data_offset = size;

0N/A _frame_size = 0;

0N/A set_oop_maps(NULL);

0N/A}

0N/A

0N/A

0N/ACodeBlob::CodeBlob(

0N/A const char* name,

0N/A CodeBuffer* cb,

0N/A int header_size,

0N/A int size,

0N/A int frame_complete,

0N/A int frame_size,

0N/A OopMapSet* oop_maps

0N/A) {

1668N/A assert(size == round_to(size, oopSize), "unaligned size");

0N/A assert(header_size == round_to(header_size, oopSize), "unaligned size");

0N/A

0N/A _name = name;

0N/A _size = size;

0N/A _frame_complete_offset = frame_complete;

0N/A _header_size = header_size;

0N/A _relocation_size = round_to(cb->total_relocation_size(), oopSize);

1668N/A _content_offset = align_code_offset(header_size + _relocation_size);

1682N/A _code_offset = _content_offset + cb->total_offset_of(cb->insts());

1668N/A _data_offset = _content_offset + round_to(cb->total_content_size(), oopSize);

0N/A assert(_data_offset <= size, "codeBlob is too small");

0N/A

0N/A cb->copy_code_and_locs_to(this);

0N/A set_oop_maps(oop_maps);

0N/A _frame_size = frame_size;

0N/A#ifdef COMPILER1

0N/A // probably wrong for tiered

0N/A assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs");

0N/A#endif // COMPILER1

0N/A}

0N/A

0N/A

0N/Avoid CodeBlob::set_oop_maps(OopMapSet* p) {

0N/A // Danger Will Robinson! This method allocates a big

0N/A // chunk of memory, its your job to free it.

0N/A if (p != NULL) {

0N/A // We need to allocate a chunk big enough to hold the OopMapSet and all of its OopMaps

3863N/A _oop_maps = (OopMapSet* )NEW_C_HEAP_ARRAY(unsigned char, p->heap_size(), mtCode);

0N/A p->copy_to((address)_oop_maps);

0N/A } else {

0N/A _oop_maps = NULL;

0N/A }

0N/A}

0N/A

0N/A

2460N/Avoid CodeBlob::trace_new_stub(CodeBlob* stub, const char* name1, const char* name2) {

2460N/A // Do not hold the CodeCache lock during name formatting.

2460N/A assert(!CodeCache_lock->owned_by_self(), "release CodeCache before registering the stub");

2460N/A

2460N/A if (stub != NULL) {

2460N/A char stub_id[256];

2460N/A assert(strlen(name1) + strlen(name2) < sizeof(stub_id), "");

2460N/A jio_snprintf(stub_id, sizeof(stub_id), "%s%s", name1, name2);

2460N/A if (PrintStubCode) {

4016N/A ttyLocker ttyl;

2460N/A tty->print_cr("Decoding %s " INTPTR_FORMAT, stub_id, (intptr_t) stub);

2460N/A Disassembler::decode(stub->code_begin(), stub->code_end());

4016N/A tty->cr();

2460N/A }

2460N/A Forte::register_stub(stub_id, stub->code_begin(), stub->code_end());

2460N/A

2460N/A if (JvmtiExport::should_post_dynamic_code_generated()) {

2460N/A const char* stub_name = name2;

2460N/A if (name2[0] == '\0') stub_name = name1;

2460N/A JvmtiExport::post_dynamic_code_generated(stub_name, stub->code_begin(), stub->code_end());

2460N/A }

2460N/A }

2460N/A

2460N/A // Track memory usage statistic after releasing CodeCache_lock

2460N/A MemoryService::track_code_cache_memory_usage();

2460N/A}

2460N/A

2460N/A

0N/Avoid CodeBlob::flush() {

0N/A if (_oop_maps) {

3863N/A FREE_C_HEAP_ARRAY(unsigned char, _oop_maps, mtCode);

0N/A _oop_maps = NULL;

0N/A }

4332N/A _strings.free();

0N/A}

0N/A

0N/A

0N/AOopMap* CodeBlob::oop_map_for_return_address(address return_address) {

1668N/A assert(oop_maps() != NULL, "nope");

1668N/A return oop_maps()->find_map_at_offset((intptr_t) return_address - (intptr_t) code_begin());

0N/A}

0N/A

0N/A

0N/A

0N/A

0N/ABufferBlob::BufferBlob(const char* name, int size)

0N/A: CodeBlob(name, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, /*locs_size:*/ 0)

0N/A{}

0N/A

0N/ABufferBlob* BufferBlob::create(const char* name, int buffer_size) {

0N/A ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock

0N/A

0N/A BufferBlob* blob = NULL;

0N/A unsigned int size = sizeof(BufferBlob);

0N/A // align the size to CodeEntryAlignment

0N/A size = align_code_offset(size);

0N/A size += round_to(buffer_size, oopSize);

0N/A assert(name != NULL, "must provide a name");

0N/A {

0N/A MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

0N/A blob = new (size) BufferBlob(name, size);

0N/A }

0N/A // Track memory usage statistic after releasing CodeCache_lock

0N/A MemoryService::track_code_cache_memory_usage();

0N/A

0N/A return blob;

0N/A}

0N/A

0N/A

0N/ABufferBlob::BufferBlob(const char* name, int size, CodeBuffer* cb)

0N/A : CodeBlob(name, cb, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, 0, NULL)

0N/A{}

0N/A

0N/ABufferBlob* BufferBlob::create(const char* name, CodeBuffer* cb) {

0N/A ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock

0N/A

0N/A BufferBlob* blob = NULL;

0N/A unsigned int size = allocation_size(cb, sizeof(BufferBlob));

0N/A assert(name != NULL, "must provide a name");

0N/A {

0N/A MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

0N/A blob = new (size) BufferBlob(name, size, cb);

0N/A }

0N/A // Track memory usage statistic after releasing CodeCache_lock

0N/A MemoryService::track_code_cache_memory_usage();

0N/A

0N/A return blob;

0N/A}

0N/A

0N/A

0N/Avoid* BufferBlob::operator new(size_t s, unsigned size) {

0N/A void* p = CodeCache::allocate(size);

0N/A return p;

0N/A}

0N/A

0N/A

0N/Avoid BufferBlob::free( BufferBlob *blob ) {

0N/A ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock

0N/A {

0N/A MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

0N/A CodeCache::free((CodeBlob*)blob);

0N/A }

0N/A // Track memory usage statistic after releasing CodeCache_lock

0N/A MemoryService::track_code_cache_memory_usage();

0N/A}

0N/A

1299N/A

1299N/A

1583N/AAdapterBlob::AdapterBlob(int size, CodeBuffer* cb) :

1583N/A BufferBlob("I2C/C2I adapters", size, cb) {

1583N/A CodeCache::commit(this);

1583N/A}

1583N/A

1299N/AAdapterBlob* AdapterBlob::create(CodeBuffer* cb) {

1299N/A ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock

1299N/A

1299N/A AdapterBlob* blob = NULL;

1299N/A unsigned int size = allocation_size(cb, sizeof(AdapterBlob));

1299N/A {

1299N/A MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

1299N/A blob = new (size) AdapterBlob(size, cb);

1299N/A }

1299N/A // Track memory usage statistic after releasing CodeCache_lock

1299N/A MemoryService::track_code_cache_memory_usage();

1299N/A

1299N/A return blob;

0N/A}

0N/A

1299N/A

1299N/A

1299N/AMethodHandlesAdapterBlob* MethodHandlesAdapterBlob::create(int buffer_size) {

1299N/A ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock

1299N/A

1299N/A MethodHandlesAdapterBlob* blob = NULL;

1299N/A unsigned int size = sizeof(MethodHandlesAdapterBlob);

1299N/A // align the size to CodeEntryAlignment

1299N/A size = align_code_offset(size);

1299N/A size += round_to(buffer_size, oopSize);

1299N/A {

1299N/A MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

1299N/A blob = new (size) MethodHandlesAdapterBlob(size);

1299N/A }

1299N/A // Track memory usage statistic after releasing CodeCache_lock

1299N/A MemoryService::track_code_cache_memory_usage();

1299N/A

1299N/A return blob;

1299N/A}

1299N/A

1299N/A

0N/A

0N/ARuntimeStub::RuntimeStub(

0N/A const char* name,

0N/A CodeBuffer* cb,

0N/A int size,

0N/A int frame_complete,

0N/A int frame_size,

0N/A OopMapSet* oop_maps,

0N/A bool caller_must_gc_arguments

0N/A)

0N/A: CodeBlob(name, cb, sizeof(RuntimeStub), size, frame_complete, frame_size, oop_maps)

0N/A{

0N/A _caller_must_gc_arguments = caller_must_gc_arguments;

0N/A}

0N/A

0N/A

0N/ARuntimeStub* RuntimeStub::new_runtime_stub(const char* stub_name,

0N/A CodeBuffer* cb,

0N/A int frame_complete,

0N/A int frame_size,

0N/A OopMapSet* oop_maps,

0N/A bool caller_must_gc_arguments)

0N/A{

0N/A RuntimeStub* stub = NULL;

0N/A ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock

0N/A {

0N/A MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

0N/A unsigned int size = allocation_size(cb, sizeof(RuntimeStub));

0N/A stub = new (size) RuntimeStub(stub_name, cb, size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments);

0N/A }

0N/A

2460N/A trace_new_stub(stub, "RuntimeStub - ", stub_name);

0N/A

0N/A return stub;

0N/A}

0N/A

0N/A

0N/Avoid* RuntimeStub::operator new(size_t s, unsigned size) {

0N/A void* p = CodeCache::allocate(size);

0N/A if (!p) fatal("Initial size of CodeCache is too small");

0N/A return p;

0N/A}

0N/A

2460N/Avoid* SingletonBlob::operator new(size_t s, unsigned size) {

2460N/A void* p = CodeCache::allocate(size);

2460N/A if (!p) fatal("Initial size of CodeCache is too small");

2460N/A return p;

2460N/A}

2460N/A

2460N/A

0N/A

0N/ADeoptimizationBlob::DeoptimizationBlob(

0N/A CodeBuffer* cb,

0N/A int size,

0N/A OopMapSet* oop_maps,

0N/A int unpack_offset,

0N/A int unpack_with_exception_offset,

0N/A int unpack_with_reexecution_offset,

0N/A int frame_size

0N/A)

0N/A: SingletonBlob("DeoptimizationBlob", cb, sizeof(DeoptimizationBlob), size, frame_size, oop_maps)

0N/A{

0N/A _unpack_offset = unpack_offset;

0N/A _unpack_with_exception = unpack_with_exception_offset;

0N/A _unpack_with_reexecution = unpack_with_reexecution_offset;

0N/A#ifdef COMPILER1

0N/A _unpack_with_exception_in_tls = -1;

0N/A#endif

0N/A}

0N/A

0N/A

0N/ADeoptimizationBlob* DeoptimizationBlob::create(

0N/A CodeBuffer* cb,

0N/A OopMapSet* oop_maps,

0N/A int unpack_offset,

0N/A int unpack_with_exception_offset,

0N/A int unpack_with_reexecution_offset,

0N/A int frame_size)

0N/A{

0N/A DeoptimizationBlob* blob = NULL;

0N/A ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock

0N/A {

0N/A MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

0N/A unsigned int size = allocation_size(cb, sizeof(DeoptimizationBlob));

0N/A blob = new (size) DeoptimizationBlob(cb,

0N/A size,

0N/A oop_maps,

0N/A unpack_offset,

0N/A unpack_with_exception_offset,

0N/A unpack_with_reexecution_offset,

0N/A frame_size);

0N/A }

0N/A

2460N/A trace_new_stub(blob, "DeoptimizationBlob");

0N/A

0N/A return blob;

0N/A}

0N/A

0N/A

0N/A

0N/A#ifdef COMPILER2

0N/AUncommonTrapBlob::UncommonTrapBlob(

0N/A CodeBuffer* cb,

0N/A int size,

0N/A OopMapSet* oop_maps,

0N/A int frame_size

0N/A)

0N/A: SingletonBlob("UncommonTrapBlob", cb, sizeof(UncommonTrapBlob), size, frame_size, oop_maps)

0N/A{}

0N/A

0N/A

0N/AUncommonTrapBlob* UncommonTrapBlob::create(

0N/A CodeBuffer* cb,

0N/A OopMapSet* oop_maps,

0N/A int frame_size)

0N/A{

0N/A UncommonTrapBlob* blob = NULL;

0N/A ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock

0N/A {

0N/A MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

0N/A unsigned int size = allocation_size(cb, sizeof(UncommonTrapBlob));

0N/A blob = new (size) UncommonTrapBlob(cb, size, oop_maps, frame_size);

0N/A }

0N/A

2460N/A trace_new_stub(blob, "UncommonTrapBlob");

0N/A

0N/A return blob;

0N/A}

0N/A

0N/A

0N/A#endif // COMPILER2

0N/A

0N/A

0N/A

0N/A#ifdef COMPILER2

0N/AExceptionBlob::ExceptionBlob(

0N/A CodeBuffer* cb,

0N/A int size,

0N/A OopMapSet* oop_maps,

0N/A int frame_size

0N/A)

0N/A: SingletonBlob("ExceptionBlob", cb, sizeof(ExceptionBlob), size, frame_size, oop_maps)

0N/A{}

0N/A

0N/A

0N/AExceptionBlob* ExceptionBlob::create(

0N/A CodeBuffer* cb,

0N/A OopMapSet* oop_maps,

0N/A int frame_size)

0N/A{

0N/A ExceptionBlob* blob = NULL;

0N/A ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock

0N/A {

0N/A MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

0N/A unsigned int size = allocation_size(cb, sizeof(ExceptionBlob));

0N/A blob = new (size) ExceptionBlob(cb, size, oop_maps, frame_size);

0N/A }

0N/A

2460N/A trace_new_stub(blob, "ExceptionBlob");

0N/A

0N/A return blob;

0N/A}

0N/A

0N/A

0N/A#endif // COMPILER2

0N/A

0N/A

0N/A

0N/ASafepointBlob::SafepointBlob(

0N/A CodeBuffer* cb,

0N/A int size,

0N/A OopMapSet* oop_maps,

0N/A int frame_size

0N/A)

0N/A: SingletonBlob("SafepointBlob", cb, sizeof(SafepointBlob), size, frame_size, oop_maps)

0N/A{}

0N/A

0N/A

0N/ASafepointBlob* SafepointBlob::create(

0N/A CodeBuffer* cb,

0N/A OopMapSet* oop_maps,

0N/A int frame_size)

0N/A{

0N/A SafepointBlob* blob = NULL;

0N/A ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock

0N/A {

0N/A MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

0N/A unsigned int size = allocation_size(cb, sizeof(SafepointBlob));

0N/A blob = new (size) SafepointBlob(cb, size, oop_maps, frame_size);

0N/A }

0N/A

2460N/A trace_new_stub(blob, "SafepointBlob");

0N/A

0N/A return blob;

0N/A}

0N/A

0N/A

0N/A

0N/Avoid CodeBlob::verify() {

0N/A ShouldNotReachHere();

0N/A}

0N/A

1601N/Avoid CodeBlob::print_on(outputStream* st) const {

1601N/A st->print_cr("[CodeBlob (" INTPTR_FORMAT ")]", this);

1601N/A st->print_cr("Framesize: %d", _frame_size);

0N/A}

0N/A

0N/Avoid CodeBlob::print_value_on(outputStream* st) const {

0N/A st->print_cr("[CodeBlob]");

0N/A}

0N/A

0N/Avoid BufferBlob::verify() {

0N/A // unimplemented

0N/A}

0N/A

1601N/Avoid BufferBlob::print_on(outputStream* st) const {

1601N/A CodeBlob::print_on(st);

1601N/A print_value_on(st);

0N/A}

0N/A

0N/Avoid BufferBlob::print_value_on(outputStream* st) const {

0N/A st->print_cr("BufferBlob (" INTPTR_FORMAT ") used for %s", this, name());

0N/A}

0N/A

0N/Avoid RuntimeStub::verify() {

0N/A // unimplemented

0N/A}

0N/A

1601N/Avoid RuntimeStub::print_on(outputStream* st) const {

4016N/A ttyLocker ttyl;

1601N/A CodeBlob::print_on(st);

1601N/A st->print("Runtime Stub (" INTPTR_FORMAT "): ", this);

1601N/A st->print_cr(name());

1601N/A Disassembler::decode((CodeBlob*)this, st);

0N/A}

0N/A

0N/Avoid RuntimeStub::print_value_on(outputStream* st) const {

0N/A st->print("RuntimeStub (" INTPTR_FORMAT "): ", this); st->print(name());

0N/A}

0N/A

0N/Avoid SingletonBlob::verify() {

0N/A // unimplemented

0N/A}

0N/A

1601N/Avoid SingletonBlob::print_on(outputStream* st) const {

4016N/A ttyLocker ttyl;

1601N/A CodeBlob::print_on(st);

1601N/A st->print_cr(name());

1601N/A Disassembler::decode((CodeBlob*)this, st);

0N/A}

0N/A

0N/Avoid SingletonBlob::print_value_on(outputStream* st) const {

0N/A st->print_cr(name());

0N/A}

0N/A

0N/Avoid DeoptimizationBlob::print_value_on(outputStream* st) const {

0N/A st->print_cr("Deoptimization (frame not available)");

0N/A}