deps/v8/src/arm64/assembler-arm64.h

   1 // Copyright 2013 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_ARM64_ASSEMBLER_ARM64_H_
   6 #define V8_ARM64_ASSEMBLER_ARM64_H_
   7
   8 #include <list>
   9 #include <map>
  10 #include <vector>
  11
  12 #include "src/arm64/instructions-arm64.h"
  13 #include "src/assembler.h"
  14 #include "src/globals.h"
  15 #include "src/serialize.h"
  16 #include "src/utils.h"
  17
  18
  19 namespace v8 {
  20 namespace internal {
  21
  22
  23 // -----------------------------------------------------------------------------
  24 // Registers.
  25 #define REGISTER_CODE_LIST(R)                                                  \
  26 R(0)  R(1)  R(2)  R(3)  R(4)  R(5)  R(6)  R(7)                                 \
  27 R(8)  R(9)  R(10) R(11) R(12) R(13) R(14) R(15)                                \
  28 R(16) R(17) R(18) R(19) R(20) R(21) R(22) R(23)                                \
  29 R(24) R(25) R(26) R(27) R(28) R(29) R(30) R(31)
  30
  31
  32 static const int kRegListSizeInBits = sizeof(RegList) * kBitsPerByte;
  33
  34
  35 // Some CPURegister methods can return Register and FPRegister types, so we
  36 // need to declare them in advance.
  37 struct Register;
  38 struct FPRegister;
  39
  40
  41 struct CPURegister {
  42   enum RegisterType {
  43     // The kInvalid value is used to detect uninitialized static instances,
  44     // which are always zero-initialized before any constructors are called.
  45     kInvalid = 0,
  46     kRegister,
  47     kFPRegister,
  48     kNoRegister
  49   };
  50
  51   static CPURegister Create(unsigned code, unsigned size, RegisterType type) {
  52     CPURegister r = {code, size, type};
  53     return r;
  54   }
  55
  56   unsigned code() const;
  57   RegisterType type() const;
  58   RegList Bit() const;
  59   unsigned SizeInBits() const;
  60   int SizeInBytes() const;
  61   bool Is32Bits() const;
  62   bool Is64Bits() const;
  63   bool IsValid() const;
  64   bool IsValidOrNone() const;
  65   bool IsValidRegister() const;
  66   bool IsValidFPRegister() const;
  67   bool IsNone() const;
  68   bool Is(const CPURegister& other) const;
  69   bool Aliases(const CPURegister& other) const;
  70
  71   bool IsZero() const;
  72   bool IsSP() const;
  73
  74   bool IsRegister() const;
  75   bool IsFPRegister() const;
  76
  77   Register X() const;
  78   Register W() const;
  79   FPRegister D() const;
  80   FPRegister S() const;
  81
  82   bool IsSameSizeAndType(const CPURegister& other) const;
  83
  84   // V8 compatibility.
  85   bool is(const CPURegister& other) const { return Is(other); }
  86   bool is_valid() const { return IsValid(); }
  87
  88   unsigned reg_code;
  89   unsigned reg_size;
  90   RegisterType reg_type;
  91 };
  92
  93
  94 struct Register : public CPURegister {
  95   static Register Create(unsigned code, unsigned size) {
  96     return Register(CPURegister::Create(code, size, CPURegister::kRegister));
  97   }
  98
  99   Register() {
 100     reg_code = 0;
 101     reg_size = 0;
 102     reg_type = CPURegister::kNoRegister;
 103   }
 104
 105   explicit Register(const CPURegister& r) {
 106     reg_code = r.reg_code;
 107     reg_size = r.reg_size;
 108     reg_type = r.reg_type;
 109     DCHECK(IsValidOrNone());
 110   }
 111
 112   Register(const Register& r) {  // NOLINT(runtime/explicit)
 113     reg_code = r.reg_code;
 114     reg_size = r.reg_size;
 115     reg_type = r.reg_type;
 116     DCHECK(IsValidOrNone());
 117   }
 118
 119   bool IsValid() const {
 120     DCHECK(IsRegister() || IsNone());
 121     return IsValidRegister();
 122   }
 123
 124   static Register XRegFromCode(unsigned code);
 125   static Register WRegFromCode(unsigned code);
 126
 127   // Start of V8 compatibility section ---------------------
 128   // These memebers are necessary for compilation.
 129   // A few of them may be unused for now.
 130
 131   static const int kNumRegisters = kNumberOfRegisters;
 132   static int NumRegisters() { return kNumRegisters; }
 133
 134   // We allow crankshaft to use the following registers:
 135   //   - x0 to x15
 136   //   - x18 to x24
 137   //   - x27 (also context)
 138   //
 139   // TODO(all): Register x25 is currently free and could be available for
 140   // crankshaft, but we don't use it as we might use it as a per function
 141   // literal pool pointer in the future.
 142   //
 143   // TODO(all): Consider storing cp in x25 to have only two ranges.
 144   // We split allocatable registers in three ranges called
 145   //   - "low range"
 146   //   - "high range"
 147   //   - "context"
 148   static const unsigned kAllocatableLowRangeBegin = 0;
 149   static const unsigned kAllocatableLowRangeEnd = 15;
 150   static const unsigned kAllocatableHighRangeBegin = 18;
 151   static const unsigned kAllocatableHighRangeEnd = 24;
 152   static const unsigned kAllocatableContext = 27;
 153
 154   // Gap between low and high ranges.
 155   static const int kAllocatableRangeGapSize =
 156       (kAllocatableHighRangeBegin - kAllocatableLowRangeEnd) - 1;
 157
 158   static const int kMaxNumAllocatableRegisters =
 159       (kAllocatableLowRangeEnd - kAllocatableLowRangeBegin + 1) +
 160       (kAllocatableHighRangeEnd - kAllocatableHighRangeBegin + 1) + 1;  // cp
 161   static int NumAllocatableRegisters() { return kMaxNumAllocatableRegisters; }
 162
 163   // Return true if the register is one that crankshaft can allocate.
 164   bool IsAllocatable() const {
 165     return ((reg_code == kAllocatableContext) ||
 166             (reg_code <= kAllocatableLowRangeEnd) ||
 167             ((reg_code >= kAllocatableHighRangeBegin) &&
 168              (reg_code <= kAllocatableHighRangeEnd)));
 169   }
 170
 171   static Register FromAllocationIndex(unsigned index) {
 172     DCHECK(index < static_cast<unsigned>(NumAllocatableRegisters()));
 173     // cp is the last allocatable register.
 174     if (index == (static_cast<unsigned>(NumAllocatableRegisters() - 1))) {
 175       return from_code(kAllocatableContext);
 176     }
 177
 178     // Handle low and high ranges.
 179     return (index <= kAllocatableLowRangeEnd)
 180         ? from_code(index)
 181         : from_code(index + kAllocatableRangeGapSize);
 182   }
 183
 184   static const char* AllocationIndexToString(int index) {
 185     DCHECK((index >= 0) && (index < NumAllocatableRegisters()));
 186     DCHECK((kAllocatableLowRangeBegin == 0) &&
 187            (kAllocatableLowRangeEnd == 15) &&
 188            (kAllocatableHighRangeBegin == 18) &&
 189            (kAllocatableHighRangeEnd == 24) &&
 190            (kAllocatableContext == 27));
 191     const char* const names[] = {
 192       "x0", "x1", "x2", "x3", "x4",
 193       "x5", "x6", "x7", "x8", "x9",
 194       "x10", "x11", "x12", "x13", "x14",
 195       "x15", "x18", "x19", "x20", "x21",
 196       "x22", "x23", "x24", "x27",
 197     };
 198     return names[index];
 199   }
 200
 201   static int ToAllocationIndex(Register reg) {
 202     DCHECK(reg.IsAllocatable());
 203     unsigned code = reg.code();
 204     if (code == kAllocatableContext) {
 205       return NumAllocatableRegisters() - 1;
 206     }
 207
 208     return (code <= kAllocatableLowRangeEnd)
 209         ? code
 210         : code - kAllocatableRangeGapSize;
 211   }
 212
 213   static Register from_code(int code) {
 214     // Always return an X register.
 215     return Register::Create(code, kXRegSizeInBits);
 216   }
 217
 218   // End of V8 compatibility section -----------------------
 219 };
 220
 221
 222 struct FPRegister : public CPURegister {
 223   static FPRegister Create(unsigned code, unsigned size) {
 224     return FPRegister(
 225         CPURegister::Create(code, size, CPURegister::kFPRegister));
 226   }
 227
 228   FPRegister() {
 229     reg_code = 0;
 230     reg_size = 0;
 231     reg_type = CPURegister::kNoRegister;
 232   }
 233
 234   explicit FPRegister(const CPURegister& r) {
 235     reg_code = r.reg_code;
 236     reg_size = r.reg_size;
 237     reg_type = r.reg_type;
 238     DCHECK(IsValidOrNone());
 239   }
 240
 241   FPRegister(const FPRegister& r) {  // NOLINT(runtime/explicit)
 242     reg_code = r.reg_code;
 243     reg_size = r.reg_size;
 244     reg_type = r.reg_type;
 245     DCHECK(IsValidOrNone());
 246   }
 247
 248   bool IsValid() const {
 249     DCHECK(IsFPRegister() || IsNone());
 250     return IsValidFPRegister();
 251   }
 252
 253   static FPRegister SRegFromCode(unsigned code);
 254   static FPRegister DRegFromCode(unsigned code);
 255
 256   // Start of V8 compatibility section ---------------------
 257   static const int kMaxNumRegisters = kNumberOfFPRegisters;
 258
 259   // Crankshaft can use all the FP registers except:
 260   //   - d15 which is used to keep the 0 double value
 261   //   - d30 which is used in crankshaft as a double scratch register
 262   //   - d31 which is used in the MacroAssembler as a double scratch register
 263   static const unsigned kAllocatableLowRangeBegin = 0;
 264   static const unsigned kAllocatableLowRangeEnd = 14;
 265   static const unsigned kAllocatableHighRangeBegin = 16;
 266   static const unsigned kAllocatableHighRangeEnd = 28;
 267
 268   static const RegList kAllocatableFPRegisters = 0x1fff7fff;
 269
 270   // Gap between low and high ranges.
 271   static const int kAllocatableRangeGapSize =
 272       (kAllocatableHighRangeBegin - kAllocatableLowRangeEnd) - 1;
 273
 274   static const int kMaxNumAllocatableRegisters =
 275       (kAllocatableLowRangeEnd - kAllocatableLowRangeBegin + 1) +
 276       (kAllocatableHighRangeEnd - kAllocatableHighRangeBegin + 1);
 277   static int NumAllocatableRegisters() { return kMaxNumAllocatableRegisters; }
 278
 279   // TODO(turbofan): Proper float32 support.
 280   static int NumAllocatableAliasedRegisters() {
 281     return NumAllocatableRegisters();
 282   }
 283
 284   // Return true if the register is one that crankshaft can allocate.
 285   bool IsAllocatable() const {
 286     return (Bit() & kAllocatableFPRegisters) != 0;
 287   }
 288
 289   static FPRegister FromAllocationIndex(unsigned int index) {
 290     DCHECK(index < static_cast<unsigned>(NumAllocatableRegisters()));
 291
 292     return (index <= kAllocatableLowRangeEnd)
 293         ? from_code(index)
 294         : from_code(index + kAllocatableRangeGapSize);
 295   }
 296
 297   static const char* AllocationIndexToString(int index) {
 298     DCHECK((index >= 0) && (index < NumAllocatableRegisters()));
 299     DCHECK((kAllocatableLowRangeBegin == 0) &&
 300            (kAllocatableLowRangeEnd == 14) &&
 301            (kAllocatableHighRangeBegin == 16) &&
 302            (kAllocatableHighRangeEnd == 28));
 303     const char* const names[] = {
 304       "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
 305       "d8", "d9", "d10", "d11", "d12", "d13", "d14",
 306       "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
 307       "d24", "d25", "d26", "d27", "d28"
 308     };
 309     return names[index];
 310   }
 311
 312   static int ToAllocationIndex(FPRegister reg) {
 313     DCHECK(reg.IsAllocatable());
 314     unsigned code = reg.code();
 315
 316     return (code <= kAllocatableLowRangeEnd)
 317         ? code
 318         : code - kAllocatableRangeGapSize;
 319   }
 320
 321   static FPRegister from_code(int code) {
 322     // Always return a D register.
 323     return FPRegister::Create(code, kDRegSizeInBits);
 324   }
 325   // End of V8 compatibility section -----------------------
 326 };
 327
 328
 329 STATIC_ASSERT(sizeof(CPURegister) == sizeof(Register));
 330 STATIC_ASSERT(sizeof(CPURegister) == sizeof(FPRegister));
 331
 332
 333 #if defined(ARM64_DEFINE_REG_STATICS)
 334 #define INITIALIZE_REGISTER(register_class, name, code, size, type)      \
 335   const CPURegister init_##register_class##_##name = {code, size, type}; \
 336   const register_class& name = *reinterpret_cast<const register_class*>( \
 337                                     &init_##register_class##_##name)
 338 #define ALIAS_REGISTER(register_class, alias, name)                       \
 339   const register_class& alias = *reinterpret_cast<const register_class*>( \
 340                                      &init_##register_class##_##name)
 341 #else
 342 #define INITIALIZE_REGISTER(register_class, name, code, size, type) \
 343   extern const register_class& name
 344 #define ALIAS_REGISTER(register_class, alias, name) \
 345   extern const register_class& alias
 346 #endif  // defined(ARM64_DEFINE_REG_STATICS)
 347
 348 // No*Reg is used to indicate an unused argument, or an error case. Note that
 349 // these all compare equal (using the Is() method). The Register and FPRegister
 350 // variants are provided for convenience.
 351 INITIALIZE_REGISTER(Register, NoReg, 0, 0, CPURegister::kNoRegister);
 352 INITIALIZE_REGISTER(FPRegister, NoFPReg, 0, 0, CPURegister::kNoRegister);
 353 INITIALIZE_REGISTER(CPURegister, NoCPUReg, 0, 0, CPURegister::kNoRegister);
 354
 355 // v8 compatibility.
 356 INITIALIZE_REGISTER(Register, no_reg, 0, 0, CPURegister::kNoRegister);
 357
 358 #define DEFINE_REGISTERS(N)                                                  \
 359   INITIALIZE_REGISTER(Register, w##N, N,                                     \
 360                       kWRegSizeInBits, CPURegister::kRegister);              \
 361   INITIALIZE_REGISTER(Register, x##N, N,                                     \
 362                       kXRegSizeInBits, CPURegister::kRegister);
 363 REGISTER_CODE_LIST(DEFINE_REGISTERS)
 364 #undef DEFINE_REGISTERS
 365
 366 INITIALIZE_REGISTER(Register, wcsp, kSPRegInternalCode, kWRegSizeInBits,
 367                     CPURegister::kRegister);
 368 INITIALIZE_REGISTER(Register, csp, kSPRegInternalCode, kXRegSizeInBits,
 369                     CPURegister::kRegister);
 370
 371 #define DEFINE_FPREGISTERS(N)                                                  \
 372   INITIALIZE_REGISTER(FPRegister, s##N, N,                                     \
 373                       kSRegSizeInBits, CPURegister::kFPRegister);              \
 374   INITIALIZE_REGISTER(FPRegister, d##N, N,                                     \
 375                       kDRegSizeInBits, CPURegister::kFPRegister);
 376 REGISTER_CODE_LIST(DEFINE_FPREGISTERS)
 377 #undef DEFINE_FPREGISTERS
 378
 379 #undef INITIALIZE_REGISTER
 380
 381 // Registers aliases.
 382 ALIAS_REGISTER(Register, ip0, x16);
 383 ALIAS_REGISTER(Register, ip1, x17);
 384 ALIAS_REGISTER(Register, wip0, w16);
 385 ALIAS_REGISTER(Register, wip1, w17);
 386 // Root register.
 387 ALIAS_REGISTER(Register, root, x26);
 388 ALIAS_REGISTER(Register, rr, x26);
 389 // Context pointer register.
 390 ALIAS_REGISTER(Register, cp, x27);
 391 // We use a register as a JS stack pointer to overcome the restriction on the
 392 // architectural SP alignment.
 393 // We chose x28 because it is contiguous with the other specific purpose
 394 // registers.
 395 STATIC_ASSERT(kJSSPCode == 28);
 396 ALIAS_REGISTER(Register, jssp, x28);
 397 ALIAS_REGISTER(Register, wjssp, w28);
 398 ALIAS_REGISTER(Register, fp, x29);
 399 ALIAS_REGISTER(Register, lr, x30);
 400 ALIAS_REGISTER(Register, xzr, x31);
 401 ALIAS_REGISTER(Register, wzr, w31);
 402
 403 // Keeps the 0 double value.
 404 ALIAS_REGISTER(FPRegister, fp_zero, d15);
 405 // Crankshaft double scratch register.
 406 ALIAS_REGISTER(FPRegister, crankshaft_fp_scratch, d29);
 407 // MacroAssembler double scratch registers.
 408 ALIAS_REGISTER(FPRegister, fp_scratch, d30);
 409 ALIAS_REGISTER(FPRegister, fp_scratch1, d30);
 410 ALIAS_REGISTER(FPRegister, fp_scratch2, d31);
 411
 412 #undef ALIAS_REGISTER
 413
 414
 415 Register GetAllocatableRegisterThatIsNotOneOf(Register reg1,
 416                                               Register reg2 = NoReg,
 417                                               Register reg3 = NoReg,
 418                                               Register reg4 = NoReg);
 419
 420
 421 // AreAliased returns true if any of the named registers overlap. Arguments set
 422 // to NoReg are ignored. The system stack pointer may be specified.
 423 bool AreAliased(const CPURegister& reg1,
 424                 const CPURegister& reg2,
 425                 const CPURegister& reg3 = NoReg,
 426                 const CPURegister& reg4 = NoReg,
 427                 const CPURegister& reg5 = NoReg,
 428                 const CPURegister& reg6 = NoReg,
 429                 const CPURegister& reg7 = NoReg,
 430                 const CPURegister& reg8 = NoReg);
 431
 432 // AreSameSizeAndType returns true if all of the specified registers have the
 433 // same size, and are of the same type. The system stack pointer may be
 434 // specified. Arguments set to NoReg are ignored, as are any subsequent
 435 // arguments. At least one argument (reg1) must be valid (not NoCPUReg).
 436 bool AreSameSizeAndType(const CPURegister& reg1,
 437                         const CPURegister& reg2,
 438                         const CPURegister& reg3 = NoCPUReg,
 439                         const CPURegister& reg4 = NoCPUReg,
 440                         const CPURegister& reg5 = NoCPUReg,
 441                         const CPURegister& reg6 = NoCPUReg,
 442                         const CPURegister& reg7 = NoCPUReg,
 443                         const CPURegister& reg8 = NoCPUReg);
 444
 445
 446 typedef FPRegister DoubleRegister;
 447
 448
 449 // -----------------------------------------------------------------------------
 450 // Lists of registers.
 451 class CPURegList {
 452  public:
 453   explicit CPURegList(CPURegister reg1,
 454                       CPURegister reg2 = NoCPUReg,
 455                       CPURegister reg3 = NoCPUReg,
 456                       CPURegister reg4 = NoCPUReg)
 457       : list_(reg1.Bit() | reg2.Bit() | reg3.Bit() | reg4.Bit()),
 458         size_(reg1.SizeInBits()), type_(reg1.type()) {
 459     DCHECK(AreSameSizeAndType(reg1, reg2, reg3, reg4));
 460     DCHECK(IsValid());
 461   }
 462
 463   CPURegList(CPURegister::RegisterType type, unsigned size, RegList list)
 464       : list_(list), size_(size), type_(type) {
 465     DCHECK(IsValid());
 466   }
 467
 468   CPURegList(CPURegister::RegisterType type, unsigned size,
 469              unsigned first_reg, unsigned last_reg)
 470       : size_(size), type_(type) {
 471     DCHECK(((type == CPURegister::kRegister) &&
 472             (last_reg < kNumberOfRegisters)) ||
 473            ((type == CPURegister::kFPRegister) &&
 474             (last_reg < kNumberOfFPRegisters)));
 475     DCHECK(last_reg >= first_reg);
 476     list_ = (1UL << (last_reg + 1)) - 1;
 477     list_ &= ~((1UL << first_reg) - 1);
 478     DCHECK(IsValid());
 479   }
 480
 481   CPURegister::RegisterType type() const {
 482     DCHECK(IsValid());
 483     return type_;
 484   }
 485
 486   RegList list() const {
 487     DCHECK(IsValid());
 488     return list_;
 489   }
 490
 491   inline void set_list(RegList new_list) {
 492     DCHECK(IsValid());
 493     list_ = new_list;
 494   }
 495
 496   // Combine another CPURegList into this one. Registers that already exist in
 497   // this list are left unchanged. The type and size of the registers in the
 498   // 'other' list must match those in this list.
 499   void Combine(const CPURegList& other);
 500
 501   // Remove every register in the other CPURegList from this one. Registers that
 502   // do not exist in this list are ignored. The type of the registers in the
 503   // 'other' list must match those in this list.
 504   void Remove(const CPURegList& other);
 505
 506   // Variants of Combine and Remove which take CPURegisters.
 507   void Combine(const CPURegister& other);
 508   void Remove(const CPURegister& other1,
 509               const CPURegister& other2 = NoCPUReg,
 510               const CPURegister& other3 = NoCPUReg,
 511               const CPURegister& other4 = NoCPUReg);
 512
 513   // Variants of Combine and Remove which take a single register by its code;
 514   // the type and size of the register is inferred from this list.
 515   void Combine(int code);
 516   void Remove(int code);
 517
 518   // Remove all callee-saved registers from the list. This can be useful when
 519   // preparing registers for an AAPCS64 function call, for example.
 520   void RemoveCalleeSaved();
 521
 522   CPURegister PopLowestIndex();
 523   CPURegister PopHighestIndex();
 524
 525   // AAPCS64 callee-saved registers.
 526   static CPURegList GetCalleeSaved(unsigned size = kXRegSizeInBits);
 527   static CPURegList GetCalleeSavedFP(unsigned size = kDRegSizeInBits);
 528
 529   // AAPCS64 caller-saved registers. Note that this includes lr.
 530   static CPURegList GetCallerSaved(unsigned size = kXRegSizeInBits);
 531   static CPURegList GetCallerSavedFP(unsigned size = kDRegSizeInBits);
 532
 533   // Registers saved as safepoints.
 534   static CPURegList GetSafepointSavedRegisters();
 535
 536   bool IsEmpty() const {
 537     DCHECK(IsValid());
 538     return list_ == 0;
 539   }
 540
 541   bool IncludesAliasOf(const CPURegister& other1,
 542                        const CPURegister& other2 = NoCPUReg,
 543                        const CPURegister& other3 = NoCPUReg,
 544                        const CPURegister& other4 = NoCPUReg) const {
 545     DCHECK(IsValid());
 546     RegList list = 0;
 547     if (!other1.IsNone() && (other1.type() == type_)) list |= other1.Bit();
 548     if (!other2.IsNone() && (other2.type() == type_)) list |= other2.Bit();
 549     if (!other3.IsNone() && (other3.type() == type_)) list |= other3.Bit();
 550     if (!other4.IsNone() && (other4.type() == type_)) list |= other4.Bit();
 551     return (list_ & list) != 0;
 552   }
 553
 554   int Count() const {
 555     DCHECK(IsValid());
 556     return CountSetBits(list_, kRegListSizeInBits);
 557   }
 558
 559   unsigned RegisterSizeInBits() const {
 560     DCHECK(IsValid());
 561     return size_;
 562   }
 563
 564   unsigned RegisterSizeInBytes() const {
 565     int size_in_bits = RegisterSizeInBits();
 566     DCHECK((size_in_bits % kBitsPerByte) == 0);
 567     return size_in_bits / kBitsPerByte;
 568   }
 569
 570   unsigned TotalSizeInBytes() const {
 571     DCHECK(IsValid());
 572     return RegisterSizeInBytes() * Count();
 573   }
 574
 575  private:
 576   RegList list_;
 577   unsigned size_;
 578   CPURegister::RegisterType type_;
 579
 580   bool IsValid() const {
 581     const RegList kValidRegisters = 0x8000000ffffffff;
 582     const RegList kValidFPRegisters = 0x0000000ffffffff;
 583     switch (type_) {
 584       case CPURegister::kRegister:
 585         return (list_ & kValidRegisters) == list_;
 586       case CPURegister::kFPRegister:
 587         return (list_ & kValidFPRegisters) == list_;
 588       case CPURegister::kNoRegister:
 589         return list_ == 0;
 590       default:
 591         UNREACHABLE();
 592         return false;
 593     }
 594   }
 595 };
 596
 597
 598 // AAPCS64 callee-saved registers.
 599 #define kCalleeSaved CPURegList::GetCalleeSaved()
 600 #define kCalleeSavedFP CPURegList::GetCalleeSavedFP()
 601
 602
 603 // AAPCS64 caller-saved registers. Note that this includes lr.
 604 #define kCallerSaved CPURegList::GetCallerSaved()
 605 #define kCallerSavedFP CPURegList::GetCallerSavedFP()
 606
 607 // -----------------------------------------------------------------------------
 608 // Immediates.
 609 class Immediate {
 610  public:
 611   template<typename T>
 612   inline explicit Immediate(Handle<T> handle);
 613
 614   // This is allowed to be an implicit constructor because Immediate is
 615   // a wrapper class that doesn't normally perform any type conversion.
 616   template<typename T>
 617   inline Immediate(T value);  // NOLINT(runtime/explicit)
 618
 619   template<typename T>
 620   inline Immediate(T value, RelocInfo::Mode rmode);
 621
 622   int64_t value() const { return value_; }
 623   RelocInfo::Mode rmode() const { return rmode_; }
 624
 625  private:
 626   void InitializeHandle(Handle<Object> value);
 627
 628   int64_t value_;
 629   RelocInfo::Mode rmode_;
 630 };
 631
 632
 633 // -----------------------------------------------------------------------------
 634 // Operands.
 635 const int kSmiShift = kSmiTagSize + kSmiShiftSize;
 636 const uint64_t kSmiShiftMask = (1UL << kSmiShift) - 1;
 637
 638 // Represents an operand in a machine instruction.
 639 class Operand {
 640   // TODO(all): If necessary, study more in details which methods
 641   // TODO(all): should be inlined or not.
 642  public:
 643   // rm, {<shift> {#<shift_amount>}}
 644   // where <shift> is one of {LSL, LSR, ASR, ROR}.
 645   //       <shift_amount> is uint6_t.
 646   // This is allowed to be an implicit constructor because Operand is
 647   // a wrapper class that doesn't normally perform any type conversion.
 648   inline Operand(Register reg,
 649                  Shift shift = LSL,
 650                  unsigned shift_amount = 0);  // NOLINT(runtime/explicit)
 651
 652   // rm, <extend> {#<shift_amount>}
 653   // where <extend> is one of {UXTB, UXTH, UXTW, UXTX, SXTB, SXTH, SXTW, SXTX}.
 654   //       <shift_amount> is uint2_t.
 655   inline Operand(Register reg,
 656                  Extend extend,
 657                  unsigned shift_amount = 0);
 658
 659   template<typename T>
 660   inline explicit Operand(Handle<T> handle);
 661
 662   // Implicit constructor for all int types, ExternalReference, and Smi.
 663   template<typename T>
 664   inline Operand(T t);  // NOLINT(runtime/explicit)
 665
 666   // Implicit constructor for int types.
 667   template<typename T>
 668   inline Operand(T t, RelocInfo::Mode rmode);
 669
 670   inline bool IsImmediate() const;
 671   inline bool IsShiftedRegister() const;
 672   inline bool IsExtendedRegister() const;
 673   inline bool IsZero() const;
 674
 675   // This returns an LSL shift (<= 4) operand as an equivalent extend operand,
 676   // which helps in the encoding of instructions that use the stack pointer.
 677   inline Operand ToExtendedRegister() const;
 678
 679   inline Immediate immediate() const;
 680   inline int64_t ImmediateValue() const;
 681   inline Register reg() const;
 682   inline Shift shift() const;
 683   inline Extend extend() const;
 684   inline unsigned shift_amount() const;
 685
 686   // Relocation information.
 687   bool NeedsRelocation(const Assembler* assembler) const;
 688
 689   // Helpers
 690   inline static Operand UntagSmi(Register smi);
 691   inline static Operand UntagSmiAndScale(Register smi, int scale);
 692
 693  private:
 694   Immediate immediate_;
 695   Register reg_;
 696   Shift shift_;
 697   Extend extend_;
 698   unsigned shift_amount_;
 699 };
 700
 701
 702 // MemOperand represents a memory operand in a load or store instruction.
 703 class MemOperand {
 704  public:
 705   inline MemOperand();
 706   inline explicit MemOperand(Register base,
 707                              int64_t offset = 0,
 708                              AddrMode addrmode = Offset);
 709   inline explicit MemOperand(Register base,
 710                              Register regoffset,
 711                              Shift shift = LSL,
 712                              unsigned shift_amount = 0);
 713   inline explicit MemOperand(Register base,
 714                              Register regoffset,
 715                              Extend extend,
 716                              unsigned shift_amount = 0);
 717   inline explicit MemOperand(Register base,
 718                              const Operand& offset,
 719                              AddrMode addrmode = Offset);
 720
 721   const Register& base() const { return base_; }
 722   const Register& regoffset() const { return regoffset_; }
 723   int64_t offset() const { return offset_; }
 724   AddrMode addrmode() const { return addrmode_; }
 725   Shift shift() const { return shift_; }
 726   Extend extend() const { return extend_; }
 727   unsigned shift_amount() const { return shift_amount_; }
 728   inline bool IsImmediateOffset() const;
 729   inline bool IsRegisterOffset() const;
 730   inline bool IsPreIndex() const;
 731   inline bool IsPostIndex() const;
 732
 733   // For offset modes, return the offset as an Operand. This helper cannot
 734   // handle indexed modes.
 735   inline Operand OffsetAsOperand() const;
 736
 737   enum PairResult {
 738     kNotPair,   // Can't use a pair instruction.
 739     kPairAB,    // Can use a pair instruction (operandA has lower address).
 740     kPairBA     // Can use a pair instruction (operandB has lower address).
 741   };
 742   // Check if two MemOperand are consistent for stp/ldp use.
 743   static PairResult AreConsistentForPair(const MemOperand& operandA,
 744                                          const MemOperand& operandB,
 745                                          int access_size_log2 = kXRegSizeLog2);
 746
 747  private:
 748   Register base_;
 749   Register regoffset_;
 750   int64_t offset_;
 751   AddrMode addrmode_;
 752   Shift shift_;
 753   Extend extend_;
 754   unsigned shift_amount_;
 755 };
 756
 757
 758 class ConstPool {
 759  public:
 760   explicit ConstPool(Assembler* assm)
 761       : assm_(assm),
 762         first_use_(-1),
 763         shared_entries_count(0) {}
 764   void RecordEntry(intptr_t data, RelocInfo::Mode mode);
 765   int EntryCount() const {
 766     return shared_entries_count + unique_entries_.size();
 767   }
 768   bool IsEmpty() const {
 769     return shared_entries_.empty() && unique_entries_.empty();
 770   }
 771   // Distance in bytes between the current pc and the first instruction
 772   // using the pool. If there are no pending entries return kMaxInt.
 773   int DistanceToFirstUse();
 774   // Offset after which instructions using the pool will be out of range.
 775   int MaxPcOffset();
 776   // Maximum size the constant pool can be with current entries. It always
 777   // includes alignment padding and branch over.
 778   int WorstCaseSize();
 779   // Size in bytes of the literal pool *if* it is emitted at the current
 780   // pc. The size will include the branch over the pool if it was requested.
 781   int SizeIfEmittedAtCurrentPc(bool require_jump);
 782   // Emit the literal pool at the current pc with a branch over the pool if
 783   // requested.
 784   void Emit(bool require_jump);
 785   // Discard any pending pool entries.
 786   void Clear();
 787
 788  private:
 789   bool CanBeShared(RelocInfo::Mode mode);
 790   void EmitMarker();
 791   void EmitGuard();
 792   void EmitEntries();
 793
 794   Assembler* assm_;
 795   // Keep track of the first instruction requiring a constant pool entry
 796   // since the previous constant pool was emitted.
 797   int first_use_;
 798   // values, pc offset(s) of entries which can be shared.
 799   std::multimap<uint64_t, int> shared_entries_;
 800   // Number of distinct literal in shared entries.
 801   int shared_entries_count;
 802   // values, pc offset of entries which cannot be shared.
 803   std::vector<std::pair<uint64_t, int> > unique_entries_;
 804 };
 805
 806
 807 // -----------------------------------------------------------------------------
 808 // Assembler.
 809
 810 class Assembler : public AssemblerBase {
 811  public:
 812   // Create an assembler. Instructions and relocation information are emitted
 813   // into a buffer, with the instructions starting from the beginning and the
 814   // relocation information starting from the end of the buffer. See CodeDesc
 815   // for a detailed comment on the layout (globals.h).
 816   //
 817   // If the provided buffer is NULL, the assembler allocates and grows its own
 818   // buffer, and buffer_size determines the initial buffer size. The buffer is
 819   // owned by the assembler and deallocated upon destruction of the assembler.
 820   //
 821   // If the provided buffer is not NULL, the assembler uses the provided buffer
 822   // for code generation and assumes its size to be buffer_size. If the buffer
 823   // is too small, a fatal error occurs. No deallocation of the buffer is done
 824   // upon destruction of the assembler.
 825   Assembler(Isolate* arg_isolate, void* buffer, int buffer_size);
 826
 827   virtual ~Assembler();
 828
 829   virtual void AbortedCodeGeneration() {
 830     constpool_.Clear();
 831   }
 832
 833   // System functions ---------------------------------------------------------
 834   // Start generating code from the beginning of the buffer, discarding any code
 835   // and data that has already been emitted into the buffer.
 836   //
 837   // In order to avoid any accidental transfer of state, Reset DCHECKs that the
 838   // constant pool is not blocked.
 839   void Reset();
 840
 841   // GetCode emits any pending (non-emitted) code and fills the descriptor
 842   // desc. GetCode() is idempotent; it returns the same result if no other
 843   // Assembler functions are invoked in between GetCode() calls.
 844   //
 845   // The descriptor (desc) can be NULL. In that case, the code is finalized as
 846   // usual, but the descriptor is not populated.
 847   void GetCode(CodeDesc* desc);
 848
 849   // Insert the smallest number of nop instructions
 850   // possible to align the pc offset to a multiple
 851   // of m. m must be a power of 2 (>= 4).
 852   void Align(int m);
 853
 854   inline void Unreachable();
 855
 856   // Label --------------------------------------------------------------------
 857   // Bind a label to the current pc. Note that labels can only be bound once,
 858   // and if labels are linked to other instructions, they _must_ be bound
 859   // before they go out of scope.
 860   void bind(Label* label);
 861
 862
 863   // RelocInfo and pools ------------------------------------------------------
 864
 865   // Record relocation information for current pc_.
 866   void RecordRelocInfo(RelocInfo::Mode rmode, intptr_t data = 0);
 867
 868   // Return the address in the constant pool of the code target address used by
 869   // the branch/call instruction at pc.
 870   inline static Address target_pointer_address_at(Address pc);
 871
 872   // Read/Modify the code target address in the branch/call instruction at pc.
 873   inline static Address target_address_at(Address pc,
 874                                           ConstantPoolArray* constant_pool);
 875   inline static void set_target_address_at(Address pc,
 876                                            ConstantPoolArray* constant_pool,
 877                                            Address target,
 878                                            ICacheFlushMode icache_flush_mode =
 879                                                FLUSH_ICACHE_IF_NEEDED);
 880   static inline Address target_address_at(Address pc, Code* code);
 881   static inline void set_target_address_at(Address pc,
 882                                            Code* code,
 883                                            Address target,
 884                                            ICacheFlushMode icache_flush_mode =
 885                                                FLUSH_ICACHE_IF_NEEDED);
 886
 887   // Return the code target address at a call site from the return address of
 888   // that call in the instruction stream.
 889   inline static Address target_address_from_return_address(Address pc);
 890
 891   // Given the address of the beginning of a call, return the address in the
 892   // instruction stream that call will return from.
 893   inline static Address return_address_from_call_start(Address pc);
 894
 895   // Return the code target address of the patch debug break slot
 896   inline static Address break_address_from_return_address(Address pc);
 897
 898   // This sets the branch destination (which is in the constant pool on ARM).
 899   // This is for calls and branches within generated code.
 900   inline static void deserialization_set_special_target_at(
 901       Address constant_pool_entry, Code* code, Address target);
 902
 903   // All addresses in the constant pool are the same size as pointers.
 904   static const int kSpecialTargetSize = kPointerSize;
 905
 906   // The sizes of the call sequences emitted by MacroAssembler::Call.
 907   // Wherever possible, use MacroAssembler::CallSize instead of these constants,
 908   // as it will choose the correct value for a given relocation mode.
 909   //
 910   // Without relocation:
 911   //  movz  temp, #(target & 0x000000000000ffff)
 912   //  movk  temp, #(target & 0x00000000ffff0000)
 913   //  movk  temp, #(target & 0x0000ffff00000000)
 914   //  blr   temp
 915   //
 916   // With relocation:
 917   //  ldr   temp, =target
 918   //  blr   temp
 919   static const int kCallSizeWithoutRelocation = 4 * kInstructionSize;
 920   static const int kCallSizeWithRelocation = 2 * kInstructionSize;
 921
 922   // Size of the generated code in bytes
 923   uint64_t SizeOfGeneratedCode() const {
 924     DCHECK((pc_ >= buffer_) && (pc_ < (buffer_ + buffer_size_)));
 925     return pc_ - buffer_;
 926   }
 927
 928   // Return the code size generated from label to the current position.
 929   uint64_t SizeOfCodeGeneratedSince(const Label* label) {
 930     DCHECK(label->is_bound());
 931     DCHECK(pc_offset() >= label->pos());
 932     DCHECK(pc_offset() < buffer_size_);
 933     return pc_offset() - label->pos();
 934   }
 935
 936   // Check the size of the code generated since the given label. This function
 937   // is used primarily to work around comparisons between signed and unsigned
 938   // quantities, since V8 uses both.
 939   // TODO(jbramley): Work out what sign to use for these things and if possible,
 940   // change things to be consistent.
 941   void AssertSizeOfCodeGeneratedSince(const Label* label, ptrdiff_t size) {
 942     DCHECK(size >= 0);
 943     DCHECK(static_cast<uint64_t>(size) == SizeOfCodeGeneratedSince(label));
 944   }
 945
 946   // Return the number of instructions generated from label to the
 947   // current position.
 948   int InstructionsGeneratedSince(const Label* label) {
 949     return SizeOfCodeGeneratedSince(label) / kInstructionSize;
 950   }
 951
 952   // Number of instructions generated for the return sequence in
 953   // FullCodeGenerator::EmitReturnSequence.
 954   static const int kJSRetSequenceInstructions = 7;
 955   // Distance between start of patched return sequence and the emitted address
 956   // to jump to.
 957   static const int kPatchReturnSequenceAddressOffset =  0;
 958   static const int kPatchDebugBreakSlotAddressOffset =  0;
 959
 960   // Number of instructions necessary to be able to later patch it to a call.
 961   // See DebugCodegen::GenerateSlot() and
 962   // BreakLocationIterator::SetDebugBreakAtSlot().
 963   static const int kDebugBreakSlotInstructions = 4;
 964   static const int kDebugBreakSlotLength =
 965     kDebugBreakSlotInstructions * kInstructionSize;
 966
 967   static const int kPatchDebugBreakSlotReturnOffset = 2 * kInstructionSize;
 968
 969   // Prevent contant pool emission until EndBlockConstPool is called.
 970   // Call to this function can be nested but must be followed by an equal
 971   // number of call to EndBlockConstpool.
 972   void StartBlockConstPool();
 973
 974   // Resume constant pool emission. Need to be called as many time as
 975   // StartBlockConstPool to have an effect.
 976   void EndBlockConstPool();
 977
 978   bool is_const_pool_blocked() const;
 979   static bool IsConstantPoolAt(Instruction* instr);
 980   static int ConstantPoolSizeAt(Instruction* instr);
 981   // See Assembler::CheckConstPool for more info.
 982   void EmitPoolGuard();
 983
 984   // Prevent veneer pool emission until EndBlockVeneerPool is called.
 985   // Call to this function can be nested but must be followed by an equal
 986   // number of call to EndBlockConstpool.
 987   void StartBlockVeneerPool();
 988
 989   // Resume constant pool emission. Need to be called as many time as
 990   // StartBlockVeneerPool to have an effect.
 991   void EndBlockVeneerPool();
 992
 993   bool is_veneer_pool_blocked() const {
 994     return veneer_pool_blocked_nesting_ > 0;
 995   }
 996
 997   // Block/resume emission of constant pools and veneer pools.
 998   void StartBlockPools() {
 999     StartBlockConstPool();
1000     StartBlockVeneerPool();
1001   }
1002   void EndBlockPools() {
1003     EndBlockConstPool();
1004     EndBlockVeneerPool();
1005   }
1006
1007   // Debugging ----------------------------------------------------------------
1008   PositionsRecorder* positions_recorder() { return &positions_recorder_; }
1009   void RecordComment(const char* msg);
1010
1011   // Record a deoptimization reason that can be used by a log or cpu profiler.
1012   // Use --trace-deopt to enable.
1013   void RecordDeoptReason(const int reason, const int raw_position);
1014
1015   int buffer_space() const;
1016
1017   // Mark address of the ExitJSFrame code.
1018   void RecordJSReturn();
1019
1020   // Mark address of a debug break slot.
1021   void RecordDebugBreakSlot();
1022
1023   // Record the emission of a constant pool.
1024   //
1025   // The emission of constant and veneer pools depends on the size of the code
1026   // generated and the number of RelocInfo recorded.
1027   // The Debug mechanism needs to map code offsets between two versions of a
1028   // function, compiled with and without debugger support (see for example
1029   // Debug::PrepareForBreakPoints()).
1030   // Compiling functions with debugger support generates additional code
1031   // (DebugCodegen::GenerateSlot()). This may affect the emission of the pools
1032   // and cause the version of the code with debugger support to have pools
1033   // generated in different places.
1034   // Recording the position and size of emitted pools allows to correctly
1035   // compute the offset mappings between the different versions of a function in
1036   // all situations.
1037   //
1038   // The parameter indicates the size of the pool (in bytes), including
1039   // the marker and branch over the data.
1040   void RecordConstPool(int size);
1041
1042
1043   // Instruction set functions ------------------------------------------------
1044
1045   // Branch / Jump instructions.
1046   // For branches offsets are scaled, i.e. they in instrcutions not in bytes.
1047   // Branch to register.
1048   void br(const Register& xn);
1049
1050   // Branch-link to register.
1051   void blr(const Register& xn);
1052
1053   // Branch to register with return hint.
1054   void ret(const Register& xn = lr);
1055
1056   // Unconditional branch to label.
1057   void b(Label* label);
1058
1059   // Conditional branch to label.
1060   void b(Label* label, Condition cond);
1061
1062   // Unconditional branch to PC offset.
1063   void b(int imm26);
1064
1065   // Conditional branch to PC offset.
1066   void b(int imm19, Condition cond);
1067
1068   // Branch-link to label / pc offset.
1069   void bl(Label* label);
1070   void bl(int imm26);
1071
1072   // Compare and branch to label / pc offset if zero.
1073   void cbz(const Register& rt, Label* label);
1074   void cbz(const Register& rt, int imm19);
1075
1076   // Compare and branch to label / pc offset if not zero.
1077   void cbnz(const Register& rt, Label* label);
1078   void cbnz(const Register& rt, int imm19);
1079
1080   // Test bit and branch to label / pc offset if zero.
1081   void tbz(const Register& rt, unsigned bit_pos, Label* label);
1082   void tbz(const Register& rt, unsigned bit_pos, int imm14);
1083
1084   // Test bit and branch to label / pc offset if not zero.
1085   void tbnz(const Register& rt, unsigned bit_pos, Label* label);
1086   void tbnz(const Register& rt, unsigned bit_pos, int imm14);
1087
1088   // Address calculation instructions.
1089   // Calculate a PC-relative address. Unlike for branches the offset in adr is
1090   // unscaled (i.e. the result can be unaligned).
1091   void adr(const Register& rd, Label* label);
1092   void adr(const Register& rd, int imm21);
1093
1094   // Data Processing instructions.
1095   // Add.
1096   void add(const Register& rd,
1097            const Register& rn,
1098            const Operand& operand);
1099
1100   // Add and update status flags.
1101   void adds(const Register& rd,
1102             const Register& rn,
1103             const Operand& operand);
1104
1105   // Compare negative.
1106   void cmn(const Register& rn, const Operand& operand);
1107
1108   // Subtract.
1109   void sub(const Register& rd,
1110            const Register& rn,
1111            const Operand& operand);
1112
1113   // Subtract and update status flags.
1114   void subs(const Register& rd,
1115             const Register& rn,
1116             const Operand& operand);
1117
1118   // Compare.
1119   void cmp(const Register& rn, const Operand& operand);
1120
1121   // Negate.
1122   void neg(const Register& rd,
1123            const Operand& operand);
1124
1125   // Negate and update status flags.
1126   void negs(const Register& rd,
1127             const Operand& operand);
1128
1129   // Add with carry bit.
1130   void adc(const Register& rd,
1131            const Register& rn,
1132            const Operand& operand);
1133
1134   // Add with carry bit and update status flags.
1135   void adcs(const Register& rd,
1136             const Register& rn,
1137             const Operand& operand);
1138
1139   // Subtract with carry bit.
1140   void sbc(const Register& rd,
1141            const Register& rn,
1142            const Operand& operand);
1143
1144   // Subtract with carry bit and update status flags.
1145   void sbcs(const Register& rd,
1146             const Register& rn,
1147             const Operand& operand);
1148
1149   // Negate with carry bit.
1150   void ngc(const Register& rd,
1151            const Operand& operand);
1152
1153   // Negate with carry bit and update status flags.
1154   void ngcs(const Register& rd,
1155             const Operand& operand);
1156
1157   // Logical instructions.
1158   // Bitwise and (A & B).
1159   void and_(const Register& rd,
1160             const Register& rn,
1161             const Operand& operand);
1162
1163   // Bitwise and (A & B) and update status flags.
1164   void ands(const Register& rd,
1165             const Register& rn,
1166             const Operand& operand);
1167
1168   // Bit test, and set flags.
1169   void tst(const Register& rn, const Operand& operand);
1170
1171   // Bit clear (A & ~B).
1172   void bic(const Register& rd,
1173            const Register& rn,
1174            const Operand& operand);
1175
1176   // Bit clear (A & ~B) and update status flags.
1177   void bics(const Register& rd,
1178             const Register& rn,
1179             const Operand& operand);
1180
1181   // Bitwise or (A | B).
1182   void orr(const Register& rd, const Register& rn, const Operand& operand);
1183
1184   // Bitwise nor (A | ~B).
1185   void orn(const Register& rd, const Register& rn, const Operand& operand);
1186
1187   // Bitwise eor/xor (A ^ B).
1188   void eor(const Register& rd, const Register& rn, const Operand& operand);
1189
1190   // Bitwise enor/xnor (A ^ ~B).
1191   void eon(const Register& rd, const Register& rn, const Operand& operand);
1192
1193   // Logical shift left variable.
1194   void lslv(const Register& rd, const Register& rn, const Register& rm);
1195
1196   // Logical shift right variable.
1197   void lsrv(const Register& rd, const Register& rn, const Register& rm);
1198
1199   // Arithmetic shift right variable.
1200   void asrv(const Register& rd, const Register& rn, const Register& rm);
1201
1202   // Rotate right variable.
1203   void rorv(const Register& rd, const Register& rn, const Register& rm);
1204
1205   // Bitfield instructions.
1206   // Bitfield move.
1207   void bfm(const Register& rd,
1208            const Register& rn,
1209            unsigned immr,
1210            unsigned imms);
1211
1212   // Signed bitfield move.
1213   void sbfm(const Register& rd,
1214             const Register& rn,
1215             unsigned immr,
1216             unsigned imms);
1217
1218   // Unsigned bitfield move.
1219   void ubfm(const Register& rd,
1220             const Register& rn,
1221             unsigned immr,
1222             unsigned imms);
1223
1224   // Bfm aliases.
1225   // Bitfield insert.
1226   void bfi(const Register& rd,
1227            const Register& rn,
1228            unsigned lsb,
1229            unsigned width) {
1230     DCHECK(width >= 1);
1231     DCHECK(lsb + width <= rn.SizeInBits());
1232     bfm(rd, rn, (rd.SizeInBits() - lsb) & (rd.SizeInBits() - 1), width - 1);
1233   }
1234
1235   // Bitfield extract and insert low.
1236   void bfxil(const Register& rd,
1237              const Register& rn,
1238              unsigned lsb,
1239              unsigned width) {
1240     DCHECK(width >= 1);
1241     DCHECK(lsb + width <= rn.SizeInBits());
1242     bfm(rd, rn, lsb, lsb + width - 1);
1243   }
1244
1245   // Sbfm aliases.
1246   // Arithmetic shift right.
1247   void asr(const Register& rd, const Register& rn, unsigned shift) {
1248     DCHECK(shift < rd.SizeInBits());
1249     sbfm(rd, rn, shift, rd.SizeInBits() - 1);
1250   }
1251
1252   // Signed bitfield insert in zero.
1253   void sbfiz(const Register& rd,
1254              const Register& rn,
1255              unsigned lsb,
1256              unsigned width) {
1257     DCHECK(width >= 1);
1258     DCHECK(lsb + width <= rn.SizeInBits());
1259     sbfm(rd, rn, (rd.SizeInBits() - lsb) & (rd.SizeInBits() - 1), width - 1);
1260   }
1261
1262   // Signed bitfield extract.
1263   void sbfx(const Register& rd,
1264             const Register& rn,
1265             unsigned lsb,
1266             unsigned width) {
1267     DCHECK(width >= 1);
1268     DCHECK(lsb + width <= rn.SizeInBits());
1269     sbfm(rd, rn, lsb, lsb + width - 1);
1270   }
1271
1272   // Signed extend byte.
1273   void sxtb(const Register& rd, const Register& rn) {
1274     sbfm(rd, rn, 0, 7);
1275   }
1276
1277   // Signed extend halfword.
1278   void sxth(const Register& rd, const Register& rn) {
1279     sbfm(rd, rn, 0, 15);
1280   }
1281
1282   // Signed extend word.
1283   void sxtw(const Register& rd, const Register& rn) {
1284     sbfm(rd, rn, 0, 31);
1285   }
1286
1287   // Ubfm aliases.
1288   // Logical shift left.
1289   void lsl(const Register& rd, const Register& rn, unsigned shift) {
1290     unsigned reg_size = rd.SizeInBits();
1291     DCHECK(shift < reg_size);
1292     ubfm(rd, rn, (reg_size - shift) % reg_size, reg_size - shift - 1);
1293   }
1294
1295   // Logical shift right.
1296   void lsr(const Register& rd, const Register& rn, unsigned shift) {
1297     DCHECK(shift < rd.SizeInBits());
1298     ubfm(rd, rn, shift, rd.SizeInBits() - 1);
1299   }
1300
1301   // Unsigned bitfield insert in zero.
1302   void ubfiz(const Register& rd,
1303              const Register& rn,
1304              unsigned lsb,
1305              unsigned width) {
1306     DCHECK(width >= 1);
1307     DCHECK(lsb + width <= rn.SizeInBits());
1308     ubfm(rd, rn, (rd.SizeInBits() - lsb) & (rd.SizeInBits() - 1), width - 1);
1309   }
1310
1311   // Unsigned bitfield extract.
1312   void ubfx(const Register& rd,
1313             const Register& rn,
1314             unsigned lsb,
1315             unsigned width) {
1316     DCHECK(width >= 1);
1317     DCHECK(lsb + width <= rn.SizeInBits());
1318     ubfm(rd, rn, lsb, lsb + width - 1);
1319   }
1320
1321   // Unsigned extend byte.
1322   void uxtb(const Register& rd, const Register& rn) {
1323     ubfm(rd, rn, 0, 7);
1324   }
1325
1326   // Unsigned extend halfword.
1327   void uxth(const Register& rd, const Register& rn) {
1328     ubfm(rd, rn, 0, 15);
1329   }
1330
1331   // Unsigned extend word.
1332   void uxtw(const Register& rd, const Register& rn) {
1333     ubfm(rd, rn, 0, 31);
1334   }
1335
1336   // Extract.
1337   void extr(const Register& rd,
1338             const Register& rn,
1339             const Register& rm,
1340             unsigned lsb);
1341
1342   // Conditional select: rd = cond ? rn : rm.
1343   void csel(const Register& rd,
1344             const Register& rn,
1345             const Register& rm,
1346             Condition cond);
1347
1348   // Conditional select increment: rd = cond ? rn : rm + 1.
1349   void csinc(const Register& rd,
1350              const Register& rn,
1351              const Register& rm,
1352              Condition cond);
1353
1354   // Conditional select inversion: rd = cond ? rn : ~rm.
1355   void csinv(const Register& rd,
1356              const Register& rn,
1357              const Register& rm,
1358              Condition cond);
1359
1360   // Conditional select negation: rd = cond ? rn : -rm.
1361   void csneg(const Register& rd,
1362              const Register& rn,
1363              const Register& rm,
1364              Condition cond);
1365
1366   // Conditional set: rd = cond ? 1 : 0.
1367   void cset(const Register& rd, Condition cond);
1368
1369   // Conditional set minus: rd = cond ? -1 : 0.
1370   void csetm(const Register& rd, Condition cond);
1371
1372   // Conditional increment: rd = cond ? rn + 1 : rn.
1373   void cinc(const Register& rd, const Register& rn, Condition cond);
1374
1375   // Conditional invert: rd = cond ? ~rn : rn.
1376   void cinv(const Register& rd, const Register& rn, Condition cond);
1377
1378   // Conditional negate: rd = cond ? -rn : rn.
1379   void cneg(const Register& rd, const Register& rn, Condition cond);
1380
1381   // Extr aliases.
1382   void ror(const Register& rd, const Register& rs, unsigned shift) {
1383     extr(rd, rs, rs, shift);
1384   }
1385
1386   // Conditional comparison.
1387   // Conditional compare negative.
1388   void ccmn(const Register& rn,
1389             const Operand& operand,
1390             StatusFlags nzcv,
1391             Condition cond);
1392
1393   // Conditional compare.
1394   void ccmp(const Register& rn,
1395             const Operand& operand,
1396             StatusFlags nzcv,
1397             Condition cond);
1398
1399   // Multiplication.
1400   // 32 x 32 -> 32-bit and 64 x 64 -> 64-bit multiply.
1401   void mul(const Register& rd, const Register& rn, const Register& rm);
1402
1403   // 32 + 32 x 32 -> 32-bit and 64 + 64 x 64 -> 64-bit multiply accumulate.
1404   void madd(const Register& rd,
1405             const Register& rn,
1406             const Register& rm,
1407             const Register& ra);
1408
1409   // -(32 x 32) -> 32-bit and -(64 x 64) -> 64-bit multiply.
1410   void mneg(const Register& rd, const Register& rn, const Register& rm);
1411
1412   // 32 - 32 x 32 -> 32-bit and 64 - 64 x 64 -> 64-bit multiply subtract.
1413   void msub(const Register& rd,
1414             const Register& rn,
1415             const Register& rm,
1416             const Register& ra);
1417
1418   // 32 x 32 -> 64-bit multiply.
1419   void smull(const Register& rd, const Register& rn, const Register& rm);
1420
1421   // Xd = bits<127:64> of Xn * Xm.
1422   void smulh(const Register& rd, const Register& rn, const Register& rm);
1423
1424   // Signed 32 x 32 -> 64-bit multiply and accumulate.
1425   void smaddl(const Register& rd,
1426               const Register& rn,
1427               const Register& rm,
1428               const Register& ra);
1429
1430   // Unsigned 32 x 32 -> 64-bit multiply and accumulate.
1431   void umaddl(const Register& rd,
1432               const Register& rn,
1433               const Register& rm,
1434               const Register& ra);
1435
1436   // Signed 32 x 32 -> 64-bit multiply and subtract.
1437   void smsubl(const Register& rd,
1438               const Register& rn,
1439               const Register& rm,
1440               const Register& ra);
1441
1442   // Unsigned 32 x 32 -> 64-bit multiply and subtract.
1443   void umsubl(const Register& rd,
1444               const Register& rn,
1445               const Register& rm,
1446               const Register& ra);
1447
1448   // Signed integer divide.
1449   void sdiv(const Register& rd, const Register& rn, const Register& rm);
1450
1451   // Unsigned integer divide.
1452   void udiv(const Register& rd, const Register& rn, const Register& rm);
1453
1454   // Bit count, bit reverse and endian reverse.
1455   void rbit(const Register& rd, const Register& rn);
1456   void rev16(const Register& rd, const Register& rn);
1457   void rev32(const Register& rd, const Register& rn);
1458   void rev(const Register& rd, const Register& rn);
1459   void clz(const Register& rd, const Register& rn);
1460   void cls(const Register& rd, const Register& rn);
1461
1462   // Memory instructions.
1463
1464   // Load integer or FP register.
1465   void ldr(const CPURegister& rt, const MemOperand& src);
1466
1467   // Store integer or FP register.
1468   void str(const CPURegister& rt, const MemOperand& dst);
1469
1470   // Load word with sign extension.
1471   void ldrsw(const Register& rt, const MemOperand& src);
1472
1473   // Load byte.
1474   void ldrb(const Register& rt, const MemOperand& src);
1475
1476   // Store byte.
1477   void strb(const Register& rt, const MemOperand& dst);
1478
1479   // Load byte with sign extension.
1480   void ldrsb(const Register& rt, const MemOperand& src);
1481
1482   // Load half-word.
1483   void ldrh(const Register& rt, const MemOperand& src);
1484
1485   // Store half-word.
1486   void strh(const Register& rt, const MemOperand& dst);
1487
1488   // Load half-word with sign extension.
1489   void ldrsh(const Register& rt, const MemOperand& src);
1490
1491   // Load integer or FP register pair.
1492   void ldp(const CPURegister& rt, const CPURegister& rt2,
1493            const MemOperand& src);
1494
1495   // Store integer or FP register pair.
1496   void stp(const CPURegister& rt, const CPURegister& rt2,
1497            const MemOperand& dst);
1498
1499   // Load word pair with sign extension.
1500   void ldpsw(const Register& rt, const Register& rt2, const MemOperand& src);
1501
1502   // Load integer or FP register pair, non-temporal.
1503   void ldnp(const CPURegister& rt, const CPURegister& rt2,
1504             const MemOperand& src);
1505
1506   // Store integer or FP register pair, non-temporal.
1507   void stnp(const CPURegister& rt, const CPURegister& rt2,
1508             const MemOperand& dst);
1509
1510   // Load literal to register from a pc relative address.
1511   void ldr_pcrel(const CPURegister& rt, int imm19);
1512
1513   // Load literal to register.
1514   void ldr(const CPURegister& rt, const Immediate& imm);
1515
1516   // Move instructions. The default shift of -1 indicates that the move
1517   // instruction will calculate an appropriate 16-bit immediate and left shift
1518   // that is equal to the 64-bit immediate argument. If an explicit left shift
1519   // is specified (0, 16, 32 or 48), the immediate must be a 16-bit value.
1520   //
1521   // For movk, an explicit shift can be used to indicate which half word should
1522   // be overwritten, eg. movk(x0, 0, 0) will overwrite the least-significant
1523   // half word with zero, whereas movk(x0, 0, 48) will overwrite the
1524   // most-significant.
1525
1526   // Move and keep.
1527   void movk(const Register& rd, uint64_t imm, int shift = -1) {
1528     MoveWide(rd, imm, shift, MOVK);
1529   }
1530
1531   // Move with non-zero.
1532   void movn(const Register& rd, uint64_t imm, int shift = -1) {
1533     MoveWide(rd, imm, shift, MOVN);
1534   }
1535
1536   // Move with zero.
1537   void movz(const Register& rd, uint64_t imm, int shift = -1) {
1538     MoveWide(rd, imm, shift, MOVZ);
1539   }
1540
1541   // Misc instructions.
1542   // Monitor debug-mode breakpoint.
1543   void brk(int code);
1544
1545   // Halting debug-mode breakpoint.
1546   void hlt(int code);
1547
1548   // Move register to register.
1549   void mov(const Register& rd, const Register& rn);
1550
1551   // Move NOT(operand) to register.
1552   void mvn(const Register& rd, const Operand& operand);
1553
1554   // System instructions.
1555   // Move to register from system register.
1556   void mrs(const Register& rt, SystemRegister sysreg);
1557
1558   // Move from register to system register.
1559   void msr(SystemRegister sysreg, const Register& rt);
1560
1561   // System hint.
1562   void hint(SystemHint code);
1563
1564   // Data memory barrier
1565   void dmb(BarrierDomain domain, BarrierType type);
1566
1567   // Data synchronization barrier
1568   void dsb(BarrierDomain domain, BarrierType type);
1569
1570   // Instruction synchronization barrier
1571   void isb();
1572
1573   // Alias for system instructions.
1574   void nop() { hint(NOP); }
1575
1576   // Different nop operations are used by the code generator to detect certain
1577   // states of the generated code.
1578   enum NopMarkerTypes {
1579     DEBUG_BREAK_NOP,
1580     INTERRUPT_CODE_NOP,
1581     ADR_FAR_NOP,
1582     FIRST_NOP_MARKER = DEBUG_BREAK_NOP,
1583     LAST_NOP_MARKER = ADR_FAR_NOP
1584   };
1585
1586   void nop(NopMarkerTypes n) {
1587     DCHECK((FIRST_NOP_MARKER <= n) && (n <= LAST_NOP_MARKER));
1588     mov(Register::XRegFromCode(n), Register::XRegFromCode(n));
1589   }
1590
1591   // FP instructions.
1592   // Move immediate to FP register.
1593   void fmov(FPRegister fd, double imm);
1594   void fmov(FPRegister fd, float imm);
1595
1596   // Move FP register to register.
1597   void fmov(Register rd, FPRegister fn);
1598
1599   // Move register to FP register.
1600   void fmov(FPRegister fd, Register rn);
1601
1602   // Move FP register to FP register.
1603   void fmov(FPRegister fd, FPRegister fn);
1604
1605   // FP add.
1606   void fadd(const FPRegister& fd, const FPRegister& fn, const FPRegister& fm);
1607
1608   // FP subtract.
1609   void fsub(const FPRegister& fd, const FPRegister& fn, const FPRegister& fm);
1610
1611   // FP multiply.
1612   void fmul(const FPRegister& fd, const FPRegister& fn, const FPRegister& fm);
1613
1614   // FP fused multiply and add.
1615   void fmadd(const FPRegister& fd,
1616              const FPRegister& fn,
1617              const FPRegister& fm,
1618              const FPRegister& fa);
1619
1620   // FP fused multiply and subtract.
1621   void fmsub(const FPRegister& fd,
1622              const FPRegister& fn,
1623              const FPRegister& fm,
1624              const FPRegister& fa);
1625
1626   // FP fused multiply, add and negate.
1627   void fnmadd(const FPRegister& fd,
1628               const FPRegister& fn,
1629               const FPRegister& fm,
1630               const FPRegister& fa);
1631
1632   // FP fused multiply, subtract and negate.
1633   void fnmsub(const FPRegister& fd,
1634               const FPRegister& fn,
1635               const FPRegister& fm,
1636               const FPRegister& fa);
1637
1638   // FP divide.
1639   void fdiv(const FPRegister& fd, const FPRegister& fn, const FPRegister& fm);
1640
1641   // FP maximum.
1642   void fmax(const FPRegister& fd, const FPRegister& fn, const FPRegister& fm);
1643
1644   // FP minimum.
1645   void fmin(const FPRegister& fd, const FPRegister& fn, const FPRegister& fm);
1646
1647   // FP maximum.
1648   void fmaxnm(const FPRegister& fd, const FPRegister& fn, const FPRegister& fm);
1649
1650   // FP minimum.
1651   void fminnm(const FPRegister& fd, const FPRegister& fn, const FPRegister& fm);
1652
1653   // FP absolute.
1654   void fabs(const FPRegister& fd, const FPRegister& fn);
1655
1656   // FP negate.
1657   void fneg(const FPRegister& fd, const FPRegister& fn);
1658
1659   // FP square root.
1660   void fsqrt(const FPRegister& fd, const FPRegister& fn);
1661
1662   // FP round to integer (nearest with ties to away).
1663   void frinta(const FPRegister& fd, const FPRegister& fn);
1664
1665   // FP round to integer (toward minus infinity).
1666   void frintm(const FPRegister& fd, const FPRegister& fn);
1667
1668   // FP round to integer (nearest with ties to even).
1669   void frintn(const FPRegister& fd, const FPRegister& fn);
1670
1671   // FP round to integer (towards plus infinity).
1672   void frintp(const FPRegister& fd, const FPRegister& fn);
1673
1674   // FP round to integer (towards zero.)
1675   void frintz(const FPRegister& fd, const FPRegister& fn);
1676
1677   // FP compare registers.
1678   void fcmp(const FPRegister& fn, const FPRegister& fm);
1679
1680   // FP compare immediate.
1681   void fcmp(const FPRegister& fn, double value);
1682
1683   // FP conditional compare.
1684   void fccmp(const FPRegister& fn,
1685              const FPRegister& fm,
1686              StatusFlags nzcv,
1687              Condition cond);
1688
1689   // FP conditional select.
1690   void fcsel(const FPRegister& fd,
1691              const FPRegister& fn,
1692              const FPRegister& fm,
1693              Condition cond);
1694
1695   // Common FP Convert function
1696   void FPConvertToInt(const Register& rd,
1697                       const FPRegister& fn,
1698                       FPIntegerConvertOp op);
1699
1700   // FP convert between single and double precision.
1701   void fcvt(const FPRegister& fd, const FPRegister& fn);
1702
1703   // Convert FP to unsigned integer (nearest with ties to away).
1704   void fcvtau(const Register& rd, const FPRegister& fn);
1705
1706   // Convert FP to signed integer (nearest with ties to away).
1707   void fcvtas(const Register& rd, const FPRegister& fn);
1708
1709   // Convert FP to unsigned integer (round towards -infinity).
1710   void fcvtmu(const Register& rd, const FPRegister& fn);
1711
1712   // Convert FP to signed integer (round towards -infinity).
1713   void fcvtms(const Register& rd, const FPRegister& fn);
1714
1715   // Convert FP to unsigned integer (nearest with ties to even).
1716   void fcvtnu(const Register& rd, const FPRegister& fn);
1717
1718   // Convert FP to signed integer (nearest with ties to even).
1719   void fcvtns(const Register& rd, const FPRegister& fn);
1720
1721   // Convert FP to unsigned integer (round towards zero).
1722   void fcvtzu(const Register& rd, const FPRegister& fn);
1723
1724   // Convert FP to signed integer (rounf towards zero).
1725   void fcvtzs(const Register& rd, const FPRegister& fn);
1726
1727   // Convert signed integer or fixed point to FP.
1728   void scvtf(const FPRegister& fd, const Register& rn, unsigned fbits = 0);
1729
1730   // Convert unsigned integer or fixed point to FP.
1731   void ucvtf(const FPRegister& fd, const Register& rn, unsigned fbits = 0);
1732
1733   // Instruction functions used only for test, debug, and patching.
1734   // Emit raw instructions in the instruction stream.
1735   void dci(Instr raw_inst) { Emit(raw_inst); }
1736
1737   // Emit 8 bits of data in the instruction stream.
1738   void dc8(uint8_t data) { EmitData(&data, sizeof(data)); }
1739
1740   // Emit 32 bits of data in the instruction stream.
1741   void dc32(uint32_t data) { EmitData(&data, sizeof(data)); }
1742
1743   // Emit 64 bits of data in the instruction stream.
1744   void dc64(uint64_t data) { EmitData(&data, sizeof(data)); }
1745
1746   // Copy a string into the instruction stream, including the terminating NULL
1747   // character. The instruction pointer (pc_) is then aligned correctly for
1748   // subsequent instructions.
1749   void EmitStringData(const char* string);
1750
1751   // Pseudo-instructions ------------------------------------------------------
1752
1753   // Parameters are described in arm64/instructions-arm64.h.
1754   void debug(const char* message, uint32_t code, Instr params = BREAK);
1755
1756   // Required by V8.
1757   void dd(uint32_t data) { dc32(data); }
1758   void db(uint8_t data) { dc8(data); }
1759
1760   // Code generation helpers --------------------------------------------------
1761
1762   bool IsConstPoolEmpty() const { return constpool_.IsEmpty(); }
1763
1764   Instruction* pc() const { return Instruction::Cast(pc_); }
1765
1766   Instruction* InstructionAt(int offset) const {
1767     return reinterpret_cast<Instruction*>(buffer_ + offset);
1768   }
1769
1770   ptrdiff_t InstructionOffset(Instruction* instr) const {
1771     return reinterpret_cast<byte*>(instr) - buffer_;
1772   }
1773
1774   // Register encoding.
1775   static Instr Rd(CPURegister rd) {
1776     DCHECK(rd.code() != kSPRegInternalCode);
1777     return rd.code() << Rd_offset;
1778   }
1779
1780   static Instr Rn(CPURegister rn) {
1781     DCHECK(rn.code() != kSPRegInternalCode);
1782     return rn.code() << Rn_offset;
1783   }
1784
1785   static Instr Rm(CPURegister rm) {
1786     DCHECK(rm.code() != kSPRegInternalCode);
1787     return rm.code() << Rm_offset;
1788   }
1789
1790   static Instr Ra(CPURegister ra) {
1791     DCHECK(ra.code() != kSPRegInternalCode);
1792     return ra.code() << Ra_offset;
1793   }
1794
1795   static Instr Rt(CPURegister rt) {
1796     DCHECK(rt.code() != kSPRegInternalCode);
1797     return rt.code() << Rt_offset;
1798   }
1799
1800   static Instr Rt2(CPURegister rt2) {
1801     DCHECK(rt2.code() != kSPRegInternalCode);
1802     return rt2.code() << Rt2_offset;
1803   }
1804
1805   // These encoding functions allow the stack pointer to be encoded, and
1806   // disallow the zero register.
1807   static Instr RdSP(Register rd) {
1808     DCHECK(!rd.IsZero());
1809     return (rd.code() & kRegCodeMask) << Rd_offset;
1810   }
1811
1812   static Instr RnSP(Register rn) {
1813     DCHECK(!rn.IsZero());
1814     return (rn.code() & kRegCodeMask) << Rn_offset;
1815   }
1816
1817   // Flags encoding.
1818   inline static Instr Flags(FlagsUpdate S);
1819   inline static Instr Cond(Condition cond);
1820
1821   // PC-relative address encoding.
1822   inline static Instr ImmPCRelAddress(int imm21);
1823
1824   // Branch encoding.
1825   inline static Instr ImmUncondBranch(int imm26);
1826   inline static Instr ImmCondBranch(int imm19);
1827   inline static Instr ImmCmpBranch(int imm19);
1828   inline static Instr ImmTestBranch(int imm14);
1829   inline static Instr ImmTestBranchBit(unsigned bit_pos);
1830
1831   // Data Processing encoding.
1832   inline static Instr SF(Register rd);
1833   inline static Instr ImmAddSub(int64_t imm);
1834   inline static Instr ImmS(unsigned imms, unsigned reg_size);
1835   inline static Instr ImmR(unsigned immr, unsigned reg_size);
1836   inline static Instr ImmSetBits(unsigned imms, unsigned reg_size);
1837   inline static Instr ImmRotate(unsigned immr, unsigned reg_size);
1838   inline static Instr ImmLLiteral(int imm19);
1839   inline static Instr BitN(unsigned bitn, unsigned reg_size);
1840   inline static Instr ShiftDP(Shift shift);
1841   inline static Instr ImmDPShift(unsigned amount);
1842   inline static Instr ExtendMode(Extend extend);
1843   inline static Instr ImmExtendShift(unsigned left_shift);
1844   inline static Instr ImmCondCmp(unsigned imm);
1845   inline static Instr Nzcv(StatusFlags nzcv);
1846
1847   static bool IsImmAddSub(int64_t immediate);
1848   static bool IsImmLogical(uint64_t value,
1849                            unsigned width,
1850                            unsigned* n,
1851                            unsigned* imm_s,
1852                            unsigned* imm_r);
1853
1854   // MemOperand offset encoding.
1855   inline static Instr ImmLSUnsigned(int imm12);
1856   inline static Instr ImmLS(int imm9);
1857   inline static Instr ImmLSPair(int imm7, LSDataSize size);
1858   inline static Instr ImmShiftLS(unsigned shift_amount);
1859   inline static Instr ImmException(int imm16);
1860   inline static Instr ImmSystemRegister(int imm15);
1861   inline static Instr ImmHint(int imm7);
1862   inline static Instr ImmBarrierDomain(int imm2);
1863   inline static Instr ImmBarrierType(int imm2);
1864   inline static LSDataSize CalcLSDataSize(LoadStoreOp op);
1865
1866   static bool IsImmLSUnscaled(int64_t offset);
1867   static bool IsImmLSScaled(int64_t offset, LSDataSize size);
1868
1869   // Move immediates encoding.
1870   inline static Instr ImmMoveWide(uint64_t imm);
1871   inline static Instr ShiftMoveWide(int64_t shift);
1872
1873   // FP Immediates.
1874   static Instr ImmFP32(float imm);
1875   static Instr ImmFP64(double imm);
1876   inline static Instr FPScale(unsigned scale);
1877
1878   // FP register type.
1879   inline static Instr FPType(FPRegister fd);
1880
1881   // Class for scoping postponing the constant pool generation.
1882   class BlockConstPoolScope {
1883    public:
1884     explicit BlockConstPoolScope(Assembler* assem) : assem_(assem) {
1885       assem_->StartBlockConstPool();
1886     }
1887     ~BlockConstPoolScope() {
1888       assem_->EndBlockConstPool();
1889     }
1890
1891    private:
1892     Assembler* assem_;
1893
1894     DISALLOW_IMPLICIT_CONSTRUCTORS(BlockConstPoolScope);
1895   };
1896
1897   // Check if is time to emit a constant pool.
1898   void CheckConstPool(bool force_emit, bool require_jump);
1899
1900   // Allocate a constant pool of the correct size for the generated code.
1901   Handle<ConstantPoolArray> NewConstantPool(Isolate* isolate);
1902
1903   // Generate the constant pool for the generated code.
1904   void PopulateConstantPool(ConstantPoolArray* constant_pool);
1905
1906   // Returns true if we should emit a veneer as soon as possible for a branch
1907   // which can at most reach to specified pc.
1908   bool ShouldEmitVeneer(int max_reachable_pc,
1909                         int margin = kVeneerDistanceMargin);
1910   bool ShouldEmitVeneers(int margin = kVeneerDistanceMargin) {
1911     return ShouldEmitVeneer(unresolved_branches_first_limit(), margin);
1912   }
1913
1914   // The maximum code size generated for a veneer. Currently one branch
1915   // instruction. This is for code size checking purposes, and can be extended
1916   // in the future for example if we decide to add nops between the veneers.
1917   static const int kMaxVeneerCodeSize = 1 * kInstructionSize;
1918
1919   void RecordVeneerPool(int location_offset, int size);
1920   // Emits veneers for branches that are approaching their maximum range.
1921   // If need_protection is true, the veneers are protected by a branch jumping
1922   // over the code.
1923   void EmitVeneers(bool force_emit, bool need_protection,
1924                    int margin = kVeneerDistanceMargin);
1925   void EmitVeneersGuard() { EmitPoolGuard(); }
1926   // Checks whether veneers need to be emitted at this point.
1927   // If force_emit is set, a veneer is generated for *all* unresolved branches.
1928   void CheckVeneerPool(bool force_emit, bool require_jump,
1929                        int margin = kVeneerDistanceMargin);
1930
1931   class BlockPoolsScope {
1932    public:
1933     explicit BlockPoolsScope(Assembler* assem) : assem_(assem) {
1934       assem_->StartBlockPools();
1935     }
1936     ~BlockPoolsScope() {
1937       assem_->EndBlockPools();
1938     }
1939
1940    private:
1941     Assembler* assem_;
1942
1943     DISALLOW_IMPLICIT_CONSTRUCTORS(BlockPoolsScope);
1944   };
1945
1946  protected:
1947   inline const Register& AppropriateZeroRegFor(const CPURegister& reg) const;
1948
1949   void LoadStore(const CPURegister& rt,
1950                  const MemOperand& addr,
1951                  LoadStoreOp op);
1952
1953   void LoadStorePair(const CPURegister& rt, const CPURegister& rt2,
1954                      const MemOperand& addr, LoadStorePairOp op);
1955   static bool IsImmLSPair(int64_t offset, LSDataSize size);
1956
1957   void Logical(const Register& rd,
1958                const Register& rn,
1959                const Operand& operand,
1960                LogicalOp op);
1961   void LogicalImmediate(const Register& rd,
1962                         const Register& rn,
1963                         unsigned n,
1964                         unsigned imm_s,
1965                         unsigned imm_r,
1966                         LogicalOp op);
1967
1968   void ConditionalCompare(const Register& rn,
1969                           const Operand& operand,
1970                           StatusFlags nzcv,
1971                           Condition cond,
1972                           ConditionalCompareOp op);
1973   static bool IsImmConditionalCompare(int64_t immediate);
1974
1975   void AddSubWithCarry(const Register& rd,
1976                        const Register& rn,
1977                        const Operand& operand,
1978                        FlagsUpdate S,
1979                        AddSubWithCarryOp op);
1980
1981   // Functions for emulating operands not directly supported by the instruction
1982   // set.
1983   void EmitShift(const Register& rd,
1984                  const Register& rn,
1985                  Shift shift,
1986                  unsigned amount);
1987   void EmitExtendShift(const Register& rd,
1988                        const Register& rn,
1989                        Extend extend,
1990                        unsigned left_shift);
1991
1992   void AddSub(const Register& rd,
1993               const Register& rn,
1994               const Operand& operand,
1995               FlagsUpdate S,
1996               AddSubOp op);
1997
1998   static bool IsImmFP32(float imm);
1999   static bool IsImmFP64(double imm);
2000
2001   // Find an appropriate LoadStoreOp or LoadStorePairOp for the specified
2002   // registers. Only simple loads are supported; sign- and zero-extension (such
2003   // as in LDPSW_x or LDRB_w) are not supported.
2004   static inline LoadStoreOp LoadOpFor(const CPURegister& rt);
2005   static inline LoadStorePairOp LoadPairOpFor(const CPURegister& rt,
2006                                               const CPURegister& rt2);
2007   static inline LoadStoreOp StoreOpFor(const CPURegister& rt);
2008   static inline LoadStorePairOp StorePairOpFor(const CPURegister& rt,
2009                                                const CPURegister& rt2);
2010   static inline LoadStorePairNonTemporalOp LoadPairNonTemporalOpFor(
2011     const CPURegister& rt, const CPURegister& rt2);
2012   static inline LoadStorePairNonTemporalOp StorePairNonTemporalOpFor(
2013     const CPURegister& rt, const CPURegister& rt2);
2014   static inline LoadLiteralOp LoadLiteralOpFor(const CPURegister& rt);
2015
2016   // Remove the specified branch from the unbound label link chain.
2017   // If available, a veneer for this label can be used for other branches in the
2018   // chain if the link chain cannot be fixed up without this branch.
2019   void RemoveBranchFromLabelLinkChain(Instruction* branch,
2020                                       Label* label,
2021                                       Instruction* label_veneer = NULL);
2022
2023  private:
2024   // Instruction helpers.
2025   void MoveWide(const Register& rd,
2026                 uint64_t imm,
2027                 int shift,
2028                 MoveWideImmediateOp mov_op);
2029   void DataProcShiftedRegister(const Register& rd,
2030                                const Register& rn,
2031                                const Operand& operand,
2032                                FlagsUpdate S,
2033                                Instr op);
2034   void DataProcExtendedRegister(const Register& rd,
2035                                 const Register& rn,
2036                                 const Operand& operand,
2037                                 FlagsUpdate S,
2038                                 Instr op);
2039   void LoadStorePairNonTemporal(const CPURegister& rt,
2040                                 const CPURegister& rt2,
2041                                 const MemOperand& addr,
2042                                 LoadStorePairNonTemporalOp op);
2043   void ConditionalSelect(const Register& rd,
2044                          const Register& rn,
2045                          const Register& rm,
2046                          Condition cond,
2047                          ConditionalSelectOp op);
2048   void DataProcessing1Source(const Register& rd,
2049                              const Register& rn,
2050                              DataProcessing1SourceOp op);
2051   void DataProcessing3Source(const Register& rd,
2052                              const Register& rn,
2053                              const Register& rm,
2054                              const Register& ra,
2055                              DataProcessing3SourceOp op);
2056   void FPDataProcessing1Source(const FPRegister& fd,
2057                                const FPRegister& fn,
2058                                FPDataProcessing1SourceOp op);
2059   void FPDataProcessing2Source(const FPRegister& fd,
2060                                const FPRegister& fn,
2061                                const FPRegister& fm,
2062                                FPDataProcessing2SourceOp op);
2063   void FPDataProcessing3Source(const FPRegister& fd,
2064                                const FPRegister& fn,
2065                                const FPRegister& fm,
2066                                const FPRegister& fa,
2067                                FPDataProcessing3SourceOp op);
2068
2069   // Label helpers.
2070
2071   // Return an offset for a label-referencing instruction, typically a branch.
2072   int LinkAndGetByteOffsetTo(Label* label);
2073
2074   // This is the same as LinkAndGetByteOffsetTo, but return an offset
2075   // suitable for fields that take instruction offsets.
2076   inline int LinkAndGetInstructionOffsetTo(Label* label);
2077
2078   static const int kStartOfLabelLinkChain = 0;
2079
2080   // Verify that a label's link chain is intact.
2081   void CheckLabelLinkChain(Label const * label);
2082
2083   void RecordLiteral(int64_t imm, unsigned size);
2084
2085   // Postpone the generation of the constant pool for the specified number of
2086   // instructions.
2087   void BlockConstPoolFor(int instructions);
2088
2089   // Set how far from current pc the next constant pool check will be.
2090   void SetNextConstPoolCheckIn(int instructions) {
2091     next_constant_pool_check_ = pc_offset() + instructions * kInstructionSize;
2092   }
2093
2094   // Emit the instruction at pc_.
2095   void Emit(Instr instruction) {
2096     STATIC_ASSERT(sizeof(*pc_) == 1);
2097     STATIC_ASSERT(sizeof(instruction) == kInstructionSize);
2098     DCHECK((pc_ + sizeof(instruction)) <= (buffer_ + buffer_size_));
2099
2100     memcpy(pc_, &instruction, sizeof(instruction));
2101     pc_ += sizeof(instruction);
2102     CheckBuffer();
2103   }
2104
2105   // Emit data inline in the instruction stream.
2106   void EmitData(void const * data, unsigned size) {
2107     DCHECK(sizeof(*pc_) == 1);
2108     DCHECK((pc_ + size) <= (buffer_ + buffer_size_));
2109
2110     // TODO(all): Somehow register we have some data here. Then we can
2111     // disassemble it correctly.
2112     memcpy(pc_, data, size);
2113     pc_ += size;
2114     CheckBuffer();
2115   }
2116
2117   void GrowBuffer();
2118   void CheckBufferSpace();
2119   void CheckBuffer();
2120
2121   // Pc offset of the next constant pool check.
2122   int next_constant_pool_check_;
2123
2124   // Constant pool generation
2125   // Pools are emitted in the instruction stream. They are emitted when:
2126   //  * the distance to the first use is above a pre-defined distance or
2127   //  * the numbers of entries in the pool is above a pre-defined size or
2128   //  * code generation is finished
2129   // If a pool needs to be emitted before code generation is finished a branch
2130   // over the emitted pool will be inserted.
2131
2132   // Constants in the pool may be addresses of functions that gets relocated;
2133   // if so, a relocation info entry is associated to the constant pool entry.
2134
2135   // Repeated checking whether the constant pool should be emitted is rather
2136   // expensive. By default we only check again once a number of instructions
2137   // has been generated. That also means that the sizing of the buffers is not
2138   // an exact science, and that we rely on some slop to not overrun buffers.
2139   static const int kCheckConstPoolInterval = 128;
2140
2141   // Distance to first use after a which a pool will be emitted. Pool entries
2142   // are accessed with pc relative load therefore this cannot be more than
2143   // 1 * MB. Since constant pool emission checks are interval based this value
2144   // is an approximation.
2145   static const int kApproxMaxDistToConstPool = 64 * KB;
2146
2147   // Number of pool entries after which a pool will be emitted. Since constant
2148   // pool emission checks are interval based this value is an approximation.
2149   static const int kApproxMaxPoolEntryCount = 512;
2150
2151   // Emission of the constant pool may be blocked in some code sequences.
2152   int const_pool_blocked_nesting_;  // Block emission if this is not zero.
2153   int no_const_pool_before_;  // Block emission before this pc offset.
2154
2155   // Emission of the veneer pools may be blocked in some code sequences.
2156   int veneer_pool_blocked_nesting_;  // Block emission if this is not zero.
2157
2158   // Relocation info generation
2159   // Each relocation is encoded as a variable size value
2160   static const int kMaxRelocSize = RelocInfoWriter::kMaxSize;
2161   RelocInfoWriter reloc_info_writer;
2162
2163   // Relocation info records are also used during code generation as temporary
2164   // containers for constants and code target addresses until they are emitted
2165   // to the constant pool. These pending relocation info records are temporarily
2166   // stored in a separate buffer until a constant pool is emitted.
2167   // If every instruction in a long sequence is accessing the pool, we need one
2168   // pending relocation entry per instruction.
2169
2170   // The pending constant pool.
2171   ConstPool constpool_;
2172
2173   // Relocation for a type-recording IC has the AST id added to it.  This
2174   // member variable is a way to pass the information from the call site to
2175   // the relocation info.
2176   TypeFeedbackId recorded_ast_id_;
2177
2178   inline TypeFeedbackId RecordedAstId();
2179   inline void ClearRecordedAstId();
2180
2181  protected:
2182   // Record the AST id of the CallIC being compiled, so that it can be placed
2183   // in the relocation information.
2184   void SetRecordedAstId(TypeFeedbackId ast_id) {
2185     DCHECK(recorded_ast_id_.IsNone());
2186     recorded_ast_id_ = ast_id;
2187   }
2188
2189   // Code generation
2190   // The relocation writer's position is at least kGap bytes below the end of
2191   // the generated instructions. This is so that multi-instruction sequences do
2192   // not have to check for overflow. The same is true for writes of large
2193   // relocation info entries, and debug strings encoded in the instruction
2194   // stream.
2195   static const int kGap = 128;
2196
2197  public:
2198   class FarBranchInfo {
2199    public:
2200     FarBranchInfo(int offset, Label* label)
2201         : pc_offset_(offset), label_(label) {}
2202     // Offset of the branch in the code generation buffer.
2203     int pc_offset_;
2204     // The label branched to.
2205     Label* label_;
2206   };
2207
2208  protected:
2209   // Information about unresolved (forward) branches.
2210   // The Assembler is only allowed to delete out-of-date information from here
2211   // after a label is bound. The MacroAssembler uses this information to
2212   // generate veneers.
2213   //
2214   // The second member gives information about the unresolved branch. The first
2215   // member of the pair is the maximum offset that the branch can reach in the
2216   // buffer. The map is sorted according to this reachable offset, allowing to
2217   // easily check when veneers need to be emitted.
2218   // Note that the maximum reachable offset (first member of the pairs) should
2219   // always be positive but has the same type as the return value for
2220   // pc_offset() for convenience.
2221   std::multimap<int, FarBranchInfo> unresolved_branches_;
2222
2223   // We generate a veneer for a branch if we reach within this distance of the
2224   // limit of the range.
2225   static const int kVeneerDistanceMargin = 1 * KB;
2226   // The factor of 2 is a finger in the air guess. With a default margin of
2227   // 1KB, that leaves us an addional 256 instructions to avoid generating a
2228   // protective branch.
2229   static const int kVeneerNoProtectionFactor = 2;
2230   static const int kVeneerDistanceCheckMargin =
2231     kVeneerNoProtectionFactor * kVeneerDistanceMargin;
2232   int unresolved_branches_first_limit() const {
2233     DCHECK(!unresolved_branches_.empty());
2234     return unresolved_branches_.begin()->first;
2235   }
2236   // This is similar to next_constant_pool_check_ and helps reduce the overhead
2237   // of checking for veneer pools.
2238   // It is maintained to the closest unresolved branch limit minus the maximum
2239   // veneer margin (or kMaxInt if there are no unresolved branches).
2240   int next_veneer_pool_check_;
2241
2242  private:
2243   // If a veneer is emitted for a branch instruction, that instruction must be
2244   // removed from the associated label's link chain so that the assembler does
2245   // not later attempt (likely unsuccessfully) to patch it to branch directly to
2246   // the label.
2247   void DeleteUnresolvedBranchInfoForLabel(Label* label);
2248   // This function deletes the information related to the label by traversing
2249   // the label chain, and for each PC-relative instruction in the chain checking
2250   // if pending unresolved information exists. Its complexity is proportional to
2251   // the length of the label chain.
2252   void DeleteUnresolvedBranchInfoForLabelTraverse(Label* label);
2253
2254  private:
2255   PositionsRecorder positions_recorder_;
2256   friend class PositionsRecorder;
2257   friend class EnsureSpace;
2258   friend class ConstPool;
2259 };
2260
2261 class PatchingAssembler : public Assembler {
2262  public:
2263   // Create an Assembler with a buffer starting at 'start'.
2264   // The buffer size is
2265   //   size of instructions to patch + kGap
2266   // Where kGap is the distance from which the Assembler tries to grow the
2267   // buffer.
2268   // If more or fewer instructions than expected are generated or if some
2269   // relocation information takes space in the buffer, the PatchingAssembler
2270   // will crash trying to grow the buffer.
2271   PatchingAssembler(Instruction* start, unsigned count)
2272     : Assembler(NULL,
2273                 reinterpret_cast<byte*>(start),
2274                 count * kInstructionSize + kGap) {
2275     StartBlockPools();
2276   }
2277
2278   PatchingAssembler(byte* start, unsigned count)
2279     : Assembler(NULL, start, count * kInstructionSize + kGap) {
2280     // Block constant pool emission.
2281     StartBlockPools();
2282   }
2283
2284   ~PatchingAssembler() {
2285     // Const pool should still be blocked.
2286     DCHECK(is_const_pool_blocked());
2287     EndBlockPools();
2288     // Verify we have generated the number of instruction we expected.
2289     DCHECK((pc_offset() + kGap) == buffer_size_);
2290     // Verify no relocation information has been emitted.
2291     DCHECK(IsConstPoolEmpty());
2292     // Flush the Instruction cache.
2293     size_t length = buffer_size_ - kGap;
2294     CpuFeatures::FlushICache(buffer_, length);
2295   }
2296
2297   // See definition of PatchAdrFar() for details.
2298   static const int kAdrFarPatchableNNops = 2;
2299   static const int kAdrFarPatchableNInstrs = kAdrFarPatchableNNops + 2;
2300   void PatchAdrFar(int64_t target_offset);
2301 };
2302
2303
2304 class EnsureSpace BASE_EMBEDDED {
2305  public:
2306   explicit EnsureSpace(Assembler* assembler) {
2307     assembler->CheckBufferSpace();
2308   }
2309 };
2310
2311 } }  // namespace v8::internal
2312
2313 #endif  // V8_ARM64_ASSEMBLER_ARM64_H_