< prev index next >

src/hotspot/share/code/relocInfo.hpp

Print this page
*** 455,10 ***
--- 455,12 ---
      // of any relocation record.
      // Extended format is length prefix, data words, and tag/offset suffix.
      length_limit       = 1 + 1 + (3*BytesPerWord/BytesPerShort) + 1,
      have_format        = format_width > 0
    };
+ 
+   static const char* type_name(relocInfo::relocType t);
  };
  
  #define FORWARD_DECLARE_EACH_CLASS(name)              \
  class name##_Relocation;
  APPLY_TO_RELOCATIONS(FORWARD_DECLARE_EACH_CLASS)

*** 645,15 ***
    int          datalen()      const { return _datalen; }
    bool     has_current()      const { return _datalen >= 0; }
    bool   addr_in_const()      const;
  
    address section_start(int n) const {
!     assert(_section_start[n], "must be initialized");
      return _section_start[n];
    }
    address section_end(int n) const {
!     assert(_section_end[n], "must be initialized");
      return _section_end[n];
    }
  
    // The address points to the affected displacement part of the instruction.
    // For RISC, this is just the whole instruction.
--- 647,15 ---
    int          datalen()      const { return _datalen; }
    bool     has_current()      const { return _datalen >= 0; }
    bool   addr_in_const()      const;
  
    address section_start(int n) const {
!     assert(_section_start[n], "section %d must be initialized", n);
      return _section_start[n];
    }
    address section_end(int n) const {
!     assert(_section_end[n], "section %d must be initialized", n);
      return _section_end[n];
    }
  
    // The address points to the affected displacement part of the instruction.
    // For RISC, this is just the whole instruction.

*** 665,15 ***
    APPLY_TO_RELOCATIONS(EACH_TYPE)
    #undef EACH_TYPE
    // generic relocation accessor; switches on type to call the above
    Relocation* reloc();
  
- #ifndef PRODUCT
   public:
!   void print();
!   void print_current();
- #endif
  };
  
  
  // A Relocation is a flyweight object allocated within a RelocationHolder.
  // It represents the relocation data of relocation record.
--- 667,13 ---
    APPLY_TO_RELOCATIONS(EACH_TYPE)
    #undef EACH_TYPE
    // generic relocation accessor; switches on type to call the above
    Relocation* reloc();
  
   public:
!   void print_on(outputStream* st);
!   void print_current_on(outputStream* st);
  };
  
  
  // A Relocation is a flyweight object allocated within a RelocationHolder.
  // It represents the relocation data of relocation record.

*** 1310,10 ***
--- 1310,29 ---
    // Return the address of the NativeCall that owns the trampoline.
    address owner() { return _owner; }
  
    void pack_data_to(CodeSection * dest) override;
    void unpack_data() override;
+ #if defined(AARCH64)
+   address    pd_destination     ();
+   void       pd_set_destination (address x);
+ #endif
+   address  destination() {
+ #if defined(AARCH64)
+     return pd_destination();
+ #else
+     fatal("trampoline_stub_Relocation::destination() unimplemented");
+     return (address)-1;
+ #endif
+   }
+   void     set_destination(address x) {
+ #if defined(AARCH64)
+     pd_set_destination(x);
+ #else
+     fatal("trampoline_stub_Relocation::set_destination() unimplemented");
+ #endif
+   }
  
    // Find the trampoline stub for a call.
    static address get_trampoline_for(address call, nmethod* code);
  };
  

*** 1354,10 ***
--- 1373,11 ---
    // to short indexes, if they are pre-registered by the stub mechanism.
    // If the "a" value is 0 (i.e., _target is nullptr), the address is stored
    // in the code stream.  See external_word_Relocation::target().
    void pack_data_to(CodeSection* dest) override;
    void unpack_data() override;
+   short* pack_data_to(short* p); // Pack address into buffer
  
    void fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest) override;
    address  target();        // if _target==nullptr, fetch addr from code stream
    address  value() override { return target(); }
  };
< prev index next >