graal-compiler: src/share/vm/asm/assembler.hpp comparison

comparison src/share/vm/asm/assembler.hpp @ 7206:d2f8c38e543d

Merge

author	roland
date	Fri, 07 Dec 2012 01:09:03 -0800
parents	f0c2369fda5a
children	18d56ca3e901

comparison

equal deleted inserted replaced

-:816b7e5bf2ed
+:d2f8c38e543d
 */
 #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; }
 class AbstractAssembler : public ResourceObj  {
 friend class Label;
 protected:
 CodeSection* _code_section;          // section within the code buffer
-address      _code_begin;            // first byte of code buffer
-address      _code_limit;            // first byte after code buffer
-address      _code_pos;              // current code generation position
 OopRecorder* _oop_recorder;          // support for relocInfo::oop_type
 // Code emission & accessing
-address addr_at(int pos) const       { return _code_begin + pos; }
+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_byte(int x);  // emit a single byte
+void emit_int8(   int8_t  x) { code_section()->emit_int8(   x); }
-void emit_word(int x);  // emit a 16-bit word (not a wordSize word!)
+void emit_int16(  int16_t x) { code_section()->emit_int16(  x); }
-void emit_long(jint x); // emit a 32-bit word (not a longSize word!)
+void emit_int32(  int32_t x) { code_section()->emit_int32(  x); }
-void emit_address(address x); // emit an address (not a longSize word!)
+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
 // 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();
+static bool pd_check_instruction_mark();
 // Add delta to short branch distance to verify that it still fit into imm8.
 int _short_branch_delta;
 int  short_branch_delta() const { return _short_branch_delta; }
 }
 ~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:
 // Creation
 AbstractAssembler(CodeBuffer* code);
-// save end pointer back to code buf.
-void sync();
 // ensure buf contains all code (call this before using/copying the code)
 void flush();
 // min and max values for signed immediate ranges
 static bool is_simm16(intptr_t x) { return is_simm(x, 16); }
 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
-CodeBuffer*   code() const;          // _code_section->outer()
 CodeSection*  code_section() const   { return _code_section; }
-int           sect() const;          // return _code_section->index()
+CodeBuffer*   code()         const   { return code_section()->outer(); }
-address       pc() const             { return _code_pos; }
+int           sect()         const   { return code_section()->index(); }
-int           offset() const         { return _code_pos - _code_begin; }
+address       pc()           const   { return code_section()->end();   }
-int           locator() const;       // CodeBuffer::locator(offset(), sect())
+int           offset()       const   { return code_section()->size();  }
+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
 // Inform assembler when generating stub code and relocation info
 address    start_a_stub(int required_space);
 void       end_a_stub();
 // Ditto for constants.
 address    start_a_const(int required_space, int required_align = sizeof(double));
-void       end_a_const();
+void       end_a_const(CodeSection* cs);  // Pass the codesection to continue in (insts or stubs?).
 // constants support
+//
+// We must remember the code section (insts or stubs) in c1
+// so we can reset to the proper section in end_a_const().
 address long_constant(jlong c) {
+CodeSection* c1 = _code_section;
 address ptr = start_a_const(sizeof(c), sizeof(c));
 if (ptr != NULL) {
-*(jlong*)ptr = c;
+emit_int64(c);
-_code_pos = ptr + sizeof(c);
+end_a_const(c1);
-end_a_const();
 }
 return ptr;
 }
 address double_constant(jdouble c) {
+CodeSection* c1 = _code_section;
 address ptr = start_a_const(sizeof(c), sizeof(c));
 if (ptr != NULL) {
-*(jdouble*)ptr = c;
+emit_double(c);
-_code_pos = ptr + sizeof(c);
+end_a_const(c1);
-end_a_const();
 }
 return ptr;
 }
 address float_constant(jfloat c) {
+CodeSection* c1 = _code_section;
 address ptr = start_a_const(sizeof(c), sizeof(c));
 if (ptr != NULL) {
-*(jfloat*)ptr = c;
+emit_float(c);
-_code_pos = ptr + sizeof(c);
+end_a_const(c1);
-end_a_const();
 }
 return ptr;
 }
 address address_constant(address c) {
+CodeSection* c1 = _code_section;
 address ptr = start_a_const(sizeof(c), sizeof(c));
 if (ptr != NULL) {
-*(address*)ptr = c;
+emit_address(c);
-_code_pos = ptr + sizeof(c);
+end_a_const(c1);
-end_a_const();
 }
 return ptr;
 }
 address address_constant(address c, RelocationHolder const& rspec) {
+CodeSection* c1 = _code_section;
 address ptr = start_a_const(sizeof(c), sizeof(c));
 if (ptr != NULL) {
 relocate(rspec);
-*(address*)ptr = c;
+emit_address(c);
-_code_pos = ptr + sizeof(c);
+end_a_const(c1);
-end_a_const();
 }
 return ptr;
 }
 // Bootstrapping aid to cope with delayed determination of constants.

Mercurial > hg > graal-compiler

comparison src/share/vm/asm/assembler.hpp @ 7206:d2f8c38e543d