Replace the constant pool access ldr instructions with movw/movt, and remove ...

src/arm/assembler-arm.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 493 matching lines @@
   static unsigned found_by_runtime_probing_;
 };
 
 
 typedef int32_t Instr;
 
 
 extern const Instr kMovLrPc;
 extern const Instr kLdrPCMask;
 extern const Instr kLdrPCPattern;
+extern const Instr kLdrMask;
+extern const Instr kLdrPattern;
+extern const Instr kMovwMovtMask;
+extern const Instr kMovwPattern;
+extern const Instr kMovtPattern;
 extern const Instr kBlxRegMask;
 extern const Instr kBlxRegPattern;
 
 
 class Assembler : public Malloced {
  public:
   // Create an assembler. Instructions and relocation information are emitted
   // into a buffer, with the instructions starting from the beginning and the
   // relocation information starting from the end of the buffer. See CodeDesc
   // for a detailed comment on the layout (globals.h).
@@ skipping 39 matching lines @@
   // Puts a labels target address at the given position.
   // The high 8 bits are set to zero.
   void label_at_put(Label* L, int at_offset);
 
   // Return the address in the constant pool of the code target address used by
   // the branch/call instruction at pc.
   INLINE(static Address target_address_address_at(Address pc));
 
   // Read/Modify the code target address in the branch/call instruction at pc.
   INLINE(static Address target_address_at(Address pc));
-  INLINE(static void set_target_address_at(Address pc, Address target));
+  INLINE(static void set_target_address_at(Address pc, Address target,
+                                           bool need_icache_flush = true));
 
   // This sets the branch destination (which is in the constant pool on ARM).
   // This is for calls and branches within generated code.
   inline static void set_target_at(Address constant_pool_entry, Address target);
 
   // This sets the branch destination (which is in the constant pool on ARM).
   // This is for calls and branches to runtime code.
   inline static void set_external_target_at(Address constant_pool_entry,
                                             Address target) {
     set_target_at(constant_pool_entry, target);
@@ skipping 115 matching lines @@
   void cmn(Register src1, const Operand& src2, Condition cond = al);
 
   void orr(Register dst, Register src1, const Operand& src2,
            SBit s = LeaveCC, Condition cond = al);
   void orr(Register dst, Register src1, Register src2,
            SBit s = LeaveCC, Condition cond = al) {
     orr(dst, src1, Operand(src2), s, cond);
   }
 
   void mov(Register dst, const Operand& src,
-           SBit s = LeaveCC, Condition cond = al);
+           SBit s = LeaveCC, Condition cond = al, bool use_movw_movt = true);

[Erik Corry, 2010/05/03 10:06:28]

Having bool arguments makes the code unreadable at the call site.  We prefer
enums like SBit.

   void mov(Register dst, Register src, SBit s = LeaveCC, Condition cond = al) {
     mov(dst, Operand(src), s, cond);
   }
 
+  void movt(Register dst, const Operand& src, Condition cond = al);
+  void movw(Register dst, const Operand& src, Condition cond = al);
+
   void bic(Register dst, Register src1, const Operand& src2,
            SBit s = LeaveCC, Condition cond = al);
 
   void mvn(Register dst, const Operand& src,
            SBit s = LeaveCC, Condition cond = al);
 
   // Multiply instructions
 
   void mla(Register dst, Register src1, Register src2, Register srcA,
            SBit s = LeaveCC, Condition cond = al);
@@ skipping 326 matching lines @@
   int current_statement_position_;
   int written_position_;
   int written_statement_position_;
 
   // Code emission
   inline void CheckBuffer();
   void GrowBuffer();
   inline void emit(Instr x);
 
   // Instruction generation
-  void addrmod1(Instr instr, Register rn, Register rd, const Operand& x);
+  void addrmod1(Instr instr, Register rn, Register rd,
+                const Operand& x, bool use_movw_movt = true);
   void addrmod2(Instr instr, Register rd, const MemOperand& x);
   void addrmod3(Instr instr, Register rd, const MemOperand& x);
   void addrmod4(Instr instr, Register rn, RegList rl);
   void addrmod5(Instr instr, CRegister crd, const MemOperand& x);
 
   // Labels
   void print(Label* L);
   void bind_to(Label* L, int pos);
   void link_to(Label* L, Label* appendix);
   void next(Label* L);
 
   // Record reloc info for current pc_
-  void RecordRelocInfo(RelocInfo::Mode rmode, intptr_t data = 0);
+  void RecordRelocInfo(RelocInfo::Mode rmode,
+                       intptr_t data = 0,
+                       bool with_const_pool = true);

[Erik Corry, 2010/05/03 10:06:28]

Also here the bool argument makes code unreadble and should be replaced with an
enum.

 
   friend class RegExpMacroAssemblerARM;
   friend class RelocInfo;
   friend class CodePatcher;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_ASSEMBLER_ARM_H_