< prev index next >

src/share/vm/code/relocInfo.hpp

Print this page


   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 
< prev index next >