Lines Matching refs:address
72 // 12 bits indicating the offset from the previous relocInfo address
75 // address within the CodeBlob, which is named RelocIterator::addr().
76 // The address of a particular relocInfo always points to the first
85 // at the corresponding code address. The format value is usually zero.
116 // Instruction: The corresponding code address is ignored
122 // Value: an oop, or else the address (handle) of an oop
123 // Instruction types: memory (load), set (load address)
132 // relocInfo::internal_word_type -- an address within the same CodeBlob
134 // Value: an address in the CodeBlob's code or constants section
135 // Instruction types: memory (load), set (load address)
139 // base address, and the section number (e.g., SECT_INSTS) is encoded
142 // relocInfo::external_word_type -- a fixed address in the runtime system
143 // Value: an address
144 // Instruction types: memory (load), set (load address)
147 // [Ll] a 32-bit address
150 // Value: an address
207 // The t is a target address which the breakpoint calls (when it is enabled).
243 // precedes the relocation address, it is profitable to store
264 external_word_type = 7, // reference to fixed external address
420 static void change_reloc_info_for_address(RelocIterator *itr, address pc, relocType old_type, relocType new_type);
421 static void remove_reloc_info_for_address(RelocIterator *itr, address pc, relocType old_type);
532 address _limit; // stop producing relocations after this _addr
536 address _addr; // instruction to which the relocation applies
543 address _section_start[SECT_LIMIT];
544 address _section_end [SECT_LIMIT];
560 void set_limits(address begin, address limit);
566 void initialize(nmethod* nm, address begin, address limit);
574 RelocIterator(nmethod* nm, address begin = NULL, address limit = NULL);
575 RelocIterator(CodeSection* cb, address begin = NULL, address limit = NULL);
604 address limit() const { return _limit; }
605 void set_limit(address x);
608 address addr() const { return _addr; }
614 void set_addr(address addr) { _addr = addr; }
617 address section_start(int n) const {
621 address section_end(int n) const {
626 // The address points to the affected displacement part of the instruction.
666 // its context, such as the address to which it applies.
772 void pd_set_data_value (address x, intptr_t off, bool verify_only = false); // a set or mem-ref
773 void pd_verify_data_value (address x, intptr_t off) { pd_set_data_value(x, off, true); }
774 address pd_call_destination (address orig_addr = NULL);
775 void pd_set_call_destination (address x);
776 void pd_swap_in_breakpoint (address x, short* instrs, int instrlen);
777 void pd_swap_out_breakpoint (address x, short* instrs, int instrlen);
780 // this extracts the address of an address in the code stream instead of the reloc data
781 address* pd_address_in_code ();
783 // this extracts an address from the code stream instead of the reloc data
784 address pd_get_address_from_code ();
787 static jint scaled_offset(address x, address base) {
793 static jint scaled_offset_null_special(address x, address base) {
800 static address address_from_scaled_offset(jint offset, address base) {
806 static int32_t runtime_address_to_index(address runtime_address);
807 static address index_to_runtime_address(int32_t index);
810 address old_addr_for(address newa, const CodeBuffer* src, CodeBuffer* dest);
811 address new_addr_for(address olda, const CodeBuffer* src, CodeBuffer* dest);
812 void normalize_address(address& addr, const CodeSection* dest, bool allow_other_sections = false);
816 address addr() const { return binding()->addr(); }
834 virtual address value();
837 virtual void set_value(address x);
880 address value() = 0;
881 void set_value(address x) { set_value(x, offset()); }
882 void set_value(address x, intptr_t o) {
884 *(address*)addr() = x;
888 void verify_value(address x) {
890 assert(*(address*)addr() == x, "must agree");
914 address destination() { return pd_call_destination(); }
915 void set_destination(address x); // pd_set_call_destination
918 address value() { return destination(); }
919 void set_value(address x) { set_destination(x); }
966 address value() { return (address) *oop_addr(); }
982 static RelocationHolder spec(address first_oop, address oop_limit = NULL) {
988 virtual_call_Relocation(address first_oop, address oop_limit) {
990 assert(first_oop != NULL, "first oop address must be specified");
994 address _first_oop; // location of first set-oop instruction
995 address _oop_limit; // search limit for set-oop instructions
1002 address first_oop();
1003 address oop_limit();
1017 // The address of the patchable oop is also deduced.
1021 static RelocIterator parse_ic(nmethod* &nm, address &ic_call, address &first_oop, oop* &oop_addr, bool *is_optimized);
1043 address static_stub();
1065 address static_stub();
1072 static RelocationHolder spec(address static_call) {
1079 address _static_call; // location of corresponding static_call
1081 static_stub_Relocation(address static_call) {
1091 address static_call() { return _static_call; }
1119 static RelocationHolder spec(address target) {
1134 // Some address looking values aren't safe to treat as relocations
1136 static bool can_be_relocated(address target) {
1141 address _target; // address in runtime
1143 external_word_Relocation(address target) {
1151 // data is packed as a well-known address in "1_int" format: [a] or [Aa]
1154 // If the "a" value is 0 (i.e., _target is NULL), the address is stored
1160 address target(); // if _target==NULL, fetch addr from code stream
1161 address value() { return target(); }
1168 static RelocationHolder spec(address target) {
1182 internal_word_Relocation(address target) {
1188 address _target; // address in CodeBlob
1189 int _section; // section providing base address, if any
1206 address target(); // if _target==NULL, fetch addr from code stream
1208 address value() { return target(); }
1215 static RelocationHolder spec(address target, int section) {
1221 section_word_Relocation(address target, int section) {
1275 static RelocationHolder spec(int kind, address target = NULL, bool internal_target = false) {
1287 address _target;
1289 breakpoint_Relocation(int kind, address target, bool internal_target);
1305 address target() const;
1306 void set_target(address x);
1344 inline RelocIterator::RelocIterator(nmethod* nm, address begin, address limit) {
1363 PatchingRelocIterator(nmethod* nm, address begin = NULL, address limit = NULL)