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 *
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 #include "code/codeBlob.hpp"
26 #include "code/codeCache.hpp"
27 #include "code/relocInfo.hpp"
28 #include "code/vtableStubs.hpp"
29 #include "compiler/disassembler.hpp"
30 #include "compiler/oopMap.hpp"
31 #include "interpreter/bytecode.hpp"
32 #include "interpreter/interpreter.hpp"
33 #include "jvm.h"
34 #include "memory/allocation.inline.hpp"
35 #include "memory/heap.hpp"
36 #include "memory/resourceArea.hpp"
37 #include "oops/oop.inline.hpp"
38 #include "prims/forte.hpp"
39 #include "prims/jvmtiExport.hpp"
40 #include "runtime/handles.inline.hpp"
41 #include "runtime/interfaceSupport.inline.hpp"
42 #include "runtime/javaFrameAnchor.hpp"
43 #include "runtime/jniHandles.inline.hpp"
44 #include "runtime/mutexLocker.hpp"
170 _code_offset(_content_offset),
171 _data_offset(size),
172 _frame_size(0),
173 S390_ONLY(_ctable_offset(0) COMMA)
174 _header_size(header_size),
175 _frame_complete_offset(CodeOffsets::frame_never_safe),
176 _kind(kind),
177 _caller_must_gc_arguments(false)
178 {
179 assert(is_aligned(size, oopSize), "unaligned size");
180 assert(is_aligned(header_size, oopSize), "unaligned size");
181 assert(_mutable_data = blob_end(), "sanity");
182 }
183
184 void CodeBlob::purge() {
185 assert(_mutable_data != nullptr, "should never be null");
186 if (_mutable_data != blob_end()) {
187 os::free(_mutable_data);
188 _mutable_data = blob_end(); // Valid not null address
189 }
190 if (_oop_maps != nullptr) {
191 delete _oop_maps;
192 _oop_maps = nullptr;
193 }
194 NOT_PRODUCT(_asm_remarks.clear());
195 NOT_PRODUCT(_dbg_strings.clear());
196 }
197
198 void CodeBlob::set_oop_maps(OopMapSet* p) {
199 // Danger Will Robinson! This method allocates a big
200 // chunk of memory, its your job to free it.
201 if (p != nullptr) {
202 _oop_maps = ImmutableOopMapSet::build_from(p);
203 } else {
204 _oop_maps = nullptr;
205 }
206 }
207
208 const ImmutableOopMap* CodeBlob::oop_map_for_return_address(address return_address) const {
209 assert(_oop_maps != nullptr, "nope");
210 return _oop_maps->find_map_at_offset((intptr_t) return_address - (intptr_t) code_begin());
211 }
212
213 void CodeBlob::print_code_on(outputStream* st) {
214 ResourceMark m;
215 Disassembler::decode(this, st);
216 }
217
218 //-----------------------------------------------------------------------------------------
219 // Creates a RuntimeBlob from a CodeBuffer and copy code and relocation info.
220
221 RuntimeBlob::RuntimeBlob(
222 const char* name,
223 CodeBlobKind kind,
224 CodeBuffer* cb,
225 int size,
226 uint16_t header_size,
227 int16_t frame_complete,
228 int frame_size,
229 OopMapSet* oop_maps,
230 bool caller_must_gc_arguments)
231 : CodeBlob(name, kind, cb, size, header_size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments,
232 align_up(cb->total_relocation_size(), oopSize))
233 {
234 cb->copy_code_and_locs_to(this);
235 }
236
237 void RuntimeBlob::free(RuntimeBlob* blob) {
|
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 *
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 #include "code/SCCache.hpp"
26 #include "code/codeBlob.hpp"
27 #include "code/codeCache.hpp"
28 #include "code/relocInfo.hpp"
29 #include "code/vtableStubs.hpp"
30 #include "compiler/disassembler.hpp"
31 #include "compiler/oopMap.hpp"
32 #include "interpreter/bytecode.hpp"
33 #include "interpreter/interpreter.hpp"
34 #include "jvm.h"
35 #include "memory/allocation.inline.hpp"
36 #include "memory/heap.hpp"
37 #include "memory/resourceArea.hpp"
38 #include "oops/oop.inline.hpp"
39 #include "prims/forte.hpp"
40 #include "prims/jvmtiExport.hpp"
41 #include "runtime/handles.inline.hpp"
42 #include "runtime/interfaceSupport.inline.hpp"
43 #include "runtime/javaFrameAnchor.hpp"
44 #include "runtime/jniHandles.inline.hpp"
45 #include "runtime/mutexLocker.hpp"
171 _code_offset(_content_offset),
172 _data_offset(size),
173 _frame_size(0),
174 S390_ONLY(_ctable_offset(0) COMMA)
175 _header_size(header_size),
176 _frame_complete_offset(CodeOffsets::frame_never_safe),
177 _kind(kind),
178 _caller_must_gc_arguments(false)
179 {
180 assert(is_aligned(size, oopSize), "unaligned size");
181 assert(is_aligned(header_size, oopSize), "unaligned size");
182 assert(_mutable_data = blob_end(), "sanity");
183 }
184
185 void CodeBlob::purge() {
186 assert(_mutable_data != nullptr, "should never be null");
187 if (_mutable_data != blob_end()) {
188 os::free(_mutable_data);
189 _mutable_data = blob_end(); // Valid not null address
190 }
191 if (_oop_maps != nullptr && !SCCache::is_address_in_aot_cache((address)_oop_maps)) {
192 delete _oop_maps;
193 _oop_maps = nullptr;
194 }
195 NOT_PRODUCT(_asm_remarks.clear());
196 NOT_PRODUCT(_dbg_strings.clear());
197 }
198
199 void CodeBlob::set_oop_maps(OopMapSet* p) {
200 // Danger Will Robinson! This method allocates a big
201 // chunk of memory, its your job to free it.
202 if (p != nullptr) {
203 _oop_maps = ImmutableOopMapSet::build_from(p);
204 } else {
205 _oop_maps = nullptr;
206 }
207 }
208
209 const ImmutableOopMap* CodeBlob::oop_map_for_return_address(address return_address) const {
210 assert(_oop_maps != nullptr, "nope");
211 return _oop_maps->find_map_at_offset((intptr_t) return_address - (intptr_t) code_begin());
212 }
213
214 void CodeBlob::print_code_on(outputStream* st) {
215 ResourceMark m;
216 Disassembler::decode(this, st);
217 }
218
219 void CodeBlob::prepare_for_archiving() {
220 set_name(nullptr);
221 _oop_maps = nullptr;
222 _mutable_data = nullptr;
223 #ifndef PRODUCT
224 asm_remarks().clear();
225 dbg_strings().clear();
226 #endif /* PRODUCT */
227 }
228
229 //-----------------------------------------------------------------------------------------
230 // Creates a RuntimeBlob from a CodeBuffer and copy code and relocation info.
231
232 RuntimeBlob::RuntimeBlob(
233 const char* name,
234 CodeBlobKind kind,
235 CodeBuffer* cb,
236 int size,
237 uint16_t header_size,
238 int16_t frame_complete,
239 int frame_size,
240 OopMapSet* oop_maps,
241 bool caller_must_gc_arguments)
242 : CodeBlob(name, kind, cb, size, header_size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments,
243 align_up(cb->total_relocation_size(), oopSize))
244 {
245 cb->copy_code_and_locs_to(this);
246 }
247
248 void RuntimeBlob::free(RuntimeBlob* blob) {
|