jdk-sandbox: comparison hotspot/src/share/vm/asm/assembler.hpp

equal deleted inserted replaced

-:b02f361c324e
+:0cf4eccf130f
 */
 #ifndef SHARE_VM_ASM_ASSEMBLER_HPP
 #define SHARE_VM_ASM_ASSEMBLER_HPP
+#include "asm/codeBuffer.hpp"
 #include "code/oopRecorder.hpp"
 #include "code/relocInfo.hpp"
 #include "memory/allocation.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/growableArray.hpp"
 #include "utilities/top.hpp"
 #ifdef TARGET_ARCH_x86
 # include "register_x86.hpp"
 # include "vm_version_x86.hpp"
 #endif
 #ifdef TARGET_ARCH_sparc
 # include "vm_version_ppc.hpp"
 #endif
 // This file contains platform-independent assembler declarations.
-class CodeBuffer;
 class MacroAssembler;
 class AbstractAssembler;
 class Label;
 /**
 void bind_loc(int loc) {
 assert(loc >= 0, "illegal locator");
 assert(_loc == -1, "already bound");
 _loc = loc;
 }
-void bind_loc(int pos, int sect);  // = bind_loc(locator(pos, sect))
+void bind_loc(int pos, int sect) { bind_loc(CodeBuffer::locator(pos, sect)); }
 #ifndef PRODUCT
 // Iterates over all unresolved instructions for printing
 void print_instructions(MacroAssembler* masm) const;
 #endif // PRODUCT
 */
 int loc() const {
 assert(_loc >= 0, "unbound label");
 return _loc;
 }
-int loc_pos() const;   // == locator_pos(loc())
+int loc_pos()  const { return CodeBuffer::locator_pos(loc()); }
-int loc_sect() const;  // == locator_sect(loc())
+int loc_sect() const { return CodeBuffer::locator_sect(loc()); }
 bool is_bound() const    { return _loc >=  0; }
 bool is_unbound() const  { return _loc == -1 && _patch_index > 0; }
 bool is_unused() const   { return _loc == -1 && _patch_index == 0; }
 protected:
 CodeSection* _code_section;          // section within the code buffer
 OopRecorder* _oop_recorder;          // support for relocInfo::oop_type
 // Code emission & accessing
-inline address addr_at(int pos) const;
+address addr_at(int pos) const { return code_section()->start() + pos; }
 // This routine is called with a label is used for an address.
 // Labels and displacements truck in offsets, but target must return a PC.
-address target(Label& L);            // return _code_section->target(L)
+address target(Label& L)             { return code_section()->target(L, pc()); }
 bool is8bit(int x) const             { return -0x80 <= x && x < 0x80; }
 bool isByte(int x) const             { return 0 <= x && x < 0x100; }
 bool isShiftCount(int x) const       { return 0 <= x && x < 32; }
+void emit_int8(   int8_t  x) { code_section()->emit_int8(   x); }
+void emit_int16(  int16_t x) { code_section()->emit_int16(  x); }
+void emit_int32(  int32_t x) { code_section()->emit_int32(  x); }
+void emit_int64(  int64_t x) { code_section()->emit_int64(  x); }
+void emit_float(  jfloat  x) { code_section()->emit_float(  x); }
+void emit_double( jdouble x) { code_section()->emit_double( x); }
+void emit_address(address x) { code_section()->emit_address(x); }
 void emit_byte(int x)  { emit_int8 (x); }  // deprecated
 void emit_word(int x)  { emit_int16(x); }  // deprecated
 void emit_long(jint x) { emit_int32(x); }  // deprecated
-inline void emit_int8(  int8_t  x);
-inline void emit_int16( int16_t x);
-inline void emit_int32( int32_t x);
-inline void emit_int64( int64_t x);
-inline void emit_float( jfloat  x);
-inline void emit_double(jdouble x);
-inline void emit_address(address x);
 // Instruction boundaries (required when emitting relocatable values).
 class InstructionMark: public StackObj {
 private:
 AbstractAssembler* _assm;
 ~InstructionMark() {
 _assm->clear_inst_mark();
 }
 };
 friend class InstructionMark;
 #ifdef ASSERT
 // Make it return true on platforms which need to verify
 // instruction boundaries for some operations.
 inline static bool pd_check_instruction_mark();
 // Add delta to short branch distance to verify that it still fit into imm8.
 }
 ~ShortBranchVerifier() {
 _assm->clear_short_branch_delta();
 }
 };
 #else
 // Dummy in product.
 class ShortBranchVerifier: public StackObj {
 public:
 ShortBranchVerifier(AbstractAssembler* assm) {}
 };
 #endif
 // Label functions
 void print(Label& L);
 public:
 static bool is_simm26(intptr_t x) { return is_simm(x, 26); }
 static bool is_simm32(intptr_t x) { return is_simm(x, 32); }
 // Accessors
 CodeSection*  code_section() const   { return _code_section; }
-inline CodeBuffer*   code() const;
+CodeBuffer*   code()         const   { return code_section()->outer(); }
-inline int           sect() const;
+int           sect()         const   { return code_section()->index(); }
-inline address       pc() const;
+address       pc()           const   { return code_section()->end();   }
-inline int           offset() const;
+int           offset()       const   { return code_section()->size();  }
-inline int           locator() const;       // CodeBuffer::locator(offset(), sect())
+int           locator()      const   { return CodeBuffer::locator(offset(), sect()); }
 OopRecorder*  oop_recorder() const   { return _oop_recorder; }
 void      set_oop_recorder(OopRecorder* r) { _oop_recorder = r; }
-address  inst_mark() const;
+address       inst_mark() const { return code_section()->mark();       }
-void set_inst_mark();
+void      set_inst_mark()       {        code_section()->set_mark();   }
-void clear_inst_mark();
+void    clear_inst_mark()       {        code_section()->clear_mark(); }
 // Constants in code
 void a_byte(int x);
 void a_long(jint x);
-void relocate(RelocationHolder const& rspec, int format = 0);
+void relocate(RelocationHolder const& rspec, int format = 0) {
+assert(!pd_check_instruction_mark()
+|| inst_mark() == NULL || inst_mark() == code_section()->end(),
+"call relocate() between instructions");
+code_section()->relocate(code_section()->end(), rspec, format);
+}
 void relocate(   relocInfo::relocType rtype, int format = 0) {
-if (rtype != relocInfo::none)
+code_section()->relocate(code_section()->end(), rtype, format);
-relocate(Relocation::spec_simple(rtype), format);
 }
 static int code_fill_byte();         // used to pad out odd-sized code buffers
 // Associate a comment with the current offset.  It will be printed

changeset 14626	0cf4eccf130f
parent 14625	b02f361c324e
child 14631	526804361522