graal-compiler: src/share/vm/code/codeBlob.cpp annotate

annotate src/share/vm/code/codeBlob.cpp @ 3992:d1bdeef3e3e2

7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 Summary: There is a race between one thread successfully forwarding and copying the klass mirror for the SoftReference class (including the static master clock) and another thread attempting to use the master clock while attempting to discover a soft reference object. Maintain a shadow copy of the soft reference master clock and use the shadow during reference discovery and reference processing. Reviewed-by: tonyp, brutisso, ysr

author	johnc
date	Wed, 12 Oct 2011 10:25:51 -0700
parents	167b70ff3abc
children	d2a62e0f25eb

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2426 1d1603768966 7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass trims parents: 2192 diff changeset	2 * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1299 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1299 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1299 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	26 #include "code/codeBlob.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	27 #include "code/codeCache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	28 #include "code/relocInfo.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	29 #include "compiler/disassembler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	30 #include "interpreter/bytecode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	31 #include "memory/allocation.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	32 #include "memory/heap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	33 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	34 #include "prims/forte.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	35 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	36 #include "runtime/interfaceSupport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	37 #include "runtime/mutexLocker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	38 #include "runtime/safepoint.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	39 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	40 #include "runtime/vframe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	41 #include "services/memoryService.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	42 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	43 # include "nativeInst_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	44 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	45 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	46 # include "nativeInst_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	47 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	48 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	49 # include "nativeInst_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	50 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	51 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	52 # include "nativeInst_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	53 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	54 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	55 # include "nativeInst_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	56 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	57 #ifdef COMPILER1
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	58 #include "c1/c1_Runtime1.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1762 diff changeset	59 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	60
a61af66fc99e Initial load duke parents: diff changeset	61 unsigned int align_code_offset(int offset) {
a61af66fc99e Initial load duke parents: diff changeset	62 // align the size to CodeEntryAlignment
a61af66fc99e Initial load duke parents: diff changeset	63 return
a61af66fc99e Initial load duke parents: diff changeset	64 ((offset + (int)CodeHeap::header_size() + (CodeEntryAlignment-1)) & ~(CodeEntryAlignment-1))
a61af66fc99e Initial load duke parents: diff changeset	65 - (int)CodeHeap::header_size();
a61af66fc99e Initial load duke parents: diff changeset	66 }
a61af66fc99e Initial load duke parents: diff changeset	67
a61af66fc99e Initial load duke parents: diff changeset	68
a61af66fc99e Initial load duke parents: diff changeset	69 // This must be consistent with the CodeBlob constructor's layout actions.
a61af66fc99e Initial load duke parents: diff changeset	70 unsigned int CodeBlob::allocation_size(CodeBuffer* cb, int header_size) {
a61af66fc99e Initial load duke parents: diff changeset	71 unsigned int size = header_size;
a61af66fc99e Initial load duke parents: diff changeset	72 size += round_to(cb->total_relocation_size(), oopSize);
a61af66fc99e Initial load duke parents: diff changeset	73 // align the size to CodeEntryAlignment
a61af66fc99e Initial load duke parents: diff changeset	74 size = align_code_offset(size);
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	75 size += round_to(cb->total_content_size(), oopSize);
0 a61af66fc99e Initial load duke parents: diff changeset	76 size += round_to(cb->total_oop_size(), oopSize);
a61af66fc99e Initial load duke parents: diff changeset	77 return size;
a61af66fc99e Initial load duke parents: diff changeset	78 }
a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80
a61af66fc99e Initial load duke parents: diff changeset	81 // Creates a simple CodeBlob. Sets up the size of the different regions.
a61af66fc99e Initial load duke parents: diff changeset	82 CodeBlob::CodeBlob(const char* name, int header_size, int size, int frame_complete, int locs_size) {
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	83 assert(size == round_to(size, oopSize), "unaligned size");
3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	84 assert(locs_size == round_to(locs_size, oopSize), "unaligned size");
0 a61af66fc99e Initial load duke parents: diff changeset	85 assert(header_size == round_to(header_size, oopSize), "unaligned size");
a61af66fc99e Initial load duke parents: diff changeset	86 assert(!UseRelocIndex, "no space allocated for reloc index yet");
a61af66fc99e Initial load duke parents: diff changeset	87
a61af66fc99e Initial load duke parents: diff changeset	88 // Note: If UseRelocIndex is enabled, there needs to be (at least) one
a61af66fc99e Initial load duke parents: diff changeset	89 // extra word for the relocation information, containing the reloc
a61af66fc99e Initial load duke parents: diff changeset	90 // index table length. Unfortunately, the reloc index table imple-
a61af66fc99e Initial load duke parents: diff changeset	91 // mentation is not easily understandable and thus it is not clear
a61af66fc99e Initial load duke parents: diff changeset	92 // what exactly the format is supposed to be. For now, we just turn
a61af66fc99e Initial load duke parents: diff changeset	93 // off the use of this table (gri 7/6/2000).
a61af66fc99e Initial load duke parents: diff changeset	94
a61af66fc99e Initial load duke parents: diff changeset	95 _name = name;
a61af66fc99e Initial load duke parents: diff changeset	96 _size = size;
a61af66fc99e Initial load duke parents: diff changeset	97 _frame_complete_offset = frame_complete;
a61af66fc99e Initial load duke parents: diff changeset	98 _header_size = header_size;
a61af66fc99e Initial load duke parents: diff changeset	99 _relocation_size = locs_size;
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	100 _content_offset = align_code_offset(header_size + _relocation_size);
3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	101 _code_offset = _content_offset;
0 a61af66fc99e Initial load duke parents: diff changeset	102 _data_offset = size;
a61af66fc99e Initial load duke parents: diff changeset	103 _frame_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	104 set_oop_maps(NULL);
a61af66fc99e Initial load duke parents: diff changeset	105 }
a61af66fc99e Initial load duke parents: diff changeset	106
a61af66fc99e Initial load duke parents: diff changeset	107
a61af66fc99e Initial load duke parents: diff changeset	108 // Creates a CodeBlob from a CodeBuffer. Sets up the size of the different regions,
a61af66fc99e Initial load duke parents: diff changeset	109 // and copy code and relocation info.
a61af66fc99e Initial load duke parents: diff changeset	110 CodeBlob::CodeBlob(
a61af66fc99e Initial load duke parents: diff changeset	111 const char* name,
a61af66fc99e Initial load duke parents: diff changeset	112 CodeBuffer* cb,
a61af66fc99e Initial load duke parents: diff changeset	113 int header_size,
a61af66fc99e Initial load duke parents: diff changeset	114 int size,
a61af66fc99e Initial load duke parents: diff changeset	115 int frame_complete,
a61af66fc99e Initial load duke parents: diff changeset	116 int frame_size,
a61af66fc99e Initial load duke parents: diff changeset	117 OopMapSet* oop_maps
a61af66fc99e Initial load duke parents: diff changeset	118 ) {
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	119 assert(size == round_to(size, oopSize), "unaligned size");
0 a61af66fc99e Initial load duke parents: diff changeset	120 assert(header_size == round_to(header_size, oopSize), "unaligned size");
a61af66fc99e Initial load duke parents: diff changeset	121
a61af66fc99e Initial load duke parents: diff changeset	122 _name = name;
a61af66fc99e Initial load duke parents: diff changeset	123 _size = size;
a61af66fc99e Initial load duke parents: diff changeset	124 _frame_complete_offset = frame_complete;
a61af66fc99e Initial load duke parents: diff changeset	125 _header_size = header_size;
a61af66fc99e Initial load duke parents: diff changeset	126 _relocation_size = round_to(cb->total_relocation_size(), oopSize);
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	127 _content_offset = align_code_offset(header_size + _relocation_size);
1762 0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	128 _code_offset = _content_offset + cb->total_offset_of(cb->insts());
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	129 _data_offset = _content_offset + round_to(cb->total_content_size(), oopSize);
0 a61af66fc99e Initial load duke parents: diff changeset	130 assert(_data_offset <= size, "codeBlob is too small");
a61af66fc99e Initial load duke parents: diff changeset	131
a61af66fc99e Initial load duke parents: diff changeset	132 cb->copy_code_and_locs_to(this);
a61af66fc99e Initial load duke parents: diff changeset	133 set_oop_maps(oop_maps);
a61af66fc99e Initial load duke parents: diff changeset	134 _frame_size = frame_size;
a61af66fc99e Initial load duke parents: diff changeset	135 #ifdef COMPILER1
a61af66fc99e Initial load duke parents: diff changeset	136 // probably wrong for tiered
a61af66fc99e Initial load duke parents: diff changeset	137 assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs");
a61af66fc99e Initial load duke parents: diff changeset	138 #endif // COMPILER1
a61af66fc99e Initial load duke parents: diff changeset	139 }
a61af66fc99e Initial load duke parents: diff changeset	140
a61af66fc99e Initial load duke parents: diff changeset	141
a61af66fc99e Initial load duke parents: diff changeset	142 void CodeBlob::set_oop_maps(OopMapSet* p) {
a61af66fc99e Initial load duke parents: diff changeset	143 // Danger Will Robinson! This method allocates a big
a61af66fc99e Initial load duke parents: diff changeset	144 // chunk of memory, its your job to free it.
a61af66fc99e Initial load duke parents: diff changeset	145 if (p != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	146 // We need to allocate a chunk big enough to hold the OopMapSet and all of its OopMaps
a61af66fc99e Initial load duke parents: diff changeset	147 _oop_maps = (OopMapSet* )NEW_C_HEAP_ARRAY(unsigned char, p->heap_size());
a61af66fc99e Initial load duke parents: diff changeset	148 p->copy_to((address)_oop_maps);
a61af66fc99e Initial load duke parents: diff changeset	149 } else {
a61af66fc99e Initial load duke parents: diff changeset	150 _oop_maps = NULL;
a61af66fc99e Initial load duke parents: diff changeset	151 }
a61af66fc99e Initial load duke parents: diff changeset	152 }
a61af66fc99e Initial load duke parents: diff changeset	153
a61af66fc99e Initial load duke parents: diff changeset	154
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	155 void CodeBlob::trace_new_stub(CodeBlob* stub, const char* name1, const char* name2) {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	156 // Do not hold the CodeCache lock during name formatting.
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	157 assert(!CodeCache_lock->owned_by_self(), "release CodeCache before registering the stub");
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	158
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	159 if (stub != NULL) {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	160 char stub_id[256];
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	161 assert(strlen(name1) + strlen(name2) < sizeof(stub_id), "");
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	162 jio_snprintf(stub_id, sizeof(stub_id), "%s%s", name1, name2);
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	163 if (PrintStubCode) {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	164 tty->print_cr("Decoding %s " INTPTR_FORMAT, stub_id, (intptr_t) stub);
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	165 Disassembler::decode(stub->code_begin(), stub->code_end());
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	166 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	167 Forte::register_stub(stub_id, stub->code_begin(), stub->code_end());
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	168
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	169 if (JvmtiExport::should_post_dynamic_code_generated()) {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	170 const char* stub_name = name2;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	171 if (name2[0] == '\0') stub_name = name1;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	172 JvmtiExport::post_dynamic_code_generated(stub_name, stub->code_begin(), stub->code_end());
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	173 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	174 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	175
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	176 // Track memory usage statistic after releasing CodeCache_lock
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	177 MemoryService::track_code_cache_memory_usage();
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	178 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	179
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	180
0 a61af66fc99e Initial load duke parents: diff changeset	181 void CodeBlob::flush() {
a61af66fc99e Initial load duke parents: diff changeset	182 if (_oop_maps) {
a61af66fc99e Initial load duke parents: diff changeset	183 FREE_C_HEAP_ARRAY(unsigned char, _oop_maps);
a61af66fc99e Initial load duke parents: diff changeset	184 _oop_maps = NULL;
a61af66fc99e Initial load duke parents: diff changeset	185 }
a61af66fc99e Initial load duke parents: diff changeset	186 _comments.free();
a61af66fc99e Initial load duke parents: diff changeset	187 }
a61af66fc99e Initial load duke parents: diff changeset	188
a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190 OopMap* CodeBlob::oop_map_for_return_address(address return_address) {
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	191 assert(oop_maps() != NULL, "nope");
3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	192 return oop_maps()->find_map_at_offset((intptr_t) return_address - (intptr_t) code_begin());
0 a61af66fc99e Initial load duke parents: diff changeset	193 }
a61af66fc99e Initial load duke parents: diff changeset	194
a61af66fc99e Initial load duke parents: diff changeset	195
a61af66fc99e Initial load duke parents: diff changeset	196 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	197 // Implementation of BufferBlob
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199
a61af66fc99e Initial load duke parents: diff changeset	200 BufferBlob::BufferBlob(const char* name, int size)
a61af66fc99e Initial load duke parents: diff changeset	201 : CodeBlob(name, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, /locs_size:/ 0)
a61af66fc99e Initial load duke parents: diff changeset	202 {}
a61af66fc99e Initial load duke parents: diff changeset	203
a61af66fc99e Initial load duke parents: diff changeset	204 BufferBlob* BufferBlob::create(const char* name, int buffer_size) {
a61af66fc99e Initial load duke parents: diff changeset	205 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 BufferBlob* blob = NULL;
a61af66fc99e Initial load duke parents: diff changeset	208 unsigned int size = sizeof(BufferBlob);
a61af66fc99e Initial load duke parents: diff changeset	209 // align the size to CodeEntryAlignment
a61af66fc99e Initial load duke parents: diff changeset	210 size = align_code_offset(size);
a61af66fc99e Initial load duke parents: diff changeset	211 size += round_to(buffer_size, oopSize);
a61af66fc99e Initial load duke parents: diff changeset	212 assert(name != NULL, "must provide a name");
a61af66fc99e Initial load duke parents: diff changeset	213 {
a61af66fc99e Initial load duke parents: diff changeset	214 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	215 blob = new (size) BufferBlob(name, size);
a61af66fc99e Initial load duke parents: diff changeset	216 }
a61af66fc99e Initial load duke parents: diff changeset	217 // Track memory usage statistic after releasing CodeCache_lock
a61af66fc99e Initial load duke parents: diff changeset	218 MemoryService::track_code_cache_memory_usage();
a61af66fc99e Initial load duke parents: diff changeset	219
a61af66fc99e Initial load duke parents: diff changeset	220 return blob;
a61af66fc99e Initial load duke parents: diff changeset	221 }
a61af66fc99e Initial load duke parents: diff changeset	222
a61af66fc99e Initial load duke parents: diff changeset	223
a61af66fc99e Initial load duke parents: diff changeset	224 BufferBlob::BufferBlob(const char* name, int size, CodeBuffer* cb)
a61af66fc99e Initial load duke parents: diff changeset	225 : CodeBlob(name, cb, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, 0, NULL)
a61af66fc99e Initial load duke parents: diff changeset	226 {}
a61af66fc99e Initial load duke parents: diff changeset	227
a61af66fc99e Initial load duke parents: diff changeset	228 BufferBlob* BufferBlob::create(const char* name, CodeBuffer* cb) {
a61af66fc99e Initial load duke parents: diff changeset	229 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load duke parents: diff changeset	230
a61af66fc99e Initial load duke parents: diff changeset	231 BufferBlob* blob = NULL;
a61af66fc99e Initial load duke parents: diff changeset	232 unsigned int size = allocation_size(cb, sizeof(BufferBlob));
a61af66fc99e Initial load duke parents: diff changeset	233 assert(name != NULL, "must provide a name");
a61af66fc99e Initial load duke parents: diff changeset	234 {
a61af66fc99e Initial load duke parents: diff changeset	235 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	236 blob = new (size) BufferBlob(name, size, cb);
a61af66fc99e Initial load duke parents: diff changeset	237 }
a61af66fc99e Initial load duke parents: diff changeset	238 // Track memory usage statistic after releasing CodeCache_lock
a61af66fc99e Initial load duke parents: diff changeset	239 MemoryService::track_code_cache_memory_usage();
a61af66fc99e Initial load duke parents: diff changeset	240
a61af66fc99e Initial load duke parents: diff changeset	241 return blob;
a61af66fc99e Initial load duke parents: diff changeset	242 }
a61af66fc99e Initial load duke parents: diff changeset	243
a61af66fc99e Initial load duke parents: diff changeset	244
a61af66fc99e Initial load duke parents: diff changeset	245 void* BufferBlob::operator new(size_t s, unsigned size) {
a61af66fc99e Initial load duke parents: diff changeset	246 void* p = CodeCache::allocate(size);
a61af66fc99e Initial load duke parents: diff changeset	247 return p;
a61af66fc99e Initial load duke parents: diff changeset	248 }
a61af66fc99e Initial load duke parents: diff changeset	249
a61af66fc99e Initial load duke parents: diff changeset	250
a61af66fc99e Initial load duke parents: diff changeset	251 void BufferBlob::free( BufferBlob *blob ) {
a61af66fc99e Initial load duke parents: diff changeset	252 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load duke parents: diff changeset	253 {
a61af66fc99e Initial load duke parents: diff changeset	254 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	255 CodeCache::free((CodeBlob*)blob);
a61af66fc99e Initial load duke parents: diff changeset	256 }
a61af66fc99e Initial load duke parents: diff changeset	257 // Track memory usage statistic after releasing CodeCache_lock
a61af66fc99e Initial load duke parents: diff changeset	258 MemoryService::track_code_cache_memory_usage();
a61af66fc99e Initial load duke parents: diff changeset	259 }
a61af66fc99e Initial load duke parents: diff changeset	260
1299 9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	261
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	262 //----------------------------------------------------------------------------------------------------
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	263 // Implementation of AdapterBlob
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	264
1663 7139e81efd2d 6970566: runThese fails with SIGSEGV never parents: 1644 diff changeset	265 AdapterBlob::AdapterBlob(int size, CodeBuffer* cb) :
7139e81efd2d 6970566: runThese fails with SIGSEGV never parents: 1644 diff changeset	266 BufferBlob("I2C/C2I adapters", size, cb) {
7139e81efd2d 6970566: runThese fails with SIGSEGV never parents: 1644 diff changeset	267 CodeCache::commit(this);
7139e81efd2d 6970566: runThese fails with SIGSEGV never parents: 1644 diff changeset	268 }
7139e81efd2d 6970566: runThese fails with SIGSEGV never parents: 1644 diff changeset	269
1299 9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	270 AdapterBlob* AdapterBlob::create(CodeBuffer* cb) {
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	271 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	272
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	273 AdapterBlob* blob = NULL;
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	274 unsigned int size = allocation_size(cb, sizeof(AdapterBlob));
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	275 {
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	276 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	277 blob = new (size) AdapterBlob(size, cb);
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	278 }
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	279 // Track memory usage statistic after releasing CodeCache_lock
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	280 MemoryService::track_code_cache_memory_usage();
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	281
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	282 return blob;
0 a61af66fc99e Initial load duke parents: diff changeset	283 }
a61af66fc99e Initial load duke parents: diff changeset	284
1299 9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	285
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	286 //----------------------------------------------------------------------------------------------------
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	287 // Implementation of MethodHandlesAdapterBlob
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	288
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	289 MethodHandlesAdapterBlob* MethodHandlesAdapterBlob::create(int buffer_size) {
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	290 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	291
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	292 MethodHandlesAdapterBlob* blob = NULL;
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	293 unsigned int size = sizeof(MethodHandlesAdapterBlob);
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	294 // align the size to CodeEntryAlignment
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	295 size = align_code_offset(size);
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	296 size += round_to(buffer_size, oopSize);
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	297 {
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	298 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	299 blob = new (size) MethodHandlesAdapterBlob(size);
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	300 }
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	301 // Track memory usage statistic after releasing CodeCache_lock
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	302 MemoryService::track_code_cache_memory_usage();
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	303
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	304 return blob;
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	305 }
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	306
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob twisti parents: 0 diff changeset	307
0 a61af66fc99e Initial load duke parents: diff changeset	308 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	309 // Implementation of RuntimeStub
a61af66fc99e Initial load duke parents: diff changeset	310
a61af66fc99e Initial load duke parents: diff changeset	311 RuntimeStub::RuntimeStub(
a61af66fc99e Initial load duke parents: diff changeset	312 const char* name,
a61af66fc99e Initial load duke parents: diff changeset	313 CodeBuffer* cb,
a61af66fc99e Initial load duke parents: diff changeset	314 int size,
a61af66fc99e Initial load duke parents: diff changeset	315 int frame_complete,
a61af66fc99e Initial load duke parents: diff changeset	316 int frame_size,
a61af66fc99e Initial load duke parents: diff changeset	317 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	318 bool caller_must_gc_arguments
a61af66fc99e Initial load duke parents: diff changeset	319 )
a61af66fc99e Initial load duke parents: diff changeset	320 : CodeBlob(name, cb, sizeof(RuntimeStub), size, frame_complete, frame_size, oop_maps)
a61af66fc99e Initial load duke parents: diff changeset	321 {
a61af66fc99e Initial load duke parents: diff changeset	322 _caller_must_gc_arguments = caller_must_gc_arguments;
a61af66fc99e Initial load duke parents: diff changeset	323 }
a61af66fc99e Initial load duke parents: diff changeset	324
a61af66fc99e Initial load duke parents: diff changeset	325
a61af66fc99e Initial load duke parents: diff changeset	326 RuntimeStub* RuntimeStub::new_runtime_stub(const char* stub_name,
a61af66fc99e Initial load duke parents: diff changeset	327 CodeBuffer* cb,
a61af66fc99e Initial load duke parents: diff changeset	328 int frame_complete,
a61af66fc99e Initial load duke parents: diff changeset	329 int frame_size,
a61af66fc99e Initial load duke parents: diff changeset	330 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	331 bool caller_must_gc_arguments)
a61af66fc99e Initial load duke parents: diff changeset	332 {
a61af66fc99e Initial load duke parents: diff changeset	333 RuntimeStub* stub = NULL;
a61af66fc99e Initial load duke parents: diff changeset	334 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load duke parents: diff changeset	335 {
a61af66fc99e Initial load duke parents: diff changeset	336 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	337 unsigned int size = allocation_size(cb, sizeof(RuntimeStub));
a61af66fc99e Initial load duke parents: diff changeset	338 stub = new (size) RuntimeStub(stub_name, cb, size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments);
a61af66fc99e Initial load duke parents: diff changeset	339 }
a61af66fc99e Initial load duke parents: diff changeset	340
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	341 trace_new_stub(stub, "RuntimeStub - ", stub_name);
0 a61af66fc99e Initial load duke parents: diff changeset	342
a61af66fc99e Initial load duke parents: diff changeset	343 return stub;
a61af66fc99e Initial load duke parents: diff changeset	344 }
a61af66fc99e Initial load duke parents: diff changeset	345
a61af66fc99e Initial load duke parents: diff changeset	346
a61af66fc99e Initial load duke parents: diff changeset	347 void* RuntimeStub::operator new(size_t s, unsigned size) {
a61af66fc99e Initial load duke parents: diff changeset	348 void* p = CodeCache::allocate(size);
a61af66fc99e Initial load duke parents: diff changeset	349 if (!p) fatal("Initial size of CodeCache is too small");
a61af66fc99e Initial load duke parents: diff changeset	350 return p;
a61af66fc99e Initial load duke parents: diff changeset	351 }
a61af66fc99e Initial load duke parents: diff changeset	352
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	353 // operator new shared by all singletons:
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	354 void* SingletonBlob::operator new(size_t s, unsigned size) {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	355 void* p = CodeCache::allocate(size);
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	356 if (!p) fatal("Initial size of CodeCache is too small");
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	357 return p;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	358 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	359
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	360
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	361 //----------------------------------------------------------------------------------------------------
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	362 // Implementation of RicochetBlob
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	363
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	364 RicochetBlob::RicochetBlob(
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	365 CodeBuffer* cb,
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	366 int size,
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	367 int bounce_offset,
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	368 int exception_offset,
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	369 int frame_size
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	370 )
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	371 : SingletonBlob("RicochetBlob", cb, sizeof(RicochetBlob), size, frame_size, (OopMapSet*) NULL)
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	372 {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	373 _bounce_offset = bounce_offset;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	374 _exception_offset = exception_offset;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	375 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	376
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	377
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	378 RicochetBlob* RicochetBlob::create(
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	379 CodeBuffer* cb,
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	380 int bounce_offset,
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	381 int exception_offset,
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	382 int frame_size)
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	383 {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	384 RicochetBlob* blob = NULL;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	385 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	386 {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	387 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	388 unsigned int size = allocation_size(cb, sizeof(RicochetBlob));
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	389 blob = new (size) RicochetBlob(cb, size, bounce_offset, exception_offset, frame_size);
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	390 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	391
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	392 trace_new_stub(blob, "RicochetBlob");
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	393
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	394 return blob;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	395 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	396
0 a61af66fc99e Initial load duke parents: diff changeset	397
a61af66fc99e Initial load duke parents: diff changeset	398 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	399 // Implementation of DeoptimizationBlob
a61af66fc99e Initial load duke parents: diff changeset	400
a61af66fc99e Initial load duke parents: diff changeset	401 DeoptimizationBlob::DeoptimizationBlob(
a61af66fc99e Initial load duke parents: diff changeset	402 CodeBuffer* cb,
a61af66fc99e Initial load duke parents: diff changeset	403 int size,
a61af66fc99e Initial load duke parents: diff changeset	404 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	405 int unpack_offset,
a61af66fc99e Initial load duke parents: diff changeset	406 int unpack_with_exception_offset,
a61af66fc99e Initial load duke parents: diff changeset	407 int unpack_with_reexecution_offset,
a61af66fc99e Initial load duke parents: diff changeset	408 int frame_size
a61af66fc99e Initial load duke parents: diff changeset	409 )
a61af66fc99e Initial load duke parents: diff changeset	410 : SingletonBlob("DeoptimizationBlob", cb, sizeof(DeoptimizationBlob), size, frame_size, oop_maps)
a61af66fc99e Initial load duke parents: diff changeset	411 {
a61af66fc99e Initial load duke parents: diff changeset	412 _unpack_offset = unpack_offset;
a61af66fc99e Initial load duke parents: diff changeset	413 _unpack_with_exception = unpack_with_exception_offset;
a61af66fc99e Initial load duke parents: diff changeset	414 _unpack_with_reexecution = unpack_with_reexecution_offset;
a61af66fc99e Initial load duke parents: diff changeset	415 #ifdef COMPILER1
a61af66fc99e Initial load duke parents: diff changeset	416 _unpack_with_exception_in_tls = -1;
a61af66fc99e Initial load duke parents: diff changeset	417 #endif
a61af66fc99e Initial load duke parents: diff changeset	418 }
a61af66fc99e Initial load duke parents: diff changeset	419
a61af66fc99e Initial load duke parents: diff changeset	420
a61af66fc99e Initial load duke parents: diff changeset	421 DeoptimizationBlob* DeoptimizationBlob::create(
a61af66fc99e Initial load duke parents: diff changeset	422 CodeBuffer* cb,
a61af66fc99e Initial load duke parents: diff changeset	423 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	424 int unpack_offset,
a61af66fc99e Initial load duke parents: diff changeset	425 int unpack_with_exception_offset,
a61af66fc99e Initial load duke parents: diff changeset	426 int unpack_with_reexecution_offset,
a61af66fc99e Initial load duke parents: diff changeset	427 int frame_size)
a61af66fc99e Initial load duke parents: diff changeset	428 {
a61af66fc99e Initial load duke parents: diff changeset	429 DeoptimizationBlob* blob = NULL;
a61af66fc99e Initial load duke parents: diff changeset	430 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load duke parents: diff changeset	431 {
a61af66fc99e Initial load duke parents: diff changeset	432 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	433 unsigned int size = allocation_size(cb, sizeof(DeoptimizationBlob));
a61af66fc99e Initial load duke parents: diff changeset	434 blob = new (size) DeoptimizationBlob(cb,
a61af66fc99e Initial load duke parents: diff changeset	435 size,
a61af66fc99e Initial load duke parents: diff changeset	436 oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	437 unpack_offset,
a61af66fc99e Initial load duke parents: diff changeset	438 unpack_with_exception_offset,
a61af66fc99e Initial load duke parents: diff changeset	439 unpack_with_reexecution_offset,
a61af66fc99e Initial load duke parents: diff changeset	440 frame_size);
a61af66fc99e Initial load duke parents: diff changeset	441 }
a61af66fc99e Initial load duke parents: diff changeset	442
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	443 trace_new_stub(blob, "DeoptimizationBlob");
0 a61af66fc99e Initial load duke parents: diff changeset	444
a61af66fc99e Initial load duke parents: diff changeset	445 return blob;
a61af66fc99e Initial load duke parents: diff changeset	446 }
a61af66fc99e Initial load duke parents: diff changeset	447
a61af66fc99e Initial load duke parents: diff changeset	448
a61af66fc99e Initial load duke parents: diff changeset	449 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	450 // Implementation of UncommonTrapBlob
a61af66fc99e Initial load duke parents: diff changeset	451
a61af66fc99e Initial load duke parents: diff changeset	452 #ifdef COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	453 UncommonTrapBlob::UncommonTrapBlob(
a61af66fc99e Initial load duke parents: diff changeset	454 CodeBuffer* cb,
a61af66fc99e Initial load duke parents: diff changeset	455 int size,
a61af66fc99e Initial load duke parents: diff changeset	456 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	457 int frame_size
a61af66fc99e Initial load duke parents: diff changeset	458 )
a61af66fc99e Initial load duke parents: diff changeset	459 : SingletonBlob("UncommonTrapBlob", cb, sizeof(UncommonTrapBlob), size, frame_size, oop_maps)
a61af66fc99e Initial load duke parents: diff changeset	460 {}
a61af66fc99e Initial load duke parents: diff changeset	461
a61af66fc99e Initial load duke parents: diff changeset	462
a61af66fc99e Initial load duke parents: diff changeset	463 UncommonTrapBlob* UncommonTrapBlob::create(
a61af66fc99e Initial load duke parents: diff changeset	464 CodeBuffer* cb,
a61af66fc99e Initial load duke parents: diff changeset	465 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	466 int frame_size)
a61af66fc99e Initial load duke parents: diff changeset	467 {
a61af66fc99e Initial load duke parents: diff changeset	468 UncommonTrapBlob* blob = NULL;
a61af66fc99e Initial load duke parents: diff changeset	469 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load duke parents: diff changeset	470 {
a61af66fc99e Initial load duke parents: diff changeset	471 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	472 unsigned int size = allocation_size(cb, sizeof(UncommonTrapBlob));
a61af66fc99e Initial load duke parents: diff changeset	473 blob = new (size) UncommonTrapBlob(cb, size, oop_maps, frame_size);
a61af66fc99e Initial load duke parents: diff changeset	474 }
a61af66fc99e Initial load duke parents: diff changeset	475
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	476 trace_new_stub(blob, "UncommonTrapBlob");
0 a61af66fc99e Initial load duke parents: diff changeset	477
a61af66fc99e Initial load duke parents: diff changeset	478 return blob;
a61af66fc99e Initial load duke parents: diff changeset	479 }
a61af66fc99e Initial load duke parents: diff changeset	480
a61af66fc99e Initial load duke parents: diff changeset	481
a61af66fc99e Initial load duke parents: diff changeset	482 #endif // COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	483
a61af66fc99e Initial load duke parents: diff changeset	484
a61af66fc99e Initial load duke parents: diff changeset	485 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	486 // Implementation of ExceptionBlob
a61af66fc99e Initial load duke parents: diff changeset	487
a61af66fc99e Initial load duke parents: diff changeset	488 #ifdef COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	489 ExceptionBlob::ExceptionBlob(
a61af66fc99e Initial load duke parents: diff changeset	490 CodeBuffer* cb,
a61af66fc99e Initial load duke parents: diff changeset	491 int size,
a61af66fc99e Initial load duke parents: diff changeset	492 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	493 int frame_size
a61af66fc99e Initial load duke parents: diff changeset	494 )
a61af66fc99e Initial load duke parents: diff changeset	495 : SingletonBlob("ExceptionBlob", cb, sizeof(ExceptionBlob), size, frame_size, oop_maps)
a61af66fc99e Initial load duke parents: diff changeset	496 {}
a61af66fc99e Initial load duke parents: diff changeset	497
a61af66fc99e Initial load duke parents: diff changeset	498
a61af66fc99e Initial load duke parents: diff changeset	499 ExceptionBlob* ExceptionBlob::create(
a61af66fc99e Initial load duke parents: diff changeset	500 CodeBuffer* cb,
a61af66fc99e Initial load duke parents: diff changeset	501 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	502 int frame_size)
a61af66fc99e Initial load duke parents: diff changeset	503 {
a61af66fc99e Initial load duke parents: diff changeset	504 ExceptionBlob* blob = NULL;
a61af66fc99e Initial load duke parents: diff changeset	505 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load duke parents: diff changeset	506 {
a61af66fc99e Initial load duke parents: diff changeset	507 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	508 unsigned int size = allocation_size(cb, sizeof(ExceptionBlob));
a61af66fc99e Initial load duke parents: diff changeset	509 blob = new (size) ExceptionBlob(cb, size, oop_maps, frame_size);
a61af66fc99e Initial load duke parents: diff changeset	510 }
a61af66fc99e Initial load duke parents: diff changeset	511
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	512 trace_new_stub(blob, "ExceptionBlob");
0 a61af66fc99e Initial load duke parents: diff changeset	513
a61af66fc99e Initial load duke parents: diff changeset	514 return blob;
a61af66fc99e Initial load duke parents: diff changeset	515 }
a61af66fc99e Initial load duke parents: diff changeset	516
a61af66fc99e Initial load duke parents: diff changeset	517
a61af66fc99e Initial load duke parents: diff changeset	518 #endif // COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	519
a61af66fc99e Initial load duke parents: diff changeset	520
a61af66fc99e Initial load duke parents: diff changeset	521 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	522 // Implementation of SafepointBlob
a61af66fc99e Initial load duke parents: diff changeset	523
a61af66fc99e Initial load duke parents: diff changeset	524 SafepointBlob::SafepointBlob(
a61af66fc99e Initial load duke parents: diff changeset	525 CodeBuffer* cb,
a61af66fc99e Initial load duke parents: diff changeset	526 int size,
a61af66fc99e Initial load duke parents: diff changeset	527 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	528 int frame_size
a61af66fc99e Initial load duke parents: diff changeset	529 )
a61af66fc99e Initial load duke parents: diff changeset	530 : SingletonBlob("SafepointBlob", cb, sizeof(SafepointBlob), size, frame_size, oop_maps)
a61af66fc99e Initial load duke parents: diff changeset	531 {}
a61af66fc99e Initial load duke parents: diff changeset	532
a61af66fc99e Initial load duke parents: diff changeset	533
a61af66fc99e Initial load duke parents: diff changeset	534 SafepointBlob* SafepointBlob::create(
a61af66fc99e Initial load duke parents: diff changeset	535 CodeBuffer* cb,
a61af66fc99e Initial load duke parents: diff changeset	536 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	537 int frame_size)
a61af66fc99e Initial load duke parents: diff changeset	538 {
a61af66fc99e Initial load duke parents: diff changeset	539 SafepointBlob* blob = NULL;
a61af66fc99e Initial load duke parents: diff changeset	540 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load duke parents: diff changeset	541 {
a61af66fc99e Initial load duke parents: diff changeset	542 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	543 unsigned int size = allocation_size(cb, sizeof(SafepointBlob));
a61af66fc99e Initial load duke parents: diff changeset	544 blob = new (size) SafepointBlob(cb, size, oop_maps, frame_size);
a61af66fc99e Initial load duke parents: diff changeset	545 }
a61af66fc99e Initial load duke parents: diff changeset	546
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 2426 diff changeset	547 trace_new_stub(blob, "SafepointBlob");
0 a61af66fc99e Initial load duke parents: diff changeset	548
a61af66fc99e Initial load duke parents: diff changeset	549 return blob;
a61af66fc99e Initial load duke parents: diff changeset	550 }
a61af66fc99e Initial load duke parents: diff changeset	551
a61af66fc99e Initial load duke parents: diff changeset	552
a61af66fc99e Initial load duke parents: diff changeset	553 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	554 // Verification and printing
a61af66fc99e Initial load duke parents: diff changeset	555
a61af66fc99e Initial load duke parents: diff changeset	556 void CodeBlob::verify() {
a61af66fc99e Initial load duke parents: diff changeset	557 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	558 }
a61af66fc99e Initial load duke parents: diff changeset	559
1681 126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	560 void CodeBlob::print_on(outputStream* st) const {
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	561 st->print_cr("[CodeBlob (" INTPTR_FORMAT ")]", this);
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	562 st->print_cr("Framesize: %d", _frame_size);
0 a61af66fc99e Initial load duke parents: diff changeset	563 }
a61af66fc99e Initial load duke parents: diff changeset	564
a61af66fc99e Initial load duke parents: diff changeset	565 void CodeBlob::print_value_on(outputStream* st) const {
a61af66fc99e Initial load duke parents: diff changeset	566 st->print_cr("[CodeBlob]");
a61af66fc99e Initial load duke parents: diff changeset	567 }
a61af66fc99e Initial load duke parents: diff changeset	568
a61af66fc99e Initial load duke parents: diff changeset	569 void BufferBlob::verify() {
a61af66fc99e Initial load duke parents: diff changeset	570 // unimplemented
a61af66fc99e Initial load duke parents: diff changeset	571 }
a61af66fc99e Initial load duke parents: diff changeset	572
1681 126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	573 void BufferBlob::print_on(outputStream* st) const {
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	574 CodeBlob::print_on(st);
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	575 print_value_on(st);
0 a61af66fc99e Initial load duke parents: diff changeset	576 }
a61af66fc99e Initial load duke parents: diff changeset	577
a61af66fc99e Initial load duke parents: diff changeset	578 void BufferBlob::print_value_on(outputStream* st) const {
a61af66fc99e Initial load duke parents: diff changeset	579 st->print_cr("BufferBlob (" INTPTR_FORMAT ") used for %s", this, name());
a61af66fc99e Initial load duke parents: diff changeset	580 }
a61af66fc99e Initial load duke parents: diff changeset	581
a61af66fc99e Initial load duke parents: diff changeset	582 void RuntimeStub::verify() {
a61af66fc99e Initial load duke parents: diff changeset	583 // unimplemented
a61af66fc99e Initial load duke parents: diff changeset	584 }
a61af66fc99e Initial load duke parents: diff changeset	585
1681 126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	586 void RuntimeStub::print_on(outputStream* st) const {
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	587 CodeBlob::print_on(st);
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	588 st->print("Runtime Stub (" INTPTR_FORMAT "): ", this);
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	589 st->print_cr(name());
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	590 Disassembler::decode((CodeBlob*)this, st);
0 a61af66fc99e Initial load duke parents: diff changeset	591 }
a61af66fc99e Initial load duke parents: diff changeset	592
a61af66fc99e Initial load duke parents: diff changeset	593 void RuntimeStub::print_value_on(outputStream* st) const {
a61af66fc99e Initial load duke parents: diff changeset	594 st->print("RuntimeStub (" INTPTR_FORMAT "): ", this); st->print(name());
a61af66fc99e Initial load duke parents: diff changeset	595 }
a61af66fc99e Initial load duke parents: diff changeset	596
a61af66fc99e Initial load duke parents: diff changeset	597 void SingletonBlob::verify() {
a61af66fc99e Initial load duke parents: diff changeset	598 // unimplemented
a61af66fc99e Initial load duke parents: diff changeset	599 }
a61af66fc99e Initial load duke parents: diff changeset	600
1681 126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	601 void SingletonBlob::print_on(outputStream* st) const {
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	602 CodeBlob::print_on(st);
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	603 st->print_cr(name());
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1663 diff changeset	604 Disassembler::decode((CodeBlob*)this, st);
0 a61af66fc99e Initial load duke parents: diff changeset	605 }
a61af66fc99e Initial load duke parents: diff changeset	606
a61af66fc99e Initial load duke parents: diff changeset	607 void SingletonBlob::print_value_on(outputStream* st) const {
a61af66fc99e Initial load duke parents: diff changeset	608 st->print_cr(name());
a61af66fc99e Initial load duke parents: diff changeset	609 }
a61af66fc99e Initial load duke parents: diff changeset	610
a61af66fc99e Initial load duke parents: diff changeset	611 void DeoptimizationBlob::print_value_on(outputStream* st) const {
a61af66fc99e Initial load duke parents: diff changeset	612 st->print_cr("Deoptimization (frame not available)");
a61af66fc99e Initial load duke parents: diff changeset	613 }

Mercurial > hg > graal-compiler

annotate src/share/vm/code/codeBlob.cpp @ 3992:d1bdeef3e3e2