1 /*
2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
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 *
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 *
193 // put no restrictions whatever upon code reorganization.
194 //
195 // The compiler is responsible for ensuring that transition from a clean
196 // state to a monomorphic compiled state is MP-safe. This implies that
197 // the system must respond well to intermediate states where a random
198 // subset of the set-oops has been correctly from the clean state
199 // upon entry to the VEP of the compiled method. In the case of a
200 // machine (Intel) with a single set-oop instruction, the 32-bit
201 // immediate field must not straddle a unit of memory coherence.
202 // //%note reloc_3
203 //
204 // relocInfo::static_stub_type -- an extra stub for each static_call_type
205 // Value: none
206 // Instruction types: a virtual call: { set_oop; jump; }
207 // Data: [[N]n] the offset of the associated static_call reloc
208 // This stub becomes the target of a static call which must be upgraded
209 // to a virtual call (because the callee is interpreted).
210 // See [About Offsets] below.
211 // //%note reloc_2
212 //
213 // For example:
214 //
215 // INSTRUCTIONS RELOC: TYPE PREFIX DATA
216 // ------------ ---- -----------
217 // sethi %hi(myObject), R oop_type [n(myObject)]
218 // ld [R+%lo(myObject)+fldOffset], R2 oop_type [n(myObject) fldOffset]
219 // add R2, 1, R2
220 // st R2, [R+%lo(myObject)+fldOffset] oop_type [n(myObject) fldOffset]
221 //%note reloc_1
222 //
223 // This uses 4 instruction words, 8 relocation halfwords,
224 // and an entry (which is sharable) in the CodeBlob's oop pool,
225 // for a total of 36 bytes.
226 //
227 // Note that the compiler is responsible for ensuring the "fldOffset" when
228 // added to "%lo(myObject)" does not overflow the immediate fields of the
229 // memory instructions.
230 //
231 //
232 // [About Offsets] Relative offsets are supplied to this module as
426 #endif
427 #ifdef TARGET_ARCH_arm
428 # include "relocInfo_arm.hpp"
429 #endif
430 #ifdef TARGET_ARCH_ppc
431 # include "relocInfo_ppc.hpp"
432 #endif
433 #ifdef TARGET_ARCH_aarch64
434 # include "relocInfo_aarch64.hpp"
435 #endif
436
437 protected:
438 // Derived constant, based on format_width which is PD:
439 enum {
440 offset_width = nontype_width - format_width,
441 offset_mask = (1<<offset_width) - 1,
442 format_mask = (1<<format_width) - 1
443 };
444 public:
445 enum {
446 // Conservatively large estimate of maximum length (in shorts)
447 // of any relocation record.
448 // Extended format is length prefix, data words, and tag/offset suffix.
449 length_limit = 1 + 1 + (3*BytesPerWord/BytesPerShort) + 1,
450 have_format = format_width > 0
451 };
452 };
453
454 #define FORWARD_DECLARE_EACH_CLASS(name) \
455 class name##_Relocation;
456 APPLY_TO_RELOCATIONS(FORWARD_DECLARE_EACH_CLASS)
457 #undef FORWARD_DECLARE_EACH_CLASS
458
459
460
461 inline relocInfo filler_relocInfo() {
462 return relocInfo(relocInfo::none, relocInfo::offset_limit() - relocInfo::offset_unit);
463 }
464
465 inline relocInfo prefix_relocInfo(int datalen = 0) {
745 } else {
746 // 3-4 halfwords needed to store jints
747 p = add_jint(p, x0); p = add_var_int(p, x1);
748 }
749 return p;
750 }
751 void unpack_2_ints(jint& x0, jint& x1) {
752 int dlen = datalen();
753 short* dp = data();
754 if (dlen <= 2) {
755 x0 = relocInfo::short_data_at(0, dp, dlen);
756 x1 = relocInfo::short_data_at(1, dp, dlen);
757 } else {
758 assert(dlen <= 4, "too much data");
759 x0 = relocInfo::jint_data_at(0, dp, dlen);
760 x1 = relocInfo::jint_data_at(2, dp, dlen);
761 }
762 }
763
764 protected:
765 // platform-dependent utilities for decoding and patching instructions
766 void pd_set_data_value (address x, intptr_t off, bool verify_only = false); // a set or mem-ref
767 void pd_verify_data_value (address x, intptr_t off) { pd_set_data_value(x, off, true); }
768 address pd_call_destination (address orig_addr = NULL);
769 void pd_set_call_destination (address x);
770
771 // this extracts the address of an address in the code stream instead of the reloc data
772 address* pd_address_in_code ();
773
774 // this extracts an address from the code stream instead of the reloc data
775 address pd_get_address_from_code ();
776
777 // these convert from byte offsets, to scaled offsets, to addresses
778 static jint scaled_offset(address x, address base) {
779 int byte_offset = x - base;
780 int offset = -byte_offset / relocInfo::addr_unit();
781 assert(address_from_scaled_offset(offset, base) == x, "just checkin'");
782 return offset;
783 }
784 static jint scaled_offset_null_special(address x, address base) {
855
856
857 relocInfo::relocType RelocationHolder::type() const {
858 return reloc()->type();
859 }
860
861 // A DataRelocation always points at a memory or load-constant instruction..
862 // It is absolute on most machines, and the constant is split on RISCs.
863 // The specific subtypes are oop, external_word, and internal_word.
864 // By convention, the "value" does not include a separately reckoned "offset".
865 class DataRelocation : public Relocation {
866 public:
867 bool is_data() { return true; }
868
869 // both target and offset must be computed somehow from relocation data
870 virtual int offset() { return 0; }
871 address value() = 0;
872 void set_value(address x) { set_value(x, offset()); }
873 void set_value(address x, intptr_t o) {
874 if (addr_in_const())
875 *(address*)addr() = x;
876 else
877 pd_set_data_value(x, o);
878 }
879 void verify_value(address x) {
880 if (addr_in_const())
881 assert(*(address*)addr() == x, "must agree");
882 else
883 pd_verify_data_value(x, offset());
884 }
885
886 // The "o" (displacement) argument is relevant only to split relocations
887 // on RISC machines. In some CPUs (SPARC), the set-hi and set-lo ins'ns
888 // can encode more than 32 bits between them. This allows compilers to
889 // share set-hi instructions between addresses that differ by a small
890 // offset (e.g., different static variables in the same class).
891 // On such machines, the "x" argument to set_value on all set-lo
892 // instructions must be the same as the "x" argument for the
893 // corresponding set-hi instructions. The "o" arguments for the
894 // set-hi instructions are ignored, and must not affect the high-half
895 // immediate constant. The "o" arguments for the set-lo instructions are
896 // added into the low-half immediate constant, and must not overflow it.
897 };
898
899 // A CallRelocation always points at a call instruction.
900 // It is PC-relative on most machines.
901 class CallRelocation : public Relocation {
1301 assert(section >= 0, "must be a valid section");
1302 _target = target;
1303 _section = section;
1304 }
1305
1306 //void pack_data_to -- inherited
1307 void unpack_data();
1308
1309 private:
1310 friend class RelocIterator;
1311 section_word_Relocation() { }
1312 };
1313
1314
1315 class poll_Relocation : public Relocation {
1316 bool is_data() { return true; }
1317 relocInfo::relocType type() { return relocInfo::poll_type; }
1318 void fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest);
1319 };
1320
1321 class poll_return_Relocation : public Relocation {
1322 bool is_data() { return true; }
1323 relocInfo::relocType type() { return relocInfo::poll_return_type; }
1324 void fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest);
1325 };
1326
1327 // We know all the xxx_Relocation classes, so now we can define these:
1328 #define EACH_CASE(name) \
1329 inline name##_Relocation* RelocIterator::name##_reloc() { \
1330 assert(type() == relocInfo::name##_type, "type must agree"); \
1331 /* The purpose of the placed "new" is to re-use the same */ \
1332 /* stack storage for each new iteration. */ \
1333 name##_Relocation* r = new(_rh) name##_Relocation(); \
1334 r->set_binding(this); \
1335 r->name##_Relocation::unpack_data(); \
1336 return r; \
1337 }
1338 APPLY_TO_RELOCATIONS(EACH_CASE);
1339 #undef EACH_CASE
1340
1341 inline RelocIterator::RelocIterator(nmethod* nm, address begin, address limit) {
1342 initialize(nm, begin, limit);
1343 }
1344
|
1 /*
2 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
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 *
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 *
193 // put no restrictions whatever upon code reorganization.
194 //
195 // The compiler is responsible for ensuring that transition from a clean
196 // state to a monomorphic compiled state is MP-safe. This implies that
197 // the system must respond well to intermediate states where a random
198 // subset of the set-oops has been correctly from the clean state
199 // upon entry to the VEP of the compiled method. In the case of a
200 // machine (Intel) with a single set-oop instruction, the 32-bit
201 // immediate field must not straddle a unit of memory coherence.
202 // //%note reloc_3
203 //
204 // relocInfo::static_stub_type -- an extra stub for each static_call_type
205 // Value: none
206 // Instruction types: a virtual call: { set_oop; jump; }
207 // Data: [[N]n] the offset of the associated static_call reloc
208 // This stub becomes the target of a static call which must be upgraded
209 // to a virtual call (because the callee is interpreted).
210 // See [About Offsets] below.
211 // //%note reloc_2
212 //
213 // relocInfo::poll_[return_]type -- a safepoint poll
214 // Value: none
215 // Instruction types: memory load or test
216 // Data: none
217 //
218 // For example:
219 //
220 // INSTRUCTIONS RELOC: TYPE PREFIX DATA
221 // ------------ ---- -----------
222 // sethi %hi(myObject), R oop_type [n(myObject)]
223 // ld [R+%lo(myObject)+fldOffset], R2 oop_type [n(myObject) fldOffset]
224 // add R2, 1, R2
225 // st R2, [R+%lo(myObject)+fldOffset] oop_type [n(myObject) fldOffset]
226 //%note reloc_1
227 //
228 // This uses 4 instruction words, 8 relocation halfwords,
229 // and an entry (which is sharable) in the CodeBlob's oop pool,
230 // for a total of 36 bytes.
231 //
232 // Note that the compiler is responsible for ensuring the "fldOffset" when
233 // added to "%lo(myObject)" does not overflow the immediate fields of the
234 // memory instructions.
235 //
236 //
237 // [About Offsets] Relative offsets are supplied to this module as
431 #endif
432 #ifdef TARGET_ARCH_arm
433 # include "relocInfo_arm.hpp"
434 #endif
435 #ifdef TARGET_ARCH_ppc
436 # include "relocInfo_ppc.hpp"
437 #endif
438 #ifdef TARGET_ARCH_aarch64
439 # include "relocInfo_aarch64.hpp"
440 #endif
441
442 protected:
443 // Derived constant, based on format_width which is PD:
444 enum {
445 offset_width = nontype_width - format_width,
446 offset_mask = (1<<offset_width) - 1,
447 format_mask = (1<<format_width) - 1
448 };
449 public:
450 enum {
451 #ifdef _LP64
452 // for use in format
453 // format_width must be at least 1 on _LP64
454 narrow_oop_in_const = 1,
455 #endif
456 // Conservatively large estimate of maximum length (in shorts)
457 // of any relocation record.
458 // Extended format is length prefix, data words, and tag/offset suffix.
459 length_limit = 1 + 1 + (3*BytesPerWord/BytesPerShort) + 1,
460 have_format = format_width > 0
461 };
462 };
463
464 #define FORWARD_DECLARE_EACH_CLASS(name) \
465 class name##_Relocation;
466 APPLY_TO_RELOCATIONS(FORWARD_DECLARE_EACH_CLASS)
467 #undef FORWARD_DECLARE_EACH_CLASS
468
469
470
471 inline relocInfo filler_relocInfo() {
472 return relocInfo(relocInfo::none, relocInfo::offset_limit() - relocInfo::offset_unit);
473 }
474
475 inline relocInfo prefix_relocInfo(int datalen = 0) {
755 } else {
756 // 3-4 halfwords needed to store jints
757 p = add_jint(p, x0); p = add_var_int(p, x1);
758 }
759 return p;
760 }
761 void unpack_2_ints(jint& x0, jint& x1) {
762 int dlen = datalen();
763 short* dp = data();
764 if (dlen <= 2) {
765 x0 = relocInfo::short_data_at(0, dp, dlen);
766 x1 = relocInfo::short_data_at(1, dp, dlen);
767 } else {
768 assert(dlen <= 4, "too much data");
769 x0 = relocInfo::jint_data_at(0, dp, dlen);
770 x1 = relocInfo::jint_data_at(2, dp, dlen);
771 }
772 }
773
774 protected:
775 // platform-independent utility for patching constant section
776 void const_set_data_value (address x);
777 void const_verify_data_value (address x);
778 // platform-dependent utilities for decoding and patching instructions
779 void pd_set_data_value (address x, intptr_t off, bool verify_only = false); // a set or mem-ref
780 void pd_verify_data_value (address x, intptr_t off) { pd_set_data_value(x, off, true); }
781 address pd_call_destination (address orig_addr = NULL);
782 void pd_set_call_destination (address x);
783
784 // this extracts the address of an address in the code stream instead of the reloc data
785 address* pd_address_in_code ();
786
787 // this extracts an address from the code stream instead of the reloc data
788 address pd_get_address_from_code ();
789
790 // these convert from byte offsets, to scaled offsets, to addresses
791 static jint scaled_offset(address x, address base) {
792 int byte_offset = x - base;
793 int offset = -byte_offset / relocInfo::addr_unit();
794 assert(address_from_scaled_offset(offset, base) == x, "just checkin'");
795 return offset;
796 }
797 static jint scaled_offset_null_special(address x, address base) {
868
869
870 relocInfo::relocType RelocationHolder::type() const {
871 return reloc()->type();
872 }
873
874 // A DataRelocation always points at a memory or load-constant instruction..
875 // It is absolute on most machines, and the constant is split on RISCs.
876 // The specific subtypes are oop, external_word, and internal_word.
877 // By convention, the "value" does not include a separately reckoned "offset".
878 class DataRelocation : public Relocation {
879 public:
880 bool is_data() { return true; }
881
882 // both target and offset must be computed somehow from relocation data
883 virtual int offset() { return 0; }
884 address value() = 0;
885 void set_value(address x) { set_value(x, offset()); }
886 void set_value(address x, intptr_t o) {
887 if (addr_in_const())
888 const_set_data_value(x);
889 else
890 pd_set_data_value(x, o);
891 }
892 void verify_value(address x) {
893 if (addr_in_const())
894 const_verify_data_value(x);
895 else
896 pd_verify_data_value(x, offset());
897 }
898
899 // The "o" (displacement) argument is relevant only to split relocations
900 // on RISC machines. In some CPUs (SPARC), the set-hi and set-lo ins'ns
901 // can encode more than 32 bits between them. This allows compilers to
902 // share set-hi instructions between addresses that differ by a small
903 // offset (e.g., different static variables in the same class).
904 // On such machines, the "x" argument to set_value on all set-lo
905 // instructions must be the same as the "x" argument for the
906 // corresponding set-hi instructions. The "o" arguments for the
907 // set-hi instructions are ignored, and must not affect the high-half
908 // immediate constant. The "o" arguments for the set-lo instructions are
909 // added into the low-half immediate constant, and must not overflow it.
910 };
911
912 // A CallRelocation always points at a call instruction.
913 // It is PC-relative on most machines.
914 class CallRelocation : public Relocation {
1314 assert(section >= 0, "must be a valid section");
1315 _target = target;
1316 _section = section;
1317 }
1318
1319 //void pack_data_to -- inherited
1320 void unpack_data();
1321
1322 private:
1323 friend class RelocIterator;
1324 section_word_Relocation() { }
1325 };
1326
1327
1328 class poll_Relocation : public Relocation {
1329 bool is_data() { return true; }
1330 relocInfo::relocType type() { return relocInfo::poll_type; }
1331 void fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest);
1332 };
1333
1334 class poll_return_Relocation : public poll_Relocation {
1335 relocInfo::relocType type() { return relocInfo::poll_return_type; }
1336 };
1337
1338 // We know all the xxx_Relocation classes, so now we can define these:
1339 #define EACH_CASE(name) \
1340 inline name##_Relocation* RelocIterator::name##_reloc() { \
1341 assert(type() == relocInfo::name##_type, "type must agree"); \
1342 /* The purpose of the placed "new" is to re-use the same */ \
1343 /* stack storage for each new iteration. */ \
1344 name##_Relocation* r = new(_rh) name##_Relocation(); \
1345 r->set_binding(this); \
1346 r->name##_Relocation::unpack_data(); \
1347 return r; \
1348 }
1349 APPLY_TO_RELOCATIONS(EACH_CASE);
1350 #undef EACH_CASE
1351
1352 inline RelocIterator::RelocIterator(nmethod* nm, address begin, address limit) {
1353 initialize(nm, begin, limit);
1354 }
1355
|