Thumb2 Backend: Update Code objects with mode, separate Assembler methods for Thumb2

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 736 matching lines @@
   void bind(Label* L);  // binds an unbound label L to the current code position
 
   // Returns the branch offset to the given label from the current code position
   // Links the label to the current position if it is still unbound
   // Manages the jump elimination optimization if the second parameter is true.
   int branch_offset(Label* L, bool jump_elimination_allowed);
 
   // Return the address in the constant pool of the code target address used by
   // the branch/call instruction at pc, or the object in a mov.
   INLINE(static Address target_pointer_address_at(Address pc));
+  INLINE(static Address thumb_target_pointer_address_at(Address pc));
 
   // Read/Modify the pointer in the branch/call/move instruction at pc.
   INLINE(static Address target_pointer_at(Address pc));
   INLINE(static void set_target_pointer_at(Address pc, Address target));
+  INLINE(static Address thumb_target_pointer_at(Address pc));
+  INLINE(static void thumb_set_target_pointer_at(Address pc,
+                                                 Address target,
+                                                 Code* host = NULL));
 
   // 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));
 
   // Return the code target address at a call site from the return address
   // of that call in the instruction stream.
   INLINE(static Address target_address_from_return_address(Address pc));
 
   // Given the address of the beginning of a call, return the address
@@ skipping 806 matching lines @@
   static bool IsTstImmediate(Instr instr);
   static bool IsCmpRegister(Instr instr);
   static bool IsCmpImmediate(Instr instr);
   static Register GetCmpImmediateRegister(Instr instr);
   static int GetCmpImmediateRawImmediate(Instr instr);
   static bool IsNop(Instr instr, int type = NON_MARKING_NOP);
   static bool IsMovT(Instr instr);
   static bool IsMovW(Instr instr);
   static bool IsMovTThumb(Instr instr);
   static bool IsMovWThumb(Instr instr);
+  static bool IsThumbLdrPcImmediateOffset(Instr instr);
+  static inline Address UntagAddress(Address addr);
+  static inline bool IsThumbAddress(Address addr);
+  static inline Address AlignAddress(Address addr);
 
   // Constants in pools are accessed via pc relative addressing, which can
   // reach +/-4KB for integer PC-relative loads and +/-1KB for floating-point
   // PC-relative loads, thereby defining a maximum distance between the
   // instruction and the accessed constant.
   static const int kMaxDistToIntPool = 4*KB;
   static const int kMaxDistToFPPool = 1*KB;
   // All relocations could be integer, it therefore acts as the limit.
   static const int kMaxNumPendingRelocInfo = kMaxDistToIntPool/kInstrSize;
 
@@ skipping 276 matching lines @@
  public:
   explicit EnsureSpace(Assembler* assembler) {
     assembler->CheckBuffer();
   }
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_ASSEMBLER_ARM_H_