Refactor the enum RelocMode changing the naming scheme from lower case to...

src/assembler-ia32.h

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // All Rights Reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 // - Redistributions of source code must retain the above copyright notice,
 // this list of conditions and the following disclaimer.
 //
@@ skipping 165 matching lines @@
 // Machine instruction Immediates
 
 class Immediate BASE_EMBEDDED {
  public:
   inline explicit Immediate(int x);
   inline explicit Immediate(const char* s);
   inline explicit Immediate(const ExternalReference& ext);
   inline explicit Immediate(Handle<Object> handle);
   inline explicit Immediate(Smi* value);
 
-  bool is_zero() const  { return x_ == 0 && rmode_ == no_reloc; }
-  bool is_int8() const  { return -128 <= x_ && x_ < 128 && rmode_ == no_reloc; }
+  bool is_zero() const { return x_ == 0 && rmode_ == RelocInfo::NONE; }
+  bool is_int8() const {
+    return -128 <= x_ && x_ < 128 && rmode_ == RelocInfo::NONE;
+  }
 
  private:
   int x_;
-  RelocMode rmode_;
+  RelocInfo::Mode rmode_;
 
   friend class Assembler;
 };
 
 
 // -----------------------------------------------------------------------------
 // Machine instruction Operands
 
 enum ScaleFactor {
   times_1 = 0,
   times_2 = 1,
   times_4 = 2,
   times_8 = 3
 };
 
 
 class Operand BASE_EMBEDDED {
  public:
   // reg
   INLINE(explicit Operand(Register reg));
 
   // [disp/r]
-  INLINE(explicit Operand(int32_t disp, RelocMode rmode));
+  INLINE(explicit Operand(int32_t disp, RelocInfo::Mode rmode));
   // disp only must always be relocated
 
   // [base + disp/r]
-  explicit Operand(Register base, int32_t disp, RelocMode rmode = no_reloc);
+  explicit Operand(Register base, int32_t disp,
+                   RelocInfo::Mode rmode = RelocInfo::NONE);
 
   // [base + index*scale + disp/r]
   explicit Operand(Register base,
                    Register index,
                    ScaleFactor scale,
                    int32_t disp,
-                   RelocMode rmode = no_reloc);
+                   RelocInfo::Mode rmode = RelocInfo::NONE);
 
   // [index*scale + disp/r]
   explicit Operand(Register index,
                    ScaleFactor scale,
                    int32_t disp,
-                   RelocMode rmode = no_reloc);
+                   RelocInfo::Mode rmode = RelocInfo::NONE);
 
   static Operand StaticVariable(const ExternalReference& ext) {
     return Operand(reinterpret_cast<int32_t>(ext.address()),
-                   external_reference);
+                   RelocInfo::EXTERNAL_REFERENCE);
   }
 
   static Operand StaticArray(Register index,
                              ScaleFactor scale,
                              const ExternalReference& arr) {
     return Operand(index, scale, reinterpret_cast<int32_t>(arr.address()),
-                   external_reference);
+                   RelocInfo::EXTERNAL_REFERENCE);
   }
 
   // Returns true if this Operand is a wrapper for the specified register.
   bool is_reg(Register reg) const;
 
  private:
   // Mutable because reg in ModR/M byte is set by Assembler via set_reg().
   mutable byte buf_[6];
   // The number of bytes in buf_.
   unsigned int len_;
   // Only valid if len_ > 4.
-  RelocMode rmode_;
+  RelocInfo::Mode rmode_;
 
   inline void set_modrm(int mod,  // reg == 0
                         Register rm);
   inline void set_sib(ScaleFactor scale, Register index, Register base);
   inline void set_disp8(int8_t disp);
-  inline void set_dispr(int32_t disp, RelocMode rmode);
+  inline void set_dispr(int32_t disp, RelocInfo::Mode rmode);
   inline void set_reg(Register reg) const;
 
   friend class Assembler;
 };
 
 
 // -----------------------------------------------------------------------------
 // A Displacement describes the 32bit immediate field of an instruction which
 // may be used together with a Label in order to refer to a yet unknown code
 // position. Displacements stored in the instruction stream are used to describe
@@ skipping 296 matching lines @@
   // j(cc, &L);  // backward branch to bound label
   // bind(&L);   // illegal: a label may be bound only once
   //
   // Note: The same Label can be used for forward and backward branches
   // but it may be bound only once.
 
   void bind(Label* L);  // binds an unbound label L to the current code position
 
   // Calls
   void call(Label* L);
-  void call(byte* entry, RelocMode rmode);
+  void call(byte* entry, RelocInfo::Mode rmode);
   void call(const Operand& adr);
-  void call(Handle<Code> code, RelocMode rmode);
+  void call(Handle<Code> code, RelocInfo::Mode rmode);
 
   // Jumps
   void jmp(Label* L);  // unconditional jump to L
-  void jmp(byte* entry, RelocMode rmode);
+  void jmp(byte* entry, RelocInfo::Mode rmode);
   void jmp(const Operand& adr);
-  void jmp(Handle<Code> code, RelocMode rmode);
+  void jmp(Handle<Code> code, RelocInfo::Mode rmode);
 
   // Conditional jumps
   void j(Condition cc, Label* L, Hint hint = no_hint);
-  void j(Condition cc, byte* entry, RelocMode rmode, Hint hint = no_hint);
+  void j(Condition cc, byte* entry, RelocInfo::Mode rmode, Hint hint = no_hint);
   void j(Condition cc, Handle<Code> code, Hint hint = no_hint);
 
   // Floating-point operations
   void fld(int i);
 
   void fld1();
   void fldz();
 
   void fld_s(const Operand& adr);
   void fld_d(const Operand& adr);
@@ skipping 71 matching lines @@
   // Record a comment relocation entry that can be used by a disassembler.
   // Use --debug_code to enable.
   void RecordComment(const char* msg);
 
   void RecordPosition(int pos);
   void RecordStatementPosition(int pos);
   void WriteRecordedPositions();
 
   // Writes a single word of data in the code stream.
   // Used for inline tables, e.g., jump-tables.
-  void dd(uint32_t data, RelocMode reloc_info);
+  void dd(uint32_t data, RelocInfo::Mode reloc_info);
 
   // Writes the absolute address of a bound label at the given position in
   // the generated code. That positions should have the relocation mode
   // internal_reference!
   void WriteInternalReference(int position, const Label& bound_label);
 
   int pc_offset() const  { return pc_ - buffer_; }
   int last_statement_position() const  { return last_statement_position_; }
   int last_position() const  { return last_position_; }
 
@@ skipping 50 matching lines @@
     return *reinterpret_cast<uint32_t*>(addr_at(pos));
   }
   void long_at_put(int pos, uint32_t x)  {
     *reinterpret_cast<uint32_t*>(addr_at(pos)) = x;
   }
 
   // code emission
   void GrowBuffer();
   inline void emit(uint32_t x);
   inline void emit(Handle<Object> handle);
-  inline void emit(uint32_t x, RelocMode rmode);
+  inline void emit(uint32_t x, RelocInfo::Mode rmode);
   inline void emit(const Immediate& x);
 
   // instruction generation
   void emit_arith_b(int op1, int op2, Register dst, int imm8);
 
   // Emit a basic arithmetic instruction (i.e. first byte of the family is 0x81)
   // with a given destination expression and an immediate operand.  It attempts
   // to use the shortest encoding possible.
   // sel specifies the /n in the modrm byte (see the Intel PRM).
   void emit_arith(int sel, Operand dst, const Immediate& x);
 
   void emit_operand(Register reg, const Operand& adr);
   void emit_operand(const Operand& adr, Register reg);
 
   void emit_farith(int b1, int b2, int i);
 
   // labels
   void print(Label* L);
   void bind_to(Label* L, int pos);
   void link_to(Label* L, Label* appendix);
 
   // displacements
   inline Displacement disp_at(Label* L);
   inline void disp_at_put(Label* L, Displacement disp);
   inline void emit_disp(Label* L, Displacement::Type type);
 
   // record reloc info for current pc_
-  void RecordRelocInfo(RelocMode rmode, intptr_t data = 0);
+  void RecordRelocInfo(RelocInfo::Mode rmode, intptr_t data = 0);
 
   friend class CodePatcher;
   friend class EnsureSpace;
 };
 
 
 // Helper class that ensures that there is enough space for generating
 // instructions and relocation information.  The constructor makes
 // sure that there is enough space and (in debug mode) the destructor
 // checks that we did not generate too much.
@@ skipping 16 matching lines @@
  private:
   Assembler* assembler_;
 #ifdef DEBUG
   int space_before_;
 #endif
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_ASSEMBLER_IA32_H_