Mercurial > hg > truffle
annotate src/share/vm/code/relocInfo.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 | 2b8e28fdf503 |
| children | d8041d695d19 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
12146
9758d9f36299
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
11041
diff
changeset
|
2 * Copyright (c) 1997, 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:
337
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
337
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:
337
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_CODE_RELOCINFO_HPP |
| 26 #define SHARE_VM_CODE_RELOCINFO_HPP | |
| 27 | |
| 28 #include "memory/allocation.hpp" | |
| 29 #include "utilities/top.hpp" | |
| 30 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
31 class NativeMovConstReg; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
32 |
| 0 | 33 // Types in this file: |
| 34 // relocInfo | |
| 35 // One element of an array of halfwords encoding compressed relocations. | |
| 36 // Also, the source of relocation types (relocInfo::oop_type, ...). | |
| 37 // Relocation | |
| 38 // A flyweight object representing a single relocation. | |
| 39 // It is fully unpacked from the compressed relocation array. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
40 // metadata_Relocation, ... (subclasses of Relocation) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
41 // The location of some type-specific operations (metadata_addr, ...). |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
42 // Also, the source of relocation specs (metadata_Relocation::spec, ...). |
| 0 | 43 // oop_Relocation, ... (subclasses of Relocation) |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
44 // oops in the code stream (strings, class loaders) |
| 0 | 45 // Also, the source of relocation specs (oop_Relocation::spec, ...). |
| 46 // RelocationHolder | |
| 47 // A ValueObj type which acts as a union holding a Relocation object. | |
| 48 // Represents a relocation spec passed into a CodeBuffer during assembly. | |
| 49 // RelocIterator | |
| 50 // A StackObj which iterates over the relocations associated with | |
| 51 // a range of code addresses. Can be used to operate a copy of code. | |
| 52 // BoundRelocation | |
| 53 // An _internal_ type shared by packers and unpackers of relocations. | |
| 54 // It pastes together a RelocationHolder with some pointers into | |
| 55 // code and relocInfo streams. | |
| 56 | |
| 57 | |
| 58 // Notes on relocType: | |
| 59 // | |
| 60 // These hold enough information to read or write a value embedded in | |
| 61 // the instructions of an CodeBlob. They're used to update: | |
| 62 // | |
| 63 // 1) embedded oops (isOop() == true) | |
| 64 // 2) inline caches (isIC() == true) | |
| 65 // 3) runtime calls (isRuntimeCall() == true) | |
| 66 // 4) internal word ref (isInternalWord() == true) | |
| 67 // 5) external word ref (isExternalWord() == true) | |
| 68 // | |
| 69 // when objects move (GC) or if code moves (compacting the code heap). | |
| 70 // They are also used to patch the code (if a call site must change) | |
| 71 // | |
| 72 // A relocInfo is represented in 16 bits: | |
| 73 // 4 bits indicating the relocation type | |
| 74 // 12 bits indicating the offset from the previous relocInfo address | |
| 75 // | |
| 76 // The offsets accumulate along the relocInfo stream to encode the | |
| 77 // address within the CodeBlob, which is named RelocIterator::addr(). | |
| 78 // The address of a particular relocInfo always points to the first | |
| 79 // byte of the relevant instruction (and not to any of its subfields | |
| 80 // or embedded immediate constants). | |
| 81 // | |
| 82 // The offset value is scaled appropriately for the target machine. | |
| 83 // (See relocInfo_<arch>.hpp for the offset scaling.) | |
| 84 // | |
| 85 // On some machines, there may also be a "format" field which may provide | |
| 86 // additional information about the format of the instruction stream | |
| 87 // at the corresponding code address. The format value is usually zero. | |
| 88 // Any machine (such as Intel) whose instructions can sometimes contain | |
| 89 // more than one relocatable constant needs format codes to distinguish | |
| 90 // which operand goes with a given relocation. | |
| 91 // | |
| 92 // If the target machine needs N format bits, the offset has 12-N bits, | |
| 93 // the format is encoded between the offset and the type, and the | |
| 94 // relocInfo_<arch>.hpp file has manifest constants for the format codes. | |
| 95 // | |
| 96 // If the type is "data_prefix_tag" then the offset bits are further encoded, | |
| 97 // and in fact represent not a code-stream offset but some inline data. | |
| 98 // The data takes the form of a counted sequence of halfwords, which | |
| 99 // precedes the actual relocation record. (Clients never see it directly.) | |
| 100 // The interpetation of this extra data depends on the relocation type. | |
| 101 // | |
| 102 // On machines that have 32-bit immediate fields, there is usually | |
| 103 // little need for relocation "prefix" data, because the instruction stream | |
| 104 // is a perfectly reasonable place to store the value. On machines in | |
| 105 // which 32-bit values must be "split" across instructions, the relocation | |
| 106 // data is the "true" specification of the value, which is then applied | |
| 107 // to some field of the instruction (22 or 13 bits, on SPARC). | |
| 108 // | |
| 109 // Whenever the location of the CodeBlob changes, any PC-relative | |
| 110 // relocations, and any internal_word_type relocations, must be reapplied. | |
| 111 // After the GC runs, oop_type relocations must be reapplied. | |
| 112 // | |
| 113 // | |
| 114 // Here are meanings of the types: | |
| 115 // | |
| 116 // relocInfo::none -- a filler record | |
| 117 // Value: none | |
| 118 // Instruction: The corresponding code address is ignored | |
| 119 // Data: Any data prefix and format code are ignored | |
| 120 // (This means that any relocInfo can be disabled by setting | |
| 121 // its type to none. See relocInfo::remove.) | |
| 122 // | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
123 // relocInfo::oop_type, relocInfo::metadata_type -- a reference to an oop or meta data |
| 0 | 124 // Value: an oop, or else the address (handle) of an oop |
| 125 // Instruction types: memory (load), set (load address) | |
| 126 // Data: [] an oop stored in 4 bytes of instruction | |
| 127 // [n] n is the index of an oop in the CodeBlob's oop pool | |
| 128 // [[N]n l] and l is a byte offset to be applied to the oop | |
| 129 // [Nn Ll] both index and offset may be 32 bits if necessary | |
| 130 // Here is a special hack, used only by the old compiler: | |
| 131 // [[N]n 00] the value is the __address__ of the nth oop in the pool | |
| 132 // (Note that the offset allows optimal references to class variables.) | |
| 133 // | |
| 134 // relocInfo::internal_word_type -- an address within the same CodeBlob | |
| 135 // relocInfo::section_word_type -- same, but can refer to another section | |
| 136 // Value: an address in the CodeBlob's code or constants section | |
| 137 // Instruction types: memory (load), set (load address) | |
| 138 // Data: [] stored in 4 bytes of instruction | |
| 139 // [[L]l] a relative offset (see [About Offsets] below) | |
| 140 // In the case of section_word_type, the offset is relative to a section | |
| 141 // base address, and the section number (e.g., SECT_INSTS) is encoded | |
| 142 // into the low two bits of the offset L. | |
| 143 // | |
| 144 // relocInfo::external_word_type -- a fixed address in the runtime system | |
| 145 // Value: an address | |
| 146 // Instruction types: memory (load), set (load address) | |
| 147 // Data: [] stored in 4 bytes of instruction | |
| 148 // [n] the index of a "well-known" stub (usual case on RISC) | |
| 149 // [Ll] a 32-bit address | |
| 150 // | |
| 151 // relocInfo::runtime_call_type -- a fixed subroutine in the runtime system | |
| 152 // Value: an address | |
| 153 // Instruction types: PC-relative call (or a PC-relative branch) | |
| 154 // Data: [] stored in 4 bytes of instruction | |
| 155 // | |
| 156 // relocInfo::static_call_type -- a static call | |
| 157 // Value: an CodeBlob, a stub, or a fixup routine | |
| 158 // Instruction types: a call | |
| 159 // Data: [] | |
| 160 // The identity of the callee is extracted from debugging information. | |
| 161 // //%note reloc_3 | |
| 162 // | |
| 163 // relocInfo::virtual_call_type -- a virtual call site (which includes an inline | |
| 164 // cache) | |
| 165 // Value: an CodeBlob, a stub, the interpreter, or a fixup routine | |
| 166 // Instruction types: a call, plus some associated set-oop instructions | |
| 167 // Data: [] the associated set-oops are adjacent to the call | |
| 168 // [n] n is a relative offset to the first set-oop | |
| 169 // [[N]n l] and l is a limit within which the set-oops occur | |
| 170 // [Nn Ll] both n and l may be 32 bits if necessary | |
| 171 // The identity of the callee is extracted from debugging information. | |
| 172 // | |
| 173 // relocInfo::opt_virtual_call_type -- a virtual call site that is statically bound | |
| 174 // | |
| 175 // Same info as a static_call_type. We use a special type, so the handling of | |
| 176 // virtuals and statics are separated. | |
| 177 // | |
| 178 // | |
| 179 // The offset n points to the first set-oop. (See [About Offsets] below.) | |
| 180 // In turn, the set-oop instruction specifies or contains an oop cell devoted | |
| 181 // exclusively to the IC call, which can be patched along with the call. | |
| 182 // | |
| 183 // The locations of any other set-oops are found by searching the relocation | |
| 184 // information starting at the first set-oop, and continuing until all | |
| 185 // relocations up through l have been inspected. The value l is another | |
| 186 // relative offset. (Both n and l are relative to the call's first byte.) | |
| 187 // | |
| 188 // The limit l of the search is exclusive. However, if it points within | |
| 189 // the call (e.g., offset zero), it is adjusted to point after the call and | |
| 190 // any associated machine-specific delay slot. | |
| 191 // | |
| 192 // Since the offsets could be as wide as 32-bits, these conventions | |
| 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 | |
| 233 // positive byte offsets, but they may be internally stored scaled | |
| 234 // and/or negated, depending on what is most compact for the target | |
| 235 // system. Since the object pointed to by the offset typically | |
| 236 // precedes the relocation address, it is profitable to store | |
| 237 // these negative offsets as positive numbers, but this decision | |
| 238 // is internal to the relocation information abstractions. | |
| 239 // | |
| 240 | |
| 241 class Relocation; | |
| 242 class CodeBuffer; | |
| 243 class CodeSection; | |
| 244 class RelocIterator; | |
| 245 | |
| 246 class relocInfo VALUE_OBJ_CLASS_SPEC { | |
| 247 friend class RelocIterator; | |
| 248 public: | |
| 249 enum relocType { | |
| 250 none = 0, // Used when no relocation should be generated | |
| 251 oop_type = 1, // embedded oop | |
| 252 virtual_call_type = 2, // a standard inline cache call for a virtual send | |
| 253 opt_virtual_call_type = 3, // a virtual call that has been statically bound (i.e., no IC cache) | |
| 254 static_call_type = 4, // a static send | |
| 255 static_stub_type = 5, // stub-entry for static send (takes care of interpreter case) | |
| 256 runtime_call_type = 6, // call to fixed external routine | |
| 257 external_word_type = 7, // reference to fixed external address | |
| 258 internal_word_type = 8, // reference within the current code blob | |
| 259 section_word_type = 9, // internal, but a cross-section reference | |
| 260 poll_type = 10, // polling instruction for safepoints | |
| 261 poll_return_type = 11, // polling instruction for safepoints at return | |
| 11041 | 262 metadata_type = 12, // metadata that used to be oops |
|
14397
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
263 trampoline_stub_type = 13, // stub-entry for trampoline |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
264 yet_unused_type_1 = 14, // Still unused |
| 0 | 265 data_prefix_tag = 15, // tag for a prefix (carries data arguments) |
| 266 type_mask = 15 // A mask which selects only the above values | |
| 267 }; | |
| 268 | |
| 269 protected: | |
| 270 unsigned short _value; | |
| 271 | |
| 272 enum RawBitsToken { RAW_BITS }; | |
| 273 relocInfo(relocType type, RawBitsToken ignore, int bits) | |
| 274 : _value((type << nontype_width) + bits) { } | |
| 275 | |
| 276 relocInfo(relocType type, RawBitsToken ignore, int off, int f) | |
| 277 : _value((type << nontype_width) + (off / (unsigned)offset_unit) + (f << offset_width)) { } | |
| 278 | |
| 279 public: | |
| 280 // constructor | |
| 281 relocInfo(relocType type, int offset, int format = 0) | |
| 282 #ifndef ASSERT | |
| 283 { | |
| 284 (*this) = relocInfo(type, RAW_BITS, offset, format); | |
| 285 } | |
| 286 #else | |
| 287 // Put a bunch of assertions out-of-line. | |
| 288 ; | |
| 289 #endif | |
| 290 | |
| 291 #define APPLY_TO_RELOCATIONS(visitor) \ | |
| 292 visitor(oop) \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
293 visitor(metadata) \ |
| 0 | 294 visitor(virtual_call) \ |
| 295 visitor(opt_virtual_call) \ | |
| 296 visitor(static_call) \ | |
| 297 visitor(static_stub) \ | |
| 298 visitor(runtime_call) \ | |
| 299 visitor(external_word) \ | |
| 300 visitor(internal_word) \ | |
| 301 visitor(poll) \ | |
| 302 visitor(poll_return) \ | |
| 303 visitor(section_word) \ | |
|
14397
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
304 visitor(trampoline_stub) \ |
| 0 | 305 |
| 306 | |
| 307 public: | |
| 308 enum { | |
| 309 value_width = sizeof(unsigned short) * BitsPerByte, | |
| 310 type_width = 4, // == log2(type_mask+1) | |
| 311 nontype_width = value_width - type_width, | |
| 312 datalen_width = nontype_width-1, | |
| 313 datalen_tag = 1 << datalen_width, // or-ed into _value | |
| 314 datalen_limit = 1 << datalen_width, | |
| 315 datalen_mask = (1 << datalen_width)-1 | |
| 316 }; | |
| 317 | |
| 318 // accessors | |
| 319 public: | |
| 320 relocType type() const { return (relocType)((unsigned)_value >> nontype_width); } | |
| 321 int format() const { return format_mask==0? 0: format_mask & | |
| 322 ((unsigned)_value >> offset_width); } | |
| 323 int addr_offset() const { assert(!is_prefix(), "must have offset"); | |
| 324 return (_value & offset_mask)*offset_unit; } | |
| 325 | |
| 326 protected: | |
| 327 const short* data() const { assert(is_datalen(), "must have data"); | |
| 328 return (const short*)(this + 1); } | |
| 329 int datalen() const { assert(is_datalen(), "must have data"); | |
| 330 return (_value & datalen_mask); } | |
| 331 int immediate() const { assert(is_immediate(), "must have immed"); | |
| 332 return (_value & datalen_mask); } | |
| 333 public: | |
| 334 static int addr_unit() { return offset_unit; } | |
| 335 static int offset_limit() { return (1 << offset_width) * offset_unit; } | |
| 336 | |
| 337 void set_type(relocType type); | |
| 338 void set_format(int format); | |
| 339 | |
| 340 void remove() { set_type(none); } | |
| 341 | |
| 342 protected: | |
| 343 bool is_none() const { return type() == none; } | |
| 344 bool is_prefix() const { return type() == data_prefix_tag; } | |
| 345 bool is_datalen() const { assert(is_prefix(), "must be prefix"); | |
| 346 return (_value & datalen_tag) != 0; } | |
| 347 bool is_immediate() const { assert(is_prefix(), "must be prefix"); | |
| 348 return (_value & datalen_tag) == 0; } | |
| 349 | |
| 350 public: | |
| 351 // Occasionally records of type relocInfo::none will appear in the stream. | |
| 352 // We do not bother to filter these out, but clients should ignore them. | |
| 353 // These records serve as "filler" in three ways: | |
| 354 // - to skip large spans of unrelocated code (this is rare) | |
| 355 // - to pad out the relocInfo array to the required oop alignment | |
| 356 // - to disable old relocation information which is no longer applicable | |
| 357 | |
| 358 inline friend relocInfo filler_relocInfo(); | |
| 359 | |
| 360 // Every non-prefix relocation may be preceded by at most one prefix, | |
| 361 // which supplies 1 or more halfwords of associated data. Conventionally, | |
| 362 // an int is represented by 0, 1, or 2 halfwords, depending on how | |
| 363 // many bits are required to represent the value. (In addition, | |
| 364 // if the sole halfword is a 10-bit unsigned number, it is made | |
| 365 // "immediate" in the prefix header word itself. This optimization | |
| 366 // is invisible outside this module.) | |
| 367 | |
| 14411 | 368 inline friend relocInfo prefix_relocInfo(int datalen); |
| 0 | 369 |
| 370 protected: | |
| 371 // an immediate relocInfo optimizes a prefix with one 10-bit unsigned value | |
| 372 static relocInfo immediate_relocInfo(int data0) { | |
| 373 assert(fits_into_immediate(data0), "data0 in limits"); | |
| 374 return relocInfo(relocInfo::data_prefix_tag, RAW_BITS, data0); | |
| 375 } | |
| 376 static bool fits_into_immediate(int data0) { | |
| 377 return (data0 >= 0 && data0 < datalen_limit); | |
| 378 } | |
| 379 | |
| 380 public: | |
| 381 // Support routines for compilers. | |
| 382 | |
| 383 // This routine takes an infant relocInfo (unprefixed) and | |
| 384 // edits in its prefix, if any. It also updates dest.locs_end. | |
| 385 void initialize(CodeSection* dest, Relocation* reloc); | |
| 386 | |
| 387 // This routine updates a prefix and returns the limit pointer. | |
| 388 // It tries to compress the prefix from 32 to 16 bits, and if | |
| 389 // successful returns a reduced "prefix_limit" pointer. | |
| 390 relocInfo* finish_prefix(short* prefix_limit); | |
| 391 | |
| 392 // bit-packers for the data array: | |
| 393 | |
| 394 // As it happens, the bytes within the shorts are ordered natively, | |
| 395 // but the shorts within the word are ordered big-endian. | |
| 396 // This is an arbitrary choice, made this way mainly to ease debugging. | |
| 397 static int data0_from_int(jint x) { return x >> value_width; } | |
| 398 static int data1_from_int(jint x) { return (short)x; } | |
| 399 static jint jint_from_data(short* data) { | |
| 400 return (data[0] << value_width) + (unsigned short)data[1]; | |
| 401 } | |
| 402 | |
| 403 static jint short_data_at(int n, short* data, int datalen) { | |
| 404 return datalen > n ? data[n] : 0; | |
| 405 } | |
| 406 | |
| 407 static jint jint_data_at(int n, short* data, int datalen) { | |
| 408 return datalen > n+1 ? jint_from_data(&data[n]) : short_data_at(n, data, datalen); | |
| 409 } | |
| 410 | |
| 411 // Update methods for relocation information | |
| 412 // (since code is dynamically patched, we also need to dynamically update the relocation info) | |
| 413 // Both methods takes old_type, so it is able to performe sanity checks on the information removed. | |
| 414 static void change_reloc_info_for_address(RelocIterator *itr, address pc, relocType old_type, relocType new_type); | |
| 415 static void remove_reloc_info_for_address(RelocIterator *itr, address pc, relocType old_type); | |
| 416 | |
| 417 // Machine dependent stuff | |
| 1972 | 418 #ifdef TARGET_ARCH_x86 |
| 419 # include "relocInfo_x86.hpp" | |
| 420 #endif | |
| 421 #ifdef TARGET_ARCH_sparc | |
| 422 # include "relocInfo_sparc.hpp" | |
| 423 #endif | |
| 424 #ifdef TARGET_ARCH_zero | |
| 425 # include "relocInfo_zero.hpp" | |
| 426 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
427 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
428 # include "relocInfo_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
429 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
430 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
431 # include "relocInfo_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
432 #endif |
| 1972 | 433 |
| 0 | 434 |
| 435 protected: | |
| 436 // Derived constant, based on format_width which is PD: | |
| 437 enum { | |
| 438 offset_width = nontype_width - format_width, | |
| 439 offset_mask = (1<<offset_width) - 1, | |
| 440 format_mask = (1<<format_width) - 1 | |
| 441 }; | |
| 442 public: | |
| 443 enum { | |
| 444 // Conservatively large estimate of maximum length (in shorts) | |
| 11041 | 445 // of any relocation record. |
| 0 | 446 // Extended format is length prefix, data words, and tag/offset suffix. |
| 447 length_limit = 1 + 1 + (3*BytesPerWord/BytesPerShort) + 1, | |
| 448 have_format = format_width > 0 | |
| 449 }; | |
| 450 }; | |
| 451 | |
| 452 #define FORWARD_DECLARE_EACH_CLASS(name) \ | |
| 453 class name##_Relocation; | |
| 454 APPLY_TO_RELOCATIONS(FORWARD_DECLARE_EACH_CLASS) | |
| 455 #undef FORWARD_DECLARE_EACH_CLASS | |
| 456 | |
| 457 | |
| 458 | |
| 459 inline relocInfo filler_relocInfo() { | |
| 460 return relocInfo(relocInfo::none, relocInfo::offset_limit() - relocInfo::offset_unit); | |
| 461 } | |
| 462 | |
| 14411 | 463 inline relocInfo prefix_relocInfo(int datalen = 0) { |
| 0 | 464 assert(relocInfo::fits_into_immediate(datalen), "datalen in limits"); |
| 465 return relocInfo(relocInfo::data_prefix_tag, relocInfo::RAW_BITS, relocInfo::datalen_tag | datalen); | |
| 466 } | |
| 467 | |
| 468 | |
| 469 // Holder for flyweight relocation objects. | |
| 470 // Although the flyweight subclasses are of varying sizes, | |
| 471 // the holder is "one size fits all". | |
| 472 class RelocationHolder VALUE_OBJ_CLASS_SPEC { | |
| 473 friend class Relocation; | |
| 474 friend class CodeSection; | |
| 475 | |
| 476 private: | |
| 477 // this preallocated memory must accommodate all subclasses of Relocation | |
| 478 // (this number is assertion-checked in Relocation::operator new) | |
| 479 enum { _relocbuf_size = 5 }; | |
| 480 void* _relocbuf[ _relocbuf_size ]; | |
| 481 | |
| 482 public: | |
| 483 Relocation* reloc() const { return (Relocation*) &_relocbuf[0]; } | |
| 484 inline relocInfo::relocType type() const; | |
| 485 | |
| 486 // Add a constant offset to a relocation. Helper for class Address. | |
| 487 RelocationHolder plus(int offset) const; | |
| 488 | |
| 489 inline RelocationHolder(); // initializes type to none | |
| 490 | |
| 491 inline RelocationHolder(Relocation* r); // make a copy | |
| 492 | |
| 493 static const RelocationHolder none; | |
| 494 }; | |
| 495 | |
| 496 // A RelocIterator iterates through the relocation information of a CodeBlob. | |
| 497 // It is a variable BoundRelocation which is able to take on successive | |
| 498 // values as it is advanced through a code stream. | |
| 499 // Usage: | |
| 500 // RelocIterator iter(nm); | |
| 501 // while (iter.next()) { | |
| 502 // iter.reloc()->some_operation(); | |
| 503 // } | |
| 504 // or: | |
| 505 // RelocIterator iter(nm); | |
| 506 // while (iter.next()) { | |
| 507 // switch (iter.type()) { | |
| 508 // case relocInfo::oop_type : | |
| 509 // case relocInfo::ic_type : | |
| 510 // case relocInfo::prim_type : | |
| 511 // case relocInfo::uncommon_type : | |
| 512 // case relocInfo::runtime_call_type : | |
| 513 // case relocInfo::internal_word_type: | |
| 514 // case relocInfo::external_word_type: | |
| 515 // ... | |
| 516 // } | |
| 517 // } | |
| 518 | |
| 519 class RelocIterator : public StackObj { | |
|
1762
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1579
diff
changeset
|
520 enum { SECT_LIMIT = 3 }; // must be equal to CodeBuffer::SECT_LIMIT, checked in ctor |
| 0 | 521 friend class Relocation; |
| 522 friend class relocInfo; // for change_reloc_info_for_address only | |
| 523 typedef relocInfo::relocType relocType; | |
| 524 | |
| 525 private: | |
| 526 address _limit; // stop producing relocations after this _addr | |
| 527 relocInfo* _current; // the current relocation information | |
| 528 relocInfo* _end; // end marker; we're done iterating when _current == _end | |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
337
diff
changeset
|
529 nmethod* _code; // compiled method containing _addr |
| 0 | 530 address _addr; // instruction to which the relocation applies |
| 531 short _databuf; // spare buffer for compressed data | |
| 532 short* _data; // pointer to the relocation's data | |
| 533 short _datalen; // number of halfwords in _data | |
| 534 char _format; // position within the instruction | |
| 535 | |
| 536 // Base addresses needed to compute targets of section_word_type relocs. | |
| 537 address _section_start[SECT_LIMIT]; | |
|
1762
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1579
diff
changeset
|
538 address _section_end [SECT_LIMIT]; |
| 0 | 539 |
| 540 void set_has_current(bool b) { | |
| 541 _datalen = !b ? -1 : 0; | |
| 542 debug_only(_data = NULL); | |
| 543 } | |
| 544 void set_current(relocInfo& ri) { | |
| 545 _current = &ri; | |
| 546 set_has_current(true); | |
| 547 } | |
| 548 | |
| 549 RelocationHolder _rh; // where the current relocation is allocated | |
| 550 | |
| 551 relocInfo* current() const { assert(has_current(), "must have current"); | |
| 552 return _current; } | |
| 553 | |
| 554 void set_limits(address begin, address limit); | |
| 555 | |
| 556 void advance_over_prefix(); // helper method | |
| 557 | |
|
1762
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1579
diff
changeset
|
558 void initialize_misc(); |
| 0 | 559 |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
337
diff
changeset
|
560 void initialize(nmethod* nm, address begin, address limit); |
| 0 | 561 |
| 562 RelocIterator() { initialize_misc(); } | |
| 563 | |
| 564 public: | |
| 565 // constructor | |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
337
diff
changeset
|
566 RelocIterator(nmethod* nm, address begin = NULL, address limit = NULL); |
| 0 | 567 RelocIterator(CodeSection* cb, address begin = NULL, address limit = NULL); |
| 568 | |
| 569 // get next reloc info, return !eos | |
| 570 bool next() { | |
| 571 _current++; | |
| 572 assert(_current <= _end, "must not overrun relocInfo"); | |
| 573 if (_current == _end) { | |
| 574 set_has_current(false); | |
| 575 return false; | |
| 576 } | |
| 577 set_has_current(true); | |
| 578 | |
| 579 if (_current->is_prefix()) { | |
| 580 advance_over_prefix(); | |
| 581 assert(!current()->is_prefix(), "only one prefix at a time"); | |
| 582 } | |
| 583 | |
| 584 _addr += _current->addr_offset(); | |
| 585 | |
| 586 if (_limit != NULL && _addr >= _limit) { | |
| 587 set_has_current(false); | |
| 588 return false; | |
| 589 } | |
| 590 | |
| 591 if (relocInfo::have_format) _format = current()->format(); | |
| 592 return true; | |
| 593 } | |
| 594 | |
| 595 // accessors | |
| 596 address limit() const { return _limit; } | |
| 597 void set_limit(address x); | |
| 598 relocType type() const { return current()->type(); } | |
| 599 int format() const { return (relocInfo::have_format) ? current()->format() : 0; } | |
| 600 address addr() const { return _addr; } | |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
337
diff
changeset
|
601 nmethod* code() const { return _code; } |
| 0 | 602 short* data() const { return _data; } |
| 603 int datalen() const { return _datalen; } | |
| 604 bool has_current() const { return _datalen >= 0; } | |
| 605 | |
| 606 void set_addr(address addr) { _addr = addr; } | |
|
1762
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1579
diff
changeset
|
607 bool addr_in_const() const; |
| 0 | 608 |
| 609 address section_start(int n) const { | |
|
1762
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1579
diff
changeset
|
610 assert(_section_start[n], "must be initialized"); |
|
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1579
diff
changeset
|
611 return _section_start[n]; |
|
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1579
diff
changeset
|
612 } |
|
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1579
diff
changeset
|
613 address section_end(int n) const { |
|
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1579
diff
changeset
|
614 assert(_section_end[n], "must be initialized"); |
|
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1579
diff
changeset
|
615 return _section_end[n]; |
| 0 | 616 } |
| 617 | |
| 618 // The address points to the affected displacement part of the instruction. | |
| 619 // For RISC, this is just the whole instruction. | |
| 620 // For Intel, this is an unaligned 32-bit word. | |
| 621 | |
| 622 // type-specific relocation accessors: oop_Relocation* oop_reloc(), etc. | |
| 623 #define EACH_TYPE(name) \ | |
| 624 inline name##_Relocation* name##_reloc(); | |
| 625 APPLY_TO_RELOCATIONS(EACH_TYPE) | |
| 626 #undef EACH_TYPE | |
| 627 // generic relocation accessor; switches on type to call the above | |
| 628 Relocation* reloc(); | |
| 629 | |
| 630 // CodeBlob's have relocation indexes for faster random access: | |
| 631 static int locs_and_index_size(int code_size, int locs_size); | |
| 632 // Store an index into [dest_start+dest_count..dest_end). | |
| 633 // At dest_start[0..dest_count] is the actual relocation information. | |
| 634 // Everything else up to dest_end is free space for the index. | |
| 635 static void create_index(relocInfo* dest_begin, int dest_count, relocInfo* dest_end); | |
| 636 | |
| 637 #ifndef PRODUCT | |
| 638 public: | |
| 639 void print(); | |
| 640 void print_current(); | |
| 641 #endif | |
| 642 }; | |
| 643 | |
| 644 | |
| 645 // A Relocation is a flyweight object allocated within a RelocationHolder. | |
| 646 // It represents the relocation data of relocation record. | |
| 647 // So, the RelocIterator unpacks relocInfos into Relocations. | |
| 648 | |
| 649 class Relocation VALUE_OBJ_CLASS_SPEC { | |
| 650 friend class RelocationHolder; | |
| 651 friend class RelocIterator; | |
| 652 | |
| 653 private: | |
| 654 static void guarantee_size(); | |
| 655 | |
| 656 // When a relocation has been created by a RelocIterator, | |
| 657 // this field is non-null. It allows the relocation to know | |
| 658 // its context, such as the address to which it applies. | |
| 659 RelocIterator* _binding; | |
| 660 | |
| 661 protected: | |
| 662 RelocIterator* binding() const { | |
| 663 assert(_binding != NULL, "must be bound"); | |
| 664 return _binding; | |
| 665 } | |
| 666 void set_binding(RelocIterator* b) { | |
| 667 assert(_binding == NULL, "must be unbound"); | |
| 668 _binding = b; | |
| 669 assert(_binding != NULL, "must now be bound"); | |
| 670 } | |
| 671 | |
| 672 Relocation() { | |
| 673 _binding = NULL; | |
| 674 } | |
| 675 | |
| 676 static RelocationHolder newHolder() { | |
| 677 return RelocationHolder(); | |
| 678 } | |
| 679 | |
| 680 public: | |
|
12146
9758d9f36299
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
11041
diff
changeset
|
681 void* operator new(size_t size, const RelocationHolder& holder) throw() { |
| 0 | 682 if (size > sizeof(holder._relocbuf)) guarantee_size(); |
| 683 assert((void* const *)holder.reloc() == &holder._relocbuf[0], "ptrs must agree"); | |
| 684 return holder.reloc(); | |
| 685 } | |
| 686 | |
| 687 // make a generic relocation for a given type (if possible) | |
| 688 static RelocationHolder spec_simple(relocInfo::relocType rtype); | |
| 689 | |
| 690 // here is the type-specific hook which writes relocation data: | |
| 691 virtual void pack_data_to(CodeSection* dest) { } | |
| 692 | |
| 693 // here is the type-specific hook which reads (unpacks) relocation data: | |
| 694 virtual void unpack_data() { | |
| 695 assert(datalen()==0 || type()==relocInfo::none, "no data here"); | |
| 696 } | |
| 697 | |
|
2455
479b4b4b6950
6777083: assert(target != __null,"must not be null")
never
parents:
2375
diff
changeset
|
698 static bool is_reloc_index(intptr_t index) { |
|
479b4b4b6950
6777083: assert(target != __null,"must not be null")
never
parents:
2375
diff
changeset
|
699 return 0 < index && index < os::vm_page_size(); |
|
479b4b4b6950
6777083: assert(target != __null,"must not be null")
never
parents:
2375
diff
changeset
|
700 } |
|
479b4b4b6950
6777083: assert(target != __null,"must not be null")
never
parents:
2375
diff
changeset
|
701 |
| 0 | 702 protected: |
| 703 // Helper functions for pack_data_to() and unpack_data(). | |
| 704 | |
| 705 // Most of the compression logic is confined here. | |
| 706 // (The "immediate data" mechanism of relocInfo works independently | |
| 707 // of this stuff, and acts to further compress most 1-word data prefixes.) | |
| 708 | |
| 709 // A variable-width int is encoded as a short if it will fit in 16 bits. | |
| 710 // The decoder looks at datalen to decide whether to unpack short or jint. | |
| 711 // Most relocation records are quite simple, containing at most two ints. | |
| 712 | |
| 713 static bool is_short(jint x) { return x == (short)x; } | |
| 714 static short* add_short(short* p, int x) { *p++ = x; return p; } | |
| 715 static short* add_jint (short* p, jint x) { | |
| 716 *p++ = relocInfo::data0_from_int(x); *p++ = relocInfo::data1_from_int(x); | |
| 717 return p; | |
| 718 } | |
| 719 static short* add_var_int(short* p, jint x) { // add a variable-width int | |
| 720 if (is_short(x)) p = add_short(p, x); | |
| 721 else p = add_jint (p, x); | |
| 722 return p; | |
| 723 } | |
| 724 | |
| 725 static short* pack_1_int_to(short* p, jint x0) { | |
| 726 // Format is one of: [] [x] [Xx] | |
| 727 if (x0 != 0) p = add_var_int(p, x0); | |
| 728 return p; | |
| 729 } | |
| 730 int unpack_1_int() { | |
| 731 assert(datalen() <= 2, "too much data"); | |
| 732 return relocInfo::jint_data_at(0, data(), datalen()); | |
| 733 } | |
| 734 | |
| 735 // With two ints, the short form is used only if both ints are short. | |
| 736 short* pack_2_ints_to(short* p, jint x0, jint x1) { | |
| 737 // Format is one of: [] [x y?] [Xx Y?y] | |
| 738 if (x0 == 0 && x1 == 0) { | |
| 739 // no halfwords needed to store zeroes | |
| 740 } else if (is_short(x0) && is_short(x1)) { | |
| 741 // 1-2 halfwords needed to store shorts | |
| 742 p = add_short(p, x0); if (x1!=0) p = add_short(p, x1); | |
| 743 } else { | |
| 744 // 3-4 halfwords needed to store jints | |
| 745 p = add_jint(p, x0); p = add_var_int(p, x1); | |
| 746 } | |
| 747 return p; | |
| 748 } | |
| 749 void unpack_2_ints(jint& x0, jint& x1) { | |
| 750 int dlen = datalen(); | |
| 751 short* dp = data(); | |
| 752 if (dlen <= 2) { | |
| 753 x0 = relocInfo::short_data_at(0, dp, dlen); | |
| 754 x1 = relocInfo::short_data_at(1, dp, dlen); | |
| 755 } else { | |
| 756 assert(dlen <= 4, "too much data"); | |
| 757 x0 = relocInfo::jint_data_at(0, dp, dlen); | |
| 758 x1 = relocInfo::jint_data_at(2, dp, dlen); | |
| 759 } | |
| 760 } | |
| 761 | |
| 762 protected: | |
| 763 // platform-dependent utilities for decoding and patching instructions | |
|
2375
d673ef06fe96
7028374: race in fix_oop_relocations for scavengeable nmethods
never
parents:
2192
diff
changeset
|
764 void pd_set_data_value (address x, intptr_t off, bool verify_only = false); // a set or mem-ref |
|
d673ef06fe96
7028374: race in fix_oop_relocations for scavengeable nmethods
never
parents:
2192
diff
changeset
|
765 void pd_verify_data_value (address x, intptr_t off) { pd_set_data_value(x, off, true); } |
| 0 | 766 address pd_call_destination (address orig_addr = NULL); |
| 767 void pd_set_call_destination (address x); | |
| 768 | |
| 769 // this extracts the address of an address in the code stream instead of the reloc data | |
| 770 address* pd_address_in_code (); | |
| 771 | |
| 772 // this extracts an address from the code stream instead of the reloc data | |
| 773 address pd_get_address_from_code (); | |
| 774 | |
| 775 // these convert from byte offsets, to scaled offsets, to addresses | |
| 776 static jint scaled_offset(address x, address base) { | |
| 777 int byte_offset = x - base; | |
| 778 int offset = -byte_offset / relocInfo::addr_unit(); | |
| 779 assert(address_from_scaled_offset(offset, base) == x, "just checkin'"); | |
| 780 return offset; | |
| 781 } | |
| 782 static jint scaled_offset_null_special(address x, address base) { | |
| 783 // Some relocations treat offset=0 as meaning NULL. | |
| 784 // Handle this extra convention carefully. | |
| 785 if (x == NULL) return 0; | |
| 786 assert(x != base, "offset must not be zero"); | |
| 787 return scaled_offset(x, base); | |
| 788 } | |
| 789 static address address_from_scaled_offset(jint offset, address base) { | |
| 790 int byte_offset = -( offset * relocInfo::addr_unit() ); | |
| 791 return base + byte_offset; | |
| 792 } | |
| 793 | |
| 794 // these convert between indexes and addresses in the runtime system | |
| 795 static int32_t runtime_address_to_index(address runtime_address); | |
| 796 static address index_to_runtime_address(int32_t index); | |
| 797 | |
| 798 // helpers for mapping between old and new addresses after a move or resize | |
| 799 address old_addr_for(address newa, const CodeBuffer* src, CodeBuffer* dest); | |
| 800 address new_addr_for(address olda, const CodeBuffer* src, CodeBuffer* dest); | |
| 801 void normalize_address(address& addr, const CodeSection* dest, bool allow_other_sections = false); | |
| 802 | |
| 803 public: | |
| 804 // accessors which only make sense for a bound Relocation | |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
337
diff
changeset
|
805 address addr() const { return binding()->addr(); } |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
337
diff
changeset
|
806 nmethod* code() const { return binding()->code(); } |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
337
diff
changeset
|
807 bool addr_in_const() const { return binding()->addr_in_const(); } |
| 0 | 808 protected: |
| 809 short* data() const { return binding()->data(); } | |
| 810 int datalen() const { return binding()->datalen(); } | |
| 811 int format() const { return binding()->format(); } | |
| 812 | |
| 813 public: | |
| 814 virtual relocInfo::relocType type() { return relocInfo::none; } | |
| 815 | |
| 816 // is it a call instruction? | |
| 817 virtual bool is_call() { return false; } | |
| 818 | |
| 819 // is it a data movement instruction? | |
| 820 virtual bool is_data() { return false; } | |
| 821 | |
| 822 // some relocations can compute their own values | |
| 823 virtual address value(); | |
| 824 | |
| 825 // all relocations are able to reassert their values | |
| 826 virtual void set_value(address x); | |
| 827 | |
| 828 virtual void clear_inline_cache() { } | |
| 829 | |
| 830 // This method assumes that all virtual/static (inline) caches are cleared (since for static_call_type and | |
| 831 // ic_call_type is not always posisition dependent (depending on the state of the cache)). However, this is | |
| 832 // probably a reasonable assumption, since empty caches simplifies code reloacation. | |
| 833 virtual void fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest) { } | |
| 834 | |
| 835 void print(); | |
| 836 }; | |
| 837 | |
| 838 | |
| 839 // certain inlines must be deferred until class Relocation is defined: | |
| 840 | |
| 841 inline RelocationHolder::RelocationHolder() { | |
| 842 // initialize the vtbl, just to keep things type-safe | |
| 843 new(*this) Relocation(); | |
| 844 } | |
| 845 | |
| 846 | |
| 847 inline RelocationHolder::RelocationHolder(Relocation* r) { | |
| 848 // wordwise copy from r (ok if it copies garbage after r) | |
| 849 for (int i = 0; i < _relocbuf_size; i++) { | |
| 850 _relocbuf[i] = ((void**)r)[i]; | |
| 851 } | |
| 852 } | |
| 853 | |
| 854 | |
| 855 relocInfo::relocType RelocationHolder::type() const { | |
| 856 return reloc()->type(); | |
| 857 } | |
| 858 | |
| 859 // A DataRelocation always points at a memory or load-constant instruction.. | |
| 860 // It is absolute on most machines, and the constant is split on RISCs. | |
| 861 // The specific subtypes are oop, external_word, and internal_word. | |
| 862 // By convention, the "value" does not include a separately reckoned "offset". | |
| 863 class DataRelocation : public Relocation { | |
| 864 public: | |
| 865 bool is_data() { return true; } | |
| 866 | |
| 867 // both target and offset must be computed somehow from relocation data | |
| 868 virtual int offset() { return 0; } | |
| 869 address value() = 0; | |
| 870 void set_value(address x) { set_value(x, offset()); } | |
| 871 void set_value(address x, intptr_t o) { | |
| 872 if (addr_in_const()) | |
| 873 *(address*)addr() = x; | |
| 874 else | |
| 875 pd_set_data_value(x, o); | |
| 876 } | |
|
2375
d673ef06fe96
7028374: race in fix_oop_relocations for scavengeable nmethods
never
parents:
2192
diff
changeset
|
877 void verify_value(address x) { |
|
d673ef06fe96
7028374: race in fix_oop_relocations for scavengeable nmethods
never
parents:
2192
diff
changeset
|
878 if (addr_in_const()) |
|
d673ef06fe96
7028374: race in fix_oop_relocations for scavengeable nmethods
never
parents:
2192
diff
changeset
|
879 assert(*(address*)addr() == x, "must agree"); |
|
d673ef06fe96
7028374: race in fix_oop_relocations for scavengeable nmethods
never
parents:
2192
diff
changeset
|
880 else |
|
d673ef06fe96
7028374: race in fix_oop_relocations for scavengeable nmethods
never
parents:
2192
diff
changeset
|
881 pd_verify_data_value(x, offset()); |
|
d673ef06fe96
7028374: race in fix_oop_relocations for scavengeable nmethods
never
parents:
2192
diff
changeset
|
882 } |
| 0 | 883 |
| 884 // The "o" (displacement) argument is relevant only to split relocations | |
| 885 // on RISC machines. In some CPUs (SPARC), the set-hi and set-lo ins'ns | |
| 886 // can encode more than 32 bits between them. This allows compilers to | |
| 887 // share set-hi instructions between addresses that differ by a small | |
| 888 // offset (e.g., different static variables in the same class). | |
| 889 // On such machines, the "x" argument to set_value on all set-lo | |
| 890 // instructions must be the same as the "x" argument for the | |
| 891 // corresponding set-hi instructions. The "o" arguments for the | |
| 892 // set-hi instructions are ignored, and must not affect the high-half | |
| 893 // immediate constant. The "o" arguments for the set-lo instructions are | |
| 894 // added into the low-half immediate constant, and must not overflow it. | |
| 895 }; | |
| 896 | |
| 897 // A CallRelocation always points at a call instruction. | |
| 898 // It is PC-relative on most machines. | |
| 899 class CallRelocation : public Relocation { | |
| 900 public: | |
| 901 bool is_call() { return true; } | |
| 902 | |
| 903 address destination() { return pd_call_destination(); } | |
| 904 void set_destination(address x); // pd_set_call_destination | |
| 905 | |
| 906 void fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest); | |
| 907 address value() { return destination(); } | |
| 908 void set_value(address x) { set_destination(x); } | |
| 909 }; | |
| 910 | |
| 911 class oop_Relocation : public DataRelocation { | |
| 912 relocInfo::relocType type() { return relocInfo::oop_type; } | |
| 913 | |
| 914 public: | |
| 915 // encode in one of these formats: [] [n] [n l] [Nn l] [Nn Ll] | |
| 916 // an oop in the CodeBlob's oop pool | |
| 917 static RelocationHolder spec(int oop_index, int offset = 0) { | |
| 918 assert(oop_index > 0, "must be a pool-resident oop"); | |
| 919 RelocationHolder rh = newHolder(); | |
| 920 new(rh) oop_Relocation(oop_index, offset); | |
| 921 return rh; | |
| 922 } | |
| 923 // an oop in the instruction stream | |
| 924 static RelocationHolder spec_for_immediate() { | |
| 925 const int oop_index = 0; | |
| 926 const int offset = 0; // if you want an offset, use the oop pool | |
| 927 RelocationHolder rh = newHolder(); | |
| 928 new(rh) oop_Relocation(oop_index, offset); | |
| 929 return rh; | |
| 930 } | |
| 931 | |
| 932 private: | |
| 933 jint _oop_index; // if > 0, index into CodeBlob::oop_at | |
| 934 jint _offset; // byte offset to apply to the oop itself | |
| 935 | |
| 936 oop_Relocation(int oop_index, int offset) { | |
| 937 _oop_index = oop_index; _offset = offset; | |
| 938 } | |
| 939 | |
| 940 friend class RelocIterator; | |
| 941 oop_Relocation() { } | |
| 942 | |
| 943 public: | |
| 944 int oop_index() { return _oop_index; } | |
| 945 int offset() { return _offset; } | |
| 946 | |
| 947 // data is packed in "2_ints" format: [i o] or [Ii Oo] | |
| 948 void pack_data_to(CodeSection* dest); | |
| 949 void unpack_data(); | |
| 950 | |
| 951 void fix_oop_relocation(); // reasserts oop value | |
| 952 | |
|
2375
d673ef06fe96
7028374: race in fix_oop_relocations for scavengeable nmethods
never
parents:
2192
diff
changeset
|
953 void verify_oop_relocation(); |
|
d673ef06fe96
7028374: race in fix_oop_relocations for scavengeable nmethods
never
parents:
2192
diff
changeset
|
954 |
| 0 | 955 address value() { return (address) *oop_addr(); } |
| 956 | |
| 957 bool oop_is_immediate() { return oop_index() == 0; } | |
| 958 | |
| 959 oop* oop_addr(); // addr or &pool[jint_data] | |
| 960 oop oop_value(); // *oop_addr | |
| 961 // Note: oop_value transparently converts Universe::non_oop_word to NULL. | |
| 962 }; | |
| 963 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
964 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
965 // copy of oop_Relocation for now but may delete stuff in both/either |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
966 class metadata_Relocation : public DataRelocation { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
967 relocInfo::relocType type() { return relocInfo::metadata_type; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
968 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
969 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
970 // encode in one of these formats: [] [n] [n l] [Nn l] [Nn Ll] |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
971 // an metadata in the CodeBlob's metadata pool |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
972 static RelocationHolder spec(int metadata_index, int offset = 0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
973 assert(metadata_index > 0, "must be a pool-resident metadata"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
974 RelocationHolder rh = newHolder(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
975 new(rh) metadata_Relocation(metadata_index, offset); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
976 return rh; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
977 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
978 // an metadata in the instruction stream |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
979 static RelocationHolder spec_for_immediate() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
980 const int metadata_index = 0; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
981 const int offset = 0; // if you want an offset, use the metadata pool |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
982 RelocationHolder rh = newHolder(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
983 new(rh) metadata_Relocation(metadata_index, offset); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
984 return rh; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
985 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
986 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
987 private: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
988 jint _metadata_index; // if > 0, index into nmethod::metadata_at |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
989 jint _offset; // byte offset to apply to the metadata itself |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
990 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
991 metadata_Relocation(int metadata_index, int offset) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
992 _metadata_index = metadata_index; _offset = offset; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
993 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
994 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
995 friend class RelocIterator; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
996 metadata_Relocation() { } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
997 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
998 // Fixes a Metadata pointer in the code. Most platforms embeds the |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
999 // Metadata pointer in the code at compile time so this is empty |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1000 // for them. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1001 void pd_fix_value(address x); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1002 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1003 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1004 int metadata_index() { return _metadata_index; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1005 int offset() { return _offset; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1006 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1007 // data is packed in "2_ints" format: [i o] or [Ii Oo] |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1008 void pack_data_to(CodeSection* dest); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1009 void unpack_data(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1010 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1011 void fix_metadata_relocation(); // reasserts metadata value |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1012 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1013 void verify_metadata_relocation(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1014 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1015 address value() { return (address) *metadata_addr(); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1016 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1017 bool metadata_is_immediate() { return metadata_index() == 0; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1018 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1019 Metadata** metadata_addr(); // addr or &pool[jint_data] |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1020 Metadata* metadata_value(); // *metadata_addr |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1021 // Note: metadata_value transparently converts Universe::non_metadata_word to NULL. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1022 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1023 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1024 |
| 0 | 1025 class virtual_call_Relocation : public CallRelocation { |
| 1026 relocInfo::relocType type() { return relocInfo::virtual_call_type; } | |
| 1027 | |
| 1028 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1029 // "cached_value" points to the first associated set-oop. |
| 0 | 1030 // The oop_limit helps find the last associated set-oop. |
| 1031 // (See comments at the top of this file.) | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1032 static RelocationHolder spec(address cached_value) { |
| 0 | 1033 RelocationHolder rh = newHolder(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1034 new(rh) virtual_call_Relocation(cached_value); |
| 0 | 1035 return rh; |
| 1036 } | |
| 1037 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1038 virtual_call_Relocation(address cached_value) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1039 _cached_value = cached_value; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1040 assert(cached_value != NULL, "first oop address must be specified"); |
| 0 | 1041 } |
| 1042 | |
| 1043 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1044 address _cached_value; // location of set-value instruction |
| 0 | 1045 |
| 1046 friend class RelocIterator; | |
| 1047 virtual_call_Relocation() { } | |
| 1048 | |
| 1049 | |
| 1050 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2468
diff
changeset
|
1051 address cached_value(); |
| 0 | 1052 |
| 1053 // data is packed as scaled offsets in "2_ints" format: [f l] or [Ff Ll] | |
| 1054 // oop_limit is set to 0 if the limit falls somewhere within the call. | |
| 1055 // When unpacking, a zero oop_limit is taken to refer to the end of the call. | |
| 1056 // (This has the effect of bringing in the call's delay slot on SPARC.) | |
| 1057 void pack_data_to(CodeSection* dest); | |
| 1058 void unpack_data(); | |
| 1059 | |
| 1060 void clear_inline_cache(); | |
| 1061 }; | |
| 1062 | |
| 1063 | |
| 1064 class opt_virtual_call_Relocation : public CallRelocation { | |
| 1065 relocInfo::relocType type() { return relocInfo::opt_virtual_call_type; } | |
| 1066 | |
| 1067 public: | |
| 1068 static RelocationHolder spec() { | |
| 1069 RelocationHolder rh = newHolder(); | |
| 1070 new(rh) opt_virtual_call_Relocation(); | |
| 1071 return rh; | |
| 1072 } | |
| 1073 | |
| 1074 private: | |
| 1075 friend class RelocIterator; | |
| 1076 opt_virtual_call_Relocation() { } | |
| 1077 | |
| 1078 public: | |
| 1079 void clear_inline_cache(); | |
| 1080 | |
| 1081 // find the matching static_stub | |
| 1082 address static_stub(); | |
| 1083 }; | |
| 1084 | |
| 1085 | |
| 1086 class static_call_Relocation : public CallRelocation { | |
| 1087 relocInfo::relocType type() { return relocInfo::static_call_type; } | |
| 1088 | |
| 1089 public: | |
| 1090 static RelocationHolder spec() { | |
| 1091 RelocationHolder rh = newHolder(); | |
| 1092 new(rh) static_call_Relocation(); | |
| 1093 return rh; | |
| 1094 } | |
| 1095 | |
| 1096 private: | |
| 1097 friend class RelocIterator; | |
| 1098 static_call_Relocation() { } | |
| 1099 | |
| 1100 public: | |
| 1101 void clear_inline_cache(); | |
| 1102 | |
| 1103 // find the matching static_stub | |
| 1104 address static_stub(); | |
| 1105 }; | |
| 1106 | |
| 1107 class static_stub_Relocation : public Relocation { | |
| 1108 relocInfo::relocType type() { return relocInfo::static_stub_type; } | |
| 1109 | |
| 1110 public: | |
| 1111 static RelocationHolder spec(address static_call) { | |
| 1112 RelocationHolder rh = newHolder(); | |
| 1113 new(rh) static_stub_Relocation(static_call); | |
| 1114 return rh; | |
| 1115 } | |
| 1116 | |
| 1117 private: | |
| 1118 address _static_call; // location of corresponding static_call | |
| 1119 | |
| 1120 static_stub_Relocation(address static_call) { | |
| 1121 _static_call = static_call; | |
| 1122 } | |
| 1123 | |
| 1124 friend class RelocIterator; | |
| 1125 static_stub_Relocation() { } | |
| 1126 | |
| 1127 public: | |
| 1128 void clear_inline_cache(); | |
| 1129 | |
| 1130 address static_call() { return _static_call; } | |
| 1131 | |
| 1132 // data is packed as a scaled offset in "1_int" format: [c] or [Cc] | |
| 1133 void pack_data_to(CodeSection* dest); | |
| 1134 void unpack_data(); | |
| 1135 }; | |
| 1136 | |
| 1137 class runtime_call_Relocation : public CallRelocation { | |
| 1138 relocInfo::relocType type() { return relocInfo::runtime_call_type; } | |
| 1139 | |
| 1140 public: | |
| 1141 static RelocationHolder spec() { | |
| 1142 RelocationHolder rh = newHolder(); | |
| 1143 new(rh) runtime_call_Relocation(); | |
| 1144 return rh; | |
| 1145 } | |
| 1146 | |
| 1147 private: | |
| 1148 friend class RelocIterator; | |
| 1149 runtime_call_Relocation() { } | |
| 1150 | |
| 1151 public: | |
| 1152 }; | |
| 1153 | |
|
14397
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1154 // Trampoline Relocations. |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1155 // A trampoline allows to encode a small branch in the code, even if there |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1156 // is the chance that this branch can not reach all possible code locations. |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1157 // If the relocation finds that a branch is too far for the instruction |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1158 // in the code, it can patch it to jump to the trampoline where is |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1159 // sufficient space for a far branch. Needed on PPC. |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1160 class trampoline_stub_Relocation : public Relocation { |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1161 relocInfo::relocType type() { return relocInfo::trampoline_stub_type; } |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1162 |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1163 public: |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1164 static RelocationHolder spec(address static_call) { |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1165 RelocationHolder rh = newHolder(); |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1166 return (new (rh) trampoline_stub_Relocation(static_call)); |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1167 } |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1168 |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1169 private: |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1170 address _owner; // Address of the NativeCall that owns the trampoline. |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1171 |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1172 trampoline_stub_Relocation(address owner) { |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1173 _owner = owner; |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1174 } |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1175 |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1176 friend class RelocIterator; |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1177 trampoline_stub_Relocation() { } |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1178 |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1179 public: |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1180 |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1181 // Return the address of the NativeCall that owns the trampoline. |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1182 address owner() { return _owner; } |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1183 |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1184 void pack_data_to(CodeSection * dest); |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1185 void unpack_data(); |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1186 |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1187 // Find the trampoline stub for a call. |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1188 static address get_trampoline_for(address call, nmethod* code); |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1189 }; |
|
53fa76359eb1
8016696: PPC64 (part 4): add relocation for trampoline stubs
goetz
parents:
11041
diff
changeset
|
1190 |
| 0 | 1191 class external_word_Relocation : public DataRelocation { |
| 1192 relocInfo::relocType type() { return relocInfo::external_word_type; } | |
| 1193 | |
| 1194 public: | |
| 1195 static RelocationHolder spec(address target) { | |
| 1196 assert(target != NULL, "must not be null"); | |
| 1197 RelocationHolder rh = newHolder(); | |
| 1198 new(rh) external_word_Relocation(target); | |
| 1199 return rh; | |
| 1200 } | |
| 1201 | |
| 1202 // Use this one where all 32/64 bits of the target live in the code stream. | |
| 1203 // The target must be an intptr_t, and must be absolute (not relative). | |
| 1204 static RelocationHolder spec_for_immediate() { | |
| 1205 RelocationHolder rh = newHolder(); | |
| 1206 new(rh) external_word_Relocation(NULL); | |
| 1207 return rh; | |
| 1208 } | |
| 1209 | |
|
2455
479b4b4b6950
6777083: assert(target != __null,"must not be null")
never
parents:
2375
diff
changeset
|
1210 // Some address looking values aren't safe to treat as relocations |
|
479b4b4b6950
6777083: assert(target != __null,"must not be null")
never
parents:
2375
diff
changeset
|
1211 // and should just be treated as constants. |
|
479b4b4b6950
6777083: assert(target != __null,"must not be null")
never
parents:
2375
diff
changeset
|
1212 static bool can_be_relocated(address target) { |
|
479b4b4b6950
6777083: assert(target != __null,"must not be null")
never
parents:
2375
diff
changeset
|
1213 return target != NULL && !is_reloc_index((intptr_t)target); |
|
479b4b4b6950
6777083: assert(target != __null,"must not be null")
never
parents:
2375
diff
changeset
|
1214 } |
|
479b4b4b6950
6777083: assert(target != __null,"must not be null")
never
parents:
2375
diff
changeset
|
1215 |
| 0 | 1216 private: |
| 1217 address _target; // address in runtime | |
| 1218 | |
| 1219 external_word_Relocation(address target) { | |
| 1220 _target = target; | |
| 1221 } | |
| 1222 | |
| 1223 friend class RelocIterator; | |
| 1224 external_word_Relocation() { } | |
| 1225 | |
| 1226 public: | |
| 1227 // data is packed as a well-known address in "1_int" format: [a] or [Aa] | |
| 1228 // The function runtime_address_to_index is used to turn full addresses | |
| 1229 // to short indexes, if they are pre-registered by the stub mechanism. | |
| 1230 // If the "a" value is 0 (i.e., _target is NULL), the address is stored | |
| 1231 // in the code stream. See external_word_Relocation::target(). | |
| 1232 void pack_data_to(CodeSection* dest); | |
| 1233 void unpack_data(); | |
| 1234 | |
| 1235 void fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest); | |
| 1236 address target(); // if _target==NULL, fetch addr from code stream | |
| 1237 address value() { return target(); } | |
| 1238 }; | |
| 1239 | |
| 1240 class internal_word_Relocation : public DataRelocation { | |
| 1241 relocInfo::relocType type() { return relocInfo::internal_word_type; } | |
| 1242 | |
| 1243 public: | |
| 1244 static RelocationHolder spec(address target) { | |
| 1245 assert(target != NULL, "must not be null"); | |
| 1246 RelocationHolder rh = newHolder(); | |
| 1247 new(rh) internal_word_Relocation(target); | |
| 1248 return rh; | |
| 1249 } | |
| 1250 | |
| 1251 // use this one where all the bits of the target can fit in the code stream: | |
| 1252 static RelocationHolder spec_for_immediate() { | |
| 1253 RelocationHolder rh = newHolder(); | |
| 1254 new(rh) internal_word_Relocation(NULL); | |
| 1255 return rh; | |
| 1256 } | |
| 1257 | |
| 1258 internal_word_Relocation(address target) { | |
| 1259 _target = target; | |
| 1260 _section = -1; // self-relative | |
| 1261 } | |
| 1262 | |
| 1263 protected: | |
| 1264 address _target; // address in CodeBlob | |
| 1265 int _section; // section providing base address, if any | |
| 1266 | |
| 1267 friend class RelocIterator; | |
| 1268 internal_word_Relocation() { } | |
| 1269 | |
| 1270 // bit-width of LSB field in packed offset, if section >= 0 | |
| 1271 enum { section_width = 2 }; // must equal CodeBuffer::sect_bits | |
| 1272 | |
| 1273 public: | |
| 1274 // data is packed as a scaled offset in "1_int" format: [o] or [Oo] | |
| 1275 // If the "o" value is 0 (i.e., _target is NULL), the offset is stored | |
| 1276 // in the code stream. See internal_word_Relocation::target(). | |
| 1277 // If _section is not -1, it is appended to the low bits of the offset. | |
| 1278 void pack_data_to(CodeSection* dest); | |
| 1279 void unpack_data(); | |
| 1280 | |
| 1281 void fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest); | |
| 1282 address target(); // if _target==NULL, fetch addr from code stream | |
| 1283 int section() { return _section; } | |
| 1284 address value() { return target(); } | |
| 1285 }; | |
| 1286 | |
| 1287 class section_word_Relocation : public internal_word_Relocation { | |
| 1288 relocInfo::relocType type() { return relocInfo::section_word_type; } | |
| 1289 | |
| 1290 public: | |
| 1291 static RelocationHolder spec(address target, int section) { | |
| 1292 RelocationHolder rh = newHolder(); | |
| 1293 new(rh) section_word_Relocation(target, section); | |
| 1294 return rh; | |
| 1295 } | |
| 1296 | |
| 1297 section_word_Relocation(address target, int section) { | |
| 1298 assert(target != NULL, "must not be null"); | |
| 1299 assert(section >= 0, "must be a valid section"); | |
| 1300 _target = target; | |
| 1301 _section = section; | |
| 1302 } | |
| 1303 | |
| 1304 //void pack_data_to -- inherited | |
| 1305 void unpack_data(); | |
| 1306 | |
| 1307 private: | |
| 1308 friend class RelocIterator; | |
| 1309 section_word_Relocation() { } | |
| 1310 }; | |
| 1311 | |
| 1312 | |
| 1313 class poll_Relocation : public Relocation { | |
| 1314 bool is_data() { return true; } | |
| 1315 relocInfo::relocType type() { return relocInfo::poll_type; } | |
| 304 | 1316 void fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest); |
| 0 | 1317 }; |
| 1318 | |
| 1319 class poll_return_Relocation : public Relocation { | |
| 1320 bool is_data() { return true; } | |
| 1321 relocInfo::relocType type() { return relocInfo::poll_return_type; } | |
| 304 | 1322 void fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest); |
| 0 | 1323 }; |
| 1324 | |
| 1325 // We know all the xxx_Relocation classes, so now we can define these: | |
| 1326 #define EACH_CASE(name) \ | |
| 1327 inline name##_Relocation* RelocIterator::name##_reloc() { \ | |
| 1328 assert(type() == relocInfo::name##_type, "type must agree"); \ | |
| 1329 /* The purpose of the placed "new" is to re-use the same */ \ | |
| 1330 /* stack storage for each new iteration. */ \ | |
| 1331 name##_Relocation* r = new(_rh) name##_Relocation(); \ | |
| 1332 r->set_binding(this); \ | |
| 1333 r->name##_Relocation::unpack_data(); \ | |
| 1334 return r; \ | |
| 1335 } | |
| 1336 APPLY_TO_RELOCATIONS(EACH_CASE); | |
| 1337 #undef EACH_CASE | |
| 1338 | |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
337
diff
changeset
|
1339 inline RelocIterator::RelocIterator(nmethod* nm, address begin, address limit) { |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
337
diff
changeset
|
1340 initialize(nm, begin, limit); |
| 0 | 1341 } |
| 1342 | |
| 1972 | 1343 #endif // SHARE_VM_CODE_RELOCINFO_HPP |