src/v8/src/arm/constants-arm.h

   1 // Copyright 2011 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_ARM_CONSTANTS_ARM_H_
   6 #define V8_ARM_CONSTANTS_ARM_H_
   7
   8 // ARM EABI is required.
   9 #if defined(__arm__) && !defined(__ARM_EABI__)
  10 #error ARM EABI support is required.
  11 #endif
  12
  13 namespace v8 {
  14 namespace internal {
  15
  16 // Constant pool marker.
  17 // Use UDF, the permanently undefined instruction.
  18 const int kConstantPoolMarkerMask = 0xfff000f0;
  19 const int kConstantPoolMarker = 0xe7f000f0;
  20 const int kConstantPoolLengthMaxMask = 0xffff;
  21 inline int EncodeConstantPoolLength(int length) {
  22   ASSERT((length & kConstantPoolLengthMaxMask) == length);
  23   return ((length & 0xfff0) << 4) | (length & 0xf);
  24 }
  25 inline int DecodeConstantPoolLength(int instr) {
  26   ASSERT((instr & kConstantPoolMarkerMask) == kConstantPoolMarker);
  27   return ((instr >> 4) & 0xfff0) | (instr & 0xf);
  28 }
  29
  30 // Used in code age prologue - ldr(pc, MemOperand(pc, -4))
  31 const int kCodeAgeJumpInstruction = 0xe51ff004;
  32
  33 // Number of registers in normal ARM mode.
  34 const int kNumRegisters = 16;
  35
  36 // VFP support.
  37 const int kNumVFPSingleRegisters = 32;
  38 const int kNumVFPDoubleRegisters = 32;
  39 const int kNumVFPRegisters = kNumVFPSingleRegisters + kNumVFPDoubleRegisters;
  40
  41 // PC is register 15.
  42 const int kPCRegister = 15;
  43 const int kNoRegister = -1;
  44
  45 // -----------------------------------------------------------------------------
  46 // Conditions.
  47
  48 // Defines constants and accessor classes to assemble, disassemble and
  49 // simulate ARM instructions.
  50 //
  51 // Section references in the code refer to the "ARM Architecture Reference
  52 // Manual" from July 2005 (available at http://www.arm.com/miscPDFs/14128.pdf)
  53 //
  54 // Constants for specific fields are defined in their respective named enums.
  55 // General constants are in an anonymous enum in class Instr.
  56
  57 // Values for the condition field as defined in section A3.2
  58 enum Condition {
  59   kNoCondition = -1,
  60
  61   eq =  0 << 28,                 // Z set            Equal.
  62   ne =  1 << 28,                 // Z clear          Not equal.
  63   cs =  2 << 28,                 // C set            Unsigned higher or same.
  64   cc =  3 << 28,                 // C clear          Unsigned lower.
  65   mi =  4 << 28,                 // N set            Negative.
  66   pl =  5 << 28,                 // N clear          Positive or zero.
  67   vs =  6 << 28,                 // V set            Overflow.
  68   vc =  7 << 28,                 // V clear          No overflow.
  69   hi =  8 << 28,                 // C set, Z clear   Unsigned higher.
  70   ls =  9 << 28,                 // C clear or Z set Unsigned lower or same.
  71   ge = 10 << 28,                 // N == V           Greater or equal.
  72   lt = 11 << 28,                 // N != V           Less than.
  73   gt = 12 << 28,                 // Z clear, N == V  Greater than.
  74   le = 13 << 28,                 // Z set or N != V  Less then or equal
  75   al = 14 << 28,                 //                  Always.
  76
  77   kSpecialCondition = 15 << 28,  // Special condition (refer to section A3.2.1).
  78   kNumberOfConditions = 16,
  79
  80   // Aliases.
  81   hs = cs,                       // C set            Unsigned higher or same.
  82   lo = cc                        // C clear          Unsigned lower.
  83 };
  84
  85
  86 inline Condition NegateCondition(Condition cond) {
  87   ASSERT(cond != al);
  88   return static_cast<Condition>(cond ^ ne);
  89 }
  90
  91
  92 // Corresponds to transposing the operands of a comparison.
  93 inline Condition ReverseCondition(Condition cond) {
  94   switch (cond) {
  95     case lo:
  96       return hi;
  97     case hi:
  98       return lo;
  99     case hs:
 100       return ls;
 101     case ls:
 102       return hs;
 103     case lt:
 104       return gt;
 105     case gt:
 106       return lt;
 107     case ge:
 108       return le;
 109     case le:
 110       return ge;
 111     default:
 112       return cond;
 113   };
 114 }
 115
 116
 117 // -----------------------------------------------------------------------------
 118 // Instructions encoding.
 119
 120 // Instr is merely used by the Assembler to distinguish 32bit integers
 121 // representing instructions from usual 32 bit values.
 122 // Instruction objects are pointers to 32bit values, and provide methods to
 123 // access the various ISA fields.
 124 typedef int32_t Instr;
 125
 126
 127 // Opcodes for Data-processing instructions (instructions with a type 0 and 1)
 128 // as defined in section A3.4
 129 enum Opcode {
 130   AND =  0 << 21,  // Logical AND.
 131   EOR =  1 << 21,  // Logical Exclusive OR.
 132   SUB =  2 << 21,  // Subtract.
 133   RSB =  3 << 21,  // Reverse Subtract.
 134   ADD =  4 << 21,  // Add.
 135   ADC =  5 << 21,  // Add with Carry.
 136   SBC =  6 << 21,  // Subtract with Carry.
 137   RSC =  7 << 21,  // Reverse Subtract with Carry.
 138   TST =  8 << 21,  // Test.
 139   TEQ =  9 << 21,  // Test Equivalence.
 140   CMP = 10 << 21,  // Compare.
 141   CMN = 11 << 21,  // Compare Negated.
 142   ORR = 12 << 21,  // Logical (inclusive) OR.
 143   MOV = 13 << 21,  // Move.
 144   BIC = 14 << 21,  // Bit Clear.
 145   MVN = 15 << 21   // Move Not.
 146 };
 147
 148
 149 // The bits for bit 7-4 for some type 0 miscellaneous instructions.
 150 enum MiscInstructionsBits74 {
 151   // With bits 22-21 01.
 152   BX   =  1 << 4,
 153   BXJ  =  2 << 4,
 154   BLX  =  3 << 4,
 155   BKPT =  7 << 4,
 156
 157   // With bits 22-21 11.
 158   CLZ  =  1 << 4
 159 };
 160
 161
 162 // Instruction encoding bits and masks.
 163 enum {
 164   H   = 1 << 5,   // Halfword (or byte).
 165   S6  = 1 << 6,   // Signed (or unsigned).
 166   L   = 1 << 20,  // Load (or store).
 167   S   = 1 << 20,  // Set condition code (or leave unchanged).
 168   W   = 1 << 21,  // Writeback base register (or leave unchanged).
 169   A   = 1 << 21,  // Accumulate in multiply instruction (or not).
 170   B   = 1 << 22,  // Unsigned byte (or word).
 171   N   = 1 << 22,  // Long (or short).
 172   U   = 1 << 23,  // Positive (or negative) offset/index.
 173   P   = 1 << 24,  // Offset/pre-indexed addressing (or post-indexed addressing).
 174   I   = 1 << 25,  // Immediate shifter operand (or not).
 175
 176   B4  = 1 << 4,
 177   B5  = 1 << 5,
 178   B6  = 1 << 6,
 179   B7  = 1 << 7,
 180   B8  = 1 << 8,
 181   B9  = 1 << 9,
 182   B12 = 1 << 12,
 183   B16 = 1 << 16,
 184   B18 = 1 << 18,
 185   B19 = 1 << 19,
 186   B20 = 1 << 20,
 187   B21 = 1 << 21,
 188   B22 = 1 << 22,
 189   B23 = 1 << 23,
 190   B24 = 1 << 24,
 191   B25 = 1 << 25,
 192   B26 = 1 << 26,
 193   B27 = 1 << 27,
 194   B28 = 1 << 28,
 195
 196   // Instruction bit masks.
 197   kCondMask   = 15 << 28,
 198   kALUMask    = 0x6f << 21,
 199   kRdMask     = 15 << 12,  // In str instruction.
 200   kCoprocessorMask = 15 << 8,
 201   kOpCodeMask = 15 << 21,  // In data-processing instructions.
 202   kImm24Mask  = (1 << 24) - 1,
 203   kImm16Mask  = (1 << 16) - 1,
 204   kImm8Mask  = (1 << 8) - 1,
 205   kOff12Mask  = (1 << 12) - 1,
 206   kOff8Mask  = (1 << 8) - 1
 207 };
 208
 209
 210 // -----------------------------------------------------------------------------
 211 // Addressing modes and instruction variants.
 212
 213 // Condition code updating mode.
 214 enum SBit {
 215   SetCC   = 1 << 20,  // Set condition code.
 216   LeaveCC = 0 << 20   // Leave condition code unchanged.
 217 };
 218
 219
 220 // Status register selection.
 221 enum SRegister {
 222   CPSR = 0 << 22,
 223   SPSR = 1 << 22
 224 };
 225
 226
 227 // Shifter types for Data-processing operands as defined in section A5.1.2.
 228 enum ShiftOp {
 229   LSL = 0 << 5,   // Logical shift left.
 230   LSR = 1 << 5,   // Logical shift right.
 231   ASR = 2 << 5,   // Arithmetic shift right.
 232   ROR = 3 << 5,   // Rotate right.
 233
 234   // RRX is encoded as ROR with shift_imm == 0.
 235   // Use a special code to make the distinction. The RRX ShiftOp is only used
 236   // as an argument, and will never actually be encoded. The Assembler will
 237   // detect it and emit the correct ROR shift operand with shift_imm == 0.
 238   RRX = -1,
 239   kNumberOfShifts = 4
 240 };
 241
 242
 243 // Status register fields.
 244 enum SRegisterField {
 245   CPSR_c = CPSR | 1 << 16,
 246   CPSR_x = CPSR | 1 << 17,
 247   CPSR_s = CPSR | 1 << 18,
 248   CPSR_f = CPSR | 1 << 19,
 249   SPSR_c = SPSR | 1 << 16,
 250   SPSR_x = SPSR | 1 << 17,
 251   SPSR_s = SPSR | 1 << 18,
 252   SPSR_f = SPSR | 1 << 19
 253 };
 254
 255 // Status register field mask (or'ed SRegisterField enum values).
 256 typedef uint32_t SRegisterFieldMask;
 257
 258
 259 // Memory operand addressing mode.
 260 enum AddrMode {
 261   // Bit encoding P U W.
 262   Offset       = (8|4|0) << 21,  // Offset (without writeback to base).
 263   PreIndex     = (8|4|1) << 21,  // Pre-indexed addressing with writeback.
 264   PostIndex    = (0|4|0) << 21,  // Post-indexed addressing with writeback.
 265   NegOffset    = (8|0|0) << 21,  // Negative offset (without writeback to base).
 266   NegPreIndex  = (8|0|1) << 21,  // Negative pre-indexed with writeback.
 267   NegPostIndex = (0|0|0) << 21   // Negative post-indexed with writeback.
 268 };
 269
 270
 271 // Load/store multiple addressing mode.
 272 enum BlockAddrMode {
 273   // Bit encoding P U W .
 274   da           = (0|0|0) << 21,  // Decrement after.
 275   ia           = (0|4|0) << 21,  // Increment after.
 276   db           = (8|0|0) << 21,  // Decrement before.
 277   ib           = (8|4|0) << 21,  // Increment before.
 278   da_w         = (0|0|1) << 21,  // Decrement after with writeback to base.
 279   ia_w         = (0|4|1) << 21,  // Increment after with writeback to base.
 280   db_w         = (8|0|1) << 21,  // Decrement before with writeback to base.
 281   ib_w         = (8|4|1) << 21,  // Increment before with writeback to base.
 282
 283   // Alias modes for comparison when writeback does not matter.
 284   da_x         = (0|0|0) << 21,  // Decrement after.
 285   ia_x         = (0|4|0) << 21,  // Increment after.
 286   db_x         = (8|0|0) << 21,  // Decrement before.
 287   ib_x         = (8|4|0) << 21,  // Increment before.
 288
 289   kBlockAddrModeMask = (8|4|1) << 21
 290 };
 291
 292
 293 // Coprocessor load/store operand size.
 294 enum LFlag {
 295   Long  = 1 << 22,  // Long load/store coprocessor.
 296   Short = 0 << 22   // Short load/store coprocessor.
 297 };
 298
 299
 300 // NEON data type
 301 enum NeonDataType {
 302   NeonS8 = 0x1,   // U = 0, imm3 = 0b001
 303   NeonS16 = 0x2,  // U = 0, imm3 = 0b010
 304   NeonS32 = 0x4,  // U = 0, imm3 = 0b100
 305   NeonU8 = 1 << 24 | 0x1,   // U = 1, imm3 = 0b001
 306   NeonU16 = 1 << 24 | 0x2,  // U = 1, imm3 = 0b010
 307   NeonU32 = 1 << 24 | 0x4,   // U = 1, imm3 = 0b100
 308   NeonDataTypeSizeMask = 0x7,
 309   NeonDataTypeUMask = 1 << 24
 310 };
 311
 312 enum NeonListType {
 313   nlt_1 = 0x7,
 314   nlt_2 = 0xA,
 315   nlt_3 = 0x6,
 316   nlt_4 = 0x2
 317 };
 318
 319 enum NeonSize {
 320   Neon8 = 0x0,
 321   Neon16 = 0x1,
 322   Neon32 = 0x2,
 323   Neon64 = 0x3
 324 };
 325
 326 // -----------------------------------------------------------------------------
 327 // Supervisor Call (svc) specific support.
 328
 329 // Special Software Interrupt codes when used in the presence of the ARM
 330 // simulator.
 331 // svc (formerly swi) provides a 24bit immediate value. Use bits 22:0 for
 332 // standard SoftwareInterrupCode. Bit 23 is reserved for the stop feature.
 333 enum SoftwareInterruptCodes {
 334   // transition to C code
 335   kCallRtRedirected= 0x10,
 336   // break point
 337   kBreakpoint= 0x20,
 338   // stop
 339   kStopCode = 1 << 23
 340 };
 341 const uint32_t kStopCodeMask = kStopCode - 1;
 342 const uint32_t kMaxStopCode = kStopCode - 1;
 343 const int32_t  kDefaultStopCode = -1;
 344
 345
 346 // Type of VFP register. Determines register encoding.
 347 enum VFPRegPrecision {
 348   kSinglePrecision = 0,
 349   kDoublePrecision = 1
 350 };
 351
 352
 353 // VFP FPSCR constants.
 354 enum VFPConversionMode {
 355   kFPSCRRounding = 0,
 356   kDefaultRoundToZero = 1
 357 };
 358
 359 // This mask does not include the "inexact" or "input denormal" cumulative
 360 // exceptions flags, because we usually don't want to check for it.
 361 const uint32_t kVFPExceptionMask = 0xf;
 362 const uint32_t kVFPInvalidOpExceptionBit = 1 << 0;
 363 const uint32_t kVFPOverflowExceptionBit = 1 << 2;
 364 const uint32_t kVFPUnderflowExceptionBit = 1 << 3;
 365 const uint32_t kVFPInexactExceptionBit = 1 << 4;
 366 const uint32_t kVFPFlushToZeroMask = 1 << 24;
 367 const uint32_t kVFPDefaultNaNModeControlBit = 1 << 25;
 368
 369 const uint32_t kVFPNConditionFlagBit = 1 << 31;
 370 const uint32_t kVFPZConditionFlagBit = 1 << 30;
 371 const uint32_t kVFPCConditionFlagBit = 1 << 29;
 372 const uint32_t kVFPVConditionFlagBit = 1 << 28;
 373
 374
 375 // VFP rounding modes. See ARM DDI 0406B Page A2-29.
 376 enum VFPRoundingMode {
 377   RN = 0 << 22,   // Round to Nearest.
 378   RP = 1 << 22,   // Round towards Plus Infinity.
 379   RM = 2 << 22,   // Round towards Minus Infinity.
 380   RZ = 3 << 22,   // Round towards zero.
 381
 382   // Aliases.
 383   kRoundToNearest = RN,
 384   kRoundToPlusInf = RP,
 385   kRoundToMinusInf = RM,
 386   kRoundToZero = RZ
 387 };
 388
 389 const uint32_t kVFPRoundingModeMask = 3 << 22;
 390
 391 enum CheckForInexactConversion {
 392   kCheckForInexactConversion,
 393   kDontCheckForInexactConversion
 394 };
 395
 396 // -----------------------------------------------------------------------------
 397 // Hints.
 398
 399 // Branch hints are not used on the ARM.  They are defined so that they can
 400 // appear in shared function signatures, but will be ignored in ARM
 401 // implementations.
 402 enum Hint { no_hint };
 403
 404 // Hints are not used on the arm.  Negating is trivial.
 405 inline Hint NegateHint(Hint ignored) { return no_hint; }
 406
 407
 408 // -----------------------------------------------------------------------------
 409 // Specific instructions, constants, and masks.
 410 // These constants are declared in assembler-arm.cc, as they use named registers
 411 // and other constants.
 412
 413
 414 // add(sp, sp, 4) instruction (aka Pop())
 415 extern const Instr kPopInstruction;
 416
 417 // str(r, MemOperand(sp, 4, NegPreIndex), al) instruction (aka push(r))
 418 // register r is not encoded.
 419 extern const Instr kPushRegPattern;
 420
 421 // ldr(r, MemOperand(sp, 4, PostIndex), al) instruction (aka pop(r))
 422 // register r is not encoded.
 423 extern const Instr kPopRegPattern;
 424
 425 // mov lr, pc
 426 extern const Instr kMovLrPc;
 427 // ldr rd, [pc, #offset]
 428 extern const Instr kLdrPCMask;
 429 extern const Instr kLdrPCPattern;
 430 // vldr dd, [pc, #offset]
 431 extern const Instr kVldrDPCMask;
 432 extern const Instr kVldrDPCPattern;
 433 // blxcc rm
 434 extern const Instr kBlxRegMask;
 435
 436 extern const Instr kBlxRegPattern;
 437
 438 extern const Instr kMovMvnMask;
 439 extern const Instr kMovMvnPattern;
 440 extern const Instr kMovMvnFlip;
 441 extern const Instr kMovLeaveCCMask;
 442 extern const Instr kMovLeaveCCPattern;
 443 extern const Instr kMovwMask;
 444 extern const Instr kMovwPattern;
 445 extern const Instr kMovwLeaveCCFlip;
 446 extern const Instr kCmpCmnMask;
 447 extern const Instr kCmpCmnPattern;
 448 extern const Instr kCmpCmnFlip;
 449 extern const Instr kAddSubFlip;
 450 extern const Instr kAndBicFlip;
 451
 452 // A mask for the Rd register for push, pop, ldr, str instructions.
 453 extern const Instr kLdrRegFpOffsetPattern;
 454
 455 extern const Instr kStrRegFpOffsetPattern;
 456
 457 extern const Instr kLdrRegFpNegOffsetPattern;
 458
 459 extern const Instr kStrRegFpNegOffsetPattern;
 460
 461 extern const Instr kLdrStrInstrTypeMask;
 462 extern const Instr kLdrStrInstrArgumentMask;
 463 extern const Instr kLdrStrOffsetMask;
 464
 465
 466 // -----------------------------------------------------------------------------
 467 // Instruction abstraction.
 468
 469 // The class Instruction enables access to individual fields defined in the ARM
 470 // architecture instruction set encoding as described in figure A3-1.
 471 // Note that the Assembler uses typedef int32_t Instr.
 472 //
 473 // Example: Test whether the instruction at ptr does set the condition code
 474 // bits.
 475 //
 476 // bool InstructionSetsConditionCodes(byte* ptr) {
 477 //   Instruction* instr = Instruction::At(ptr);
 478 //   int type = instr->TypeValue();
 479 //   return ((type == 0) || (type == 1)) && instr->HasS();
 480 // }
 481 //
 482 class Instruction {
 483  public:
 484   enum {
 485     kInstrSize = 4,
 486     kInstrSizeLog2 = 2,
 487     kPCReadOffset = 8
 488   };
 489
 490   // Helper macro to define static accessors.
 491   // We use the cast to char* trick to bypass the strict anti-aliasing rules.
 492   #define DECLARE_STATIC_TYPED_ACCESSOR(return_type, Name)                     \
 493     static inline return_type Name(Instr instr) {                              \
 494       char* temp = reinterpret_cast<char*>(&instr);                            \
 495       return reinterpret_cast<Instruction*>(temp)->Name();                     \
 496     }
 497
 498   #define DECLARE_STATIC_ACCESSOR(Name) DECLARE_STATIC_TYPED_ACCESSOR(int, Name)
 499
 500   // Get the raw instruction bits.
 501   inline Instr InstructionBits() const {
 502     return *reinterpret_cast<const Instr*>(this);
 503   }
 504
 505   // Set the raw instruction bits to value.
 506   inline void SetInstructionBits(Instr value) {
 507     *reinterpret_cast<Instr*>(this) = value;
 508   }
 509
 510   // Read one particular bit out of the instruction bits.
 511   inline int Bit(int nr) const {
 512     return (InstructionBits() >> nr) & 1;
 513   }
 514
 515   // Read a bit field's value out of the instruction bits.
 516   inline int Bits(int hi, int lo) const {
 517     return (InstructionBits() >> lo) & ((2 << (hi - lo)) - 1);
 518   }
 519
 520   // Read a bit field out of the instruction bits.
 521   inline int BitField(int hi, int lo) const {
 522     return InstructionBits() & (((2 << (hi - lo)) - 1) << lo);
 523   }
 524
 525   // Static support.
 526
 527   // Read one particular bit out of the instruction bits.
 528   static inline int Bit(Instr instr, int nr) {
 529     return (instr >> nr) & 1;
 530   }
 531
 532   // Read the value of a bit field out of the instruction bits.
 533   static inline int Bits(Instr instr, int hi, int lo) {
 534     return (instr >> lo) & ((2 << (hi - lo)) - 1);
 535   }
 536
 537
 538   // Read a bit field out of the instruction bits.
 539   static inline int BitField(Instr instr, int hi, int lo) {
 540     return instr & (((2 << (hi - lo)) - 1) << lo);
 541   }
 542
 543
 544   // Accessors for the different named fields used in the ARM encoding.
 545   // The naming of these accessor corresponds to figure A3-1.
 546   //
 547   // Two kind of accessors are declared:
 548   // - <Name>Field() will return the raw field, i.e. the field's bits at their
 549   //   original place in the instruction encoding.
 550   //   e.g. if instr is the 'addgt r0, r1, r2' instruction, encoded as
 551   //   0xC0810002 ConditionField(instr) will return 0xC0000000.
 552   // - <Name>Value() will return the field value, shifted back to bit 0.
 553   //   e.g. if instr is the 'addgt r0, r1, r2' instruction, encoded as
 554   //   0xC0810002 ConditionField(instr) will return 0xC.
 555
 556
 557   // Generally applicable fields
 558   inline Condition ConditionValue() const {
 559     return static_cast<Condition>(Bits(31, 28));
 560   }
 561   inline Condition ConditionField() const {
 562     return static_cast<Condition>(BitField(31, 28));
 563   }
 564   DECLARE_STATIC_TYPED_ACCESSOR(Condition, ConditionValue);
 565   DECLARE_STATIC_TYPED_ACCESSOR(Condition, ConditionField);
 566
 567   inline int TypeValue() const { return Bits(27, 25); }
 568   inline int SpecialValue() const { return Bits(27, 23); }
 569
 570   inline int RnValue() const { return Bits(19, 16); }
 571   DECLARE_STATIC_ACCESSOR(RnValue);
 572   inline int RdValue() const { return Bits(15, 12); }
 573   DECLARE_STATIC_ACCESSOR(RdValue);
 574
 575   inline int CoprocessorValue() const { return Bits(11, 8); }
 576   // Support for VFP.
 577   // Vn(19-16) | Vd(15-12) |  Vm(3-0)
 578   inline int VnValue() const { return Bits(19, 16); }
 579   inline int VmValue() const { return Bits(3, 0); }
 580   inline int VdValue() const { return Bits(15, 12); }
 581   inline int NValue() const { return Bit(7); }
 582   inline int MValue() const { return Bit(5); }
 583   inline int DValue() const { return Bit(22); }
 584   inline int RtValue() const { return Bits(15, 12); }
 585   inline int PValue() const { return Bit(24); }
 586   inline int UValue() const { return Bit(23); }
 587   inline int Opc1Value() const { return (Bit(23) << 2) | Bits(21, 20); }
 588   inline int Opc2Value() const { return Bits(19, 16); }
 589   inline int Opc3Value() const { return Bits(7, 6); }
 590   inline int SzValue() const { return Bit(8); }
 591   inline int VLValue() const { return Bit(20); }
 592   inline int VCValue() const { return Bit(8); }
 593   inline int VAValue() const { return Bits(23, 21); }
 594   inline int VBValue() const { return Bits(6, 5); }
 595   inline int VFPNRegValue(VFPRegPrecision pre) {
 596     return VFPGlueRegValue(pre, 16, 7);
 597   }
 598   inline int VFPMRegValue(VFPRegPrecision pre) {
 599     return VFPGlueRegValue(pre, 0, 5);
 600   }
 601   inline int VFPDRegValue(VFPRegPrecision pre) {
 602     return VFPGlueRegValue(pre, 12, 22);
 603   }
 604
 605   // Fields used in Data processing instructions
 606   inline int OpcodeValue() const {
 607     return static_cast<Opcode>(Bits(24, 21));
 608   }
 609   inline Opcode OpcodeField() const {
 610     return static_cast<Opcode>(BitField(24, 21));
 611   }
 612   inline int SValue() const { return Bit(20); }
 613     // with register
 614   inline int RmValue() const { return Bits(3, 0); }
 615   DECLARE_STATIC_ACCESSOR(RmValue);
 616   inline int ShiftValue() const { return static_cast<ShiftOp>(Bits(6, 5)); }
 617   inline ShiftOp ShiftField() const {
 618     return static_cast<ShiftOp>(BitField(6, 5));
 619   }
 620   inline int RegShiftValue() const { return Bit(4); }
 621   inline int RsValue() const { return Bits(11, 8); }
 622   inline int ShiftAmountValue() const { return Bits(11, 7); }
 623     // with immediate
 624   inline int RotateValue() const { return Bits(11, 8); }
 625   inline int Immed8Value() const { return Bits(7, 0); }
 626   inline int Immed4Value() const { return Bits(19, 16); }
 627   inline int ImmedMovwMovtValue() const {
 628       return Immed4Value() << 12 | Offset12Value(); }
 629
 630   // Fields used in Load/Store instructions
 631   inline int PUValue() const { return Bits(24, 23); }
 632   inline int PUField() const { return BitField(24, 23); }
 633   inline int  BValue() const { return Bit(22); }
 634   inline int  WValue() const { return Bit(21); }
 635   inline int  LValue() const { return Bit(20); }
 636     // with register uses same fields as Data processing instructions above
 637     // with immediate
 638   inline int Offset12Value() const { return Bits(11, 0); }
 639     // multiple
 640   inline int RlistValue() const { return Bits(15, 0); }
 641     // extra loads and stores
 642   inline int SignValue() const { return Bit(6); }
 643   inline int HValue() const { return Bit(5); }
 644   inline int ImmedHValue() const { return Bits(11, 8); }
 645   inline int ImmedLValue() const { return Bits(3, 0); }
 646
 647   // Fields used in Branch instructions
 648   inline int LinkValue() const { return Bit(24); }
 649   inline int SImmed24Value() const { return ((InstructionBits() << 8) >> 8); }
 650
 651   // Fields used in Software interrupt instructions
 652   inline SoftwareInterruptCodes SvcValue() const {
 653     return static_cast<SoftwareInterruptCodes>(Bits(23, 0));
 654   }
 655
 656   // Test for special encodings of type 0 instructions (extra loads and stores,
 657   // as well as multiplications).
 658   inline bool IsSpecialType0() const { return (Bit(7) == 1) && (Bit(4) == 1); }
 659
 660   // Test for miscellaneous instructions encodings of type 0 instructions.
 661   inline bool IsMiscType0() const { return (Bit(24) == 1)
 662                                            && (Bit(23) == 0)
 663                                            && (Bit(20) == 0)
 664                                            && ((Bit(7) == 0)); }
 665
 666   // Test for a nop instruction, which falls under type 1.
 667   inline bool IsNopType1() const { return Bits(24, 0) == 0x0120F000; }
 668
 669   // Test for a stop instruction.
 670   inline bool IsStop() const {
 671     return (TypeValue() == 7) && (Bit(24) == 1) && (SvcValue() >= kStopCode);
 672   }
 673
 674   // Special accessors that test for existence of a value.
 675   inline bool HasS()    const { return SValue() == 1; }
 676   inline bool HasB()    const { return BValue() == 1; }
 677   inline bool HasW()    const { return WValue() == 1; }
 678   inline bool HasL()    const { return LValue() == 1; }
 679   inline bool HasU()    const { return UValue() == 1; }
 680   inline bool HasSign() const { return SignValue() == 1; }
 681   inline bool HasH()    const { return HValue() == 1; }
 682   inline bool HasLink() const { return LinkValue() == 1; }
 683
 684   // Decoding the double immediate in the vmov instruction.
 685   double DoubleImmedVmov() const;
 686
 687   // Instructions are read of out a code stream. The only way to get a
 688   // reference to an instruction is to convert a pointer. There is no way
 689   // to allocate or create instances of class Instruction.
 690   // Use the At(pc) function to create references to Instruction.
 691   static Instruction* At(byte* pc) {
 692     return reinterpret_cast<Instruction*>(pc);
 693   }
 694
 695
 696  private:
 697   // Join split register codes, depending on single or double precision.
 698   // four_bit is the position of the least-significant bit of the four
 699   // bit specifier. one_bit is the position of the additional single bit
 700   // specifier.
 701   inline int VFPGlueRegValue(VFPRegPrecision pre, int four_bit, int one_bit) {
 702     if (pre == kSinglePrecision) {
 703       return (Bits(four_bit + 3, four_bit) << 1) | Bit(one_bit);
 704     }
 705     return (Bit(one_bit) << 4) | Bits(four_bit + 3, four_bit);
 706   }
 707
 708   // We need to prevent the creation of instances of class Instruction.
 709   DISALLOW_IMPLICIT_CONSTRUCTORS(Instruction);
 710 };
 711
 712
 713 // Helper functions for converting between register numbers and names.
 714 class Registers {
 715  public:
 716   // Return the name of the register.
 717   static const char* Name(int reg);
 718
 719   // Lookup the register number for the name provided.
 720   static int Number(const char* name);
 721
 722   struct RegisterAlias {
 723     int reg;
 724     const char* name;
 725   };
 726
 727  private:
 728   static const char* names_[kNumRegisters];
 729   static const RegisterAlias aliases_[];
 730 };
 731
 732 // Helper functions for converting between VFP register numbers and names.
 733 class VFPRegisters {
 734  public:
 735   // Return the name of the register.
 736   static const char* Name(int reg, bool is_double);
 737
 738   // Lookup the register number for the name provided.
 739   // Set flag pointed by is_double to true if register
 740   // is double-precision.
 741   static int Number(const char* name, bool* is_double);
 742
 743  private:
 744   static const char* names_[kNumVFPRegisters];
 745 };
 746
 747
 748 } }  // namespace v8::internal
 749
 750 #endif  // V8_ARM_CONSTANTS_ARM_H_