Forking disassembler and simulator for Thumb2 support;...

src/arm/assembler-thumb2.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 12 matching lines @@
 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 // COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// The original source code covered by the above license above has been modified
+// The original source code covered by the above license has been modified
 // significantly by Google Inc.
-// Copyright 2006-2008 the V8 project authors. All rights reserved.
+// Copyright 2010 the V8 project authors. All rights reserved.
 
 // A light-weight ARM Assembler
 // Generates user mode instructions for the ARM architecture up to version 5
 
 #ifndef V8_ARM_ASSEMBLER_THUMB2_H_
 #define V8_ARM_ASSEMBLER_THUMB2_H_
 #include <stdio.h>
 #include "assembler.h"
 #include "serialize.h"
 
 namespace v8 {
 namespace internal {
 
+// The beginning of this file contains some enum declarations that are
+// redundant with declarations in constants-arm.h, but in a different namespace
+// Please keep the order and values consistent, so we can merge the files
+// later easily.
+
+// Opcodes for Data-processing instructions (instructions with a type 0 and 1)
+// as defined in section A3.4
+enum Opcode {
+  no_operand = -1,
+  AND =  0,  // Logical AND
+  EOR =  1,  // Logical Exclusive OR
+  SUB =  2,  // Subtract
+  RSB =  3,  // Reverse Subtract
+  ADD =  4,  // Add
+  ADC =  5,  // Add with Carry
+  SBC =  6,  // Subtract with Carry
+  RSC =  7,  // Reverse Subtract with Carry
+  TST =  8,  // Test
+  TEQ =  9,  // Test Equivalence
+  CMP = 10,  // Compare
+  CMN = 11,  // Compare Negated
+  ORR = 12,  // Logical (inclusive) OR
+  MOV = 13,  // Move
+  BIC = 14,  // Bit Clear
+  MVN = 15,  // Move Not
+  max_operand = 16
+};
+
+enum BitPositions {
+  B0  = 1 << 0,
+  B1  = 1 << 1,
+  B2  = 1 << 2,
+  B3  = 1 << 3,
+  B4  = 1 << 4,
+  B5  = 1 << 5,
+  B6  = 1 << 6,
+  B7  = 1 << 7,
+  B8  = 1 << 8,
+  B9  = 1 << 9,
+  B10 = 1 << 10,
+  B11 = 1 << 11,
+  B12 = 1 << 12,
+  B16 = 1 << 16,
+  B18 = 1 << 18,
+  B19 = 1 << 19,
+  B20 = 1 << 20,
+  B21 = 1 << 21,
+  B22 = 1 << 22,
+  B23 = 1 << 23,
+  B24 = 1 << 24,
+  B25 = 1 << 25,
+  B26 = 1 << 26,
+  B27 = 1 << 27
+};
+
+enum Bits1 {
+  b0 = 0x0,
+  b1 = 0x1
+};
+
+enum Bits2 {
+  b00 = 0x0,
+  b01 = 0x1,
+  b10 = 0x2,
+  b11 = 0x3
+};
+
+enum Bits3 {
+  b000 = 0x0,
+  b001 = 0x1,
+  b010 = 0x2,
+  b011 = 0x3,
+  b100 = 0x4,
+  b101 = 0x5,
+  b110 = 0x6,
+  b111 = 0x7
+};
+
+enum Bits4 {
+  b0000 = 0x0,
+  b0001 = 0x1,
+  b0010 = 0x2,
+  b0011 = 0x3,
+  b0100 = 0x4,
+  b0101 = 0x5,
+  b0110 = 0x6,
+  b0111 = 0x7,
+  b1000 = 0x8,
+  b1001 = 0x9,
+  b1010 = 0xa,
+  b1011 = 0xb,
+  b1100 = 0xc,
+  b1101 = 0xd,
+  b1110 = 0xe,
+  b1111 = 0xf
+};
+
+enum Bits5 {
+  b00000 = 0x00,
+  b00001 = 0x01,
+  b00010 = 0x02,
+  b00011 = 0x03,
+  b00100 = 0x04,
+  b00101 = 0x05,
+  b00110 = 0x06,
+  b00111 = 0x07,
+  b01000 = 0x08,
+  b01001 = 0x09,
+  b01010 = 0x0a,
+  b01011 = 0x0b,
+  b01100 = 0x0c,
+  b01101 = 0x0d,
+  b01110 = 0x0e,
+  b01111 = 0x0f,
+  b10000 = 0x10,
+  b10001 = 0x11,
+  b10010 = 0x12,
+  b10011 = 0x13,
+  b10100 = 0x14,
+  b10101 = 0x15,
+  b10110 = 0x16,
+  b10111 = 0x17,
+  b11000 = 0x18,
+  b11001 = 0x19,
+  b11010 = 0x1a,
+  b11011 = 0x1b,
+  b11100 = 0x1c,
+  b11101 = 0x1d,
+  b11110 = 0x1e,
+  b11111 = 0x1f
+};
+
 // CPU Registers.
 //
 // 1) We would prefer to use an enum, but enum values are assignment-
 // compatible with int, which has caused code-generation bugs.
 //
 // 2) We would prefer to use a class instead of a struct but we don't like
 // the register initialization to depend on the particular initialization
 // order (which appears to be different on OS X, Linux, and Windows for the
 // installed versions of C++ we tried). Using a struct permits C-style
 // "initialization". Also, the Register objects cannot be const as this
@@ skipping 184 matching lines @@
   p9  = 9,
   p10 = 10,
   p11 = 11,
   p12 = 12,
   p13 = 13,
   p14 = 14,
   p15 = 15
 };
 
 
-// Condition field in instructions
+// Condition field in instructions.
 enum Condition {
   eq =  0 << 28,  // Z set            equal.
   ne =  1 << 28,  // Z clear          not equal.
   nz =  1 << 28,  // Z clear          not zero.
   cs =  2 << 28,  // C set            carry set.
   hs =  2 << 28,  // C set            unsigned higher or same.
   cc =  3 << 28,  // C clear          carry clear.
   lo =  3 << 28,  // C clear          unsigned lower.
   mi =  4 << 28,  // N set            negative.
   pl =  5 << 28,  // N clear          positive or zero.
@@ skipping 45 matching lines @@
 
 // Hints are not used on the arm.  Negating is trivial.
 inline Hint NegateHint(Hint ignored) { return no_hint; }
 
 
 // -----------------------------------------------------------------------------
 // Addressing modes and instruction variants
 
 // Shifter operand shift operation
 enum ShiftOp {
-  LSL = 0 << 5,
-  LSR = 1 << 5,
-  ASR = 2 << 5,
-  ROR = 3 << 5,
+  LSL = 0,
+  LSR = 1,
+  ASR = 2,
+  ROR = 3,
   RRX = -1
 };
 
 
 // Condition code updating mode
 enum SBit {
   SetCC   = 1 << 20,  // set condition code
   LeaveCC = 0 << 20   // leave condition code unchanged
 };
 
@@ skipping 166 matching lines @@
     explicit Scope(CpuFeature f) {}
 #endif
   };
 
  private:
   static unsigned supported_;
   static unsigned enabled_;
   static unsigned found_by_runtime_probing_;
 };
 
+typedef int32_t InstrArm;
+typedef int16_t InstrThumb;
 
-typedef int32_t Instr;
+// hack to keep the code patcher happy for now
+typedef InstrArm Instr;
 
-
-extern const Instr kMovLrPc;
-extern const Instr kLdrPCPattern;
+extern const InstrArm kMovLrPc;
+extern const InstrArm kLdrPCPattern;
 
 
 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).
   //
   // If the provided buffer is NULL, the assembler allocates and grows its own
@@ skipping 57 matching lines @@
     set_target_at(constant_pool_entry, target);
   }
 
   // Here we are patching the address in the constant pool, not the actual call
   // instruction.  The address in the constant pool is the same size as a
   // pointer.
   static const int kCallTargetSize = kPointerSize;
   static const int kExternalTargetSize = kPointerSize;
 
   // Size of an instruction.
+  static const int kInstrArmSize = sizeof(InstrArm);
+  static const int kInstrThumbSize = sizeof(InstrThumb);
+  // Keep the code generator happy for now.
   static const int kInstrSize = sizeof(Instr);
 
+
   // Distance between the instruction referring to the address of the call
   // target (ldr pc, [target addr in const pool]) and the return address
-  static const int kCallTargetAddressOffset = kInstrSize;
+  static const int kCallTargetAddressOffset = kInstrArmSize;
 
   // Distance between start of patched return sequence and the emitted address
   // to jump to.
-  static const int kPatchReturnSequenceAddressOffset = kInstrSize;
+  static const int kPatchReturnSequenceAddressOffset = kInstrArmSize;
 
   // Difference between address of current opcode and value read from pc
   // register.
   static const int kPcLoadDelta = 8;
 
   static const int kJSReturnSequenceLength = 4;
 
   // ---------------------------------------------------------------------------
   // Code generation
 
@@ skipping 12 matching lines @@
   // Convenience branch instructions using labels
   void b(Label* L, Condition cond = al)  {
     b(branch_offset(L, cond == al), cond);
   }
   void b(Condition cond, Label* L)  { b(branch_offset(L, cond == al), cond); }
   void bl(Label* L, Condition cond = al)  { bl(branch_offset(L, false), cond); }
   void bl(Condition cond, Label* L)  { bl(branch_offset(L, false), cond); }
   void blx(Label* L)  { blx(branch_offset(L, false)); }  // v5 and above
 
   // Data-processing instructions
+  void ubfx(Register dst, Register src1, const Operand& src2,
+            const Operand& src3, Condition cond = al);
+
   void and_(Register dst, Register src1, const Operand& src2,
             SBit s = LeaveCC, Condition cond = al);
 
   void eor(Register dst, Register src1, const Operand& src2,
            SBit s = LeaveCC, Condition cond = al);
 
   void sub(Register dst, Register src1, const Operand& src2,
            SBit s = LeaveCC, Condition cond = al);
   void sub(Register dst, Register src1, Register src2,
            SBit s = LeaveCC, Condition cond = al) {
@@ skipping 146 matching lines @@
             LFlag l = Short);  // v5 and above
   void stc2(Coprocessor coproc, CRegister crd, Register base, int option,
             LFlag l = Short);  // v5 and above
 
   // Support for VFP.
   // All these APIs support S0 to S31 and D0 to D15.
   // Currently these APIs do not support extended D registers, i.e, D16 to D31.
   // However, some simple modifications can allow
   // these APIs to support D16 to D31.
 
+  void vldr(const DwVfpRegister dst,
+            const Register base,
+            int offset,  // Offset must be a multiple of 4.
+            const Condition cond = al);
+  void vstr(const DwVfpRegister src,
+            const Register base,
+            int offset,  // Offset must be a multiple of 4.
+            const Condition cond = al);
   void vmov(const DwVfpRegister dst,
             const Register src1,
             const Register src2,
             const Condition cond = al);
   void vmov(const Register dst1,
             const Register dst2,
             const DwVfpRegister src,
             const Condition cond = al);
   void vmov(const SwVfpRegister dst,
             const Register src,
@@ skipping 48 matching lines @@
 
   // Load effective address of memory operand x into register dst
   void lea(Register dst, const MemOperand& x,
            SBit s = LeaveCC, Condition cond = al);
 
   // Jump unconditionally to given label.
   void jmp(Label* L) { b(L, al); }
 
   // Check the code size generated from label to here.
   int InstructionsGeneratedSince(Label* l) {
-    return (pc_offset() - l->pos()) / kInstrSize;
+    return (pc_offset() - l->pos()) / kInstrArmSize;
   }
 
   // Check whether an immediate fits an addressing mode 1 instruction.
   bool ImmediateFitsAddrMode1Instruction(int32_t imm32);
 
   // Postpone the generation of the constant pool for the specified number of
   // instructions.
   void BlockConstPoolFor(int instructions);
 
   // Debugging
@@ skipping 10 matching lines @@
   void WriteRecordedPositions();
 
   int pc_offset() const { return pc_ - buffer_; }
   int current_position() const { return current_position_; }
   int current_statement_position() const { return current_position_; }
 
  protected:
   int buffer_space() const { return reloc_info_writer.pos() - pc_; }
 
   // Read/patch instructions
-  static Instr instr_at(byte* pc) { return *reinterpret_cast<Instr*>(pc); }
-  void instr_at_put(byte* pc, Instr instr) {
-    *reinterpret_cast<Instr*>(pc) = instr;
+  static InstrArm instr_arm_at(byte* pc) {
+    return *reinterpret_cast<InstrArm*>(pc);
   }
-  Instr instr_at(int pos) { return *reinterpret_cast<Instr*>(buffer_ + pos); }
-  void instr_at_put(int pos, Instr instr) {
-    *reinterpret_cast<Instr*>(buffer_ + pos) = instr;
+
+  void instr_arm_at_put(byte* pc, InstrArm instr) {
+    *reinterpret_cast<InstrArm*>(pc) = instr;
+  }
+
+  InstrArm instr_arm_at(int pos) {
+    return *reinterpret_cast<InstrArm*>(buffer_ + pos);
+  }
+
+  void instr_arm_at_put(int pos, InstrArm instr) {
+    *reinterpret_cast<InstrArm*>(buffer_ + pos) = instr;
   }
 
   // Decode branch instruction at pos and return branch target pos
   int target_at(int pos);
 
   // Patch branch instruction at pos to branch to given branch target pos
   void target_at_put(int pos, int target_pos);
 
   // Check if is time to emit a constant pool for pending reloc info entries
   void CheckConstPool(bool force_emit, bool require_jump);
@@ skipping 32 matching lines @@
   // location it is accessed from. In this case, we emit a jump over the emitted
   // constant pool.
   // Constants in the pool may be addresses of functions that gets relocated;
   // if so, a relocation info entry is associated to the constant pool entry.
 
   // Repeated checking whether the constant pool should be emitted is rather
   // expensive. By default we only check again once a number of instructions
   // has been generated. That also means that the sizing of the buffers is not
   // an exact science, and that we rely on some slop to not overrun buffers.
   static const int kCheckConstIntervalInst = 32;
-  static const int kCheckConstInterval = kCheckConstIntervalInst * kInstrSize;
+  static const int kCheckConstInterval =
+      kCheckConstIntervalInst * kInstrArmSize;
 
 
   // Pools are emitted after function return and in dead code at (more or less)
   // regular intervals of kDistBetweenPools bytes
   static const int kDistBetweenPools = 1*KB;
 
   // Constants in pools are accessed via pc relative addressing, which can
   // reach +/-4KB thereby defining a maximum distance between the instruction
   // and the accessed constant. We satisfy this constraint by limiting the
   // distance between pools.
   static const int kMaxDistBetweenPools = 4*KB - 2*kBufferCheckInterval;
 
   // Emission of the constant pool may be blocked in some code sequences
   int no_const_pool_before_;  // block emission before this pc offset
 
   // Keep track of the last emitted pool to guarantee a maximal distance
   int last_const_pool_end_;  // pc offset following the last constant pool
 
   // Relocation info generation
   // Each relocation is encoded as a variable size value
   static const int kMaxRelocSize = RelocInfoWriter::kMaxSize;
   RelocInfoWriter reloc_info_writer;
   // Relocation info records are also used during code generation as temporary
   // containers for constants and code target addresses until they are emitted
   // to the constant pool. These pending relocation info records are temporarily
   // stored in a separate buffer until a constant pool is emitted.
   // If every instruction in a long sequence is accessing the pool, we need one
   // pending relocation entry per instruction.
-  static const int kMaxNumPRInfo = kMaxDistBetweenPools/kInstrSize;
+  static const int kMaxNumPRInfo = kMaxDistBetweenPools/kInstrArmSize;
   RelocInfo prinfo_[kMaxNumPRInfo];  // the buffer of pending relocation info
   int num_prinfo_;  // number of pending reloc info entries in the buffer
 
   // The bound position, before this we cannot do instruction elimination.
   int last_bound_pos_;
 
   // source position information
   int current_position_;
   int current_statement_position_;
   int written_position_;
   int written_statement_position_;
+  bool thumb_mode_;
+
 
   // Code emission
   inline void CheckBuffer();
+  inline void EnsureThumbMode();
+  inline void EnsureArmMode();
   void GrowBuffer();
-  inline void emit(Instr x);
+  inline void emit_thumb(InstrThumb x);
+  inline void emit_arm(InstrArm x);
+  inline void emit_int32(int32_t x);
 
-  // Instruction generation
-  void addrmod1(Instr instr, Register rn, Register rd, const Operand& x);
-  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);
+  // ARM Instruction generation
+  void addrmod1(InstrArm instr, Register rn, Register rd, const Operand& x);
+  void addrmod2(InstrArm instr, Register rd, const MemOperand& x);
+  void addrmod3(InstrArm instr, Register rd, const MemOperand& x);
+  void addrmod4(InstrArm instr, Register rn, RegList rl);
+  void addrmod5(InstrArm instr, CRegister crd, const MemOperand& x);
+
+  // Thumb2 Instruction generation
+  void DataProcessing(Condition cond, Opcode op, SBit s,
+                      Register rn, Register rd, const Operand& x);
+  void DataProcessingReg(Opcode op, SBit s, Register rn, Register rd,
+                          Register rm, ShiftOp shiftOp, int shiftBy);
+  void DataProcessingImm(Opcode op, SBit s, Register rn, Register rd, int imm);
 
   // 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);
 
   friend class RegExpMacroAssemblerARM;
   friend class RelocInfo;
   friend class CodePatcher;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_ASSEMBLER_THUMB2_H_