src/ia32/assembler-ia32.cc

   1 // Copyright (c) 1994-2006 Sun Microsystems Inc.
   2 // All Rights Reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions
   6 // are met:
   7 //
   8 // - Redistributions of source code must retain the above copyright notice,
   9 // this list of conditions and the following disclaimer.
  10 //
  11 // - Redistribution in binary form must reproduce the above copyright
  12 // notice, this list of conditions and the following disclaimer in the
  13 // documentation and/or other materials provided with the
  14 // distribution.
  15 //
  16 // - Neither the name of Sun Microsystems or the names of contributors may
  17 // be used to endorse or promote products derived from this software without
  18 // specific prior written permission.
  19 //
  20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  24 // COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  25 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29 // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  31 // OF THE POSSIBILITY OF SUCH DAMAGE.
  32
  33 // The original source code covered by the above license above has been modified
  34 // significantly by Google Inc.
  35 // Copyright 2012 the V8 project authors. All rights reserved.
  36
  37 #include "src/ia32/assembler-ia32.h"
  38
  39 #include <cstring>
  40
  41 #if V8_TARGET_ARCH_IA32
  42
  43 #if V8_LIBC_MSVCRT
  44 #include <intrin.h>  // _xgetbv()
  45 #endif
  46 #if V8_OS_MACOSX
  47 #include <sys/sysctl.h>
  48 #endif
  49
  50 #include "src/base/bits.h"
  51 #include "src/base/cpu.h"
  52 #include "src/disassembler.h"
  53 #include "src/macro-assembler.h"
  54 #include "src/v8.h"
  55
  56 namespace v8 {
  57 namespace internal {
  58
  59 // -----------------------------------------------------------------------------
  60 // Implementation of CpuFeatures
  61
  62 namespace {
  63
  64 #if !V8_LIBC_MSVCRT
  65
  66 V8_INLINE uint64_t _xgetbv(unsigned int xcr) {
  67   unsigned eax, edx;
  68   // Check xgetbv; this uses a .byte sequence instead of the instruction
  69   // directly because older assemblers do not include support for xgetbv and
  70   // there is no easy way to conditionally compile based on the assembler
  71   // used.
  72   __asm__ volatile(".byte 0x0f, 0x01, 0xd0" : "=a"(eax), "=d"(edx) : "c"(xcr));
  73   return static_cast<uint64_t>(eax) | (static_cast<uint64_t>(edx) << 32);
  74 }
  75
  76 #define _XCR_XFEATURE_ENABLED_MASK 0
  77
  78 #endif  // !V8_LIBC_MSVCRT
  79
  80
  81 bool OSHasAVXSupport() {
  82 #if V8_OS_MACOSX
  83   // Mac OS X up to 10.9 has a bug where AVX transitions were indeed being
  84   // caused by ISRs, so we detect that here and disable AVX in that case.
  85   char buffer[128];
  86   size_t buffer_size = arraysize(buffer);
  87   int ctl_name[] = {CTL_KERN, KERN_OSRELEASE};
  88   if (sysctl(ctl_name, 2, buffer, &buffer_size, nullptr, 0) != 0) {
  89     V8_Fatal(__FILE__, __LINE__, "V8 failed to get kernel version");
  90   }
  91   // The buffer now contains a string of the form XX.YY.ZZ, where
  92   // XX is the major kernel version component.
  93   char* period_pos = strchr(buffer, '.');
  94   DCHECK_NOT_NULL(period_pos);
  95   *period_pos = '\0';
  96   long kernel_version_major = strtol(buffer, nullptr, 10);  // NOLINT
  97   if (kernel_version_major <= 13) return false;
  98 #endif  // V8_OS_MACOSX
  99   // Check whether OS claims to support AVX.
 100   uint64_t feature_mask = _xgetbv(_XCR_XFEATURE_ENABLED_MASK);
 101   return (feature_mask & 0x6) == 0x6;
 102 }
 103
 104 }  // namespace
 105
 106
 107 void CpuFeatures::ProbeImpl(bool cross_compile) {
 108   base::CPU cpu;
 109   CHECK(cpu.has_sse2());  // SSE2 support is mandatory.
 110   CHECK(cpu.has_cmov());  // CMOV support is mandatory.
 111
 112   // Only use statically determined features for cross compile (snapshot).
 113   if (cross_compile) return;
 114
 115   if (cpu.has_sse41() && FLAG_enable_sse4_1) supported_ |= 1u << SSE4_1;
 116   if (cpu.has_sse3() && FLAG_enable_sse3) supported_ |= 1u << SSE3;
 117   if (cpu.has_avx() && FLAG_enable_avx && cpu.has_osxsave() &&
 118       OSHasAVXSupport()) {
 119     supported_ |= 1u << AVX;
 120   }
 121   if (cpu.has_fma3() && FLAG_enable_fma3 && cpu.has_osxsave() &&
 122       OSHasAVXSupport()) {
 123     supported_ |= 1u << FMA3;
 124   }
 125   if (cpu.has_bmi1() && FLAG_enable_bmi1) supported_ |= 1u << BMI1;
 126   if (cpu.has_bmi2() && FLAG_enable_bmi2) supported_ |= 1u << BMI2;
 127   if (cpu.has_lzcnt() && FLAG_enable_lzcnt) supported_ |= 1u << LZCNT;
 128   if (cpu.has_popcnt() && FLAG_enable_popcnt) supported_ |= 1u << POPCNT;
 129   if (strcmp(FLAG_mcpu, "auto") == 0) {
 130     if (cpu.is_atom()) supported_ |= 1u << ATOM;
 131   } else if (strcmp(FLAG_mcpu, "atom") == 0) {
 132     supported_ |= 1u << ATOM;
 133   }
 134 }
 135
 136
 137 void CpuFeatures::PrintTarget() { }
 138 void CpuFeatures::PrintFeatures() {
 139   printf(
 140       "SSE3=%d SSE4_1=%d AVX=%d FMA3=%d BMI1=%d BMI2=%d LZCNT=%d POPCNT=%d "
 141       "ATOM=%d\n",
 142       CpuFeatures::IsSupported(SSE3), CpuFeatures::IsSupported(SSE4_1),
 143       CpuFeatures::IsSupported(AVX), CpuFeatures::IsSupported(FMA3),
 144       CpuFeatures::IsSupported(BMI1), CpuFeatures::IsSupported(BMI2),
 145       CpuFeatures::IsSupported(LZCNT), CpuFeatures::IsSupported(POPCNT),
 146       CpuFeatures::IsSupported(ATOM));
 147 }
 148
 149
 150 // -----------------------------------------------------------------------------
 151 // Implementation of Displacement
 152
 153 void Displacement::init(Label* L, Type type) {
 154   DCHECK(!L->is_bound());
 155   int next = 0;
 156   if (L->is_linked()) {
 157     next = L->pos();
 158     DCHECK(next > 0);  // Displacements must be at positions > 0
 159   }
 160   // Ensure that we _never_ overflow the next field.
 161   DCHECK(NextField::is_valid(Assembler::kMaximalBufferSize));
 162   data_ = NextField::encode(next) | TypeField::encode(type);
 163 }
 164
 165
 166 // -----------------------------------------------------------------------------
 167 // Implementation of RelocInfo
 168
 169
 170 const int RelocInfo::kApplyMask =
 171     RelocInfo::kCodeTargetMask | 1 << RelocInfo::RUNTIME_ENTRY |
 172     1 << RelocInfo::INTERNAL_REFERENCE | 1 << RelocInfo::CODE_AGE_SEQUENCE |
 173     RelocInfo::kDebugBreakSlotMask;
 174
 175
 176 bool RelocInfo::IsCodedSpecially() {
 177   // The deserializer needs to know whether a pointer is specially coded.  Being
 178   // specially coded on IA32 means that it is a relative address, as used by
 179   // branch instructions.  These are also the ones that need changing when a
 180   // code object moves.
 181   return (1 << rmode_) & kApplyMask;
 182 }
 183
 184
 185 bool RelocInfo::IsInConstantPool() {
 186   return false;
 187 }
 188
 189
 190 // Patch the code at the current PC with a call to the target address.
 191 // Additional guard int3 instructions can be added if required.
 192 void RelocInfo::PatchCodeWithCall(Address target, int guard_bytes) {
 193   // Call instruction takes up 5 bytes and int3 takes up one byte.
 194   static const int kCallCodeSize = 5;
 195   int code_size = kCallCodeSize + guard_bytes;
 196
 197   // Create a code patcher.
 198   CodePatcher patcher(pc_, code_size);
 199
 200   // Add a label for checking the size of the code used for returning.
 201 #ifdef DEBUG
 202   Label check_codesize;
 203   patcher.masm()->bind(&check_codesize);
 204 #endif
 205
 206   // Patch the code.
 207   patcher.masm()->call(target, RelocInfo::NONE32);
 208
 209   // Check that the size of the code generated is as expected.
 210   DCHECK_EQ(kCallCodeSize,
 211             patcher.masm()->SizeOfCodeGeneratedSince(&check_codesize));
 212
 213   // Add the requested number of int3 instructions after the call.
 214   DCHECK_GE(guard_bytes, 0);
 215   for (int i = 0; i < guard_bytes; i++) {
 216     patcher.masm()->int3();
 217   }
 218 }
 219
 220
 221 // -----------------------------------------------------------------------------
 222 // Implementation of Operand
 223
 224 Operand::Operand(Register base, int32_t disp, RelocInfo::Mode rmode) {
 225   // [base + disp/r]
 226   if (disp == 0 && RelocInfo::IsNone(rmode) && !base.is(ebp)) {
 227     // [base]
 228     set_modrm(0, base);
 229     if (base.is(esp)) set_sib(times_1, esp, base);
 230   } else if (is_int8(disp) && RelocInfo::IsNone(rmode)) {
 231     // [base + disp8]
 232     set_modrm(1, base);
 233     if (base.is(esp)) set_sib(times_1, esp, base);
 234     set_disp8(disp);
 235   } else {
 236     // [base + disp/r]
 237     set_modrm(2, base);
 238     if (base.is(esp)) set_sib(times_1, esp, base);
 239     set_dispr(disp, rmode);
 240   }
 241 }
 242
 243
 244 Operand::Operand(Register base,
 245                  Register index,
 246                  ScaleFactor scale,
 247                  int32_t disp,
 248                  RelocInfo::Mode rmode) {
 249   DCHECK(!index.is(esp));  // illegal addressing mode
 250   // [base + index*scale + disp/r]
 251   if (disp == 0 && RelocInfo::IsNone(rmode) && !base.is(ebp)) {
 252     // [base + index*scale]
 253     set_modrm(0, esp);
 254     set_sib(scale, index, base);
 255   } else if (is_int8(disp) && RelocInfo::IsNone(rmode)) {
 256     // [base + index*scale + disp8]
 257     set_modrm(1, esp);
 258     set_sib(scale, index, base);
 259     set_disp8(disp);
 260   } else {
 261     // [base + index*scale + disp/r]
 262     set_modrm(2, esp);
 263     set_sib(scale, index, base);
 264     set_dispr(disp, rmode);
 265   }
 266 }
 267
 268
 269 Operand::Operand(Register index,
 270                  ScaleFactor scale,
 271                  int32_t disp,
 272                  RelocInfo::Mode rmode) {
 273   DCHECK(!index.is(esp));  // illegal addressing mode
 274   // [index*scale + disp/r]
 275   set_modrm(0, esp);
 276   set_sib(scale, index, ebp);
 277   set_dispr(disp, rmode);
 278 }
 279
 280
 281 bool Operand::is_reg(Register reg) const {
 282   return ((buf_[0] & 0xF8) == 0xC0)  // addressing mode is register only.
 283       && ((buf_[0] & 0x07) == reg.code());  // register codes match.
 284 }
 285
 286
 287 bool Operand::is_reg_only() const {
 288   return (buf_[0] & 0xF8) == 0xC0;  // Addressing mode is register only.
 289 }
 290
 291
 292 Register Operand::reg() const {
 293   DCHECK(is_reg_only());
 294   return Register::from_code(buf_[0] & 0x07);
 295 }
 296
 297
 298 // -----------------------------------------------------------------------------
 299 // Implementation of Assembler.
 300
 301 // Emit a single byte. Must always be inlined.
 302 #define EMIT(x)                                 \
 303   *pc_++ = (x)
 304
 305
 306 #ifdef GENERATED_CODE_COVERAGE
 307 static void InitCoverageLog();
 308 #endif
 309
 310 Assembler::Assembler(Isolate* isolate, void* buffer, int buffer_size)
 311     : AssemblerBase(isolate, buffer, buffer_size),
 312       positions_recorder_(this) {
 313   // Clear the buffer in debug mode unless it was provided by the
 314   // caller in which case we can't be sure it's okay to overwrite
 315   // existing code in it; see CodePatcher::CodePatcher(...).
 316 #ifdef DEBUG
 317   if (own_buffer_) {
 318     memset(buffer_, 0xCC, buffer_size_);  // int3
 319   }
 320 #endif
 321
 322   reloc_info_writer.Reposition(buffer_ + buffer_size_, pc_);
 323
 324 #ifdef GENERATED_CODE_COVERAGE
 325   InitCoverageLog();
 326 #endif
 327 }
 328
 329
 330 void Assembler::GetCode(CodeDesc* desc) {
 331   // Finalize code (at this point overflow() may be true, but the gap ensures
 332   // that we are still not overlapping instructions and relocation info).
 333   reloc_info_writer.Finish();
 334   DCHECK(pc_ <= reloc_info_writer.pos());  // No overlap.
 335   // Set up code descriptor.
 336   desc->buffer = buffer_;
 337   desc->buffer_size = buffer_size_;
 338   desc->instr_size = pc_offset();
 339   desc->reloc_size = (buffer_ + buffer_size_) - reloc_info_writer.pos();
 340   desc->origin = this;
 341 }
 342
 343
 344 void Assembler::Align(int m) {
 345   DCHECK(base::bits::IsPowerOfTwo32(m));
 346   int mask = m - 1;
 347   int addr = pc_offset();
 348   Nop((m - (addr & mask)) & mask);
 349 }
 350
 351
 352 bool Assembler::IsNop(Address addr) {
 353   Address a = addr;
 354   while (*a == 0x66) a++;
 355   if (*a == 0x90) return true;
 356   if (a[0] == 0xf && a[1] == 0x1f) return true;
 357   return false;
 358 }
 359
 360
 361 void Assembler::Nop(int bytes) {
 362   EnsureSpace ensure_space(this);
 363
 364   // Multi byte nops from http://support.amd.com/us/Processor_TechDocs/40546.pdf
 365   while (bytes > 0) {
 366     switch (bytes) {
 367       case 2:
 368         EMIT(0x66);
 369       case 1:
 370         EMIT(0x90);
 371         return;
 372       case 3:
 373         EMIT(0xf);
 374         EMIT(0x1f);
 375         EMIT(0);
 376         return;
 377       case 4:
 378         EMIT(0xf);
 379         EMIT(0x1f);
 380         EMIT(0x40);
 381         EMIT(0);
 382         return;
 383       case 6:
 384         EMIT(0x66);
 385       case 5:
 386         EMIT(0xf);
 387         EMIT(0x1f);
 388         EMIT(0x44);
 389         EMIT(0);
 390         EMIT(0);
 391         return;
 392       case 7:
 393         EMIT(0xf);
 394         EMIT(0x1f);
 395         EMIT(0x80);
 396         EMIT(0);
 397         EMIT(0);
 398         EMIT(0);
 399         EMIT(0);
 400         return;
 401       default:
 402       case 11:
 403         EMIT(0x66);
 404         bytes--;
 405       case 10:
 406         EMIT(0x66);
 407         bytes--;
 408       case 9:
 409         EMIT(0x66);
 410         bytes--;
 411       case 8:
 412         EMIT(0xf);
 413         EMIT(0x1f);
 414         EMIT(0x84);
 415         EMIT(0);
 416         EMIT(0);
 417         EMIT(0);
 418         EMIT(0);
 419         EMIT(0);
 420         bytes -= 8;
 421     }
 422   }
 423 }
 424
 425
 426 void Assembler::CodeTargetAlign() {
 427   Align(16);  // Preferred alignment of jump targets on ia32.
 428 }
 429
 430
 431 void Assembler::cpuid() {
 432   EnsureSpace ensure_space(this);
 433   EMIT(0x0F);
 434   EMIT(0xA2);
 435 }
 436
 437
 438 void Assembler::pushad() {
 439   EnsureSpace ensure_space(this);
 440   EMIT(0x60);
 441 }
 442
 443
 444 void Assembler::popad() {
 445   EnsureSpace ensure_space(this);
 446   EMIT(0x61);
 447 }
 448
 449
 450 void Assembler::pushfd() {
 451   EnsureSpace ensure_space(this);
 452   EMIT(0x9C);
 453 }
 454
 455
 456 void Assembler::popfd() {
 457   EnsureSpace ensure_space(this);
 458   EMIT(0x9D);
 459 }
 460
 461
 462 void Assembler::push(const Immediate& x) {
 463   EnsureSpace ensure_space(this);
 464   if (x.is_int8()) {
 465     EMIT(0x6a);
 466     EMIT(x.x_);
 467   } else {
 468     EMIT(0x68);
 469     emit(x);
 470   }
 471 }
 472
 473
 474 void Assembler::push_imm32(int32_t imm32) {
 475   EnsureSpace ensure_space(this);
 476   EMIT(0x68);
 477   emit(imm32);
 478 }
 479
 480
 481 void Assembler::push(Register src) {
 482   EnsureSpace ensure_space(this);
 483   EMIT(0x50 | src.code());
 484 }
 485
 486
 487 void Assembler::push(const Operand& src) {
 488   EnsureSpace ensure_space(this);
 489   EMIT(0xFF);
 490   emit_operand(esi, src);
 491 }
 492
 493
 494 void Assembler::pop(Register dst) {
 495   DCHECK(reloc_info_writer.last_pc() != NULL);
 496   EnsureSpace ensure_space(this);
 497   EMIT(0x58 | dst.code());
 498 }
 499
 500
 501 void Assembler::pop(const Operand& dst) {
 502   EnsureSpace ensure_space(this);
 503   EMIT(0x8F);
 504   emit_operand(eax, dst);
 505 }
 506
 507
 508 void Assembler::enter(const Immediate& size) {
 509   EnsureSpace ensure_space(this);
 510   EMIT(0xC8);
 511   emit_w(size);
 512   EMIT(0);
 513 }
 514
 515
 516 void Assembler::leave() {
 517   EnsureSpace ensure_space(this);
 518   EMIT(0xC9);
 519 }
 520
 521
 522 void Assembler::mov_b(Register dst, const Operand& src) {
 523   CHECK(dst.is_byte_register());
 524   EnsureSpace ensure_space(this);
 525   EMIT(0x8A);
 526   emit_operand(dst, src);
 527 }
 528
 529
 530 void Assembler::mov_b(const Operand& dst, const Immediate& src) {
 531   EnsureSpace ensure_space(this);
 532   EMIT(0xC6);
 533   emit_operand(eax, dst);
 534   EMIT(static_cast<int8_t>(src.x_));
 535 }
 536
 537
 538 void Assembler::mov_b(const Operand& dst, Register src) {
 539   CHECK(src.is_byte_register());
 540   EnsureSpace ensure_space(this);
 541   EMIT(0x88);
 542   emit_operand(src, dst);
 543 }
 544
 545
 546 void Assembler::mov_w(Register dst, const Operand& src) {
 547   EnsureSpace ensure_space(this);
 548   EMIT(0x66);
 549   EMIT(0x8B);
 550   emit_operand(dst, src);
 551 }
 552
 553
 554 void Assembler::mov_w(const Operand& dst, Register src) {
 555   EnsureSpace ensure_space(this);
 556   EMIT(0x66);
 557   EMIT(0x89);
 558   emit_operand(src, dst);
 559 }
 560
 561
 562 void Assembler::mov_w(const Operand& dst, const Immediate& src) {
 563   EnsureSpace ensure_space(this);
 564   EMIT(0x66);
 565   EMIT(0xC7);
 566   emit_operand(eax, dst);
 567   EMIT(static_cast<int8_t>(src.x_ & 0xff));
 568   EMIT(static_cast<int8_t>(src.x_ >> 8));
 569 }
 570
 571
 572 void Assembler::mov(Register dst, int32_t imm32) {
 573   EnsureSpace ensure_space(this);
 574   EMIT(0xB8 | dst.code());
 575   emit(imm32);
 576 }
 577
 578
 579 void Assembler::mov(Register dst, const Immediate& x) {
 580   EnsureSpace ensure_space(this);
 581   EMIT(0xB8 | dst.code());
 582   emit(x);
 583 }
 584
 585
 586 void Assembler::mov(Register dst, Handle<Object> handle) {
 587   EnsureSpace ensure_space(this);
 588   EMIT(0xB8 | dst.code());
 589   emit(handle);
 590 }
 591
 592
 593 void Assembler::mov(Register dst, const Operand& src) {
 594   EnsureSpace ensure_space(this);
 595   EMIT(0x8B);
 596   emit_operand(dst, src);
 597 }
 598
 599
 600 void Assembler::mov(Register dst, Register src) {
 601   EnsureSpace ensure_space(this);
 602   EMIT(0x89);
 603   EMIT(0xC0 | src.code() << 3 | dst.code());
 604 }
 605
 606
 607 void Assembler::mov(const Operand& dst, const Immediate& x) {
 608   EnsureSpace ensure_space(this);
 609   EMIT(0xC7);
 610   emit_operand(eax, dst);
 611   emit(x);
 612 }
 613
 614
 615 void Assembler::mov(const Operand& dst, Handle<Object> handle) {
 616   EnsureSpace ensure_space(this);
 617   EMIT(0xC7);
 618   emit_operand(eax, dst);
 619   emit(handle);
 620 }
 621
 622
 623 void Assembler::mov(const Operand& dst, Register src) {
 624   EnsureSpace ensure_space(this);
 625   EMIT(0x89);
 626   emit_operand(src, dst);
 627 }
 628
 629
 630 void Assembler::movsx_b(Register dst, const Operand& src) {
 631   EnsureSpace ensure_space(this);
 632   EMIT(0x0F);
 633   EMIT(0xBE);
 634   emit_operand(dst, src);
 635 }
 636
 637
 638 void Assembler::movsx_w(Register dst, const Operand& src) {
 639   EnsureSpace ensure_space(this);
 640   EMIT(0x0F);
 641   EMIT(0xBF);
 642   emit_operand(dst, src);
 643 }
 644
 645
 646 void Assembler::movzx_b(Register dst, const Operand& src) {
 647   EnsureSpace ensure_space(this);
 648   EMIT(0x0F);
 649   EMIT(0xB6);
 650   emit_operand(dst, src);
 651 }
 652
 653
 654 void Assembler::movzx_w(Register dst, const Operand& src) {
 655   EnsureSpace ensure_space(this);
 656   EMIT(0x0F);
 657   EMIT(0xB7);
 658   emit_operand(dst, src);
 659 }
 660
 661
 662 void Assembler::cmov(Condition cc, Register dst, const Operand& src) {
 663   EnsureSpace ensure_space(this);
 664   // Opcode: 0f 40 + cc /r.
 665   EMIT(0x0F);
 666   EMIT(0x40 + cc);
 667   emit_operand(dst, src);
 668 }
 669
 670
 671 void Assembler::cld() {
 672   EnsureSpace ensure_space(this);
 673   EMIT(0xFC);
 674 }
 675
 676
 677 void Assembler::rep_movs() {
 678   EnsureSpace ensure_space(this);
 679   EMIT(0xF3);
 680   EMIT(0xA5);
 681 }
 682
 683
 684 void Assembler::rep_stos() {
 685   EnsureSpace ensure_space(this);
 686   EMIT(0xF3);
 687   EMIT(0xAB);
 688 }
 689
 690
 691 void Assembler::stos() {
 692   EnsureSpace ensure_space(this);
 693   EMIT(0xAB);
 694 }
 695
 696
 697 void Assembler::xchg(Register dst, Register src) {
 698   EnsureSpace ensure_space(this);
 699   if (src.is(eax) || dst.is(eax)) {  // Single-byte encoding.
 700     EMIT(0x90 | (src.is(eax) ? dst.code() : src.code()));
 701   } else {
 702     EMIT(0x87);
 703     EMIT(0xC0 | src.code() << 3 | dst.code());
 704   }
 705 }
 706
 707
 708 void Assembler::xchg(Register dst, const Operand& src) {
 709   EnsureSpace ensure_space(this);
 710   EMIT(0x87);
 711   emit_operand(dst, src);
 712 }
 713
 714
 715 void Assembler::adc(Register dst, int32_t imm32) {
 716   EnsureSpace ensure_space(this);
 717   emit_arith(2, Operand(dst), Immediate(imm32));
 718 }
 719
 720
 721 void Assembler::adc(Register dst, const Operand& src) {
 722   EnsureSpace ensure_space(this);
 723   EMIT(0x13);
 724   emit_operand(dst, src);
 725 }
 726
 727
 728 void Assembler::add(Register dst, const Operand& src) {
 729   EnsureSpace ensure_space(this);
 730   EMIT(0x03);
 731   emit_operand(dst, src);
 732 }
 733
 734
 735 void Assembler::add(const Operand& dst, Register src) {
 736   EnsureSpace ensure_space(this);
 737   EMIT(0x01);
 738   emit_operand(src, dst);
 739 }
 740
 741
 742 void Assembler::add(const Operand& dst, const Immediate& x) {
 743   DCHECK(reloc_info_writer.last_pc() != NULL);
 744   EnsureSpace ensure_space(this);
 745   emit_arith(0, dst, x);
 746 }
 747
 748
 749 void Assembler::and_(Register dst, int32_t imm32) {
 750   and_(dst, Immediate(imm32));
 751 }
 752
 753
 754 void Assembler::and_(Register dst, const Immediate& x) {
 755   EnsureSpace ensure_space(this);
 756   emit_arith(4, Operand(dst), x);
 757 }
 758
 759
 760 void Assembler::and_(Register dst, const Operand& src) {
 761   EnsureSpace ensure_space(this);
 762   EMIT(0x23);
 763   emit_operand(dst, src);
 764 }
 765
 766
 767 void Assembler::and_(const Operand& dst, const Immediate& x) {
 768   EnsureSpace ensure_space(this);
 769   emit_arith(4, dst, x);
 770 }
 771
 772
 773 void Assembler::and_(const Operand& dst, Register src) {
 774   EnsureSpace ensure_space(this);
 775   EMIT(0x21);
 776   emit_operand(src, dst);
 777 }
 778
 779
 780 void Assembler::cmpb(const Operand& op, int8_t imm8) {
 781   EnsureSpace ensure_space(this);
 782   if (op.is_reg(eax)) {
 783     EMIT(0x3C);
 784   } else {
 785     EMIT(0x80);
 786     emit_operand(edi, op);  // edi == 7
 787   }
 788   EMIT(imm8);
 789 }
 790
 791
 792 void Assembler::cmpb(const Operand& op, Register reg) {
 793   CHECK(reg.is_byte_register());
 794   EnsureSpace ensure_space(this);
 795   EMIT(0x38);
 796   emit_operand(reg, op);
 797 }
 798
 799
 800 void Assembler::cmpb(Register reg, const Operand& op) {
 801   CHECK(reg.is_byte_register());
 802   EnsureSpace ensure_space(this);
 803   EMIT(0x3A);
 804   emit_operand(reg, op);
 805 }
 806
 807
 808 void Assembler::cmpw(const Operand& op, Immediate imm16) {
 809   DCHECK(imm16.is_int16());
 810   EnsureSpace ensure_space(this);
 811   EMIT(0x66);
 812   EMIT(0x81);
 813   emit_operand(edi, op);
 814   emit_w(imm16);
 815 }
 816
 817
 818 void Assembler::cmp(Register reg, int32_t imm32) {
 819   EnsureSpace ensure_space(this);
 820   emit_arith(7, Operand(reg), Immediate(imm32));
 821 }
 822
 823
 824 void Assembler::cmp(Register reg, Handle<Object> handle) {
 825   EnsureSpace ensure_space(this);
 826   emit_arith(7, Operand(reg), Immediate(handle));
 827 }
 828
 829
 830 void Assembler::cmp(Register reg, const Operand& op) {
 831   EnsureSpace ensure_space(this);
 832   EMIT(0x3B);
 833   emit_operand(reg, op);
 834 }
 835
 836
 837 void Assembler::cmp(const Operand& op, const Immediate& imm) {
 838   EnsureSpace ensure_space(this);
 839   emit_arith(7, op, imm);
 840 }
 841
 842
 843 void Assembler::cmp(const Operand& op, Handle<Object> handle) {
 844   EnsureSpace ensure_space(this);
 845   emit_arith(7, op, Immediate(handle));
 846 }
 847
 848
 849 void Assembler::cmpb_al(const Operand& op) {
 850   EnsureSpace ensure_space(this);
 851   EMIT(0x38);  // CMP r/m8, r8
 852   emit_operand(eax, op);  // eax has same code as register al.
 853 }
 854
 855
 856 void Assembler::cmpw_ax(const Operand& op) {
 857   EnsureSpace ensure_space(this);
 858   EMIT(0x66);
 859   EMIT(0x39);  // CMP r/m16, r16
 860   emit_operand(eax, op);  // eax has same code as register ax.
 861 }
 862
 863
 864 void Assembler::dec_b(Register dst) {
 865   CHECK(dst.is_byte_register());
 866   EnsureSpace ensure_space(this);
 867   EMIT(0xFE);
 868   EMIT(0xC8 | dst.code());
 869 }
 870
 871
 872 void Assembler::dec_b(const Operand& dst) {
 873   EnsureSpace ensure_space(this);
 874   EMIT(0xFE);
 875   emit_operand(ecx, dst);
 876 }
 877
 878
 879 void Assembler::dec(Register dst) {
 880   EnsureSpace ensure_space(this);
 881   EMIT(0x48 | dst.code());
 882 }
 883
 884
 885 void Assembler::dec(const Operand& dst) {
 886   EnsureSpace ensure_space(this);
 887   EMIT(0xFF);
 888   emit_operand(ecx, dst);
 889 }
 890
 891
 892 void Assembler::cdq() {
 893   EnsureSpace ensure_space(this);
 894   EMIT(0x99);
 895 }
 896
 897
 898 void Assembler::idiv(const Operand& src) {
 899   EnsureSpace ensure_space(this);
 900   EMIT(0xF7);
 901   emit_operand(edi, src);
 902 }
 903
 904
 905 void Assembler::div(const Operand& src) {
 906   EnsureSpace ensure_space(this);
 907   EMIT(0xF7);
 908   emit_operand(esi, src);
 909 }
 910
 911
 912 void Assembler::imul(Register reg) {
 913   EnsureSpace ensure_space(this);
 914   EMIT(0xF7);
 915   EMIT(0xE8 | reg.code());
 916 }
 917
 918
 919 void Assembler::imul(Register dst, const Operand& src) {
 920   EnsureSpace ensure_space(this);
 921   EMIT(0x0F);
 922   EMIT(0xAF);
 923   emit_operand(dst, src);
 924 }
 925
 926
 927 void Assembler::imul(Register dst, Register src, int32_t imm32) {
 928   imul(dst, Operand(src), imm32);
 929 }
 930
 931
 932 void Assembler::imul(Register dst, const Operand& src, int32_t imm32) {
 933   EnsureSpace ensure_space(this);
 934   if (is_int8(imm32)) {
 935     EMIT(0x6B);
 936     emit_operand(dst, src);
 937     EMIT(imm32);
 938   } else {
 939     EMIT(0x69);
 940     emit_operand(dst, src);
 941     emit(imm32);
 942   }
 943 }
 944
 945
 946 void Assembler::inc(Register dst) {
 947   EnsureSpace ensure_space(this);
 948   EMIT(0x40 | dst.code());
 949 }
 950
 951
 952 void Assembler::inc(const Operand& dst) {
 953   EnsureSpace ensure_space(this);
 954   EMIT(0xFF);
 955   emit_operand(eax, dst);
 956 }
 957
 958
 959 void Assembler::lea(Register dst, const Operand& src) {
 960   EnsureSpace ensure_space(this);
 961   EMIT(0x8D);
 962   emit_operand(dst, src);
 963 }
 964
 965
 966 void Assembler::mul(Register src) {
 967   EnsureSpace ensure_space(this);
 968   EMIT(0xF7);
 969   EMIT(0xE0 | src.code());
 970 }
 971
 972
 973 void Assembler::neg(Register dst) {
 974   EnsureSpace ensure_space(this);
 975   EMIT(0xF7);
 976   EMIT(0xD8 | dst.code());
 977 }
 978
 979
 980 void Assembler::neg(const Operand& dst) {
 981   EnsureSpace ensure_space(this);
 982   EMIT(0xF7);
 983   emit_operand(ebx, dst);
 984 }
 985
 986
 987 void Assembler::not_(Register dst) {
 988   EnsureSpace ensure_space(this);
 989   EMIT(0xF7);
 990   EMIT(0xD0 | dst.code());
 991 }
 992
 993
 994 void Assembler::not_(const Operand& dst) {
 995   EnsureSpace ensure_space(this);
 996   EMIT(0xF7);
 997   emit_operand(edx, dst);
 998 }
 999
1000
1001 void Assembler::or_(Register dst, int32_t imm32) {
1002   EnsureSpace ensure_space(this);
1003   emit_arith(1, Operand(dst), Immediate(imm32));
1004 }
1005
1006
1007 void Assembler::or_(Register dst, const Operand& src) {
1008   EnsureSpace ensure_space(this);
1009   EMIT(0x0B);
1010   emit_operand(dst, src);
1011 }
1012
1013
1014 void Assembler::or_(const Operand& dst, const Immediate& x) {
1015   EnsureSpace ensure_space(this);
1016   emit_arith(1, dst, x);
1017 }
1018
1019
1020 void Assembler::or_(const Operand& dst, Register src) {
1021   EnsureSpace ensure_space(this);
1022   EMIT(0x09);
1023   emit_operand(src, dst);
1024 }
1025
1026
1027 void Assembler::rcl(Register dst, uint8_t imm8) {
1028   EnsureSpace ensure_space(this);
1029   DCHECK(is_uint5(imm8));  // illegal shift count
1030   if (imm8 == 1) {
1031     EMIT(0xD1);
1032     EMIT(0xD0 | dst.code());
1033   } else {
1034     EMIT(0xC1);
1035     EMIT(0xD0 | dst.code());
1036     EMIT(imm8);
1037   }
1038 }
1039
1040
1041 void Assembler::rcr(Register dst, uint8_t imm8) {
1042   EnsureSpace ensure_space(this);
1043   DCHECK(is_uint5(imm8));  // illegal shift count
1044   if (imm8 == 1) {
1045     EMIT(0xD1);
1046     EMIT(0xD8 | dst.code());
1047   } else {
1048     EMIT(0xC1);
1049     EMIT(0xD8 | dst.code());
1050     EMIT(imm8);
1051   }
1052 }
1053
1054
1055 void Assembler::ror(const Operand& dst, uint8_t imm8) {
1056   EnsureSpace ensure_space(this);
1057   DCHECK(is_uint5(imm8));  // illegal shift count
1058   if (imm8 == 1) {
1059     EMIT(0xD1);
1060     emit_operand(ecx, dst);
1061   } else {
1062     EMIT(0xC1);
1063     emit_operand(ecx, dst);
1064     EMIT(imm8);
1065   }
1066 }
1067
1068
1069 void Assembler::ror_cl(const Operand& dst) {
1070   EnsureSpace ensure_space(this);
1071   EMIT(0xD3);
1072   emit_operand(ecx, dst);
1073 }
1074
1075
1076 void Assembler::sar(const Operand& dst, uint8_t imm8) {
1077   EnsureSpace ensure_space(this);
1078   DCHECK(is_uint5(imm8));  // illegal shift count
1079   if (imm8 == 1) {
1080     EMIT(0xD1);
1081     emit_operand(edi, dst);
1082   } else {
1083     EMIT(0xC1);
1084     emit_operand(edi, dst);
1085     EMIT(imm8);
1086   }
1087 }
1088
1089
1090 void Assembler::sar_cl(const Operand& dst) {
1091   EnsureSpace ensure_space(this);
1092   EMIT(0xD3);
1093   emit_operand(edi, dst);
1094 }
1095
1096
1097 void Assembler::sbb(Register dst, const Operand& src) {
1098   EnsureSpace ensure_space(this);
1099   EMIT(0x1B);
1100   emit_operand(dst, src);
1101 }
1102
1103
1104 void Assembler::shld(Register dst, const Operand& src) {
1105   EnsureSpace ensure_space(this);
1106   EMIT(0x0F);
1107   EMIT(0xA5);
1108   emit_operand(dst, src);
1109 }
1110
1111
1112 void Assembler::shl(const Operand& dst, uint8_t imm8) {
1113   EnsureSpace ensure_space(this);
1114   DCHECK(is_uint5(imm8));  // illegal shift count
1115   if (imm8 == 1) {
1116     EMIT(0xD1);
1117     emit_operand(esp, dst);
1118   } else {
1119     EMIT(0xC1);
1120     emit_operand(esp, dst);
1121     EMIT(imm8);
1122   }
1123 }
1124
1125
1126 void Assembler::shl_cl(const Operand& dst) {
1127   EnsureSpace ensure_space(this);
1128   EMIT(0xD3);
1129   emit_operand(esp, dst);
1130 }
1131
1132
1133 void Assembler::shrd(Register dst, const Operand& src) {
1134   EnsureSpace ensure_space(this);
1135   EMIT(0x0F);
1136   EMIT(0xAD);
1137   emit_operand(dst, src);
1138 }
1139
1140
1141 void Assembler::shr(const Operand& dst, uint8_t imm8) {
1142   EnsureSpace ensure_space(this);
1143   DCHECK(is_uint5(imm8));  // illegal shift count
1144   if (imm8 == 1) {
1145     EMIT(0xD1);
1146     emit_operand(ebp, dst);
1147   } else {
1148     EMIT(0xC1);
1149     emit_operand(ebp, dst);
1150     EMIT(imm8);
1151   }
1152 }
1153
1154
1155 void Assembler::shr_cl(const Operand& dst) {
1156   EnsureSpace ensure_space(this);
1157   EMIT(0xD3);
1158   emit_operand(ebp, dst);
1159 }
1160
1161
1162 void Assembler::sub(const Operand& dst, const Immediate& x) {
1163   EnsureSpace ensure_space(this);
1164   emit_arith(5, dst, x);
1165 }
1166
1167
1168 void Assembler::sub(Register dst, const Operand& src) {
1169   EnsureSpace ensure_space(this);
1170   EMIT(0x2B);
1171   emit_operand(dst, src);
1172 }
1173
1174
1175 void Assembler::sub(const Operand& dst, Register src) {
1176   EnsureSpace ensure_space(this);
1177   EMIT(0x29);
1178   emit_operand(src, dst);
1179 }
1180
1181
1182 void Assembler::test(Register reg, const Immediate& imm) {
1183   if (RelocInfo::IsNone(imm.rmode_) && is_uint8(imm.x_)) {
1184     test_b(reg, imm.x_);
1185     return;
1186   }
1187
1188   EnsureSpace ensure_space(this);
1189   // This is not using emit_arith because test doesn't support
1190   // sign-extension of 8-bit operands.
1191   if (reg.is(eax)) {
1192     EMIT(0xA9);
1193   } else {
1194     EMIT(0xF7);
1195     EMIT(0xC0 | reg.code());
1196   }
1197   emit(imm);
1198 }
1199
1200
1201 void Assembler::test(Register reg, const Operand& op) {
1202   EnsureSpace ensure_space(this);
1203   EMIT(0x85);
1204   emit_operand(reg, op);
1205 }
1206
1207
1208 void Assembler::test_b(Register reg, const Operand& op) {
1209   CHECK(reg.is_byte_register());
1210   EnsureSpace ensure_space(this);
1211   EMIT(0x84);
1212   emit_operand(reg, op);
1213 }
1214
1215
1216 void Assembler::test(const Operand& op, const Immediate& imm) {
1217   if (op.is_reg_only()) {
1218     test(op.reg(), imm);
1219     return;
1220   }
1221   if (RelocInfo::IsNone(imm.rmode_) && is_uint8(imm.x_)) {
1222     return test_b(op, imm.x_);
1223   }
1224   EnsureSpace ensure_space(this);
1225   EMIT(0xF7);
1226   emit_operand(eax, op);
1227   emit(imm);
1228 }
1229
1230
1231 void Assembler::test_b(Register reg, uint8_t imm8) {
1232   EnsureSpace ensure_space(this);
1233   // Only use test against byte for registers that have a byte
1234   // variant: eax, ebx, ecx, and edx.
1235   if (reg.is(eax)) {
1236     EMIT(0xA8);
1237     EMIT(imm8);
1238   } else if (reg.is_byte_register()) {
1239     emit_arith_b(0xF6, 0xC0, reg, imm8);
1240   } else {
1241     EMIT(0xF7);
1242     EMIT(0xC0 | reg.code());
1243     emit(imm8);
1244   }
1245 }
1246
1247
1248 void Assembler::test_b(const Operand& op, uint8_t imm8) {
1249   if (op.is_reg_only()) {
1250     test_b(op.reg(), imm8);
1251     return;
1252   }
1253   EnsureSpace ensure_space(this);
1254   EMIT(0xF6);
1255   emit_operand(eax, op);
1256   EMIT(imm8);
1257 }
1258
1259
1260 void Assembler::xor_(Register dst, int32_t imm32) {
1261   EnsureSpace ensure_space(this);
1262   emit_arith(6, Operand(dst), Immediate(imm32));
1263 }
1264
1265
1266 void Assembler::xor_(Register dst, const Operand& src) {
1267   EnsureSpace ensure_space(this);
1268   EMIT(0x33);
1269   emit_operand(dst, src);
1270 }
1271
1272
1273 void Assembler::xor_(const Operand& dst, Register src) {
1274   EnsureSpace ensure_space(this);
1275   EMIT(0x31);
1276   emit_operand(src, dst);
1277 }
1278
1279
1280 void Assembler::xor_(const Operand& dst, const Immediate& x) {
1281   EnsureSpace ensure_space(this);
1282   emit_arith(6, dst, x);
1283 }
1284
1285
1286 void Assembler::bt(const Operand& dst, Register src) {
1287   EnsureSpace ensure_space(this);
1288   EMIT(0x0F);
1289   EMIT(0xA3);
1290   emit_operand(src, dst);
1291 }
1292
1293
1294 void Assembler::bts(const Operand& dst, Register src) {
1295   EnsureSpace ensure_space(this);
1296   EMIT(0x0F);
1297   EMIT(0xAB);
1298   emit_operand(src, dst);
1299 }
1300
1301
1302 void Assembler::bsr(Register dst, const Operand& src) {
1303   EnsureSpace ensure_space(this);
1304   EMIT(0x0F);
1305   EMIT(0xBD);
1306   emit_operand(dst, src);
1307 }
1308
1309
1310 void Assembler::hlt() {
1311   EnsureSpace ensure_space(this);
1312   EMIT(0xF4);
1313 }
1314
1315
1316 void Assembler::int3() {
1317   EnsureSpace ensure_space(this);
1318   EMIT(0xCC);
1319 }
1320
1321
1322 void Assembler::nop() {
1323   EnsureSpace ensure_space(this);
1324   EMIT(0x90);
1325 }
1326
1327
1328 void Assembler::ret(int imm16) {
1329   EnsureSpace ensure_space(this);
1330   DCHECK(is_uint16(imm16));
1331   if (imm16 == 0) {
1332     EMIT(0xC3);
1333   } else {
1334     EMIT(0xC2);
1335     EMIT(imm16 & 0xFF);
1336     EMIT((imm16 >> 8) & 0xFF);
1337   }
1338 }
1339
1340
1341 void Assembler::ud2() {
1342   EnsureSpace ensure_space(this);
1343   EMIT(0x0F);
1344   EMIT(0x0B);
1345 }
1346
1347
1348 // Labels refer to positions in the (to be) generated code.
1349 // There are bound, linked, and unused labels.
1350 //
1351 // Bound labels refer to known positions in the already
1352 // generated code. pos() is the position the label refers to.
1353 //
1354 // Linked labels refer to unknown positions in the code
1355 // to be generated; pos() is the position of the 32bit
1356 // Displacement of the last instruction using the label.
1357
1358
1359 void Assembler::print(Label* L) {
1360   if (L->is_unused()) {
1361     PrintF("unused label\n");
1362   } else if (L->is_bound()) {
1363     PrintF("bound label to %d\n", L->pos());
1364   } else if (L->is_linked()) {
1365     Label l = *L;
1366     PrintF("unbound label");
1367     while (l.is_linked()) {
1368       Displacement disp = disp_at(&l);
1369       PrintF("@ %d ", l.pos());
1370       disp.print();
1371       PrintF("\n");
1372       disp.next(&l);
1373     }
1374   } else {
1375     PrintF("label in inconsistent state (pos = %d)\n", L->pos_);
1376   }
1377 }
1378
1379
1380 void Assembler::bind_to(Label* L, int pos) {
1381   EnsureSpace ensure_space(this);
1382   DCHECK(0 <= pos && pos <= pc_offset());  // must have a valid binding position
1383   while (L->is_linked()) {
1384     Displacement disp = disp_at(L);
1385     int fixup_pos = L->pos();
1386     if (disp.type() == Displacement::CODE_ABSOLUTE) {
1387       long_at_put(fixup_pos, reinterpret_cast<int>(buffer_ + pos));
1388       internal_reference_positions_.push_back(fixup_pos);
1389     } else if (disp.type() == Displacement::CODE_RELATIVE) {
1390       // Relative to Code* heap object pointer.
1391       long_at_put(fixup_pos, pos + Code::kHeaderSize - kHeapObjectTag);
1392     } else {
1393       if (disp.type() == Displacement::UNCONDITIONAL_JUMP) {
1394         DCHECK(byte_at(fixup_pos - 1) == 0xE9);  // jmp expected
1395       }
1396       // Relative address, relative to point after address.
1397       int imm32 = pos - (fixup_pos + sizeof(int32_t));
1398       long_at_put(fixup_pos, imm32);
1399     }
1400     disp.next(L);
1401   }
1402   while (L->is_near_linked()) {
1403     int fixup_pos = L->near_link_pos();
1404     int offset_to_next =
1405         static_cast<int>(*reinterpret_cast<int8_t*>(addr_at(fixup_pos)));
1406     DCHECK(offset_to_next <= 0);
1407     // Relative address, relative to point after address.
1408     int disp = pos - fixup_pos - sizeof(int8_t);
1409     CHECK(0 <= disp && disp <= 127);
1410     set_byte_at(fixup_pos, disp);
1411     if (offset_to_next < 0) {
1412       L->link_to(fixup_pos + offset_to_next, Label::kNear);
1413     } else {
1414       L->UnuseNear();
1415     }
1416   }
1417   L->bind_to(pos);
1418 }
1419
1420
1421 void Assembler::bind(Label* L) {
1422   EnsureSpace ensure_space(this);
1423   DCHECK(!L->is_bound());  // label can only be bound once
1424   bind_to(L, pc_offset());
1425 }
1426
1427
1428 void Assembler::call(Label* L) {
1429   positions_recorder()->WriteRecordedPositions();
1430   EnsureSpace ensure_space(this);
1431   if (L->is_bound()) {
1432     const int long_size = 5;
1433     int offs = L->pos() - pc_offset();
1434     DCHECK(offs <= 0);
1435     // 1110 1000 #32-bit disp.
1436     EMIT(0xE8);
1437     emit(offs - long_size);
1438   } else {
1439     // 1110 1000 #32-bit disp.
1440     EMIT(0xE8);
1441     emit_disp(L, Displacement::OTHER);
1442   }
1443 }
1444
1445
1446 void Assembler::call(byte* entry, RelocInfo::Mode rmode) {
1447   positions_recorder()->WriteRecordedPositions();
1448   EnsureSpace ensure_space(this);
1449   DCHECK(!RelocInfo::IsCodeTarget(rmode));
1450   EMIT(0xE8);
1451   if (RelocInfo::IsRuntimeEntry(rmode)) {
1452     emit(reinterpret_cast<uint32_t>(entry), rmode);
1453   } else {
1454     emit(entry - (pc_ + sizeof(int32_t)), rmode);
1455   }
1456 }
1457
1458
1459 int Assembler::CallSize(const Operand& adr) {
1460   // Call size is 1 (opcode) + adr.len_ (operand).
1461   return 1 + adr.len_;
1462 }
1463
1464
1465 void Assembler::call(const Operand& adr) {
1466   positions_recorder()->WriteRecordedPositions();
1467   EnsureSpace ensure_space(this);
1468   EMIT(0xFF);
1469   emit_operand(edx, adr);
1470 }
1471
1472
1473 int Assembler::CallSize(Handle<Code> code, RelocInfo::Mode rmode) {
1474   return 1 /* EMIT */ + sizeof(uint32_t) /* emit */;
1475 }
1476
1477
1478 void Assembler::call(Handle<Code> code,
1479                      RelocInfo::Mode rmode,
1480                      TypeFeedbackId ast_id) {
1481   positions_recorder()->WriteRecordedPositions();
1482   EnsureSpace ensure_space(this);
1483   DCHECK(RelocInfo::IsCodeTarget(rmode)
1484       || rmode == RelocInfo::CODE_AGE_SEQUENCE);
1485   EMIT(0xE8);
1486   emit(code, rmode, ast_id);
1487 }
1488
1489
1490 void Assembler::jmp(Label* L, Label::Distance distance) {
1491   EnsureSpace ensure_space(this);
1492   if (L->is_bound()) {
1493     const int short_size = 2;
1494     const int long_size  = 5;
1495     int offs = L->pos() - pc_offset();
1496     DCHECK(offs <= 0);
1497     if (is_int8(offs - short_size)) {
1498       // 1110 1011 #8-bit disp.
1499       EMIT(0xEB);
1500       EMIT((offs - short_size) & 0xFF);
1501     } else {
1502       // 1110 1001 #32-bit disp.
1503       EMIT(0xE9);
1504       emit(offs - long_size);
1505     }
1506   } else if (distance == Label::kNear) {
1507     EMIT(0xEB);
1508     emit_near_disp(L);
1509   } else {
1510     // 1110 1001 #32-bit disp.
1511     EMIT(0xE9);
1512     emit_disp(L, Displacement::UNCONDITIONAL_JUMP);
1513   }
1514 }
1515
1516
1517 void Assembler::jmp(byte* entry, RelocInfo::Mode rmode) {
1518   EnsureSpace ensure_space(this);
1519   DCHECK(!RelocInfo::IsCodeTarget(rmode));
1520   EMIT(0xE9);
1521   if (RelocInfo::IsRuntimeEntry(rmode)) {
1522     emit(reinterpret_cast<uint32_t>(entry), rmode);
1523   } else {
1524     emit(entry - (pc_ + sizeof(int32_t)), rmode);
1525   }
1526 }
1527
1528
1529 void Assembler::jmp(const Operand& adr) {
1530   EnsureSpace ensure_space(this);
1531   EMIT(0xFF);
1532   emit_operand(esp, adr);
1533 }
1534
1535
1536 void Assembler::jmp(Handle<Code> code, RelocInfo::Mode rmode) {
1537   EnsureSpace ensure_space(this);
1538   DCHECK(RelocInfo::IsCodeTarget(rmode));
1539   EMIT(0xE9);
1540   emit(code, rmode);
1541 }
1542
1543
1544 void Assembler::j(Condition cc, Label* L, Label::Distance distance) {
1545   EnsureSpace ensure_space(this);
1546   DCHECK(0 <= cc && static_cast<int>(cc) < 16);
1547   if (L->is_bound()) {
1548     const int short_size = 2;
1549     const int long_size  = 6;
1550     int offs = L->pos() - pc_offset();
1551     DCHECK(offs <= 0);
1552     if (is_int8(offs - short_size)) {
1553       // 0111 tttn #8-bit disp
1554       EMIT(0x70 | cc);
1555       EMIT((offs - short_size) & 0xFF);
1556     } else {
1557       // 0000 1111 1000 tttn #32-bit disp
1558       EMIT(0x0F);
1559       EMIT(0x80 | cc);
1560       emit(offs - long_size);
1561     }
1562   } else if (distance == Label::kNear) {
1563     EMIT(0x70 | cc);
1564     emit_near_disp(L);
1565   } else {
1566     // 0000 1111 1000 tttn #32-bit disp
1567     // Note: could eliminate cond. jumps to this jump if condition
1568     //       is the same however, seems to be rather unlikely case.
1569     EMIT(0x0F);
1570     EMIT(0x80 | cc);
1571     emit_disp(L, Displacement::OTHER);
1572   }
1573 }
1574
1575
1576 void Assembler::j(Condition cc, byte* entry, RelocInfo::Mode rmode) {
1577   EnsureSpace ensure_space(this);
1578   DCHECK((0 <= cc) && (static_cast<int>(cc) < 16));
1579   // 0000 1111 1000 tttn #32-bit disp.
1580   EMIT(0x0F);
1581   EMIT(0x80 | cc);
1582   if (RelocInfo::IsRuntimeEntry(rmode)) {
1583     emit(reinterpret_cast<uint32_t>(entry), rmode);
1584   } else {
1585     emit(entry - (pc_ + sizeof(int32_t)), rmode);
1586   }
1587 }
1588
1589
1590 void Assembler::j(Condition cc, Handle<Code> code, RelocInfo::Mode rmode) {
1591   EnsureSpace ensure_space(this);
1592   // 0000 1111 1000 tttn #32-bit disp
1593   EMIT(0x0F);
1594   EMIT(0x80 | cc);
1595   emit(code, rmode);
1596 }
1597
1598
1599 // FPU instructions.
1600
1601 void Assembler::fld(int i) {
1602   EnsureSpace ensure_space(this);
1603   emit_farith(0xD9, 0xC0, i);
1604 }
1605
1606
1607 void Assembler::fstp(int i) {
1608   EnsureSpace ensure_space(this);
1609   emit_farith(0xDD, 0xD8, i);
1610 }
1611
1612
1613 void Assembler::fld1() {
1614   EnsureSpace ensure_space(this);
1615   EMIT(0xD9);
1616   EMIT(0xE8);
1617 }
1618
1619
1620 void Assembler::fldpi() {
1621   EnsureSpace ensure_space(this);
1622   EMIT(0xD9);
1623   EMIT(0xEB);
1624 }
1625
1626
1627 void Assembler::fldz() {
1628   EnsureSpace ensure_space(this);
1629   EMIT(0xD9);
1630   EMIT(0xEE);
1631 }
1632
1633
1634 void Assembler::fldln2() {
1635   EnsureSpace ensure_space(this);
1636   EMIT(0xD9);
1637   EMIT(0xED);
1638 }
1639
1640
1641 void Assembler::fld_s(const Operand& adr) {
1642   EnsureSpace ensure_space(this);
1643   EMIT(0xD9);
1644   emit_operand(eax, adr);
1645 }
1646
1647
1648 void Assembler::fld_d(const Operand& adr) {
1649   EnsureSpace ensure_space(this);
1650   EMIT(0xDD);
1651   emit_operand(eax, adr);
1652 }
1653
1654
1655 void Assembler::fstp_s(const Operand& adr) {
1656   EnsureSpace ensure_space(this);
1657   EMIT(0xD9);
1658   emit_operand(ebx, adr);
1659 }
1660
1661
1662 void Assembler::fst_s(const Operand& adr) {
1663   EnsureSpace ensure_space(this);
1664   EMIT(0xD9);
1665   emit_operand(edx, adr);
1666 }
1667
1668
1669 void Assembler::fstp_d(const Operand& adr) {
1670   EnsureSpace ensure_space(this);
1671   EMIT(0xDD);
1672   emit_operand(ebx, adr);
1673 }
1674
1675
1676 void Assembler::fst_d(const Operand& adr) {
1677   EnsureSpace ensure_space(this);
1678   EMIT(0xDD);
1679   emit_operand(edx, adr);
1680 }
1681
1682
1683 void Assembler::fild_s(const Operand& adr) {
1684   EnsureSpace ensure_space(this);
1685   EMIT(0xDB);
1686   emit_operand(eax, adr);
1687 }
1688
1689
1690 void Assembler::fild_d(const Operand& adr) {
1691   EnsureSpace ensure_space(this);
1692   EMIT(0xDF);
1693   emit_operand(ebp, adr);
1694 }
1695
1696
1697 void Assembler::fistp_s(const Operand& adr) {
1698   EnsureSpace ensure_space(this);
1699   EMIT(0xDB);
1700   emit_operand(ebx, adr);
1701 }
1702
1703
1704 void Assembler::fisttp_s(const Operand& adr) {
1705   DCHECK(IsEnabled(SSE3));
1706   EnsureSpace ensure_space(this);
1707   EMIT(0xDB);
1708   emit_operand(ecx, adr);
1709 }
1710
1711
1712 void Assembler::fisttp_d(const Operand& adr) {
1713   DCHECK(IsEnabled(SSE3));
1714   EnsureSpace ensure_space(this);
1715   EMIT(0xDD);
1716   emit_operand(ecx, adr);
1717 }
1718
1719
1720 void Assembler::fist_s(const Operand& adr) {
1721   EnsureSpace ensure_space(this);
1722   EMIT(0xDB);
1723   emit_operand(edx, adr);
1724 }
1725
1726
1727 void Assembler::fistp_d(const Operand& adr) {
1728   EnsureSpace ensure_space(this);
1729   EMIT(0xDF);
1730   emit_operand(edi, adr);
1731 }
1732
1733
1734 void Assembler::fabs() {
1735   EnsureSpace ensure_space(this);
1736   EMIT(0xD9);
1737   EMIT(0xE1);
1738 }
1739
1740
1741 void Assembler::fchs() {
1742   EnsureSpace ensure_space(this);
1743   EMIT(0xD9);
1744   EMIT(0xE0);
1745 }
1746
1747
1748 void Assembler::fcos() {
1749   EnsureSpace ensure_space(this);
1750   EMIT(0xD9);
1751   EMIT(0xFF);
1752 }
1753
1754
1755 void Assembler::fsin() {
1756   EnsureSpace ensure_space(this);
1757   EMIT(0xD9);
1758   EMIT(0xFE);
1759 }
1760
1761
1762 void Assembler::fptan() {
1763   EnsureSpace ensure_space(this);
1764   EMIT(0xD9);
1765   EMIT(0xF2);
1766 }
1767
1768
1769 void Assembler::fyl2x() {
1770   EnsureSpace ensure_space(this);
1771   EMIT(0xD9);
1772   EMIT(0xF1);
1773 }
1774
1775
1776 void Assembler::f2xm1() {
1777   EnsureSpace ensure_space(this);
1778   EMIT(0xD9);
1779   EMIT(0xF0);
1780 }
1781
1782
1783 void Assembler::fscale() {
1784   EnsureSpace ensure_space(this);
1785   EMIT(0xD9);
1786   EMIT(0xFD);
1787 }
1788
1789
1790 void Assembler::fninit() {
1791   EnsureSpace ensure_space(this);
1792   EMIT(0xDB);
1793   EMIT(0xE3);
1794 }
1795
1796
1797 void Assembler::fadd(int i) {
1798   EnsureSpace ensure_space(this);
1799   emit_farith(0xDC, 0xC0, i);
1800 }
1801
1802
1803 void Assembler::fadd_i(int i) {
1804   EnsureSpace ensure_space(this);
1805   emit_farith(0xD8, 0xC0, i);
1806 }
1807
1808
1809 void Assembler::fsub(int i) {
1810   EnsureSpace ensure_space(this);
1811   emit_farith(0xDC, 0xE8, i);
1812 }
1813
1814
1815 void Assembler::fsub_i(int i) {
1816   EnsureSpace ensure_space(this);
1817   emit_farith(0xD8, 0xE0, i);
1818 }
1819
1820
1821 void Assembler::fisub_s(const Operand& adr) {
1822   EnsureSpace ensure_space(this);
1823   EMIT(0xDA);
1824   emit_operand(esp, adr);
1825 }
1826
1827
1828 void Assembler::fmul_i(int i) {
1829   EnsureSpace ensure_space(this);
1830   emit_farith(0xD8, 0xC8, i);
1831 }
1832
1833
1834 void Assembler::fmul(int i) {
1835   EnsureSpace ensure_space(this);
1836   emit_farith(0xDC, 0xC8, i);
1837 }
1838
1839
1840 void Assembler::fdiv(int i) {
1841   EnsureSpace ensure_space(this);
1842   emit_farith(0xDC, 0xF8, i);
1843 }
1844
1845
1846 void Assembler::fdiv_i(int i) {
1847   EnsureSpace ensure_space(this);
1848   emit_farith(0xD8, 0xF0, i);
1849 }
1850
1851
1852 void Assembler::faddp(int i) {
1853   EnsureSpace ensure_space(this);
1854   emit_farith(0xDE, 0xC0, i);
1855 }
1856
1857
1858 void Assembler::fsubp(int i) {
1859   EnsureSpace ensure_space(this);
1860   emit_farith(0xDE, 0xE8, i);
1861 }
1862
1863
1864 void Assembler::fsubrp(int i) {
1865   EnsureSpace ensure_space(this);
1866   emit_farith(0xDE, 0xE0, i);
1867 }
1868
1869
1870 void Assembler::fmulp(int i) {
1871   EnsureSpace ensure_space(this);
1872   emit_farith(0xDE, 0xC8, i);
1873 }
1874
1875
1876 void Assembler::fdivp(int i) {
1877   EnsureSpace ensure_space(this);
1878   emit_farith(0xDE, 0xF8, i);
1879 }
1880
1881
1882 void Assembler::fprem() {
1883   EnsureSpace ensure_space(this);
1884   EMIT(0xD9);
1885   EMIT(0xF8);
1886 }
1887
1888
1889 void Assembler::fprem1() {
1890   EnsureSpace ensure_space(this);
1891   EMIT(0xD9);
1892   EMIT(0xF5);
1893 }
1894
1895
1896 void Assembler::fxch(int i) {
1897   EnsureSpace ensure_space(this);
1898   emit_farith(0xD9, 0xC8, i);
1899 }
1900
1901
1902 void Assembler::fincstp() {
1903   EnsureSpace ensure_space(this);
1904   EMIT(0xD9);
1905   EMIT(0xF7);
1906 }
1907
1908
1909 void Assembler::ffree(int i) {
1910   EnsureSpace ensure_space(this);
1911   emit_farith(0xDD, 0xC0, i);
1912 }
1913
1914
1915 void Assembler::ftst() {
1916   EnsureSpace ensure_space(this);
1917   EMIT(0xD9);
1918   EMIT(0xE4);
1919 }
1920
1921
1922 void Assembler::fucomp(int i) {
1923   EnsureSpace ensure_space(this);
1924   emit_farith(0xDD, 0xE8, i);
1925 }
1926
1927
1928 void Assembler::fucompp() {
1929   EnsureSpace ensure_space(this);
1930   EMIT(0xDA);
1931   EMIT(0xE9);
1932 }
1933
1934
1935 void Assembler::fucomi(int i) {
1936   EnsureSpace ensure_space(this);
1937   EMIT(0xDB);
1938   EMIT(0xE8 + i);
1939 }
1940
1941
1942 void Assembler::fucomip() {
1943   EnsureSpace ensure_space(this);
1944   EMIT(0xDF);
1945   EMIT(0xE9);
1946 }
1947
1948
1949 void Assembler::fcompp() {
1950   EnsureSpace ensure_space(this);
1951   EMIT(0xDE);
1952   EMIT(0xD9);
1953 }
1954
1955
1956 void Assembler::fnstsw_ax() {
1957   EnsureSpace ensure_space(this);
1958   EMIT(0xDF);
1959   EMIT(0xE0);
1960 }
1961
1962
1963 void Assembler::fwait() {
1964   EnsureSpace ensure_space(this);
1965   EMIT(0x9B);
1966 }
1967
1968
1969 void Assembler::frndint() {
1970   EnsureSpace ensure_space(this);
1971   EMIT(0xD9);
1972   EMIT(0xFC);
1973 }
1974
1975
1976 void Assembler::fnclex() {
1977   EnsureSpace ensure_space(this);
1978   EMIT(0xDB);
1979   EMIT(0xE2);
1980 }
1981
1982
1983 void Assembler::sahf() {
1984   EnsureSpace ensure_space(this);
1985   EMIT(0x9E);
1986 }
1987
1988
1989 void Assembler::setcc(Condition cc, Register reg) {
1990   DCHECK(reg.is_byte_register());
1991   EnsureSpace ensure_space(this);
1992   EMIT(0x0F);
1993   EMIT(0x90 | cc);
1994   EMIT(0xC0 | reg.code());
1995 }
1996
1997
1998 void Assembler::cvttss2si(Register dst, const Operand& src) {
1999   EnsureSpace ensure_space(this);
2000   EMIT(0xF3);
2001   EMIT(0x0F);
2002   EMIT(0x2C);
2003   emit_operand(dst, src);
2004 }
2005
2006
2007 void Assembler::cvttsd2si(Register dst, const Operand& src) {
2008   EnsureSpace ensure_space(this);
2009   EMIT(0xF2);
2010   EMIT(0x0F);
2011   EMIT(0x2C);
2012   emit_operand(dst, src);
2013 }
2014
2015
2016 void Assembler::cvtsd2si(Register dst, XMMRegister src) {
2017   EnsureSpace ensure_space(this);
2018   EMIT(0xF2);
2019   EMIT(0x0F);
2020   EMIT(0x2D);
2021   emit_sse_operand(dst, src);
2022 }
2023
2024
2025 void Assembler::cvtsi2sd(XMMRegister dst, const Operand& src) {
2026   EnsureSpace ensure_space(this);
2027   EMIT(0xF2);
2028   EMIT(0x0F);
2029   EMIT(0x2A);
2030   emit_sse_operand(dst, src);
2031 }
2032
2033
2034 void Assembler::cvtss2sd(XMMRegister dst, const Operand& src) {
2035   EnsureSpace ensure_space(this);
2036   EMIT(0xF3);
2037   EMIT(0x0F);
2038   EMIT(0x5A);
2039   emit_sse_operand(dst, src);
2040 }
2041
2042
2043 void Assembler::cvtsd2ss(XMMRegister dst, const Operand& src) {
2044   EnsureSpace ensure_space(this);
2045   EMIT(0xF2);
2046   EMIT(0x0F);
2047   EMIT(0x5A);
2048   emit_sse_operand(dst, src);
2049 }
2050
2051
2052 void Assembler::addsd(XMMRegister dst, const Operand& src) {
2053   EnsureSpace ensure_space(this);
2054   EMIT(0xF2);
2055   EMIT(0x0F);
2056   EMIT(0x58);
2057   emit_sse_operand(dst, src);
2058 }
2059
2060
2061 void Assembler::mulsd(XMMRegister dst, const Operand& src) {
2062   EnsureSpace ensure_space(this);
2063   EMIT(0xF2);
2064   EMIT(0x0F);
2065   EMIT(0x59);
2066   emit_sse_operand(dst, src);
2067 }
2068
2069
2070 void Assembler::subsd(XMMRegister dst, const Operand& src) {
2071   EnsureSpace ensure_space(this);
2072   EMIT(0xF2);
2073   EMIT(0x0F);
2074   EMIT(0x5C);
2075   emit_sse_operand(dst, src);
2076 }
2077
2078
2079 void Assembler::divsd(XMMRegister dst, const Operand& src) {
2080   EnsureSpace ensure_space(this);
2081   EMIT(0xF2);
2082   EMIT(0x0F);
2083   EMIT(0x5E);
2084   emit_sse_operand(dst, src);
2085 }
2086
2087
2088 void Assembler::xorpd(XMMRegister dst, XMMRegister src) {
2089   EnsureSpace ensure_space(this);
2090   EMIT(0x66);
2091   EMIT(0x0F);
2092   EMIT(0x57);
2093   emit_sse_operand(dst, src);
2094 }
2095
2096
2097 void Assembler::andps(XMMRegister dst, const Operand& src) {
2098   EnsureSpace ensure_space(this);
2099   EMIT(0x0F);
2100   EMIT(0x54);
2101   emit_sse_operand(dst, src);
2102 }
2103
2104
2105 void Assembler::orps(XMMRegister dst, const Operand& src) {
2106   EnsureSpace ensure_space(this);
2107   EMIT(0x0F);
2108   EMIT(0x56);
2109   emit_sse_operand(dst, src);
2110 }
2111
2112
2113 void Assembler::xorps(XMMRegister dst, const Operand& src) {
2114   EnsureSpace ensure_space(this);
2115   EMIT(0x0F);
2116   EMIT(0x57);
2117   emit_sse_operand(dst, src);
2118 }
2119
2120
2121 void Assembler::addps(XMMRegister dst, const Operand& src) {
2122   EnsureSpace ensure_space(this);
2123   EMIT(0x0F);
2124   EMIT(0x58);
2125   emit_sse_operand(dst, src);
2126 }
2127
2128
2129 void Assembler::subps(XMMRegister dst, const Operand& src) {
2130   EnsureSpace ensure_space(this);
2131   EMIT(0x0F);
2132   EMIT(0x5C);
2133   emit_sse_operand(dst, src);
2134 }
2135
2136
2137 void Assembler::mulps(XMMRegister dst, const Operand& src) {
2138   EnsureSpace ensure_space(this);
2139   EMIT(0x0F);
2140   EMIT(0x59);
2141   emit_sse_operand(dst, src);
2142 }
2143
2144
2145 void Assembler::divps(XMMRegister dst, const Operand& src) {
2146   EnsureSpace ensure_space(this);
2147   EMIT(0x0F);
2148   EMIT(0x5E);
2149   emit_sse_operand(dst, src);
2150 }
2151
2152
2153 void Assembler::sqrtsd(XMMRegister dst, const Operand& src) {
2154   EnsureSpace ensure_space(this);
2155   EMIT(0xF2);
2156   EMIT(0x0F);
2157   EMIT(0x51);
2158   emit_sse_operand(dst, src);
2159 }
2160
2161
2162 void Assembler::andpd(XMMRegister dst, XMMRegister src) {
2163   EnsureSpace ensure_space(this);
2164   EMIT(0x66);
2165   EMIT(0x0F);
2166   EMIT(0x54);
2167   emit_sse_operand(dst, src);
2168 }
2169
2170
2171 void Assembler::orpd(XMMRegister dst, XMMRegister src) {
2172   EnsureSpace ensure_space(this);
2173   EMIT(0x66);
2174   EMIT(0x0F);
2175   EMIT(0x56);
2176   emit_sse_operand(dst, src);
2177 }
2178
2179
2180 void Assembler::ucomisd(XMMRegister dst, const Operand& src) {
2181   EnsureSpace ensure_space(this);
2182   EMIT(0x66);
2183   EMIT(0x0F);
2184   EMIT(0x2E);
2185   emit_sse_operand(dst, src);
2186 }
2187
2188
2189 void Assembler::roundsd(XMMRegister dst, XMMRegister src, RoundingMode mode) {
2190   DCHECK(IsEnabled(SSE4_1));
2191   EnsureSpace ensure_space(this);
2192   EMIT(0x66);
2193   EMIT(0x0F);
2194   EMIT(0x3A);
2195   EMIT(0x0B);
2196   emit_sse_operand(dst, src);
2197   // Mask precision exeption.
2198   EMIT(static_cast<byte>(mode) | 0x8);
2199 }
2200
2201
2202 void Assembler::movmskpd(Register dst, XMMRegister src) {
2203   EnsureSpace ensure_space(this);
2204   EMIT(0x66);
2205   EMIT(0x0F);
2206   EMIT(0x50);
2207   emit_sse_operand(dst, src);
2208 }
2209
2210
2211 void Assembler::movmskps(Register dst, XMMRegister src) {
2212   EnsureSpace ensure_space(this);
2213   EMIT(0x0F);
2214   EMIT(0x50);
2215   emit_sse_operand(dst, src);
2216 }
2217
2218
2219 void Assembler::pcmpeqd(XMMRegister dst, XMMRegister src) {
2220   EnsureSpace ensure_space(this);
2221   EMIT(0x66);
2222   EMIT(0x0F);
2223   EMIT(0x76);
2224   emit_sse_operand(dst, src);
2225 }
2226
2227
2228 void Assembler::punpckldq(XMMRegister dst, XMMRegister src) {
2229   EnsureSpace ensure_space(this);
2230   EMIT(0x66);
2231   EMIT(0x0F);
2232   EMIT(0x62);
2233   emit_sse_operand(dst, src);
2234 }
2235
2236
2237 void Assembler::punpckhdq(XMMRegister dst, XMMRegister src) {
2238   EnsureSpace ensure_space(this);
2239   EMIT(0x66);
2240   EMIT(0x0F);
2241   EMIT(0x6A);
2242   emit_sse_operand(dst, src);
2243 }
2244
2245
2246 void Assembler::maxsd(XMMRegister dst, const Operand& src) {
2247   EnsureSpace ensure_space(this);
2248   EMIT(0xF2);
2249   EMIT(0x0F);
2250   EMIT(0x5F);
2251   emit_sse_operand(dst, src);
2252 }
2253
2254
2255 void Assembler::minsd(XMMRegister dst, const Operand& src) {
2256   EnsureSpace ensure_space(this);
2257   EMIT(0xF2);
2258   EMIT(0x0F);
2259   EMIT(0x5D);
2260   emit_sse_operand(dst, src);
2261 }
2262
2263
2264 void Assembler::cmpltsd(XMMRegister dst, XMMRegister src) {
2265   EnsureSpace ensure_space(this);
2266   EMIT(0xF2);
2267   EMIT(0x0F);
2268   EMIT(0xC2);
2269   emit_sse_operand(dst, src);
2270   EMIT(1);  // LT == 1
2271 }
2272
2273
2274 void Assembler::movaps(XMMRegister dst, XMMRegister src) {
2275   EnsureSpace ensure_space(this);
2276   EMIT(0x0F);
2277   EMIT(0x28);
2278   emit_sse_operand(dst, src);
2279 }
2280
2281
2282 void Assembler::shufps(XMMRegister dst, XMMRegister src, byte imm8) {
2283   DCHECK(is_uint8(imm8));
2284   EnsureSpace ensure_space(this);
2285   EMIT(0x0F);
2286   EMIT(0xC6);
2287   emit_sse_operand(dst, src);
2288   EMIT(imm8);
2289 }
2290
2291
2292 void Assembler::movdqa(const Operand& dst, XMMRegister src) {
2293   EnsureSpace ensure_space(this);
2294   EMIT(0x66);
2295   EMIT(0x0F);
2296   EMIT(0x7F);
2297   emit_sse_operand(src, dst);
2298 }
2299
2300
2301 void Assembler::movdqa(XMMRegister dst, const Operand& src) {
2302   EnsureSpace ensure_space(this);
2303   EMIT(0x66);
2304   EMIT(0x0F);
2305   EMIT(0x6F);
2306   emit_sse_operand(dst, src);
2307 }
2308
2309
2310 void Assembler::movdqu(const Operand& dst, XMMRegister src ) {
2311   EnsureSpace ensure_space(this);
2312   EMIT(0xF3);
2313   EMIT(0x0F);
2314   EMIT(0x7F);
2315   emit_sse_operand(src, dst);
2316 }
2317
2318
2319 void Assembler::movdqu(XMMRegister dst, const Operand& src) {
2320   EnsureSpace ensure_space(this);
2321   EMIT(0xF3);
2322   EMIT(0x0F);
2323   EMIT(0x6F);
2324   emit_sse_operand(dst, src);
2325 }
2326
2327
2328 void Assembler::prefetch(const Operand& src, int level) {
2329   DCHECK(is_uint2(level));
2330   EnsureSpace ensure_space(this);
2331   EMIT(0x0F);
2332   EMIT(0x18);
2333   // Emit hint number in Reg position of RegR/M.
2334   XMMRegister code = XMMRegister::from_code(level);
2335   emit_sse_operand(code, src);
2336 }
2337
2338
2339 void Assembler::movsd(const Operand& dst, XMMRegister src ) {
2340   EnsureSpace ensure_space(this);
2341   EMIT(0xF2);  // double
2342   EMIT(0x0F);
2343   EMIT(0x11);  // store
2344   emit_sse_operand(src, dst);
2345 }
2346
2347
2348 void Assembler::movsd(XMMRegister dst, const Operand& src) {
2349   EnsureSpace ensure_space(this);
2350   EMIT(0xF2);  // double
2351   EMIT(0x0F);
2352   EMIT(0x10);  // load
2353   emit_sse_operand(dst, src);
2354 }
2355
2356
2357 void Assembler::movss(const Operand& dst, XMMRegister src ) {
2358   EnsureSpace ensure_space(this);
2359   EMIT(0xF3);  // float
2360   EMIT(0x0F);
2361   EMIT(0x11);  // store
2362   emit_sse_operand(src, dst);
2363 }
2364
2365
2366 void Assembler::movss(XMMRegister dst, const Operand& src) {
2367   EnsureSpace ensure_space(this);
2368   EMIT(0xF3);  // float
2369   EMIT(0x0F);
2370   EMIT(0x10);  // load
2371   emit_sse_operand(dst, src);
2372 }
2373
2374
2375 void Assembler::movd(XMMRegister dst, const Operand& src) {
2376   EnsureSpace ensure_space(this);
2377   EMIT(0x66);
2378   EMIT(0x0F);
2379   EMIT(0x6E);
2380   emit_sse_operand(dst, src);
2381 }
2382
2383
2384 void Assembler::movd(const Operand& dst, XMMRegister src) {
2385   EnsureSpace ensure_space(this);
2386   EMIT(0x66);
2387   EMIT(0x0F);
2388   EMIT(0x7E);
2389   emit_sse_operand(src, dst);
2390 }
2391
2392
2393 void Assembler::extractps(Register dst, XMMRegister src, byte imm8) {
2394   DCHECK(IsEnabled(SSE4_1));
2395   DCHECK(is_uint8(imm8));
2396   EnsureSpace ensure_space(this);
2397   EMIT(0x66);
2398   EMIT(0x0F);
2399   EMIT(0x3A);
2400   EMIT(0x17);
2401   emit_sse_operand(src, dst);
2402   EMIT(imm8);
2403 }
2404
2405
2406 void Assembler::pand(XMMRegister dst, XMMRegister src) {
2407   EnsureSpace ensure_space(this);
2408   EMIT(0x66);
2409   EMIT(0x0F);
2410   EMIT(0xDB);
2411   emit_sse_operand(dst, src);
2412 }
2413
2414
2415 void Assembler::pxor(XMMRegister dst, XMMRegister src) {
2416   EnsureSpace ensure_space(this);
2417   EMIT(0x66);
2418   EMIT(0x0F);
2419   EMIT(0xEF);
2420   emit_sse_operand(dst, src);
2421 }
2422
2423
2424 void Assembler::por(XMMRegister dst, XMMRegister src) {
2425   EnsureSpace ensure_space(this);
2426   EMIT(0x66);
2427   EMIT(0x0F);
2428   EMIT(0xEB);
2429   emit_sse_operand(dst, src);
2430 }
2431
2432
2433 void Assembler::ptest(XMMRegister dst, XMMRegister src) {
2434   DCHECK(IsEnabled(SSE4_1));
2435   EnsureSpace ensure_space(this);
2436   EMIT(0x66);
2437   EMIT(0x0F);
2438   EMIT(0x38);
2439   EMIT(0x17);
2440   emit_sse_operand(dst, src);
2441 }
2442
2443
2444 void Assembler::pslld(XMMRegister reg, int8_t shift) {
2445   EnsureSpace ensure_space(this);
2446   EMIT(0x66);
2447   EMIT(0x0F);
2448   EMIT(0x72);
2449   emit_sse_operand(esi, reg);  // esi == 6
2450   EMIT(shift);
2451 }
2452
2453
2454 void Assembler::psrld(XMMRegister reg, int8_t shift) {
2455   EnsureSpace ensure_space(this);
2456   EMIT(0x66);
2457   EMIT(0x0F);
2458   EMIT(0x72);
2459   emit_sse_operand(edx, reg);  // edx == 2
2460   EMIT(shift);
2461 }
2462
2463
2464 void Assembler::psllq(XMMRegister reg, int8_t shift) {
2465   EnsureSpace ensure_space(this);
2466   EMIT(0x66);
2467   EMIT(0x0F);
2468   EMIT(0x73);
2469   emit_sse_operand(esi, reg);  // esi == 6
2470   EMIT(shift);
2471 }
2472
2473
2474 void Assembler::psllq(XMMRegister dst, XMMRegister src) {
2475   EnsureSpace ensure_space(this);
2476   EMIT(0x66);
2477   EMIT(0x0F);
2478   EMIT(0xF3);
2479   emit_sse_operand(dst, src);
2480 }
2481
2482
2483 void Assembler::psrlq(XMMRegister reg, int8_t shift) {
2484   EnsureSpace ensure_space(this);
2485   EMIT(0x66);
2486   EMIT(0x0F);
2487   EMIT(0x73);
2488   emit_sse_operand(edx, reg);  // edx == 2
2489   EMIT(shift);
2490 }
2491
2492
2493 void Assembler::psrlq(XMMRegister dst, XMMRegister src) {
2494   EnsureSpace ensure_space(this);
2495   EMIT(0x66);
2496   EMIT(0x0F);
2497   EMIT(0xD3);
2498   emit_sse_operand(dst, src);
2499 }
2500
2501
2502 void Assembler::pshufd(XMMRegister dst, XMMRegister src, uint8_t shuffle) {
2503   EnsureSpace ensure_space(this);
2504   EMIT(0x66);
2505   EMIT(0x0F);
2506   EMIT(0x70);
2507   emit_sse_operand(dst, src);
2508   EMIT(shuffle);
2509 }
2510
2511
2512 void Assembler::pextrd(const Operand& dst, XMMRegister src, int8_t offset) {
2513   DCHECK(IsEnabled(SSE4_1));
2514   EnsureSpace ensure_space(this);
2515   EMIT(0x66);
2516   EMIT(0x0F);
2517   EMIT(0x3A);
2518   EMIT(0x16);
2519   emit_sse_operand(src, dst);
2520   EMIT(offset);
2521 }
2522
2523
2524 void Assembler::pinsrd(XMMRegister dst, const Operand& src, int8_t offset) {
2525   DCHECK(IsEnabled(SSE4_1));
2526   EnsureSpace ensure_space(this);
2527   EMIT(0x66);
2528   EMIT(0x0F);
2529   EMIT(0x3A);
2530   EMIT(0x22);
2531   emit_sse_operand(dst, src);
2532   EMIT(offset);
2533 }
2534
2535
2536 void Assembler::addss(XMMRegister dst, const Operand& src) {
2537   EnsureSpace ensure_space(this);
2538   EMIT(0xF3);
2539   EMIT(0x0F);
2540   EMIT(0x58);
2541   emit_sse_operand(dst, src);
2542 }
2543
2544
2545 void Assembler::subss(XMMRegister dst, const Operand& src) {
2546   EnsureSpace ensure_space(this);
2547   EMIT(0xF3);
2548   EMIT(0x0F);
2549   EMIT(0x5C);
2550   emit_sse_operand(dst, src);
2551 }
2552
2553
2554 void Assembler::mulss(XMMRegister dst, const Operand& src) {
2555   EnsureSpace ensure_space(this);
2556   EMIT(0xF3);
2557   EMIT(0x0F);
2558   EMIT(0x59);
2559   emit_sse_operand(dst, src);
2560 }
2561
2562
2563 void Assembler::divss(XMMRegister dst, const Operand& src) {
2564   EnsureSpace ensure_space(this);
2565   EMIT(0xF3);
2566   EMIT(0x0F);
2567   EMIT(0x5E);
2568   emit_sse_operand(dst, src);
2569 }
2570
2571
2572 void Assembler::sqrtss(XMMRegister dst, const Operand& src) {
2573   EnsureSpace ensure_space(this);
2574   EMIT(0xF3);
2575   EMIT(0x0F);
2576   EMIT(0x51);
2577   emit_sse_operand(dst, src);
2578 }
2579
2580
2581 void Assembler::ucomiss(XMMRegister dst, const Operand& src) {
2582   EnsureSpace ensure_space(this);
2583   EMIT(0x0f);
2584   EMIT(0x2e);
2585   emit_sse_operand(dst, src);
2586 }
2587
2588
2589 void Assembler::maxss(XMMRegister dst, const Operand& src) {
2590   EnsureSpace ensure_space(this);
2591   EMIT(0xF3);
2592   EMIT(0x0F);
2593   EMIT(0x5F);
2594   emit_sse_operand(dst, src);
2595 }
2596
2597
2598 void Assembler::minss(XMMRegister dst, const Operand& src) {
2599   EnsureSpace ensure_space(this);
2600   EMIT(0xF3);
2601   EMIT(0x0F);
2602   EMIT(0x5D);
2603   emit_sse_operand(dst, src);
2604 }
2605
2606
2607 // AVX instructions
2608 void Assembler::vfmasd(byte op, XMMRegister dst, XMMRegister src1,
2609                        const Operand& src2) {
2610   DCHECK(IsEnabled(FMA3));
2611   EnsureSpace ensure_space(this);
2612   emit_vex_prefix(src1, kLIG, k66, k0F38, kW1);
2613   EMIT(op);
2614   emit_sse_operand(dst, src2);
2615 }
2616
2617
2618 void Assembler::vfmass(byte op, XMMRegister dst, XMMRegister src1,
2619                        const Operand& src2) {
2620   DCHECK(IsEnabled(FMA3));
2621   EnsureSpace ensure_space(this);
2622   emit_vex_prefix(src1, kLIG, k66, k0F38, kW0);
2623   EMIT(op);
2624   emit_sse_operand(dst, src2);
2625 }
2626
2627
2628 void Assembler::vsd(byte op, XMMRegister dst, XMMRegister src1,
2629                     const Operand& src2) {
2630   DCHECK(IsEnabled(AVX));
2631   EnsureSpace ensure_space(this);
2632   emit_vex_prefix(src1, kLIG, kF2, k0F, kWIG);
2633   EMIT(op);
2634   emit_sse_operand(dst, src2);
2635 }
2636
2637
2638 void Assembler::vss(byte op, XMMRegister dst, XMMRegister src1,
2639                     const Operand& src2) {
2640   DCHECK(IsEnabled(AVX));
2641   EnsureSpace ensure_space(this);
2642   emit_vex_prefix(src1, kLIG, kF3, k0F, kWIG);
2643   EMIT(op);
2644   emit_sse_operand(dst, src2);
2645 }
2646
2647
2648 void Assembler::vps(byte op, XMMRegister dst, XMMRegister src1,
2649                     const Operand& src2) {
2650   DCHECK(IsEnabled(AVX));
2651   EnsureSpace ensure_space(this);
2652   emit_vex_prefix(src1, kL128, kNone, k0F, kWIG);
2653   EMIT(op);
2654   emit_sse_operand(dst, src2);
2655 }
2656
2657
2658 void Assembler::vpd(byte op, XMMRegister dst, XMMRegister src1,
2659                     const Operand& src2) {
2660   DCHECK(IsEnabled(AVX));
2661   EnsureSpace ensure_space(this);
2662   emit_vex_prefix(src1, kL128, k66, k0F, kWIG);
2663   EMIT(op);
2664   emit_sse_operand(dst, src2);
2665 }
2666
2667
2668 void Assembler::bmi1(byte op, Register reg, Register vreg, const Operand& rm) {
2669   DCHECK(IsEnabled(BMI1));
2670   EnsureSpace ensure_space(this);
2671   emit_vex_prefix(vreg, kLZ, kNone, k0F38, kW0);
2672   EMIT(op);
2673   emit_operand(reg, rm);
2674 }
2675
2676
2677 void Assembler::tzcnt(Register dst, const Operand& src) {
2678   DCHECK(IsEnabled(BMI1));
2679   EnsureSpace ensure_space(this);
2680   EMIT(0xF3);
2681   EMIT(0x0F);
2682   EMIT(0xBC);
2683   emit_operand(dst, src);
2684 }
2685
2686
2687 void Assembler::lzcnt(Register dst, const Operand& src) {
2688   DCHECK(IsEnabled(LZCNT));
2689   EnsureSpace ensure_space(this);
2690   EMIT(0xF3);
2691   EMIT(0x0F);
2692   EMIT(0xBD);
2693   emit_operand(dst, src);
2694 }
2695
2696
2697 void Assembler::popcnt(Register dst, const Operand& src) {
2698   DCHECK(IsEnabled(POPCNT));
2699   EnsureSpace ensure_space(this);
2700   EMIT(0xF3);
2701   EMIT(0x0F);
2702   EMIT(0xB8);
2703   emit_operand(dst, src);
2704 }
2705
2706
2707 void Assembler::bmi2(SIMDPrefix pp, byte op, Register reg, Register vreg,
2708                      const Operand& rm) {
2709   DCHECK(IsEnabled(BMI2));
2710   EnsureSpace ensure_space(this);
2711   emit_vex_prefix(vreg, kLZ, pp, k0F38, kW0);
2712   EMIT(op);
2713   emit_operand(reg, rm);
2714 }
2715
2716
2717 void Assembler::rorx(Register dst, const Operand& src, byte imm8) {
2718   DCHECK(IsEnabled(BMI2));
2719   DCHECK(is_uint8(imm8));
2720   Register vreg = {0};  // VEX.vvvv unused
2721   EnsureSpace ensure_space(this);
2722   emit_vex_prefix(vreg, kLZ, kF2, k0F3A, kW0);
2723   EMIT(0xF0);
2724   emit_operand(dst, src);
2725   EMIT(imm8);
2726 }
2727
2728
2729 void Assembler::emit_sse_operand(XMMRegister reg, const Operand& adr) {
2730   Register ireg = { reg.code() };
2731   emit_operand(ireg, adr);
2732 }
2733
2734
2735 void Assembler::emit_sse_operand(XMMRegister dst, XMMRegister src) {
2736   EMIT(0xC0 | dst.code() << 3 | src.code());
2737 }
2738
2739
2740 void Assembler::emit_sse_operand(Register dst, XMMRegister src) {
2741   EMIT(0xC0 | dst.code() << 3 | src.code());
2742 }
2743
2744
2745 void Assembler::emit_sse_operand(XMMRegister dst, Register src) {
2746   EMIT(0xC0 | (dst.code() << 3) | src.code());
2747 }
2748
2749
2750 void Assembler::emit_vex_prefix(XMMRegister vreg, VectorLength l, SIMDPrefix pp,
2751                                 LeadingOpcode mm, VexW w) {
2752   if (mm != k0F || w != kW0) {
2753     EMIT(0xc4);
2754     // Change RXB from "110" to "111" to align with gdb disassembler.
2755     EMIT(0xe0 | mm);
2756     EMIT(w | ((~vreg.code() & 0xf) << 3) | l | pp);
2757   } else {
2758     EMIT(0xc5);
2759     EMIT(((~vreg.code()) << 3) | l | pp);
2760   }
2761 }
2762
2763
2764 void Assembler::emit_vex_prefix(Register vreg, VectorLength l, SIMDPrefix pp,
2765                                 LeadingOpcode mm, VexW w) {
2766   XMMRegister ivreg = {vreg.code()};
2767   emit_vex_prefix(ivreg, l, pp, mm, w);
2768 }
2769
2770
2771 void Assembler::GrowBuffer() {
2772   DCHECK(buffer_overflow());
2773   if (!own_buffer_) FATAL("external code buffer is too small");
2774
2775   // Compute new buffer size.
2776   CodeDesc desc;  // the new buffer
2777   desc.buffer_size = 2 * buffer_size_;
2778
2779   // Some internal data structures overflow for very large buffers,
2780   // they must ensure that kMaximalBufferSize is not too large.
2781   if ((desc.buffer_size > kMaximalBufferSize) ||
2782       (desc.buffer_size > isolate()->heap()->MaxOldGenerationSize())) {
2783     V8::FatalProcessOutOfMemory("Assembler::GrowBuffer");
2784   }
2785
2786   // Set up new buffer.
2787   desc.buffer = NewArray<byte>(desc.buffer_size);
2788   desc.instr_size = pc_offset();
2789   desc.reloc_size = (buffer_ + buffer_size_) - (reloc_info_writer.pos());
2790
2791   // Clear the buffer in debug mode. Use 'int3' instructions to make
2792   // sure to get into problems if we ever run uninitialized code.
2793 #ifdef DEBUG
2794   memset(desc.buffer, 0xCC, desc.buffer_size);
2795 #endif
2796
2797   // Copy the data.
2798   int pc_delta = desc.buffer - buffer_;
2799   int rc_delta = (desc.buffer + desc.buffer_size) - (buffer_ + buffer_size_);
2800   MemMove(desc.buffer, buffer_, desc.instr_size);
2801   MemMove(rc_delta + reloc_info_writer.pos(), reloc_info_writer.pos(),
2802           desc.reloc_size);
2803
2804   // Switch buffers.
2805   DeleteArray(buffer_);
2806   buffer_ = desc.buffer;
2807   buffer_size_ = desc.buffer_size;
2808   pc_ += pc_delta;
2809   reloc_info_writer.Reposition(reloc_info_writer.pos() + rc_delta,
2810                                reloc_info_writer.last_pc() + pc_delta);
2811
2812   // Relocate internal references.
2813   for (auto pos : internal_reference_positions_) {
2814     int32_t* p = reinterpret_cast<int32_t*>(buffer_ + pos);
2815     *p += pc_delta;
2816   }
2817
2818   DCHECK(!buffer_overflow());
2819 }
2820
2821
2822 void Assembler::emit_arith_b(int op1, int op2, Register dst, int imm8) {
2823   DCHECK(is_uint8(op1) && is_uint8(op2));  // wrong opcode
2824   DCHECK(is_uint8(imm8));
2825   DCHECK((op1 & 0x01) == 0);  // should be 8bit operation
2826   EMIT(op1);
2827   EMIT(op2 | dst.code());
2828   EMIT(imm8);
2829 }
2830
2831
2832 void Assembler::emit_arith(int sel, Operand dst, const Immediate& x) {
2833   DCHECK((0 <= sel) && (sel <= 7));
2834   Register ireg = { sel };
2835   if (x.is_int8()) {
2836     EMIT(0x83);  // using a sign-extended 8-bit immediate.
2837     emit_operand(ireg, dst);
2838     EMIT(x.x_ & 0xFF);
2839   } else if (dst.is_reg(eax)) {
2840     EMIT((sel << 3) | 0x05);  // short form if the destination is eax.
2841     emit(x);
2842   } else {
2843     EMIT(0x81);  // using a literal 32-bit immediate.
2844     emit_operand(ireg, dst);
2845     emit(x);
2846   }
2847 }
2848
2849
2850 void Assembler::emit_operand(Register reg, const Operand& adr) {
2851   const unsigned length = adr.len_;
2852   DCHECK(length > 0);
2853
2854   // Emit updated ModRM byte containing the given register.
2855   pc_[0] = (adr.buf_[0] & ~0x38) | (reg.code() << 3);
2856
2857   // Emit the rest of the encoded operand.
2858   for (unsigned i = 1; i < length; i++) pc_[i] = adr.buf_[i];
2859   pc_ += length;
2860
2861   // Emit relocation information if necessary.
2862   if (length >= sizeof(int32_t) && !RelocInfo::IsNone(adr.rmode_)) {
2863     pc_ -= sizeof(int32_t);  // pc_ must be *at* disp32
2864     RecordRelocInfo(adr.rmode_);
2865     if (adr.rmode_ == RelocInfo::INTERNAL_REFERENCE) {  // Fixup for labels
2866       emit_label(*reinterpret_cast<Label**>(pc_));
2867     } else {
2868       pc_ += sizeof(int32_t);
2869     }
2870   }
2871 }
2872
2873
2874 void Assembler::emit_label(Label* label) {
2875   if (label->is_bound()) {
2876     internal_reference_positions_.push_back(pc_offset());
2877     emit(reinterpret_cast<uint32_t>(buffer_ + label->pos()));
2878   } else {
2879     emit_disp(label, Displacement::CODE_ABSOLUTE);
2880   }
2881 }
2882
2883
2884 void Assembler::emit_farith(int b1, int b2, int i) {
2885   DCHECK(is_uint8(b1) && is_uint8(b2));  // wrong opcode
2886   DCHECK(0 <= i &&  i < 8);  // illegal stack offset
2887   EMIT(b1);
2888   EMIT(b2 + i);
2889 }
2890
2891
2892 void Assembler::db(uint8_t data) {
2893   EnsureSpace ensure_space(this);
2894   EMIT(data);
2895 }
2896
2897
2898 void Assembler::dd(uint32_t data) {
2899   EnsureSpace ensure_space(this);
2900   emit(data);
2901 }
2902
2903
2904 void Assembler::dq(uint64_t data) {
2905   EnsureSpace ensure_space(this);
2906   emit_q(data);
2907 }
2908
2909
2910 void Assembler::dd(Label* label) {
2911   EnsureSpace ensure_space(this);
2912   RecordRelocInfo(RelocInfo::INTERNAL_REFERENCE);
2913   emit_label(label);
2914 }
2915
2916
2917 void Assembler::RecordRelocInfo(RelocInfo::Mode rmode, intptr_t data) {
2918   DCHECK(!RelocInfo::IsNone(rmode));
2919   // Don't record external references unless the heap will be serialized.
2920   if (rmode == RelocInfo::EXTERNAL_REFERENCE &&
2921       !serializer_enabled() && !emit_debug_code()) {
2922     return;
2923   }
2924   RelocInfo rinfo(pc_, rmode, data, NULL);
2925   reloc_info_writer.Write(&rinfo);
2926 }
2927
2928
2929 #ifdef GENERATED_CODE_COVERAGE
2930 static FILE* coverage_log = NULL;
2931
2932
2933 static void InitCoverageLog() {
2934   char* file_name = getenv("V8_GENERATED_CODE_COVERAGE_LOG");
2935   if (file_name != NULL) {
2936     coverage_log = fopen(file_name, "aw+");
2937   }
2938 }
2939
2940
2941 void LogGeneratedCodeCoverage(const char* file_line) {
2942   const char* return_address = (&file_line)[-1];
2943   char* push_insn = const_cast<char*>(return_address - 12);
2944   push_insn[0] = 0xeb;  // Relative branch insn.
2945   push_insn[1] = 13;    // Skip over coverage insns.
2946   if (coverage_log != NULL) {
2947     fprintf(coverage_log, "%s\n", file_line);
2948     fflush(coverage_log);
2949   }
2950 }
2951
2952 #endif
2953
2954 }  // namespace internal
2955 }  // namespace v8
2956
2957 #endif  // V8_TARGET_ARCH_IA32