Mercurial > hg > truffle
annotate src/share/vm/code/codeBlob.hpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | 469216acdb28 |
| children | 096c224171c4 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
12146
9758d9f36299
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
8767
diff
changeset
|
2 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 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 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_CODE_CODEBLOB_HPP |
| 26 #define SHARE_VM_CODE_CODEBLOB_HPP | |
| 27 | |
| 28 #include "asm/codeBuffer.hpp" | |
| 29 #include "compiler/oopMap.hpp" | |
| 30 #include "runtime/frame.hpp" | |
| 31 #include "runtime/handles.hpp" | |
| 32 | |
| 0 | 33 // CodeBlob - superclass for all entries in the CodeCache. |
| 34 // | |
| 35 // Suptypes are: | |
| 36 // nmethod : Compiled Java methods (include method that calls to native code) | |
| 37 // RuntimeStub : Call to VM runtime methods | |
| 38 // DeoptimizationBlob : Used for deoptimizatation | |
| 39 // ExceptionBlob : Used for stack unrolling | |
| 40 // SafepointBlob : Used to handle illegal instruction exceptions | |
| 41 // | |
| 42 // | |
| 43 // Layout: | |
| 44 // - header | |
| 45 // - relocation | |
| 1748 | 46 // - content space |
| 47 // - instruction space | |
| 0 | 48 // - data space |
| 49 class DeoptimizationBlob; | |
| 50 | |
| 51 class CodeBlob VALUE_OBJ_CLASS_SPEC { | |
| 52 | |
| 53 friend class VMStructs; | |
| 54 | |
| 55 private: | |
| 56 const char* _name; | |
| 57 int _size; // total size of CodeBlob in bytes | |
| 58 int _header_size; // size of header (depends on subclass) | |
| 59 int _relocation_size; // size of relocation | |
| 1748 | 60 int _content_offset; // offset to where content region begins (this includes consts, insts, stubs) |
| 61 int _code_offset; // offset to where instructions region begins (this includes insts, stubs) | |
| 0 | 62 int _frame_complete_offset; // instruction offsets in [0.._frame_complete_offset) have |
| 63 // not finished setting up their frame. Beware of pc's in | |
| 64 // that range. There is a similar range(s) on returns | |
| 65 // which we don't detect. | |
| 66 int _data_offset; // offset to where data region begins | |
| 67 int _frame_size; // size of stack frame | |
| 68 OopMapSet* _oop_maps; // OopMap for this CodeBlob | |
|
8767
a5de0cc2f91c
8008555: Debugging code in compiled method sometimes leaks memory
roland
parents:
6796
diff
changeset
|
69 CodeStrings _strings; |
| 0 | 70 |
| 71 public: | |
| 72 // Returns the space needed for CodeBlob | |
| 73 static unsigned int allocation_size(CodeBuffer* cb, int header_size); | |
| 74 | |
| 75 // Creation | |
| 76 // a) simple CodeBlob | |
| 77 // frame_complete is the offset from the beginning of the instructions | |
| 78 // to where the frame setup (from stackwalk viewpoint) is complete. | |
| 79 CodeBlob(const char* name, int header_size, int size, int frame_complete, int locs_size); | |
| 80 | |
| 81 // b) full CodeBlob | |
| 82 CodeBlob( | |
| 83 const char* name, | |
| 84 CodeBuffer* cb, | |
| 85 int header_size, | |
| 86 int size, | |
| 87 int frame_complete, | |
| 88 int frame_size, | |
| 89 OopMapSet* oop_maps | |
| 90 ); | |
| 91 | |
| 92 // Deletion | |
| 93 void flush(); | |
| 94 | |
| 95 // Typing | |
|
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
96 virtual bool is_buffer_blob() const { return false; } |
|
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
97 virtual bool is_nmethod() const { return false; } |
|
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
98 virtual bool is_runtime_stub() const { return false; } |
|
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
99 virtual bool is_deoptimization_stub() const { return false; } |
|
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
100 virtual bool is_uncommon_trap_stub() const { return false; } |
|
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
101 virtual bool is_exception_stub() const { return false; } |
|
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
102 virtual bool is_safepoint_stub() const { return false; } |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
103 virtual bool is_adapter_blob() const { return false; } |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
104 virtual bool is_method_handles_adapter_blob() const { return false; } |
| 0 | 105 |
| 106 virtual bool is_compiled_by_c2() const { return false; } | |
| 107 virtual bool is_compiled_by_c1() const { return false; } | |
| 108 | |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
989
diff
changeset
|
109 // Casting |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
989
diff
changeset
|
110 nmethod* as_nmethod_or_null() { return is_nmethod() ? (nmethod*) this : NULL; } |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
989
diff
changeset
|
111 |
| 0 | 112 // Boundaries |
| 113 address header_begin() const { return (address) this; } | |
| 114 address header_end() const { return ((address) this) + _header_size; }; | |
| 115 relocInfo* relocation_begin() const { return (relocInfo*) header_end(); }; | |
| 116 relocInfo* relocation_end() const { return (relocInfo*)(header_end() + _relocation_size); } | |
| 1748 | 117 address content_begin() const { return (address) header_begin() + _content_offset; } |
| 118 address content_end() const { return (address) header_begin() + _data_offset; } | |
| 119 address code_begin() const { return (address) header_begin() + _code_offset; } | |
| 120 address code_end() const { return (address) header_begin() + _data_offset; } | |
| 0 | 121 address data_begin() const { return (address) header_begin() + _data_offset; } |
| 122 address data_end() const { return (address) header_begin() + _size; } | |
| 123 | |
| 124 // Offsets | |
| 125 int relocation_offset() const { return _header_size; } | |
| 1748 | 126 int content_offset() const { return _content_offset; } |
| 127 int code_offset() const { return _code_offset; } | |
| 0 | 128 int data_offset() const { return _data_offset; } |
| 129 | |
| 130 // Sizes | |
| 131 int size() const { return _size; } | |
| 132 int header_size() const { return _header_size; } | |
| 133 int relocation_size() const { return (address) relocation_end() - (address) relocation_begin(); } | |
| 1748 | 134 int content_size() const { return content_end() - content_begin(); } |
| 135 int code_size() const { return code_end() - code_begin(); } | |
| 136 int data_size() const { return data_end() - data_begin(); } | |
| 0 | 137 |
| 138 // Containment | |
| 1748 | 139 bool blob_contains(address addr) const { return header_begin() <= addr && addr < data_end(); } |
| 0 | 140 bool relocation_contains(relocInfo* addr) const{ return relocation_begin() <= addr && addr < relocation_end(); } |
| 1748 | 141 bool content_contains(address addr) const { return content_begin() <= addr && addr < content_end(); } |
| 142 bool code_contains(address addr) const { return code_begin() <= addr && addr < code_end(); } | |
| 143 bool data_contains(address addr) const { return data_begin() <= addr && addr < data_end(); } | |
| 144 bool contains(address addr) const { return content_contains(addr); } | |
| 145 bool is_frame_complete_at(address addr) const { return code_contains(addr) && | |
| 146 addr >= code_begin() + _frame_complete_offset; } | |
| 0 | 147 |
| 148 // CodeCache support: really only used by the nmethods, but in order to get | |
| 149 // asserts and certain bookkeeping to work in the CodeCache they are defined | |
| 150 // virtual here. | |
| 151 virtual bool is_zombie() const { return false; } | |
| 152 virtual bool is_locked_by_vm() const { return false; } | |
| 153 | |
| 154 virtual bool is_unloaded() const { return false; } | |
| 155 virtual bool is_not_entrant() const { return false; } | |
| 156 | |
| 157 // GC support | |
| 158 virtual bool is_alive() const = 0; | |
| 159 | |
| 160 // OopMap for frame | |
| 161 OopMapSet* oop_maps() const { return _oop_maps; } | |
| 162 void set_oop_maps(OopMapSet* p); | |
| 163 OopMap* oop_map_for_return_address(address return_address); | |
| 164 virtual void preserve_callee_argument_oops(frame fr, const RegisterMap* reg_map, OopClosure* f) { ShouldNotReachHere(); } | |
| 165 | |
| 166 // Frame support | |
| 167 int frame_size() const { return _frame_size; } | |
| 168 void set_frame_size(int size) { _frame_size = size; } | |
| 169 | |
| 170 // Returns true, if the next frame is responsible for GC'ing oops passed as arguments | |
| 171 virtual bool caller_must_gc_arguments(JavaThread* thread) const { return false; } | |
| 172 | |
| 173 // Naming | |
| 174 const char* name() const { return _name; } | |
| 175 void set_name(const char* name) { _name = name; } | |
| 176 | |
| 177 // Debugging | |
| 178 virtual void verify(); | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
179 void print() const { print_on(tty); } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
180 virtual void print_on(outputStream* st) const; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
181 virtual void print_value_on(outputStream* st) const; |
| 0 | 182 |
|
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
183 // Deal with Disassembler, VTune, Forte, JvmtiExport, MemoryService. |
|
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
184 static void trace_new_stub(CodeBlob* blob, const char* name1, const char* name2 = ""); |
|
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
185 |
| 0 | 186 // Print the comment associated with offset on stream, if there is one |
|
6796
b31471cdc53e
7200163: add CodeComments functionality to assember stubs
kvn
parents:
6725
diff
changeset
|
187 virtual void print_block_comment(outputStream* stream, address block_begin) const { |
| 1748 | 188 intptr_t offset = (intptr_t)(block_begin - code_begin()); |
|
8767
a5de0cc2f91c
8008555: Debugging code in compiled method sometimes leaks memory
roland
parents:
6796
diff
changeset
|
189 _strings.print_block_comment(stream, offset); |
| 0 | 190 } |
| 191 | |
| 192 // Transfer ownership of comments to this CodeBlob | |
|
8767
a5de0cc2f91c
8008555: Debugging code in compiled method sometimes leaks memory
roland
parents:
6796
diff
changeset
|
193 void set_strings(CodeStrings& strings) { |
|
a5de0cc2f91c
8008555: Debugging code in compiled method sometimes leaks memory
roland
parents:
6796
diff
changeset
|
194 _strings.assign(strings); |
| 0 | 195 } |
| 196 }; | |
| 197 | |
| 198 | |
| 199 //---------------------------------------------------------------------------------------------------- | |
| 200 // BufferBlob: used to hold non-relocatable machine code such as the interpreter, stubroutines, etc. | |
| 201 | |
| 202 class BufferBlob: public CodeBlob { | |
| 203 friend class VMStructs; | |
|
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
204 friend class AdapterBlob; |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
205 friend class MethodHandlesAdapterBlob; |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
206 |
| 0 | 207 private: |
| 208 // Creation support | |
| 209 BufferBlob(const char* name, int size); | |
| 210 BufferBlob(const char* name, int size, CodeBuffer* cb); | |
| 211 | |
|
12880
469216acdb28
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
12146
diff
changeset
|
212 void* operator new(size_t s, unsigned size, bool is_critical = false) throw(); |
| 0 | 213 |
| 214 public: | |
| 215 // Creation | |
| 216 static BufferBlob* create(const char* name, int buffer_size); | |
| 217 static BufferBlob* create(const char* name, CodeBuffer* cb); | |
| 218 | |
| 219 static void free(BufferBlob* buf); | |
| 220 | |
| 221 // Typing | |
|
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
222 virtual bool is_buffer_blob() const { return true; } |
| 0 | 223 |
| 224 // GC/Verification support | |
| 225 void preserve_callee_argument_oops(frame fr, const RegisterMap* reg_map, OopClosure* f) { /* nothing to do */ } | |
| 226 bool is_alive() const { return true; } | |
| 227 | |
| 228 void verify(); | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
229 void print_on(outputStream* st) const; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
230 void print_value_on(outputStream* st) const; |
| 0 | 231 }; |
| 232 | |
| 233 | |
| 234 //---------------------------------------------------------------------------------------------------- | |
|
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
235 // AdapterBlob: used to hold C2I/I2C adapters |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
236 |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
237 class AdapterBlob: public BufferBlob { |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
238 private: |
| 1663 | 239 AdapterBlob(int size, CodeBuffer* cb); |
|
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
240 |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
241 public: |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
242 // Creation |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
243 static AdapterBlob* create(CodeBuffer* cb); |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
244 |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
245 // Typing |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
246 virtual bool is_adapter_blob() const { return true; } |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
247 }; |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
248 |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
249 |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
250 //---------------------------------------------------------------------------------------------------- |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
251 // MethodHandlesAdapterBlob: used to hold MethodHandles adapters |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
252 |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
253 class MethodHandlesAdapterBlob: public BufferBlob { |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
254 private: |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
255 MethodHandlesAdapterBlob(int size) : BufferBlob("MethodHandles adapters", size) {} |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
256 |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
257 public: |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
258 // Creation |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
259 static MethodHandlesAdapterBlob* create(int buffer_size); |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
260 |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
261 // Typing |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
262 virtual bool is_method_handles_adapter_blob() const { return true; } |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
263 }; |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
264 |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
265 |
|
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1155
diff
changeset
|
266 //---------------------------------------------------------------------------------------------------- |
| 0 | 267 // RuntimeStub: describes stubs used by compiled code to call a (static) C++ runtime routine |
| 268 | |
| 269 class RuntimeStub: public CodeBlob { | |
| 270 friend class VMStructs; | |
| 271 private: | |
| 272 bool _caller_must_gc_arguments; | |
| 273 | |
| 274 // Creation support | |
| 275 RuntimeStub( | |
| 276 const char* name, | |
| 277 CodeBuffer* cb, | |
| 278 int size, | |
| 279 int frame_complete, | |
| 280 int frame_size, | |
| 281 OopMapSet* oop_maps, | |
| 282 bool caller_must_gc_arguments | |
| 283 ); | |
| 284 | |
|
12146
9758d9f36299
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
8767
diff
changeset
|
285 void* operator new(size_t s, unsigned size) throw(); |
| 0 | 286 |
| 287 public: | |
| 288 // Creation | |
| 289 static RuntimeStub* new_runtime_stub( | |
| 290 const char* stub_name, | |
| 291 CodeBuffer* cb, | |
| 292 int frame_complete, | |
| 293 int frame_size, | |
| 294 OopMapSet* oop_maps, | |
| 295 bool caller_must_gc_arguments | |
| 296 ); | |
| 297 | |
| 298 // Typing | |
| 299 bool is_runtime_stub() const { return true; } | |
| 300 | |
| 301 // GC support | |
| 302 bool caller_must_gc_arguments(JavaThread* thread) const { return _caller_must_gc_arguments; } | |
| 303 | |
| 1748 | 304 address entry_point() { return code_begin(); } |
| 0 | 305 |
| 306 // GC/Verification support | |
| 307 void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f) { /* nothing to do */ } | |
| 308 bool is_alive() const { return true; } | |
| 309 | |
| 310 void verify(); | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
311 void print_on(outputStream* st) const; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
312 void print_value_on(outputStream* st) const; |
| 0 | 313 }; |
| 314 | |
| 315 | |
| 316 //---------------------------------------------------------------------------------------------------- | |
| 317 // Super-class for all blobs that exist in only one instance. Implements default behaviour. | |
| 318 | |
| 319 class SingletonBlob: public CodeBlob { | |
| 320 friend class VMStructs; | |
|
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
321 |
|
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
322 protected: |
|
12146
9758d9f36299
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
8767
diff
changeset
|
323 void* operator new(size_t s, unsigned size) throw(); |
|
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
324 |
|
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
1972
diff
changeset
|
325 public: |
| 0 | 326 SingletonBlob( |
| 327 const char* name, | |
| 328 CodeBuffer* cb, | |
| 329 int header_size, | |
| 330 int size, | |
| 331 int frame_size, | |
| 332 OopMapSet* oop_maps | |
| 333 ) | |
| 334 : CodeBlob(name, cb, header_size, size, CodeOffsets::frame_never_safe, frame_size, oop_maps) | |
| 1748 | 335 {}; |
| 0 | 336 |
| 1748 | 337 address entry_point() { return code_begin(); } |
| 0 | 338 |
| 1748 | 339 bool is_alive() const { return true; } |
| 340 | |
| 341 void verify(); // does nothing | |
| 342 void print_on(outputStream* st) const; | |
| 343 void print_value_on(outputStream* st) const; | |
| 0 | 344 }; |
| 345 | |
| 346 | |
| 347 //---------------------------------------------------------------------------------------------------- | |
| 348 // DeoptimizationBlob | |
| 349 | |
| 350 class DeoptimizationBlob: public SingletonBlob { | |
| 351 friend class VMStructs; | |
| 352 private: | |
| 353 int _unpack_offset; | |
| 354 int _unpack_with_exception; | |
| 355 int _unpack_with_reexecution; | |
| 356 | |
| 357 int _unpack_with_exception_in_tls; | |
| 358 | |
| 359 // Creation support | |
| 360 DeoptimizationBlob( | |
| 361 CodeBuffer* cb, | |
| 362 int size, | |
| 363 OopMapSet* oop_maps, | |
| 364 int unpack_offset, | |
| 365 int unpack_with_exception_offset, | |
| 366 int unpack_with_reexecution_offset, | |
| 367 int frame_size | |
| 368 ); | |
| 369 | |
| 370 public: | |
| 371 // Creation | |
| 372 static DeoptimizationBlob* create( | |
| 373 CodeBuffer* cb, | |
| 374 OopMapSet* oop_maps, | |
| 375 int unpack_offset, | |
| 376 int unpack_with_exception_offset, | |
| 377 int unpack_with_reexecution_offset, | |
| 378 int frame_size | |
| 379 ); | |
| 380 | |
| 381 // Typing | |
| 382 bool is_deoptimization_stub() const { return true; } | |
| 383 bool exception_address_is_unpack_entry(address pc) const { | |
| 384 address unpack_pc = unpack(); | |
| 385 return (pc == unpack_pc || (pc + frame::pc_return_offset) == unpack_pc); | |
| 386 } | |
| 387 | |
| 388 | |
| 389 | |
| 390 | |
| 391 // GC for args | |
| 392 void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f) { /* Nothing to do */ } | |
| 393 | |
| 394 // Printing | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
395 void print_value_on(outputStream* st) const; |
| 0 | 396 |
| 1748 | 397 address unpack() const { return code_begin() + _unpack_offset; } |
| 398 address unpack_with_exception() const { return code_begin() + _unpack_with_exception; } | |
| 399 address unpack_with_reexecution() const { return code_begin() + _unpack_with_reexecution; } | |
| 0 | 400 |
| 401 // Alternate entry point for C1 where the exception and issuing pc | |
| 402 // are in JavaThread::_exception_oop and JavaThread::_exception_pc | |
| 403 // instead of being in registers. This is needed because C1 doesn't | |
| 404 // model exception paths in a way that keeps these registers free so | |
| 405 // there may be live values in those registers during deopt. | |
| 406 void set_unpack_with_exception_in_tls_offset(int offset) { | |
| 407 _unpack_with_exception_in_tls = offset; | |
| 1748 | 408 assert(code_contains(code_begin() + _unpack_with_exception_in_tls), "must be PC inside codeblob"); |
| 0 | 409 } |
| 1748 | 410 address unpack_with_exception_in_tls() const { return code_begin() + _unpack_with_exception_in_tls; } |
| 0 | 411 }; |
| 412 | |
| 413 | |
| 414 //---------------------------------------------------------------------------------------------------- | |
| 415 // UncommonTrapBlob (currently only used by Compiler 2) | |
| 416 | |
| 417 #ifdef COMPILER2 | |
| 418 | |
| 419 class UncommonTrapBlob: public SingletonBlob { | |
| 420 friend class VMStructs; | |
| 421 private: | |
| 422 // Creation support | |
| 423 UncommonTrapBlob( | |
| 424 CodeBuffer* cb, | |
| 425 int size, | |
| 426 OopMapSet* oop_maps, | |
| 427 int frame_size | |
| 428 ); | |
| 429 | |
| 430 public: | |
| 431 // Creation | |
| 432 static UncommonTrapBlob* create( | |
| 433 CodeBuffer* cb, | |
| 434 OopMapSet* oop_maps, | |
| 435 int frame_size | |
| 436 ); | |
| 437 | |
| 438 // GC for args | |
| 439 void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f) { /* nothing to do */ } | |
| 440 | |
| 441 // Typing | |
| 442 bool is_uncommon_trap_stub() const { return true; } | |
| 443 }; | |
| 444 | |
| 445 | |
| 446 //---------------------------------------------------------------------------------------------------- | |
| 447 // ExceptionBlob: used for exception unwinding in compiled code (currently only used by Compiler 2) | |
| 448 | |
| 449 class ExceptionBlob: public SingletonBlob { | |
| 450 friend class VMStructs; | |
| 451 private: | |
| 452 // Creation support | |
| 453 ExceptionBlob( | |
| 454 CodeBuffer* cb, | |
| 455 int size, | |
| 456 OopMapSet* oop_maps, | |
| 457 int frame_size | |
| 458 ); | |
| 459 | |
| 460 public: | |
| 461 // Creation | |
| 462 static ExceptionBlob* create( | |
| 463 CodeBuffer* cb, | |
| 464 OopMapSet* oop_maps, | |
| 465 int frame_size | |
| 466 ); | |
| 467 | |
| 468 // GC for args | |
| 469 void preserve_callee_argument_oops(frame fr, const RegisterMap* reg_map, OopClosure* f) { /* nothing to do */ } | |
| 470 | |
| 471 // Typing | |
| 472 bool is_exception_stub() const { return true; } | |
| 473 }; | |
| 474 #endif // COMPILER2 | |
| 475 | |
| 476 | |
| 477 //---------------------------------------------------------------------------------------------------- | |
| 478 // SafepointBlob: handles illegal_instruction exceptions during a safepoint | |
| 479 | |
| 480 class SafepointBlob: public SingletonBlob { | |
| 481 friend class VMStructs; | |
| 482 private: | |
| 483 // Creation support | |
| 484 SafepointBlob( | |
| 485 CodeBuffer* cb, | |
| 486 int size, | |
| 487 OopMapSet* oop_maps, | |
| 488 int frame_size | |
| 489 ); | |
| 490 | |
| 491 public: | |
| 492 // Creation | |
| 493 static SafepointBlob* create( | |
| 494 CodeBuffer* cb, | |
| 495 OopMapSet* oop_maps, | |
| 496 int frame_size | |
| 497 ); | |
| 498 | |
| 499 // GC for args | |
| 500 void preserve_callee_argument_oops(frame fr, const RegisterMap* reg_map, OopClosure* f) { /* nothing to do */ } | |
| 501 | |
| 502 // Typing | |
| 503 bool is_safepoint_stub() const { return true; } | |
| 504 }; | |
| 1972 | 505 |
| 506 #endif // SHARE_VM_CODE_CODEBLOB_HPP |