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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_CODE_CODEBLOB_HPP
26 #define SHARE_CODE_CODEBLOB_HPP
27
28 #include "asm/codeBuffer.hpp"
29 #include "compiler/compilerDefinitions.hpp"
30 #include "compiler/oopMap.hpp"
31 #include "runtime/javaFrameAnchor.hpp"
32 #include "runtime/frame.hpp"
33 #include "runtime/handles.hpp"
34 #include "utilities/align.hpp"
35 #include "utilities/macros.hpp"
36
37 class ImmutableOopMap;
38 class ImmutableOopMapSet;
39 class JNIHandleBlock;
40 class OopMapSet;
41
42 // CodeBlob Types
43 // Used in the CodeCache to assign CodeBlobs to different CodeHeaps
44 enum class CodeBlobType {
45 MethodNonProfiled = 0, // Execution level 1 and 4 (non-profiled) nmethods (including native nmethods)
46 MethodProfiled = 1, // Execution level 2 and 3 (profiled) nmethods
47 NonNMethod = 2, // Non-nmethods like Buffers, Adapters and Runtime Stubs
48 All = 3, // All types (No code cache segmentation)
139 class Vptr {
140 public:
141 virtual void print_on(const CodeBlob* instance, outputStream* st) const = 0;
142 virtual void print_value_on(const CodeBlob* instance, outputStream* st) const = 0;
143 };
144
145 const Vptr* vptr() const;
146
147 CodeBlob(const char* name, CodeBlobKind kind, CodeBuffer* cb, int size, uint16_t header_size,
148 int16_t frame_complete_offset, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments,
149 int mutable_data_size);
150
151 // Simple CodeBlob used for simple BufferBlob.
152 CodeBlob(const char* name, CodeBlobKind kind, int size, uint16_t header_size);
153
154 void operator delete(void* p) { }
155
156 public:
157
158 ~CodeBlob() {
159 assert(_oop_maps == nullptr, "Not flushed");
160 }
161
162 // Returns the space needed for CodeBlob
163 static unsigned int allocation_size(CodeBuffer* cb, int header_size);
164 static unsigned int align_code_offset(int offset);
165
166 // Deletion
167 void purge();
168
169 // Typing
170 bool is_nmethod() const { return _kind == CodeBlobKind::Nmethod; }
171 bool is_buffer_blob() const { return _kind == CodeBlobKind::Buffer; }
172 bool is_runtime_stub() const { return _kind == CodeBlobKind::RuntimeStub; }
173 bool is_deoptimization_stub() const { return _kind == CodeBlobKind::Deoptimization; }
174 #ifdef COMPILER2
175 bool is_uncommon_trap_stub() const { return _kind == CodeBlobKind::UncommonTrap; }
176 bool is_exception_stub() const { return _kind == CodeBlobKind::Exception; }
177 #else
178 bool is_uncommon_trap_stub() const { return false; }
179 bool is_exception_stub() const { return false; }
227 int content_size() const { return pointer_delta_as_int(content_end(), content_begin()); }
228 int code_size() const { return pointer_delta_as_int(code_end(), code_begin()); }
229
230 // Only used from CodeCache::free_unused_tail() after the Interpreter blob was trimmed
231 void adjust_size(size_t used) {
232 _size = (int)used;
233 _data_offset = _size;
234 }
235
236 // Containment
237 bool blob_contains(address addr) const { return header_begin() <= addr && addr < blob_end(); }
238 bool code_contains(address addr) const { return code_begin() <= addr && addr < code_end(); }
239 bool contains(address addr) const { return content_begin() <= addr && addr < content_end(); }
240 bool is_frame_complete_at(address addr) const { return _frame_complete_offset != CodeOffsets::frame_never_safe &&
241 code_contains(addr) && addr >= code_begin() + _frame_complete_offset; }
242 int frame_complete_offset() const { return _frame_complete_offset; }
243
244 // OopMap for frame
245 ImmutableOopMapSet* oop_maps() const { return _oop_maps; }
246 void set_oop_maps(OopMapSet* p);
247
248 const ImmutableOopMap* oop_map_for_slot(int slot, address return_address) const;
249 const ImmutableOopMap* oop_map_for_return_address(address return_address) const;
250
251 // Frame support. Sizes are in word units.
252 int frame_size() const { return _frame_size; }
253 void set_frame_size(int size) { _frame_size = size; }
254
255 // Returns true, if the next frame is responsible for GC'ing oops passed as arguments
256 bool caller_must_gc_arguments(JavaThread* thread) const { return _caller_must_gc_arguments; }
257
258 // Naming
259 const char* name() const { return _name; }
260 void set_name(const char* name) { _name = name; }
261
262 // Debugging
263 void verify();
264 void print() const;
265 void print_on(outputStream* st) const;
266 void print_value_on(outputStream* st) const;
267
268 void dump_for_addr(address addr, outputStream* st, bool verbose) const;
269 void print_code_on(outputStream* st);
270
271 // Print to stream, any comments associated with offset.
272 void print_block_comment(outputStream* stream, address block_begin) const;
273
274 #ifndef PRODUCT
275 AsmRemarks &asm_remarks() { return _asm_remarks; }
276 DbgStrings &dbg_strings() { return _dbg_strings; }
277
278 void use_remarks(AsmRemarks &remarks) { _asm_remarks.share(remarks); }
279 void use_strings(DbgStrings &strings) { _dbg_strings.share(strings); }
280 #endif
281 };
282
283 //----------------------------------------------------------------------------------------------------
284 // RuntimeBlob: used for non-compiled method code (adapters, stubs, blobs)
285
286 class RuntimeBlob : public CodeBlob {
287 friend class VMStructs;
288 public:
289
290 // Creation
291 // a) simple CodeBlob
292 RuntimeBlob(const char* name, CodeBlobKind kind, int size, uint16_t header_size)
293 : CodeBlob(name, kind, size, header_size)
294 {}
295
296 // b) full CodeBlob
297 // frame_complete is the offset from the beginning of the instructions
298 // to where the frame setup (from stackwalk viewpoint) is complete.
299 RuntimeBlob(
300 const char* name,
|
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_CODE_CODEBLOB_HPP
26 #define SHARE_CODE_CODEBLOB_HPP
27
28 #include "asm/codeBuffer.hpp"
29 #include "code/SCCache.hpp"
30 #include "compiler/compilerDefinitions.hpp"
31 #include "compiler/oopMap.hpp"
32 #include "runtime/javaFrameAnchor.hpp"
33 #include "runtime/frame.hpp"
34 #include "runtime/handles.hpp"
35 #include "utilities/align.hpp"
36 #include "utilities/macros.hpp"
37
38 class ImmutableOopMap;
39 class ImmutableOopMapSet;
40 class JNIHandleBlock;
41 class OopMapSet;
42
43 // CodeBlob Types
44 // Used in the CodeCache to assign CodeBlobs to different CodeHeaps
45 enum class CodeBlobType {
46 MethodNonProfiled = 0, // Execution level 1 and 4 (non-profiled) nmethods (including native nmethods)
47 MethodProfiled = 1, // Execution level 2 and 3 (profiled) nmethods
48 NonNMethod = 2, // Non-nmethods like Buffers, Adapters and Runtime Stubs
49 All = 3, // All types (No code cache segmentation)
140 class Vptr {
141 public:
142 virtual void print_on(const CodeBlob* instance, outputStream* st) const = 0;
143 virtual void print_value_on(const CodeBlob* instance, outputStream* st) const = 0;
144 };
145
146 const Vptr* vptr() const;
147
148 CodeBlob(const char* name, CodeBlobKind kind, CodeBuffer* cb, int size, uint16_t header_size,
149 int16_t frame_complete_offset, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments,
150 int mutable_data_size);
151
152 // Simple CodeBlob used for simple BufferBlob.
153 CodeBlob(const char* name, CodeBlobKind kind, int size, uint16_t header_size);
154
155 void operator delete(void* p) { }
156
157 public:
158
159 ~CodeBlob() {
160 assert(_oop_maps == nullptr || SCCache::is_address_in_aot_cache((address)_oop_maps), "Not flushed");
161 }
162
163 // Returns the space needed for CodeBlob
164 static unsigned int allocation_size(CodeBuffer* cb, int header_size);
165 static unsigned int align_code_offset(int offset);
166
167 // Deletion
168 void purge();
169
170 // Typing
171 bool is_nmethod() const { return _kind == CodeBlobKind::Nmethod; }
172 bool is_buffer_blob() const { return _kind == CodeBlobKind::Buffer; }
173 bool is_runtime_stub() const { return _kind == CodeBlobKind::RuntimeStub; }
174 bool is_deoptimization_stub() const { return _kind == CodeBlobKind::Deoptimization; }
175 #ifdef COMPILER2
176 bool is_uncommon_trap_stub() const { return _kind == CodeBlobKind::UncommonTrap; }
177 bool is_exception_stub() const { return _kind == CodeBlobKind::Exception; }
178 #else
179 bool is_uncommon_trap_stub() const { return false; }
180 bool is_exception_stub() const { return false; }
228 int content_size() const { return pointer_delta_as_int(content_end(), content_begin()); }
229 int code_size() const { return pointer_delta_as_int(code_end(), code_begin()); }
230
231 // Only used from CodeCache::free_unused_tail() after the Interpreter blob was trimmed
232 void adjust_size(size_t used) {
233 _size = (int)used;
234 _data_offset = _size;
235 }
236
237 // Containment
238 bool blob_contains(address addr) const { return header_begin() <= addr && addr < blob_end(); }
239 bool code_contains(address addr) const { return code_begin() <= addr && addr < code_end(); }
240 bool contains(address addr) const { return content_begin() <= addr && addr < content_end(); }
241 bool is_frame_complete_at(address addr) const { return _frame_complete_offset != CodeOffsets::frame_never_safe &&
242 code_contains(addr) && addr >= code_begin() + _frame_complete_offset; }
243 int frame_complete_offset() const { return _frame_complete_offset; }
244
245 // OopMap for frame
246 ImmutableOopMapSet* oop_maps() const { return _oop_maps; }
247 void set_oop_maps(OopMapSet* p);
248 void set_oop_maps(ImmutableOopMapSet* p) { _oop_maps = p; }
249
250 const ImmutableOopMap* oop_map_for_slot(int slot, address return_address) const;
251 const ImmutableOopMap* oop_map_for_return_address(address return_address) const;
252
253 // Frame support. Sizes are in word units.
254 int frame_size() const { return _frame_size; }
255 void set_frame_size(int size) { _frame_size = size; }
256
257 // Returns true, if the next frame is responsible for GC'ing oops passed as arguments
258 bool caller_must_gc_arguments(JavaThread* thread) const { return _caller_must_gc_arguments; }
259
260 // Naming
261 const char* name() const { return _name; }
262 void set_name(const char* name) { _name = name; }
263
264 // Debugging
265 void verify();
266 void print() const;
267 void print_on(outputStream* st) const;
268 void print_value_on(outputStream* st) const;
269
270 void dump_for_addr(address addr, outputStream* st, bool verbose) const;
271 void print_code_on(outputStream* st);
272
273 // Print to stream, any comments associated with offset.
274 void print_block_comment(outputStream* stream, address block_begin) const;
275
276 #ifndef PRODUCT
277 AsmRemarks &asm_remarks() { return _asm_remarks; }
278 DbgStrings &dbg_strings() { return _dbg_strings; }
279
280 void use_remarks(AsmRemarks &remarks) { _asm_remarks.share(remarks); }
281 void use_strings(DbgStrings &strings) { _dbg_strings.share(strings); }
282 #endif
283
284 void prepare_for_archiving();
285 };
286
287 //----------------------------------------------------------------------------------------------------
288 // RuntimeBlob: used for non-compiled method code (adapters, stubs, blobs)
289
290 class RuntimeBlob : public CodeBlob {
291 friend class VMStructs;
292 public:
293
294 // Creation
295 // a) simple CodeBlob
296 RuntimeBlob(const char* name, CodeBlobKind kind, int size, uint16_t header_size)
297 : CodeBlob(name, kind, size, header_size)
298 {}
299
300 // b) full CodeBlob
301 // frame_complete is the offset from the beginning of the instructions
302 // to where the frame setup (from stackwalk viewpoint) is complete.
303 RuntimeBlob(
304 const char* name,
|