summaryrefslogtreecommitdiff
path: root/deps/v8/src/x64
diff options
context:
space:
mode:
Diffstat (limited to 'deps/v8/src/x64')
-rw-r--r--deps/v8/src/x64/assembler-x64-inl.h3
-rw-r--r--deps/v8/src/x64/assembler-x64.cc206
-rw-r--r--deps/v8/src/x64/assembler-x64.h553
-rw-r--r--deps/v8/src/x64/builtins-x64.cc314
-rw-r--r--deps/v8/src/x64/code-stubs-x64.cc285
-rw-r--r--deps/v8/src/x64/code-stubs-x64.h19
-rw-r--r--deps/v8/src/x64/codegen-x64.cc63
-rw-r--r--deps/v8/src/x64/codegen-x64.h3
-rw-r--r--deps/v8/src/x64/deoptimizer-x64.cc30
-rw-r--r--deps/v8/src/x64/disasm-x64.cc138
-rw-r--r--deps/v8/src/x64/frames-x64.h3
-rw-r--r--deps/v8/src/x64/interface-descriptors-x64.cc46
-rw-r--r--deps/v8/src/x64/lithium-codegen-x64.cc5923
-rw-r--r--deps/v8/src/x64/lithium-codegen-x64.h392
-rw-r--r--deps/v8/src/x64/lithium-gap-resolver-x64.cc318
-rw-r--r--deps/v8/src/x64/lithium-gap-resolver-x64.h49
-rw-r--r--deps/v8/src/x64/lithium-x64.cc2749
-rw-r--r--deps/v8/src/x64/lithium-x64.h2869
-rw-r--r--deps/v8/src/x64/macro-assembler-x64.cc709
-rw-r--r--deps/v8/src/x64/macro-assembler-x64.h124
-rw-r--r--deps/v8/src/x64/simulator-x64.h3
21 files changed, 1719 insertions, 13080 deletions
diff --git a/deps/v8/src/x64/assembler-x64-inl.h b/deps/v8/src/x64/assembler-x64-inl.h
index c66e86df3f..17376581b5 100644
--- a/deps/v8/src/x64/assembler-x64-inl.h
+++ b/deps/v8/src/x64/assembler-x64-inl.h
@@ -629,6 +629,7 @@ void Operand::set_disp64(int64_t disp) {
*p = disp;
len_ += sizeof(disp);
}
-} } // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_X64_ASSEMBLER_X64_INL_H_
diff --git a/deps/v8/src/x64/assembler-x64.cc b/deps/v8/src/x64/assembler-x64.cc
index cb93ab878b..c8f99a11a6 100644
--- a/deps/v8/src/x64/assembler-x64.cc
+++ b/deps/v8/src/x64/assembler-x64.cc
@@ -116,20 +116,6 @@ void CpuFeatures::PrintFeatures() {
// -----------------------------------------------------------------------------
-// Register constants.
-
-const int
- Register::kRegisterCodeByAllocationIndex[kMaxNumAllocatableRegisters] = {
- // rax, rbx, rdx, rcx, rsi, rdi, r8, r9, r11, r12, r14, r15
- 0, 3, 2, 1, 6, 7, 8, 9, 11, 12, 14, 15
-};
-
-const int Register::kAllocationIndexByRegisterCode[kNumRegisters] = {
- 0, 3, 2, 1, -1, -1, 4, 5, 6, 7, -1, 8, 9, -1, 10, 11
-};
-
-
-// -----------------------------------------------------------------------------
// Implementation of Operand
Operand::Operand(Register base, int32_t disp) : rex_(0) {
@@ -759,6 +745,60 @@ void Assembler::bsrl(Register dst, const Operand& src) {
}
+void Assembler::bsrq(Register dst, Register src) {
+ EnsureSpace ensure_space(this);
+ emit_rex_64(dst, src);
+ emit(0x0F);
+ emit(0xBD);
+ emit_modrm(dst, src);
+}
+
+
+void Assembler::bsrq(Register dst, const Operand& src) {
+ EnsureSpace ensure_space(this);
+ emit_rex_64(dst, src);
+ emit(0x0F);
+ emit(0xBD);
+ emit_operand(dst, src);
+}
+
+
+void Assembler::bsfl(Register dst, Register src) {
+ EnsureSpace ensure_space(this);
+ emit_optional_rex_32(dst, src);
+ emit(0x0F);
+ emit(0xBC);
+ emit_modrm(dst, src);
+}
+
+
+void Assembler::bsfl(Register dst, const Operand& src) {
+ EnsureSpace ensure_space(this);
+ emit_optional_rex_32(dst, src);
+ emit(0x0F);
+ emit(0xBC);
+ emit_operand(dst, src);
+}
+
+
+void Assembler::bsfq(Register dst, Register src) {
+ EnsureSpace ensure_space(this);
+ emit_rex_64(dst, src);
+ emit(0x0F);
+ emit(0xBC);
+ emit_modrm(dst, src);
+}
+
+
+void Assembler::bsfq(Register dst, const Operand& src) {
+ EnsureSpace ensure_space(this);
+ emit_rex_64(dst, src);
+ emit(0x0F);
+ emit(0xBC);
+ emit_operand(dst, src);
+}
+
+
void Assembler::call(Label* L) {
positions_recorder()->WriteRecordedPositions();
EnsureSpace ensure_space(this);
@@ -2445,6 +2485,7 @@ void Assembler::orps(XMMRegister dst, const Operand& src) {
void Assembler::xorps(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit_optional_rex_32(dst, src);
emit(0x0F);
@@ -2454,6 +2495,7 @@ void Assembler::xorps(XMMRegister dst, XMMRegister src) {
void Assembler::xorps(XMMRegister dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit_optional_rex_32(dst, src);
emit(0x0F);
@@ -2537,6 +2579,7 @@ void Assembler::divps(XMMRegister dst, const Operand& src) {
// SSE 2 operations.
void Assembler::movd(XMMRegister dst, Register src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0x66);
emit_optional_rex_32(dst, src);
@@ -2547,6 +2590,7 @@ void Assembler::movd(XMMRegister dst, Register src) {
void Assembler::movd(XMMRegister dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0x66);
emit_optional_rex_32(dst, src);
@@ -2557,6 +2601,7 @@ void Assembler::movd(XMMRegister dst, const Operand& src) {
void Assembler::movd(Register dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0x66);
emit_optional_rex_32(src, dst);
@@ -2567,6 +2612,7 @@ void Assembler::movd(Register dst, XMMRegister src) {
void Assembler::movq(XMMRegister dst, Register src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0x66);
emit_rex_64(dst, src);
@@ -2577,6 +2623,7 @@ void Assembler::movq(XMMRegister dst, Register src) {
void Assembler::movq(Register dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0x66);
emit_rex_64(src, dst);
@@ -2587,6 +2634,7 @@ void Assembler::movq(Register dst, XMMRegister src) {
void Assembler::movq(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
if (dst.low_bits() == 4) {
// Avoid unnecessary SIB byte.
@@ -2699,6 +2747,7 @@ void Assembler::pinsrd(XMMRegister dst, const Operand& src, int8_t imm8) {
void Assembler::movsd(const Operand& dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2); // double
emit_optional_rex_32(src, dst);
@@ -2709,6 +2758,7 @@ void Assembler::movsd(const Operand& dst, XMMRegister src) {
void Assembler::movsd(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2); // double
emit_optional_rex_32(dst, src);
@@ -2719,6 +2769,7 @@ void Assembler::movsd(XMMRegister dst, XMMRegister src) {
void Assembler::movsd(XMMRegister dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2); // double
emit_optional_rex_32(dst, src);
@@ -2729,6 +2780,7 @@ void Assembler::movsd(XMMRegister dst, const Operand& src) {
void Assembler::movaps(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
if (src.low_bits() == 4) {
// Try to avoid an unnecessary SIB byte.
@@ -2757,6 +2809,7 @@ void Assembler::shufps(XMMRegister dst, XMMRegister src, byte imm8) {
void Assembler::movapd(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
if (src.low_bits() == 4) {
// Try to avoid an unnecessary SIB byte.
@@ -2916,6 +2969,7 @@ void Assembler::sqrtss(XMMRegister dst, const Operand& src) {
void Assembler::ucomiss(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit_optional_rex_32(dst, src);
emit(0x0f);
@@ -2925,6 +2979,7 @@ void Assembler::ucomiss(XMMRegister dst, XMMRegister src) {
void Assembler::ucomiss(XMMRegister dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit_optional_rex_32(dst, src);
emit(0x0f);
@@ -2933,7 +2988,19 @@ void Assembler::ucomiss(XMMRegister dst, const Operand& src) {
}
+void Assembler::movss(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
+ EnsureSpace ensure_space(this);
+ emit(0xF3); // single
+ emit_optional_rex_32(dst, src);
+ emit(0x0F);
+ emit(0x10); // load
+ emit_sse_operand(dst, src);
+}
+
+
void Assembler::movss(XMMRegister dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF3); // single
emit_optional_rex_32(dst, src);
@@ -2944,6 +3011,7 @@ void Assembler::movss(XMMRegister dst, const Operand& src) {
void Assembler::movss(const Operand& src, XMMRegister dst) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF3); // single
emit_optional_rex_32(dst, src);
@@ -2954,6 +3022,7 @@ void Assembler::movss(const Operand& src, XMMRegister dst) {
void Assembler::psllq(XMMRegister reg, byte imm8) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0x66);
emit_optional_rex_32(reg);
@@ -2965,6 +3034,7 @@ void Assembler::psllq(XMMRegister reg, byte imm8) {
void Assembler::psrlq(XMMRegister reg, byte imm8) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0x66);
emit_optional_rex_32(reg);
@@ -2998,6 +3068,7 @@ void Assembler::psrld(XMMRegister reg, byte imm8) {
void Assembler::cvttss2si(Register dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF3);
emit_optional_rex_32(dst, src);
@@ -3008,6 +3079,7 @@ void Assembler::cvttss2si(Register dst, const Operand& src) {
void Assembler::cvttss2si(Register dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF3);
emit_optional_rex_32(dst, src);
@@ -3018,6 +3090,7 @@ void Assembler::cvttss2si(Register dst, XMMRegister src) {
void Assembler::cvttsd2si(Register dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_optional_rex_32(dst, src);
@@ -3028,6 +3101,7 @@ void Assembler::cvttsd2si(Register dst, const Operand& src) {
void Assembler::cvttsd2si(Register dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_optional_rex_32(dst, src);
@@ -3038,6 +3112,7 @@ void Assembler::cvttsd2si(Register dst, XMMRegister src) {
void Assembler::cvttsd2siq(Register dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_rex_64(dst, src);
@@ -3048,6 +3123,7 @@ void Assembler::cvttsd2siq(Register dst, XMMRegister src) {
void Assembler::cvttsd2siq(Register dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_rex_64(dst, src);
@@ -3058,6 +3134,7 @@ void Assembler::cvttsd2siq(Register dst, const Operand& src) {
void Assembler::cvtlsi2sd(XMMRegister dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_optional_rex_32(dst, src);
@@ -3068,6 +3145,7 @@ void Assembler::cvtlsi2sd(XMMRegister dst, const Operand& src) {
void Assembler::cvtlsi2sd(XMMRegister dst, Register src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_optional_rex_32(dst, src);
@@ -3087,7 +3165,30 @@ void Assembler::cvtlsi2ss(XMMRegister dst, Register src) {
}
+void Assembler::cvtqsi2ss(XMMRegister dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
+ EnsureSpace ensure_space(this);
+ emit(0xF3);
+ emit_rex_64(dst, src);
+ emit(0x0F);
+ emit(0x2A);
+ emit_sse_operand(dst, src);
+}
+
+
+void Assembler::cvtqsi2ss(XMMRegister dst, Register src) {
+ DCHECK(!IsEnabled(AVX));
+ EnsureSpace ensure_space(this);
+ emit(0xF3);
+ emit_rex_64(dst, src);
+ emit(0x0F);
+ emit(0x2A);
+ emit_sse_operand(dst, src);
+}
+
+
void Assembler::cvtqsi2sd(XMMRegister dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_rex_64(dst, src);
@@ -3098,6 +3199,7 @@ void Assembler::cvtqsi2sd(XMMRegister dst, const Operand& src) {
void Assembler::cvtqsi2sd(XMMRegister dst, Register src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_rex_64(dst, src);
@@ -3108,6 +3210,7 @@ void Assembler::cvtqsi2sd(XMMRegister dst, Register src) {
void Assembler::cvtss2sd(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF3);
emit_optional_rex_32(dst, src);
@@ -3118,6 +3221,7 @@ void Assembler::cvtss2sd(XMMRegister dst, XMMRegister src) {
void Assembler::cvtss2sd(XMMRegister dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF3);
emit_optional_rex_32(dst, src);
@@ -3128,6 +3232,7 @@ void Assembler::cvtss2sd(XMMRegister dst, const Operand& src) {
void Assembler::cvtsd2ss(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_optional_rex_32(dst, src);
@@ -3138,6 +3243,7 @@ void Assembler::cvtsd2ss(XMMRegister dst, XMMRegister src) {
void Assembler::cvtsd2ss(XMMRegister dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_optional_rex_32(dst, src);
@@ -3148,6 +3254,7 @@ void Assembler::cvtsd2ss(XMMRegister dst, const Operand& src) {
void Assembler::cvtsd2si(Register dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_optional_rex_32(dst, src);
@@ -3158,6 +3265,7 @@ void Assembler::cvtsd2si(Register dst, XMMRegister src) {
void Assembler::cvtsd2siq(Register dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_rex_64(dst, src);
@@ -3308,6 +3416,7 @@ void Assembler::orpd(XMMRegister dst, XMMRegister src) {
void Assembler::xorpd(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0x66);
emit_optional_rex_32(dst, src);
@@ -3318,6 +3427,7 @@ void Assembler::xorpd(XMMRegister dst, XMMRegister src) {
void Assembler::sqrtsd(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_optional_rex_32(dst, src);
@@ -3328,6 +3438,7 @@ void Assembler::sqrtsd(XMMRegister dst, XMMRegister src) {
void Assembler::sqrtsd(XMMRegister dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0xF2);
emit_optional_rex_32(dst, src);
@@ -3338,6 +3449,7 @@ void Assembler::sqrtsd(XMMRegister dst, const Operand& src) {
void Assembler::ucomisd(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0x66);
emit_optional_rex_32(dst, src);
@@ -3348,6 +3460,7 @@ void Assembler::ucomisd(XMMRegister dst, XMMRegister src) {
void Assembler::ucomisd(XMMRegister dst, const Operand& src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0x66);
emit_optional_rex_32(dst, src);
@@ -3369,6 +3482,7 @@ void Assembler::cmpltsd(XMMRegister dst, XMMRegister src) {
void Assembler::roundsd(XMMRegister dst, XMMRegister src, RoundingMode mode) {
+ DCHECK(!IsEnabled(AVX));
DCHECK(IsEnabled(SSE4_1));
EnsureSpace ensure_space(this);
emit(0x66);
@@ -3377,7 +3491,7 @@ void Assembler::roundsd(XMMRegister dst, XMMRegister src, RoundingMode mode) {
emit(0x3a);
emit(0x0b);
emit_sse_operand(dst, src);
- // Mask precision exeption.
+ // Mask precision exception.
emit(static_cast<byte>(mode) | 0x8);
}
@@ -3402,6 +3516,7 @@ void Assembler::movmskps(Register dst, XMMRegister src) {
void Assembler::pcmpeqd(XMMRegister dst, XMMRegister src) {
+ DCHECK(!IsEnabled(AVX));
EnsureSpace ensure_space(this);
emit(0x66);
emit_optional_rex_32(dst, src);
@@ -3472,39 +3587,80 @@ void Assembler::vfmass(byte op, XMMRegister dst, XMMRegister src1,
}
-void Assembler::vucomisd(XMMRegister dst, XMMRegister src) {
+void Assembler::vmovd(XMMRegister dst, Register src) {
DCHECK(IsEnabled(AVX));
EnsureSpace ensure_space(this);
- emit_vex_prefix(dst, xmm0, src, kLIG, k66, k0F, kWIG);
- emit(0x2e);
+ XMMRegister isrc = {src.code()};
+ emit_vex_prefix(dst, xmm0, isrc, kL128, k66, k0F, kW0);
+ emit(0x6e);
emit_sse_operand(dst, src);
}
-void Assembler::vucomisd(XMMRegister dst, const Operand& src) {
+void Assembler::vmovd(XMMRegister dst, const Operand& src) {
DCHECK(IsEnabled(AVX));
EnsureSpace ensure_space(this);
- emit_vex_prefix(dst, xmm0, src, kLIG, k66, k0F, kWIG);
- emit(0x2e);
+ emit_vex_prefix(dst, xmm0, src, kL128, k66, k0F, kW0);
+ emit(0x6e);
+ emit_sse_operand(dst, src);
+}
+
+
+void Assembler::vmovd(Register dst, XMMRegister src) {
+ DCHECK(IsEnabled(AVX));
+ EnsureSpace ensure_space(this);
+ XMMRegister idst = {dst.code()};
+ emit_vex_prefix(src, xmm0, idst, kL128, k66, k0F, kW0);
+ emit(0x7e);
+ emit_sse_operand(src, dst);
+}
+
+
+void Assembler::vmovq(XMMRegister dst, Register src) {
+ DCHECK(IsEnabled(AVX));
+ EnsureSpace ensure_space(this);
+ XMMRegister isrc = {src.code()};
+ emit_vex_prefix(dst, xmm0, isrc, kL128, k66, k0F, kW1);
+ emit(0x6e);
emit_sse_operand(dst, src);
}
+void Assembler::vmovq(XMMRegister dst, const Operand& src) {
+ DCHECK(IsEnabled(AVX));
+ EnsureSpace ensure_space(this);
+ emit_vex_prefix(dst, xmm0, src, kL128, k66, k0F, kW1);
+ emit(0x6e);
+ emit_sse_operand(dst, src);
+}
+
+
+void Assembler::vmovq(Register dst, XMMRegister src) {
+ DCHECK(IsEnabled(AVX));
+ EnsureSpace ensure_space(this);
+ XMMRegister idst = {dst.code()};
+ emit_vex_prefix(src, xmm0, idst, kL128, k66, k0F, kW1);
+ emit(0x7e);
+ emit_sse_operand(src, dst);
+}
+
+
void Assembler::vsd(byte op, XMMRegister dst, XMMRegister src1,
- XMMRegister src2) {
+ XMMRegister src2, SIMDPrefix pp, LeadingOpcode m, VexW w) {
DCHECK(IsEnabled(AVX));
EnsureSpace ensure_space(this);
- emit_vex_prefix(dst, src1, src2, kLIG, kF2, k0F, kWIG);
+ emit_vex_prefix(dst, src1, src2, kLIG, pp, m, w);
emit(op);
emit_sse_operand(dst, src2);
}
void Assembler::vsd(byte op, XMMRegister dst, XMMRegister src1,
- const Operand& src2) {
+ const Operand& src2, SIMDPrefix pp, LeadingOpcode m,
+ VexW w) {
DCHECK(IsEnabled(AVX));
EnsureSpace ensure_space(this);
- emit_vex_prefix(dst, src1, src2, kLIG, kF2, k0F, kWIG);
+ emit_vex_prefix(dst, src1, src2, kLIG, pp, m, w);
emit(op);
emit_sse_operand(dst, src2);
}
diff --git a/deps/v8/src/x64/assembler-x64.h b/deps/v8/src/x64/assembler-x64.h
index 47e4d2bdda..2182dbb3ff 100644
--- a/deps/v8/src/x64/assembler-x64.h
+++ b/deps/v8/src/x64/assembler-x64.h
@@ -40,13 +40,45 @@
#include <deque>
#include "src/assembler.h"
-#include "src/compiler.h"
namespace v8 {
namespace internal {
// Utility functions
+#define GENERAL_REGISTERS(V) \
+ V(rax) \
+ V(rcx) \
+ V(rdx) \
+ V(rbx) \
+ V(rsp) \
+ V(rbp) \
+ V(rsi) \
+ V(rdi) \
+ V(r8) \
+ V(r9) \
+ V(r10) \
+ V(r11) \
+ V(r12) \
+ V(r13) \
+ V(r14) \
+ V(r15)
+
+#define ALLOCATABLE_GENERAL_REGISTERS(V) \
+ V(rax) \
+ V(rbx) \
+ V(rdx) \
+ V(rcx) \
+ V(rsi) \
+ V(rdi) \
+ V(r8) \
+ V(r9) \
+ V(r11) \
+ V(r12) \
+ V(r14) \
+ V(r15)
+
+
// CPU Registers.
//
// 1) We would prefer to use an enum, but enum values are assignment-
@@ -68,226 +100,153 @@ namespace internal {
// mode. This way we get the compile-time error checking in debug mode
// and best performance in optimized code.
//
-
struct Register {
- // The non-allocatable registers are:
- // rsp - stack pointer
- // rbp - frame pointer
- // r10 - fixed scratch register
- // r13 - root register
- static const int kMaxNumAllocatableRegisters = 12;
- static int NumAllocatableRegisters() {
- return kMaxNumAllocatableRegisters;
- }
- static const int kNumRegisters = 16;
-
- static int ToAllocationIndex(Register reg) {
- return kAllocationIndexByRegisterCode[reg.code()];
- }
-
- static Register FromAllocationIndex(int index) {
- DCHECK(index >= 0 && index < kMaxNumAllocatableRegisters);
- Register result = { kRegisterCodeByAllocationIndex[index] };
- return result;
- }
+ enum Code {
+#define REGISTER_CODE(R) kCode_##R,
+ GENERAL_REGISTERS(REGISTER_CODE)
+#undef REGISTER_CODE
+ kAfterLast,
+ kCode_no_reg = -1
+ };
- static const char* AllocationIndexToString(int index) {
- DCHECK(index >= 0 && index < kMaxNumAllocatableRegisters);
- const char* const names[] = {
- "rax",
- "rbx",
- "rdx",
- "rcx",
- "rsi",
- "rdi",
- "r8",
- "r9",
- "r11",
- "r12",
- "r14",
- "r15"
- };
- return names[index];
- }
+ static const int kNumRegisters = Code::kAfterLast;
static Register from_code(int code) {
- Register r = { code };
+ DCHECK(code >= 0);
+ DCHECK(code < kNumRegisters);
+ Register r = {code};
return r;
}
- bool is_valid() const { return 0 <= code_ && code_ < kNumRegisters; }
- bool is(Register reg) const { return code_ == reg.code_; }
- // rax, rbx, rcx and rdx are byte registers, the rest are not.
- bool is_byte_register() const { return code_ <= 3; }
+ const char* ToString();
+ bool IsAllocatable() const;
+ bool is_valid() const { return 0 <= reg_code && reg_code < kNumRegisters; }
+ bool is(Register reg) const { return reg_code == reg.reg_code; }
int code() const {
DCHECK(is_valid());
- return code_;
+ return reg_code;
}
int bit() const {
- return 1 << code_;
+ DCHECK(is_valid());
+ return 1 << reg_code;
}
+ bool is_byte_register() const { return reg_code <= 3; }
// Return the high bit of the register code as a 0 or 1. Used often
// when constructing the REX prefix byte.
- int high_bit() const {
- return code_ >> 3;
- }
+ int high_bit() const { return reg_code >> 3; }
// Return the 3 low bits of the register code. Used when encoding registers
// in modR/M, SIB, and opcode bytes.
- int low_bits() const {
- return code_ & 0x7;
- }
+ int low_bits() const { return reg_code & 0x7; }
// Unfortunately we can't make this private in a struct when initializing
// by assignment.
- int code_;
-
- private:
- static const int kRegisterCodeByAllocationIndex[kMaxNumAllocatableRegisters];
- static const int kAllocationIndexByRegisterCode[kNumRegisters];
+ int reg_code;
};
-const int kRegister_rax_Code = 0;
-const int kRegister_rcx_Code = 1;
-const int kRegister_rdx_Code = 2;
-const int kRegister_rbx_Code = 3;
-const int kRegister_rsp_Code = 4;
-const int kRegister_rbp_Code = 5;
-const int kRegister_rsi_Code = 6;
-const int kRegister_rdi_Code = 7;
-const int kRegister_r8_Code = 8;
-const int kRegister_r9_Code = 9;
-const int kRegister_r10_Code = 10;
-const int kRegister_r11_Code = 11;
-const int kRegister_r12_Code = 12;
-const int kRegister_r13_Code = 13;
-const int kRegister_r14_Code = 14;
-const int kRegister_r15_Code = 15;
-const int kRegister_no_reg_Code = -1;
-
-const Register rax = { kRegister_rax_Code };
-const Register rcx = { kRegister_rcx_Code };
-const Register rdx = { kRegister_rdx_Code };
-const Register rbx = { kRegister_rbx_Code };
-const Register rsp = { kRegister_rsp_Code };
-const Register rbp = { kRegister_rbp_Code };
-const Register rsi = { kRegister_rsi_Code };
-const Register rdi = { kRegister_rdi_Code };
-const Register r8 = { kRegister_r8_Code };
-const Register r9 = { kRegister_r9_Code };
-const Register r10 = { kRegister_r10_Code };
-const Register r11 = { kRegister_r11_Code };
-const Register r12 = { kRegister_r12_Code };
-const Register r13 = { kRegister_r13_Code };
-const Register r14 = { kRegister_r14_Code };
-const Register r15 = { kRegister_r15_Code };
-const Register no_reg = { kRegister_no_reg_Code };
+
+#define DECLARE_REGISTER(R) const Register R = {Register::kCode_##R};
+GENERAL_REGISTERS(DECLARE_REGISTER)
+#undef DECLARE_REGISTER
+const Register no_reg = {Register::kCode_no_reg};
+
#ifdef _WIN64
// Windows calling convention
- const Register arg_reg_1 = { kRegister_rcx_Code };
- const Register arg_reg_2 = { kRegister_rdx_Code };
- const Register arg_reg_3 = { kRegister_r8_Code };
- const Register arg_reg_4 = { kRegister_r9_Code };
+const Register arg_reg_1 = {Register::kCode_rcx};
+const Register arg_reg_2 = {Register::kCode_rdx};
+const Register arg_reg_3 = {Register::kCode_r8};
+const Register arg_reg_4 = {Register::kCode_r9};
#else
// AMD64 calling convention
- const Register arg_reg_1 = { kRegister_rdi_Code };
- const Register arg_reg_2 = { kRegister_rsi_Code };
- const Register arg_reg_3 = { kRegister_rdx_Code };
- const Register arg_reg_4 = { kRegister_rcx_Code };
+const Register arg_reg_1 = {Register::kCode_rdi};
+const Register arg_reg_2 = {Register::kCode_rsi};
+const Register arg_reg_3 = {Register::kCode_rdx};
+const Register arg_reg_4 = {Register::kCode_rcx};
#endif // _WIN64
-struct XMMRegister {
- static const int kMaxNumRegisters = 16;
- static const int kMaxNumAllocatableRegisters = 15;
- static int NumAllocatableRegisters() {
- return kMaxNumAllocatableRegisters;
- }
-
- // TODO(turbofan): Proper support for float32.
- static int NumAllocatableAliasedRegisters() {
- return NumAllocatableRegisters();
- }
-
- static int ToAllocationIndex(XMMRegister reg) {
- DCHECK(reg.code() != 0);
- return reg.code() - 1;
- }
- static XMMRegister FromAllocationIndex(int index) {
- DCHECK(0 <= index && index < kMaxNumAllocatableRegisters);
- XMMRegister result = { index + 1 };
+#define DOUBLE_REGISTERS(V) \
+ V(xmm0) \
+ V(xmm1) \
+ V(xmm2) \
+ V(xmm3) \
+ V(xmm4) \
+ V(xmm5) \
+ V(xmm6) \
+ V(xmm7) \
+ V(xmm8) \
+ V(xmm9) \
+ V(xmm10) \
+ V(xmm11) \
+ V(xmm12) \
+ V(xmm13) \
+ V(xmm14) \
+ V(xmm15)
+
+#define ALLOCATABLE_DOUBLE_REGISTERS(V) \
+ V(xmm1) \
+ V(xmm2) \
+ V(xmm3) \
+ V(xmm4) \
+ V(xmm5) \
+ V(xmm6) \
+ V(xmm7) \
+ V(xmm8) \
+ V(xmm9) \
+ V(xmm10) \
+ V(xmm11) \
+ V(xmm12) \
+ V(xmm13) \
+ V(xmm14) \
+ V(xmm15)
+
+
+struct DoubleRegister {
+ enum Code {
+#define REGISTER_CODE(R) kCode_##R,
+ DOUBLE_REGISTERS(REGISTER_CODE)
+#undef REGISTER_CODE
+ kAfterLast,
+ kCode_no_reg = -1
+ };
+
+ static const int kMaxNumRegisters = Code::kAfterLast;
+
+ static DoubleRegister from_code(int code) {
+ DoubleRegister result = {code};
return result;
}
- static const char* AllocationIndexToString(int index) {
- DCHECK(index >= 0 && index < kMaxNumAllocatableRegisters);
- const char* const names[] = {
- "xmm1",
- "xmm2",
- "xmm3",
- "xmm4",
- "xmm5",
- "xmm6",
- "xmm7",
- "xmm8",
- "xmm9",
- "xmm10",
- "xmm11",
- "xmm12",
- "xmm13",
- "xmm14",
- "xmm15"
- };
- return names[index];
- }
-
- static XMMRegister from_code(int code) {
- DCHECK(code >= 0);
- DCHECK(code < kMaxNumRegisters);
- XMMRegister r = { code };
- return r;
- }
- bool is_valid() const { return 0 <= code_ && code_ < kMaxNumRegisters; }
- bool is(XMMRegister reg) const { return code_ == reg.code_; }
+ const char* ToString();
+ bool IsAllocatable() const;
+ bool is_valid() const { return 0 <= reg_code && reg_code < kMaxNumRegisters; }
+ bool is(DoubleRegister reg) const { return reg_code == reg.reg_code; }
int code() const {
DCHECK(is_valid());
- return code_;
+ return reg_code;
}
// Return the high bit of the register code as a 0 or 1. Used often
// when constructing the REX prefix byte.
- int high_bit() const {
- return code_ >> 3;
- }
+ int high_bit() const { return reg_code >> 3; }
// Return the 3 low bits of the register code. Used when encoding registers
// in modR/M, SIB, and opcode bytes.
- int low_bits() const {
- return code_ & 0x7;
- }
+ int low_bits() const { return reg_code & 0x7; }
- int code_;
+ // Unfortunately we can't make this private in a struct when initializing
+ // by assignment.
+ int reg_code;
};
-const XMMRegister xmm0 = { 0 };
-const XMMRegister xmm1 = { 1 };
-const XMMRegister xmm2 = { 2 };
-const XMMRegister xmm3 = { 3 };
-const XMMRegister xmm4 = { 4 };
-const XMMRegister xmm5 = { 5 };
-const XMMRegister xmm6 = { 6 };
-const XMMRegister xmm7 = { 7 };
-const XMMRegister xmm8 = { 8 };
-const XMMRegister xmm9 = { 9 };
-const XMMRegister xmm10 = { 10 };
-const XMMRegister xmm11 = { 11 };
-const XMMRegister xmm12 = { 12 };
-const XMMRegister xmm13 = { 13 };
-const XMMRegister xmm14 = { 14 };
-const XMMRegister xmm15 = { 15 };
+#define DECLARE_REGISTER(R) \
+ const DoubleRegister R = {DoubleRegister::kCode_##R};
+DOUBLE_REGISTERS(DECLARE_REGISTER)
+#undef DECLARE_REGISTER
+const DoubleRegister no_double_reg = {DoubleRegister::kCode_no_reg};
-typedef XMMRegister DoubleRegister;
+typedef DoubleRegister XMMRegister;
enum Condition {
// any value < 0 is considered no_condition
@@ -617,6 +576,11 @@ class Assembler : public AssemblerBase {
static const byte kJnzShortOpcode = kJccShortPrefix | not_zero;
static const byte kJzShortOpcode = kJccShortPrefix | zero;
+ // VEX prefix encodings.
+ enum SIMDPrefix { kNone = 0x0, k66 = 0x1, kF3 = 0x2, kF2 = 0x3 };
+ enum VectorLength { kL128 = 0x0, kL256 = 0x4, kLIG = kL128, kLZ = kL128 };
+ enum VexW { kW0 = 0x0, kW1 = 0x80, kWIG = kW0 };
+ enum LeadingOpcode { k0F = 0x1, k0F38 = 0x2, k0F3A = 0x3 };
// ---------------------------------------------------------------------------
// Code generation
@@ -883,8 +847,14 @@ class Assembler : public AssemblerBase {
// Bit operations.
void bt(const Operand& dst, Register src);
void bts(const Operand& dst, Register src);
+ void bsrq(Register dst, Register src);
+ void bsrq(Register dst, const Operand& src);
void bsrl(Register dst, Register src);
void bsrl(Register dst, const Operand& src);
+ void bsfq(Register dst, Register src);
+ void bsfq(Register dst, const Operand& src);
+ void bsfl(Register dst, Register src);
+ void bsfl(Register dst, const Operand& src);
// Miscellaneous
void clc();
@@ -1042,6 +1012,13 @@ class Assembler : public AssemblerBase {
void ucomiss(XMMRegister dst, XMMRegister src);
void ucomiss(XMMRegister dst, const Operand& src);
void movaps(XMMRegister dst, XMMRegister src);
+
+ // Don't use this unless it's important to keep the
+ // top half of the destination register unchanged.
+ // Use movaps when moving float values and movd for integer
+ // values in xmm registers.
+ void movss(XMMRegister dst, XMMRegister src);
+
void movss(XMMRegister dst, const Operand& src);
void movss(const Operand& dst, XMMRegister src);
void shufps(XMMRegister dst, XMMRegister src, byte imm8);
@@ -1078,7 +1055,7 @@ class Assembler : public AssemblerBase {
// Don't use this unless it's important to keep the
// top half of the destination register unchanged.
- // Used movaps when moving double values and movq for integer
+ // Use movapd when moving double values and movq for integer
// values in xmm registers.
void movsd(XMMRegister dst, XMMRegister src);
@@ -1105,6 +1082,10 @@ class Assembler : public AssemblerBase {
void cvtlsi2sd(XMMRegister dst, const Operand& src);
void cvtlsi2sd(XMMRegister dst, Register src);
+
+ void cvtqsi2ss(XMMRegister dst, const Operand& src);
+ void cvtqsi2ss(XMMRegister dst, Register src);
+
void cvtqsi2sd(XMMRegister dst, const Operand& src);
void cvtqsi2sd(XMMRegister dst, Register src);
@@ -1308,88 +1289,167 @@ class Assembler : public AssemblerBase {
void vfmass(byte op, XMMRegister dst, XMMRegister src1, XMMRegister src2);
void vfmass(byte op, XMMRegister dst, XMMRegister src1, const Operand& src2);
- void vaddsd(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
- vsd(0x58, dst, src1, src2);
+ void vmovd(XMMRegister dst, Register src);
+ void vmovd(XMMRegister dst, const Operand& src);
+ void vmovd(Register dst, XMMRegister src);
+ void vmovq(XMMRegister dst, Register src);
+ void vmovq(XMMRegister dst, const Operand& src);
+ void vmovq(Register dst, XMMRegister src);
+
+ void vmovsd(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
+ vsd(0x10, dst, src1, src2);
+ }
+ void vmovsd(XMMRegister dst, const Operand& src) {
+ vsd(0x10, dst, xmm0, src);
+ }
+ void vmovsd(const Operand& dst, XMMRegister src) {
+ vsd(0x11, src, xmm0, dst);
+ }
+
+#define AVX_SP_3(instr, opcode) \
+ AVX_S_3(instr, opcode) \
+ AVX_P_3(instr, opcode)
+
+#define AVX_S_3(instr, opcode) \
+ AVX_3(instr##ss, opcode, vss) \
+ AVX_3(instr##sd, opcode, vsd)
+
+#define AVX_P_3(instr, opcode) \
+ AVX_3(instr##ps, opcode, vps) \
+ AVX_3(instr##pd, opcode, vpd)
+
+#define AVX_3(instr, opcode, impl) \
+ void instr(XMMRegister dst, XMMRegister src1, XMMRegister src2) { \
+ impl(opcode, dst, src1, src2); \
+ } \
+ void instr(XMMRegister dst, XMMRegister src1, const Operand& src2) { \
+ impl(opcode, dst, src1, src2); \
}
- void vaddsd(XMMRegister dst, XMMRegister src1, const Operand& src2) {
- vsd(0x58, dst, src1, src2);
+
+ AVX_SP_3(vsqrt, 0x51);
+ AVX_SP_3(vadd, 0x58);
+ AVX_SP_3(vsub, 0x5c);
+ AVX_SP_3(vmul, 0x59);
+ AVX_SP_3(vdiv, 0x5e);
+ AVX_SP_3(vmin, 0x5d);
+ AVX_SP_3(vmax, 0x5f);
+ AVX_P_3(vand, 0x54);
+ AVX_P_3(vor, 0x56);
+ AVX_P_3(vxor, 0x57);
+ AVX_3(vpcmpeqd, 0x76, vpd);
+ AVX_3(vcvtsd2ss, 0x5a, vsd);
+
+#undef AVX_3
+#undef AVX_S_3
+#undef AVX_P_3
+#undef AVX_SP_3
+
+ void vpsrlq(XMMRegister dst, XMMRegister src, byte imm8) {
+ XMMRegister iop = {2};
+ vpd(0x73, iop, dst, src);
+ emit(imm8);
}
- void vsubsd(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
- vsd(0x5c, dst, src1, src2);
+ void vpsllq(XMMRegister dst, XMMRegister src, byte imm8) {
+ XMMRegister iop = {6};
+ vpd(0x73, iop, dst, src);
+ emit(imm8);
}
- void vsubsd(XMMRegister dst, XMMRegister src1, const Operand& src2) {
- vsd(0x5c, dst, src1, src2);
+ void vcvtss2sd(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
+ vsd(0x5a, dst, src1, src2, kF3, k0F, kWIG);
}
- void vmulsd(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
- vsd(0x59, dst, src1, src2);
+ void vcvtss2sd(XMMRegister dst, XMMRegister src1, const Operand& src2) {
+ vsd(0x5a, dst, src1, src2, kF3, k0F, kWIG);
}
- void vmulsd(XMMRegister dst, XMMRegister src1, const Operand& src2) {
- vsd(0x59, dst, src1, src2);
+ void vcvtlsi2sd(XMMRegister dst, XMMRegister src1, Register src2) {
+ XMMRegister isrc2 = {src2.code()};
+ vsd(0x2a, dst, src1, isrc2, kF2, k0F, kW0);
}
- void vdivsd(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
- vsd(0x5e, dst, src1, src2);
+ void vcvtlsi2sd(XMMRegister dst, XMMRegister src1, const Operand& src2) {
+ vsd(0x2a, dst, src1, src2, kF2, k0F, kW0);
}
- void vdivsd(XMMRegister dst, XMMRegister src1, const Operand& src2) {
- vsd(0x5e, dst, src1, src2);
+ void vcvtqsi2ss(XMMRegister dst, XMMRegister src1, Register src2) {
+ XMMRegister isrc2 = {src2.code()};
+ vsd(0x2a, dst, src1, isrc2, kF3, k0F, kW1);
}
- void vmaxsd(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
- vsd(0x5f, dst, src1, src2);
+ void vcvtqsi2ss(XMMRegister dst, XMMRegister src1, const Operand& src2) {
+ vsd(0x2a, dst, src1, src2, kF3, k0F, kW1);
}
- void vmaxsd(XMMRegister dst, XMMRegister src1, const Operand& src2) {
- vsd(0x5f, dst, src1, src2);
+ void vcvtqsi2sd(XMMRegister dst, XMMRegister src1, Register src2) {
+ XMMRegister isrc2 = {src2.code()};
+ vsd(0x2a, dst, src1, isrc2, kF2, k0F, kW1);
}
- void vminsd(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
- vsd(0x5d, dst, src1, src2);
+ void vcvtqsi2sd(XMMRegister dst, XMMRegister src1, const Operand& src2) {
+ vsd(0x2a, dst, src1, src2, kF2, k0F, kW1);
}
- void vminsd(XMMRegister dst, XMMRegister src1, const Operand& src2) {
- vsd(0x5d, dst, src1, src2);
+ void vcvttsd2si(Register dst, XMMRegister src) {
+ XMMRegister idst = {dst.code()};
+ vsd(0x2c, idst, xmm0, src, kF2, k0F, kW0);
}
- void vucomisd(XMMRegister dst, XMMRegister src);
- void vucomisd(XMMRegister dst, const Operand& src);
- void vsd(byte op, XMMRegister dst, XMMRegister src1, XMMRegister src2);
- void vsd(byte op, XMMRegister dst, XMMRegister src1, const Operand& src2);
-
- void vaddss(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
- vss(0x58, dst, src1, src2);
+ void vcvttsd2si(Register dst, const Operand& src) {
+ XMMRegister idst = {dst.code()};
+ vsd(0x2c, idst, xmm0, src, kF2, k0F, kW0);
}
- void vaddss(XMMRegister dst, XMMRegister src1, const Operand& src2) {
- vss(0x58, dst, src1, src2);
+ void vcvttsd2siq(Register dst, XMMRegister src) {
+ XMMRegister idst = {dst.code()};
+ vsd(0x2c, idst, xmm0, src, kF2, k0F, kW1);
}
- void vsubss(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
- vss(0x5c, dst, src1, src2);
+ void vcvttsd2siq(Register dst, const Operand& src) {
+ XMMRegister idst = {dst.code()};
+ vsd(0x2c, idst, xmm0, src, kF2, k0F, kW1);
}
- void vsubss(XMMRegister dst, XMMRegister src1, const Operand& src2) {
- vss(0x5c, dst, src1, src2);
+ void vcvtsd2si(Register dst, XMMRegister src) {
+ XMMRegister idst = {dst.code()};
+ vsd(0x2d, idst, xmm0, src, kF2, k0F, kW0);
}
- void vmulss(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
- vss(0x59, dst, src1, src2);
+ void vucomisd(XMMRegister dst, XMMRegister src) {
+ vsd(0x2e, dst, xmm0, src, k66, k0F, kWIG);
}
- void vmulss(XMMRegister dst, XMMRegister src1, const Operand& src2) {
- vss(0x59, dst, src1, src2);
+ void vucomisd(XMMRegister dst, const Operand& src) {
+ vsd(0x2e, dst, xmm0, src, k66, k0F, kWIG);
}
- void vdivss(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
- vss(0x5e, dst, src1, src2);
+ void vroundsd(XMMRegister dst, XMMRegister src1, XMMRegister src2,
+ RoundingMode mode) {
+ vsd(0x0b, dst, src1, src2, k66, k0F3A, kWIG);
+ emit(static_cast<byte>(mode) | 0x8); // Mask precision exception.
}
- void vdivss(XMMRegister dst, XMMRegister src1, const Operand& src2) {
- vss(0x5e, dst, src1, src2);
+
+ void vsd(byte op, XMMRegister dst, XMMRegister src1, XMMRegister src2) {
+ vsd(op, dst, src1, src2, kF2, k0F, kWIG);
}
- void vmaxss(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
- vss(0x5f, dst, src1, src2);
+ void vsd(byte op, XMMRegister dst, XMMRegister src1, const Operand& src2) {
+ vsd(op, dst, src1, src2, kF2, k0F, kWIG);
}
- void vmaxss(XMMRegister dst, XMMRegister src1, const Operand& src2) {
- vss(0x5f, dst, src1, src2);
+ void vsd(byte op, XMMRegister dst, XMMRegister src1, XMMRegister src2,
+ SIMDPrefix pp, LeadingOpcode m, VexW w);
+ void vsd(byte op, XMMRegister dst, XMMRegister src1, const Operand& src2,
+ SIMDPrefix pp, LeadingOpcode m, VexW w);
+
+ void vmovss(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
+ vss(0x10, dst, src1, src2);
}
- void vminss(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
- vss(0x5d, dst, src1, src2);
+ void vmovss(XMMRegister dst, const Operand& src) {
+ vss(0x10, dst, xmm0, src);
}
- void vminss(XMMRegister dst, XMMRegister src1, const Operand& src2) {
- vss(0x5d, dst, src1, src2);
+ void vmovss(const Operand& dst, XMMRegister src) {
+ vss(0x11, src, xmm0, dst);
}
void vucomiss(XMMRegister dst, XMMRegister src);
void vucomiss(XMMRegister dst, const Operand& src);
void vss(byte op, XMMRegister dst, XMMRegister src1, XMMRegister src2);
void vss(byte op, XMMRegister dst, XMMRegister src1, const Operand& src2);
+ void vmovaps(XMMRegister dst, XMMRegister src) { vps(0x28, dst, xmm0, src); }
+ void vmovapd(XMMRegister dst, XMMRegister src) { vpd(0x28, dst, xmm0, src); }
+ void vmovmskpd(Register dst, XMMRegister src) {
+ XMMRegister idst = {dst.code()};
+ vpd(0x50, idst, xmm0, src);
+ }
+
+ void vps(byte op, XMMRegister dst, XMMRegister src1, XMMRegister src2);
+ void vps(byte op, XMMRegister dst, XMMRegister src1, const Operand& src2);
+ void vpd(byte op, XMMRegister dst, XMMRegister src1, XMMRegister src2);
+ void vpd(byte op, XMMRegister dst, XMMRegister src1, const Operand& src2);
+
// BMI instruction
void andnq(Register dst, Register src1, Register src2) {
bmi1q(0xf2, dst, src1, src2);
@@ -1567,33 +1627,6 @@ class Assembler : public AssemblerBase {
void rorxl(Register dst, Register src, byte imm8);
void rorxl(Register dst, const Operand& src, byte imm8);
-#define PACKED_OP_LIST(V) \
- V(and, 0x54) \
- V(xor, 0x57)
-
-#define AVX_PACKED_OP_DECLARE(name, opcode) \
- void v##name##ps(XMMRegister dst, XMMRegister src1, XMMRegister src2) { \
- vps(opcode, dst, src1, src2); \
- } \
- void v##name##ps(XMMRegister dst, XMMRegister src1, const Operand& src2) { \
- vps(opcode, dst, src1, src2); \
- } \
- void v##name##pd(XMMRegister dst, XMMRegister src1, XMMRegister src2) { \
- vpd(opcode, dst, src1, src2); \
- } \
- void v##name##pd(XMMRegister dst, XMMRegister src1, const Operand& src2) { \
- vpd(opcode, dst, src1, src2); \
- }
-
- PACKED_OP_LIST(AVX_PACKED_OP_DECLARE);
- void vps(byte op, XMMRegister dst, XMMRegister src1, XMMRegister src2);
- void vps(byte op, XMMRegister dst, XMMRegister src1, const Operand& src2);
- void vpd(byte op, XMMRegister dst, XMMRegister src1, XMMRegister src2);
- void vpd(byte op, XMMRegister dst, XMMRegister src1, const Operand& src2);
-
- // Debugging
- void Print();
-
// Check the code size generated from label to here.
int SizeOfCodeGeneratedSince(Label* label) {
return pc_offset() - label->pos();
@@ -1790,11 +1823,6 @@ class Assembler : public AssemblerBase {
}
// Emit vex prefix
- enum SIMDPrefix { kNone = 0x0, k66 = 0x1, kF3 = 0x2, kF2 = 0x3 };
- enum VectorLength { kL128 = 0x0, kL256 = 0x4, kLIG = kL128, kLZ = kL128 };
- enum VexW { kW0 = 0x0, kW1 = 0x80, kWIG = kW0 };
- enum LeadingOpcode { k0F = 0x1, k0F38 = 0x2, k0F3A = 0x3 };
-
void emit_vex2_byte0() { emit(0xc5); }
inline void emit_vex2_byte1(XMMRegister reg, XMMRegister v, VectorLength l,
SIMDPrefix pp);
@@ -2148,6 +2176,7 @@ class EnsureSpace BASE_EMBEDDED {
#endif
};
-} } // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_X64_ASSEMBLER_X64_H_
diff --git a/deps/v8/src/x64/builtins-x64.cc b/deps/v8/src/x64/builtins-x64.cc
index 38d7e5abeb..4efd3bfb23 100644
--- a/deps/v8/src/x64/builtins-x64.cc
+++ b/deps/v8/src/x64/builtins-x64.cc
@@ -21,12 +21,13 @@ void Builtins::Generate_Adaptor(MacroAssembler* masm,
BuiltinExtraArguments extra_args) {
// ----------- S t a t e -------------
// -- rax : number of arguments excluding receiver
- // -- rdi : called function (only guaranteed when
- // extra_args requires it)
+ // (only guaranteed when the called function
+ // is not marked as DontAdaptArguments)
+ // -- rdi : called function
// -- rsp[0] : return address
// -- rsp[8] : last argument
// -- ...
- // -- rsp[8 * argc] : first argument (argc == rax)
+ // -- rsp[8 * argc] : first argument
// -- rsp[8 * (argc + 1)] : receiver
// -----------------------------------
__ AssertFunction(rdi);
@@ -50,8 +51,21 @@ void Builtins::Generate_Adaptor(MacroAssembler* masm,
}
// JumpToExternalReference expects rax to contain the number of arguments
- // including the receiver and the extra arguments.
+ // including the receiver and the extra arguments. But rax is only valid
+ // if the called function is marked as DontAdaptArguments, otherwise we
+ // need to load the argument count from the SharedFunctionInfo.
+ Label argc, done_argc;
+ __ movp(rdx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
+ __ LoadSharedFunctionInfoSpecialField(
+ rbx, rdx, SharedFunctionInfo::kFormalParameterCountOffset);
+ __ cmpp(rbx, Immediate(SharedFunctionInfo::kDontAdaptArgumentsSentinel));
+ __ j(equal, &argc, Label::kNear);
+ __ leap(rax, Operand(rbx, num_extra_args + 1));
+ __ jmp(&done_argc, Label::kNear);
+ __ bind(&argc);
__ addp(rax, Immediate(num_extra_args + 1));
+ __ bind(&done_argc);
+
__ JumpToExternalReference(ExternalReference(id, masm->isolate()), 1);
}
@@ -135,14 +149,13 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm,
__ cmpp(Operand(kScratchRegister, 0), Immediate(0));
__ j(not_equal, &rt_call);
- // Fall back to runtime if the original constructor and function differ.
- __ cmpp(rdx, rdi);
+ // Verify that the original constructor is a JSFunction.
+ __ CmpObjectType(rdx, JS_FUNCTION_TYPE, rbx);
__ j(not_equal, &rt_call);
- // Verified that the constructor is a JSFunction.
// Load the initial map and verify that it is in fact a map.
- // rdi: constructor
- __ movp(rax, FieldOperand(rdi, JSFunction::kPrototypeOrInitialMapOffset));
+ // rdx: original constructor
+ __ movp(rax, FieldOperand(rdx, JSFunction::kPrototypeOrInitialMapOffset));
// Will both indicate a NULL and a Smi
DCHECK(kSmiTag == 0);
__ JumpIfSmi(rax, &rt_call);
@@ -151,6 +164,11 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm,
__ CmpObjectType(rax, MAP_TYPE, rbx);
__ j(not_equal, &rt_call);
+ // Fall back to runtime if the expected base constructor and base
+ // constructor differ.
+ __ cmpp(rdi, FieldOperand(rax, Map::kConstructorOrBackPointerOffset));
+ __ j(not_equal, &rt_call);
+
// Check that the constructor is not constructing a JSFunction (see
// comments in Runtime_NewObject in runtime.cc). In which case the
// initial map's instance type would be JS_FUNCTION_TYPE.
@@ -178,7 +196,7 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm,
__ Push(rdx);
__ Push(rdi);
- __ Push(rdi); // constructor
+ __ Push(rax); // initial map
__ CallRuntime(Runtime::kFinalizeInstanceSize, 1);
__ Pop(rdi);
@@ -263,8 +281,8 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm,
// Must restore rsi (context) and rdi (constructor) before calling runtime.
__ movp(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
__ movp(rdi, Operand(rsp, offset));
- __ Push(rdi); // argument 2/1: constructor function
- __ Push(rdx); // argument 3/2: original constructor
+ __ Push(rdi); // constructor function
+ __ Push(rdx); // original constructor
__ CallRuntime(Runtime::kNewObject, 2);
__ movp(rbx, rax); // store result in rbx
@@ -698,28 +716,16 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
// - Support profiler (specifically profiling_counter).
// - Call ProfileEntryHookStub when isolate has a function_entry_hook.
// - Allow simulator stop operations if FLAG_stop_at is set.
- // - Deal with sloppy mode functions which need to replace the
- // receiver with the global proxy when called as functions (without an
- // explicit receiver object).
// - Code aging of the BytecodeArray object.
- // - Supporting FLAG_trace.
- //
- // The following items are also not done here, and will probably be done using
- // explicit bytecodes instead:
- // - Allocating a new local context if applicable.
- // - Setting up a local binding to the this function, which is used in
- // derived constructors with super calls.
- // - Setting new.target if required.
- // - Dealing with REST parameters (only if
- // https://codereview.chromium.org/1235153006 doesn't land by then).
- // - Dealing with argument objects.
// Perform stack guard check.
{
Label ok;
__ CompareRoot(rsp, Heap::kStackLimitRootIndex);
__ j(above_equal, &ok, Label::kNear);
+ __ Push(kInterpreterBytecodeArrayRegister);
__ CallRuntime(Runtime::kStackGuard, 0);
+ __ Pop(kInterpreterBytecodeArrayRegister);
__ bind(&ok);
}
@@ -771,6 +777,86 @@ void Builtins::Generate_InterpreterExitTrampoline(MacroAssembler* masm) {
}
+static void Generate_InterpreterPushArgs(MacroAssembler* masm,
+ bool push_receiver) {
+ // ----------- S t a t e -------------
+ // -- rax : the number of arguments (not including the receiver)
+ // -- rbx : the address of the first argument to be pushed. Subsequent
+ // arguments should be consecutive above this, in the same order as
+ // they are to be pushed onto the stack.
+ // -----------------------------------
+
+ // Find the address of the last argument.
+ __ movp(rcx, rax);
+ if (push_receiver) {
+ __ addp(rcx, Immediate(1)); // Add one for receiver.
+ }
+
+ __ shlp(rcx, Immediate(kPointerSizeLog2));
+ __ negp(rcx);
+ __ addp(rcx, rbx);
+
+ // Push the arguments.
+ Label loop_header, loop_check;
+ __ j(always, &loop_check);
+ __ bind(&loop_header);
+ __ Push(Operand(rbx, 0));
+ __ subp(rbx, Immediate(kPointerSize));
+ __ bind(&loop_check);
+ __ cmpp(rbx, rcx);
+ __ j(greater, &loop_header, Label::kNear);
+}
+
+
+// static
+void Builtins::Generate_InterpreterPushArgsAndCall(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- rax : the number of arguments (not including the receiver)
+ // -- rbx : the address of the first argument to be pushed. Subsequent
+ // arguments should be consecutive above this, in the same order as
+ // they are to be pushed onto the stack.
+ // -- rdi : the target to call (can be any Object).
+ // -----------------------------------
+
+ // Pop return address to allow tail-call after pushing arguments.
+ __ PopReturnAddressTo(kScratchRegister);
+
+ Generate_InterpreterPushArgs(masm, true);
+
+ // Call the target.
+ __ PushReturnAddressFrom(kScratchRegister); // Re-push return address.
+ __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET);
+}
+
+
+// static
+void Builtins::Generate_InterpreterPushArgsAndConstruct(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- rax : the number of arguments (not including the receiver)
+ // -- rdx : the original constructor (either the same as the constructor or
+ // the JSFunction on which new was invoked initially)
+ // -- rdi : the constructor to call (can be any Object)
+ // -- rbx : the address of the first argument to be pushed. Subsequent
+ // arguments should be consecutive above this, in the same order as
+ // they are to be pushed onto the stack.
+ // -----------------------------------
+
+ // Pop return address to allow tail-call after pushing arguments.
+ __ PopReturnAddressTo(kScratchRegister);
+
+ // Push slot for the receiver to be constructed.
+ __ Push(Immediate(0));
+
+ Generate_InterpreterPushArgs(masm, false);
+
+ // Push return address in preparation for the tail-call.
+ __ PushReturnAddressFrom(kScratchRegister);
+
+ // Call the constructor (rax, rdx, rdi passed on).
+ __ Jump(masm->isolate()->builtins()->Construct(), RelocInfo::CONSTRUCT_CALL);
+}
+
+
void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
CallRuntimePassFunction(masm, Runtime::kCompileLazy);
GenerateTailCallToReturnedCode(masm);
@@ -1338,6 +1424,7 @@ void Builtins::Generate_StringConstructor_ConstructStub(MacroAssembler* masm) {
// ----------- S t a t e -------------
// -- rax : number of arguments
// -- rdi : constructor function
+ // -- rdx : original constructor
// -- rsp[0] : return address
// -- rsp[(argc - n) * 8] : arg[n] (zero-based)
// -- rsp[(argc + 1) * 8] : receiver
@@ -1364,17 +1451,19 @@ void Builtins::Generate_StringConstructor_ConstructStub(MacroAssembler* masm) {
{
Label convert, done_convert;
__ JumpIfSmi(rbx, &convert, Label::kNear);
- __ CmpObjectType(rbx, FIRST_NONSTRING_TYPE, rdx);
+ __ CmpObjectType(rbx, FIRST_NONSTRING_TYPE, rcx);
__ j(below, &done_convert);
__ bind(&convert);
{
FrameScope scope(masm, StackFrame::INTERNAL);
ToStringStub stub(masm->isolate());
+ __ Push(rdx);
__ Push(rdi);
__ Move(rax, rbx);
__ CallStub(&stub);
__ Move(rbx, rax);
__ Pop(rdi);
+ __ Pop(rdx);
}
__ bind(&done_convert);
}
@@ -1384,9 +1473,14 @@ void Builtins::Generate_StringConstructor_ConstructStub(MacroAssembler* masm) {
// ----------- S t a t e -------------
// -- rbx : the first argument
// -- rdi : constructor function
+ // -- rdx : original constructor
// -----------------------------------
+ Label allocate, done_allocate, rt_call;
+
+ // Fall back to runtime if the original constructor and constructor differ.
+ __ cmpp(rdx, rdi);
+ __ j(not_equal, &rt_call);
- Label allocate, done_allocate;
__ Allocate(JSValue::kSize, rax, rcx, no_reg, &allocate, TAG_OBJECT);
__ bind(&done_allocate);
@@ -1412,6 +1506,21 @@ void Builtins::Generate_StringConstructor_ConstructStub(MacroAssembler* masm) {
__ Pop(rbx);
}
__ jmp(&done_allocate);
+
+ // Fallback to the runtime to create new object.
+ __ bind(&rt_call);
+ {
+ FrameScope scope(masm, StackFrame::INTERNAL);
+ __ Push(rbx);
+ __ Push(rdi);
+ __ Push(rdi); // constructor function
+ __ Push(rdx); // original constructor
+ __ CallRuntime(Runtime::kNewObject, 2);
+ __ Pop(rdi);
+ __ Pop(rbx);
+ }
+ __ movp(FieldOperand(rax, JSValue::kValueOffset), rbx);
+ __ Ret();
}
}
@@ -1612,75 +1721,92 @@ void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) {
// static
-void Builtins::Generate_CallFunction(MacroAssembler* masm) {
+void Builtins::Generate_CallFunction(MacroAssembler* masm,
+ ConvertReceiverMode mode) {
// ----------- S t a t e -------------
// -- rax : the number of arguments (not including the receiver)
// -- rdi : the function to call (checked to be a JSFunction)
// -----------------------------------
-
- Label convert, convert_global_proxy, convert_to_object, done_convert;
StackArgumentsAccessor args(rsp, rax);
__ AssertFunction(rdi);
- // TODO(bmeurer): Throw a TypeError if function's [[FunctionKind]] internal
- // slot is "classConstructor".
+
+ // ES6 section 9.2.1 [[Call]] ( thisArgument, argumentsList)
+ // Check that the function is not a "classConstructor".
+ Label class_constructor;
+ __ movp(rdx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
+ __ testb(FieldOperand(rdx, SharedFunctionInfo::kFunctionKindByteOffset),
+ Immediate(SharedFunctionInfo::kClassConstructorBitsWithinByte));
+ __ j(not_zero, &class_constructor);
+
+ // ----------- S t a t e -------------
+ // -- rax : the number of arguments (not including the receiver)
+ // -- rdx : the shared function info.
+ // -- rdi : the function to call (checked to be a JSFunction)
+ // -----------------------------------
+
// Enter the context of the function; ToObject has to run in the function
// context, and we also need to take the global proxy from the function
// context in case of conversion.
- // See ES6 section 9.2.1 [[Call]] ( thisArgument, argumentsList)
STATIC_ASSERT(SharedFunctionInfo::kNativeByteOffset ==
SharedFunctionInfo::kStrictModeByteOffset);
__ movp(rsi, FieldOperand(rdi, JSFunction::kContextOffset));
- __ movp(rdx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
// We need to convert the receiver for non-native sloppy mode functions.
+ Label done_convert;
__ testb(FieldOperand(rdx, SharedFunctionInfo::kNativeByteOffset),
Immediate((1 << SharedFunctionInfo::kNativeBitWithinByte) |
(1 << SharedFunctionInfo::kStrictModeBitWithinByte)));
__ j(not_zero, &done_convert);
{
- __ movp(rcx, args.GetReceiverOperand());
-
// ----------- S t a t e -------------
// -- rax : the number of arguments (not including the receiver)
- // -- rcx : the receiver
// -- rdx : the shared function info.
// -- rdi : the function to call (checked to be a JSFunction)
// -- rsi : the function context.
// -----------------------------------
- Label convert_receiver;
- __ JumpIfSmi(rcx, &convert_to_object, Label::kNear);
- STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
- __ CmpObjectType(rcx, FIRST_JS_RECEIVER_TYPE, rbx);
- __ j(above_equal, &done_convert);
- __ JumpIfRoot(rcx, Heap::kUndefinedValueRootIndex, &convert_global_proxy,
- Label::kNear);
- __ JumpIfNotRoot(rcx, Heap::kNullValueRootIndex, &convert_to_object,
- Label::kNear);
- __ bind(&convert_global_proxy);
- {
+ if (mode == ConvertReceiverMode::kNullOrUndefined) {
// Patch receiver to global proxy.
__ LoadGlobalProxy(rcx);
+ } else {
+ Label convert_to_object, convert_receiver;
+ __ movp(rcx, args.GetReceiverOperand());
+ __ JumpIfSmi(rcx, &convert_to_object, Label::kNear);
+ STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
+ __ CmpObjectType(rcx, FIRST_JS_RECEIVER_TYPE, rbx);
+ __ j(above_equal, &done_convert);
+ if (mode != ConvertReceiverMode::kNotNullOrUndefined) {
+ Label convert_global_proxy;
+ __ JumpIfRoot(rcx, Heap::kUndefinedValueRootIndex,
+ &convert_global_proxy, Label::kNear);
+ __ JumpIfNotRoot(rcx, Heap::kNullValueRootIndex, &convert_to_object,
+ Label::kNear);
+ __ bind(&convert_global_proxy);
+ {
+ // Patch receiver to global proxy.
+ __ LoadGlobalProxy(rcx);
+ }
+ __ jmp(&convert_receiver);
+ }
+ __ bind(&convert_to_object);
+ {
+ // Convert receiver using ToObject.
+ // TODO(bmeurer): Inline the allocation here to avoid building the frame
+ // in the fast case? (fall back to AllocateInNewSpace?)
+ FrameScope scope(masm, StackFrame::INTERNAL);
+ __ Integer32ToSmi(rax, rax);
+ __ Push(rax);
+ __ Push(rdi);
+ __ movp(rax, rcx);
+ ToObjectStub stub(masm->isolate());
+ __ CallStub(&stub);
+ __ movp(rcx, rax);
+ __ Pop(rdi);
+ __ Pop(rax);
+ __ SmiToInteger32(rax, rax);
+ }
+ __ movp(rdx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
+ __ bind(&convert_receiver);
}
- __ jmp(&convert_receiver);
- __ bind(&convert_to_object);
- {
- // Convert receiver using ToObject.
- // TODO(bmeurer): Inline the allocation here to avoid building the frame
- // in the fast case? (fall back to AllocateInNewSpace?)
- FrameScope scope(masm, StackFrame::INTERNAL);
- __ Integer32ToSmi(rax, rax);
- __ Push(rax);
- __ Push(rdi);
- __ movp(rax, rcx);
- ToObjectStub stub(masm->isolate());
- __ CallStub(&stub);
- __ movp(rcx, rax);
- __ Pop(rdi);
- __ Pop(rax);
- __ SmiToInteger32(rax, rax);
- }
- __ movp(rdx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
- __ bind(&convert_receiver);
__ movp(args.GetReceiverOperand(), rcx);
}
__ bind(&done_convert);
@@ -1698,11 +1824,18 @@ void Builtins::Generate_CallFunction(MacroAssembler* masm) {
ParameterCount actual(rax);
ParameterCount expected(rbx);
__ InvokeCode(rdx, expected, actual, JUMP_FUNCTION, NullCallWrapper());
+
+ // The function is a "classConstructor", need to raise an exception.
+ __ bind(&class_constructor);
+ {
+ FrameScope frame(masm, StackFrame::INTERNAL);
+ __ CallRuntime(Runtime::kThrowConstructorNonCallableError, 0);
+ }
}
// static
-void Builtins::Generate_Call(MacroAssembler* masm) {
+void Builtins::Generate_Call(MacroAssembler* masm, ConvertReceiverMode mode) {
// ----------- S t a t e -------------
// -- rax : the number of arguments (not including the receiver)
// -- rdi : the target to call (can be any Object)
@@ -1713,7 +1846,7 @@ void Builtins::Generate_Call(MacroAssembler* masm) {
__ JumpIfSmi(rdi, &non_callable);
__ bind(&non_smi);
__ CmpObjectType(rdi, JS_FUNCTION_TYPE, rcx);
- __ j(equal, masm->isolate()->builtins()->CallFunction(),
+ __ j(equal, masm->isolate()->builtins()->CallFunction(mode),
RelocInfo::CODE_TARGET);
__ CmpInstanceType(rcx, JS_FUNCTION_PROXY_TYPE);
__ j(not_equal, &non_function);
@@ -1735,7 +1868,9 @@ void Builtins::Generate_Call(MacroAssembler* masm) {
__ movp(args.GetReceiverOperand(), rdi);
// Let the "call_as_function_delegate" take care of the rest.
__ LoadGlobalFunction(Context::CALL_AS_FUNCTION_DELEGATE_INDEX, rdi);
- __ Jump(masm->isolate()->builtins()->CallFunction(), RelocInfo::CODE_TARGET);
+ __ Jump(masm->isolate()->builtins()->CallFunction(
+ ConvertReceiverMode::kNotNullOrUndefined),
+ RelocInfo::CODE_TARGET);
// 3. Call to something that is not callable.
__ bind(&non_callable);
@@ -1832,41 +1967,6 @@ void Builtins::Generate_Construct(MacroAssembler* masm) {
}
-// static
-void Builtins::Generate_PushArgsAndCall(MacroAssembler* masm) {
- // ----------- S t a t e -------------
- // -- rax : the number of arguments (not including the receiver)
- // -- rbx : the address of the first argument to be pushed. Subsequent
- // arguments should be consecutive above this, in the same order as
- // they are to be pushed onto the stack.
- // -- rdi : the target to call (can be any Object).
-
- // Pop return address to allow tail-call after pushing arguments.
- __ Pop(rdx);
-
- // Find the address of the last argument.
- __ movp(rcx, rax);
- __ addp(rcx, Immediate(1)); // Add one for receiver.
- __ shlp(rcx, Immediate(kPointerSizeLog2));
- __ negp(rcx);
- __ addp(rcx, rbx);
-
- // Push the arguments.
- Label loop_header, loop_check;
- __ j(always, &loop_check);
- __ bind(&loop_header);
- __ Push(Operand(rbx, 0));
- __ subp(rbx, Immediate(kPointerSize));
- __ bind(&loop_check);
- __ cmpp(rbx, rcx);
- __ j(greater, &loop_header, Label::kNear);
-
- // Call the target.
- __ Push(rdx); // Re-push return address.
- __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET);
-}
-
-
void Builtins::Generate_OnStackReplacement(MacroAssembler* masm) {
// Lookup the function in the JavaScript frame.
__ movp(rax, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
diff --git a/deps/v8/src/x64/code-stubs-x64.cc b/deps/v8/src/x64/code-stubs-x64.cc
index 0942b2fb3c..b7fb099512 100644
--- a/deps/v8/src/x64/code-stubs-x64.cc
+++ b/deps/v8/src/x64/code-stubs-x64.cc
@@ -180,7 +180,7 @@ void DoubleToIStub::Generate(MacroAssembler* masm) {
bool stash_exponent_copy = !input_reg.is(rsp);
__ movl(scratch1, mantissa_operand);
- __ movsd(xmm0, mantissa_operand);
+ __ Movsd(xmm0, mantissa_operand);
__ movl(rcx, exponent_operand);
if (stash_exponent_copy) __ pushq(rcx);
@@ -200,7 +200,7 @@ void DoubleToIStub::Generate(MacroAssembler* masm) {
__ jmp(&check_negative);
__ bind(&process_64_bits);
- __ cvttsd2siq(result_reg, xmm0);
+ __ Cvttsd2siq(result_reg, xmm0);
__ jmp(&done, Label::kNear);
// If the double was negative, negate the integer result.
@@ -237,14 +237,14 @@ void FloatingPointHelper::LoadSSE2UnknownOperands(MacroAssembler* masm,
__ JumpIfSmi(rdx, &load_smi_rdx);
__ cmpp(FieldOperand(rdx, HeapObject::kMapOffset), rcx);
__ j(not_equal, not_numbers); // Argument in rdx is not a number.
- __ movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
+ __ Movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
// Load operand in rax into xmm1, or branch to not_numbers.
__ JumpIfSmi(rax, &load_smi_rax);
__ bind(&load_nonsmi_rax);
__ cmpp(FieldOperand(rax, HeapObject::kMapOffset), rcx);
__ j(not_equal, not_numbers);
- __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
+ __ Movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
__ jmp(&done);
__ bind(&load_smi_rdx);
@@ -288,7 +288,7 @@ void MathPowStub::Generate(MacroAssembler* masm) {
Heap::kHeapNumberMapRootIndex);
__ j(not_equal, &call_runtime);
- __ movsd(double_base, FieldOperand(base, HeapNumber::kValueOffset));
+ __ Movsd(double_base, FieldOperand(base, HeapNumber::kValueOffset));
__ jmp(&unpack_exponent, Label::kNear);
__ bind(&base_is_smi);
@@ -304,14 +304,14 @@ void MathPowStub::Generate(MacroAssembler* masm) {
__ CompareRoot(FieldOperand(exponent, HeapObject::kMapOffset),
Heap::kHeapNumberMapRootIndex);
__ j(not_equal, &call_runtime);
- __ movsd(double_exponent, FieldOperand(exponent, HeapNumber::kValueOffset));
+ __ Movsd(double_exponent, FieldOperand(exponent, HeapNumber::kValueOffset));
} else if (exponent_type() == TAGGED) {
__ JumpIfNotSmi(exponent, &exponent_not_smi, Label::kNear);
__ SmiToInteger32(exponent, exponent);
__ jmp(&int_exponent);
__ bind(&exponent_not_smi);
- __ movsd(double_exponent, FieldOperand(exponent, HeapNumber::kValueOffset));
+ __ Movsd(double_exponent, FieldOperand(exponent, HeapNumber::kValueOffset));
}
if (exponent_type() != INTEGER) {
@@ -324,7 +324,7 @@ void MathPowStub::Generate(MacroAssembler* masm) {
__ jmp(&int_exponent);
__ bind(&try_arithmetic_simplification);
- __ cvttsd2si(exponent, double_exponent);
+ __ Cvttsd2si(exponent, double_exponent);
// Skip to runtime if possibly NaN (indicated by the indefinite integer).
__ cmpl(exponent, Immediate(0x1));
__ j(overflow, &call_runtime);
@@ -337,9 +337,9 @@ void MathPowStub::Generate(MacroAssembler* masm) {
// Test for 0.5.
// Load double_scratch with 0.5.
__ movq(scratch, V8_UINT64_C(0x3FE0000000000000));
- __ movq(double_scratch, scratch);
+ __ Movq(double_scratch, scratch);
// Already ruled out NaNs for exponent.
- __ ucomisd(double_scratch, double_exponent);
+ __ Ucomisd(double_scratch, double_exponent);
__ j(not_equal, &not_plus_half, Label::kNear);
// Calculates square root of base. Check for the special case of
@@ -347,31 +347,31 @@ void MathPowStub::Generate(MacroAssembler* masm) {
// According to IEEE-754, double-precision -Infinity has the highest
// 12 bits set and the lowest 52 bits cleared.
__ movq(scratch, V8_UINT64_C(0xFFF0000000000000));
- __ movq(double_scratch, scratch);
- __ ucomisd(double_scratch, double_base);
+ __ Movq(double_scratch, scratch);
+ __ Ucomisd(double_scratch, double_base);
// Comparing -Infinity with NaN results in "unordered", which sets the
// zero flag as if both were equal. However, it also sets the carry flag.
__ j(not_equal, &continue_sqrt, Label::kNear);
__ j(carry, &continue_sqrt, Label::kNear);
// Set result to Infinity in the special case.
- __ xorps(double_result, double_result);
- __ subsd(double_result, double_scratch);
+ __ Xorpd(double_result, double_result);
+ __ Subsd(double_result, double_scratch);
__ jmp(&done);
__ bind(&continue_sqrt);
// sqrtsd returns -0 when input is -0. ECMA spec requires +0.
- __ xorps(double_scratch, double_scratch);
- __ addsd(double_scratch, double_base); // Convert -0 to 0.
- __ sqrtsd(double_result, double_scratch);
+ __ Xorpd(double_scratch, double_scratch);
+ __ Addsd(double_scratch, double_base); // Convert -0 to 0.
+ __ Sqrtsd(double_result, double_scratch);
__ jmp(&done);
// Test for -0.5.
__ bind(&not_plus_half);
// Load double_scratch with -0.5 by substracting 1.
- __ subsd(double_scratch, double_result);
+ __ Subsd(double_scratch, double_result);
// Already ruled out NaNs for exponent.
- __ ucomisd(double_scratch, double_exponent);
+ __ Ucomisd(double_scratch, double_exponent);
__ j(not_equal, &fast_power, Label::kNear);
// Calculates reciprocal of square root of base. Check for the special
@@ -379,23 +379,23 @@ void MathPowStub::Generate(MacroAssembler* masm) {
// According to IEEE-754, double-precision -Infinity has the highest
// 12 bits set and the lowest 52 bits cleared.
__ movq(scratch, V8_UINT64_C(0xFFF0000000000000));
- __ movq(double_scratch, scratch);
- __ ucomisd(double_scratch, double_base);
+ __ Movq(double_scratch, scratch);
+ __ Ucomisd(double_scratch, double_base);
// Comparing -Infinity with NaN results in "unordered", which sets the
// zero flag as if both were equal. However, it also sets the carry flag.
__ j(not_equal, &continue_rsqrt, Label::kNear);
__ j(carry, &continue_rsqrt, Label::kNear);
// Set result to 0 in the special case.
- __ xorps(double_result, double_result);
+ __ Xorpd(double_result, double_result);
__ jmp(&done);
__ bind(&continue_rsqrt);
// sqrtsd returns -0 when input is -0. ECMA spec requires +0.
- __ xorps(double_exponent, double_exponent);
- __ addsd(double_exponent, double_base); // Convert -0 to +0.
- __ sqrtsd(double_exponent, double_exponent);
- __ divsd(double_result, double_exponent);
+ __ Xorpd(double_exponent, double_exponent);
+ __ Addsd(double_exponent, double_base); // Convert -0 to +0.
+ __ Sqrtsd(double_exponent, double_exponent);
+ __ Divsd(double_result, double_exponent);
__ jmp(&done);
}
@@ -405,9 +405,9 @@ void MathPowStub::Generate(MacroAssembler* masm) {
__ fnclex(); // Clear flags to catch exceptions later.
// Transfer (B)ase and (E)xponent onto the FPU register stack.
__ subp(rsp, Immediate(kDoubleSize));
- __ movsd(Operand(rsp, 0), double_exponent);
+ __ Movsd(Operand(rsp, 0), double_exponent);
__ fld_d(Operand(rsp, 0)); // E
- __ movsd(Operand(rsp, 0), double_base);
+ __ Movsd(Operand(rsp, 0), double_base);
__ fld_d(Operand(rsp, 0)); // B, E
// Exponent is in st(1) and base is in st(0)
@@ -430,7 +430,7 @@ void MathPowStub::Generate(MacroAssembler* masm) {
__ testb(rax, Immediate(0x5F)); // Check for all but precision exception.
__ j(not_zero, &fast_power_failed, Label::kNear);
__ fstp_d(Operand(rsp, 0));
- __ movsd(double_result, Operand(rsp, 0));
+ __ Movsd(double_result, Operand(rsp, 0));
__ addp(rsp, Immediate(kDoubleSize));
__ jmp(&done);
@@ -445,8 +445,8 @@ void MathPowStub::Generate(MacroAssembler* masm) {
const XMMRegister double_scratch2 = double_exponent;
// Back up exponent as we need to check if exponent is negative later.
__ movp(scratch, exponent); // Back up exponent.
- __ movsd(double_scratch, double_base); // Back up base.
- __ movsd(double_scratch2, double_result); // Load double_exponent with 1.
+ __ Movsd(double_scratch, double_base); // Back up base.
+ __ Movsd(double_scratch2, double_result); // Load double_exponent with 1.
// Get absolute value of exponent.
Label no_neg, while_true, while_false;
@@ -460,26 +460,26 @@ void MathPowStub::Generate(MacroAssembler* masm) {
// Above condition means CF==0 && ZF==0. This means that the
// bit that has been shifted out is 0 and the result is not 0.
__ j(above, &while_true, Label::kNear);
- __ movsd(double_result, double_scratch);
+ __ Movsd(double_result, double_scratch);
__ j(zero, &while_false, Label::kNear);
__ bind(&while_true);
__ shrl(scratch, Immediate(1));
- __ mulsd(double_scratch, double_scratch);
+ __ Mulsd(double_scratch, double_scratch);
__ j(above, &while_true, Label::kNear);
- __ mulsd(double_result, double_scratch);
+ __ Mulsd(double_result, double_scratch);
__ j(not_zero, &while_true);
__ bind(&while_false);
// If the exponent is negative, return 1/result.
__ testl(exponent, exponent);
__ j(greater, &done);
- __ divsd(double_scratch2, double_result);
- __ movsd(double_result, double_scratch2);
+ __ Divsd(double_scratch2, double_result);
+ __ Movsd(double_result, double_scratch2);
// Test whether result is zero. Bail out to check for subnormal result.
// Due to subnormals, x^-y == (1/x)^y does not hold in all cases.
- __ xorps(double_scratch2, double_scratch2);
- __ ucomisd(double_scratch2, double_result);
+ __ Xorpd(double_scratch2, double_scratch2);
+ __ Ucomisd(double_scratch2, double_result);
// double_exponent aliased as double_scratch2 has already been overwritten
// and may not have contained the exponent value in the first place when the
// input was a smi. We reset it with exponent value before bailing out.
@@ -497,13 +497,13 @@ void MathPowStub::Generate(MacroAssembler* masm) {
// as heap number in rax.
__ bind(&done);
__ AllocateHeapNumber(rax, rcx, &call_runtime);
- __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), double_result);
+ __ Movsd(FieldOperand(rax, HeapNumber::kValueOffset), double_result);
__ IncrementCounter(counters->math_pow(), 1);
__ ret(2 * kPointerSize);
} else {
__ bind(&call_runtime);
// Move base to the correct argument register. Exponent is already in xmm1.
- __ movsd(xmm0, double_base);
+ __ Movsd(xmm0, double_base);
DCHECK(double_exponent.is(xmm1));
{
AllowExternalCallThatCantCauseGC scope(masm);
@@ -512,7 +512,7 @@ void MathPowStub::Generate(MacroAssembler* masm) {
ExternalReference::power_double_double_function(isolate()), 2);
}
// Return value is in xmm0.
- __ movsd(double_result, xmm0);
+ __ Movsd(double_result, xmm0);
__ bind(&done);
__ IncrementCounter(counters->math_pow(), 1);
@@ -664,7 +664,7 @@ void ArgumentsAccessStub::GenerateNewSloppyFast(MacroAssembler* masm) {
// Get the arguments map from the current native context into r9.
Label has_mapped_parameters, instantiate;
__ movp(r9, Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
- __ movp(r9, FieldOperand(r9, GlobalObject::kNativeContextOffset));
+ __ movp(r9, FieldOperand(r9, JSGlobalObject::kNativeContextOffset));
__ testp(rbx, rbx);
__ j(not_zero, &has_mapped_parameters, Label::kNear);
@@ -946,7 +946,7 @@ void ArgumentsAccessStub::GenerateNewStrict(MacroAssembler* masm) {
// Get the arguments map from the current native context.
__ movp(rdi, Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
- __ movp(rdi, FieldOperand(rdi, GlobalObject::kNativeContextOffset));
+ __ movp(rdi, FieldOperand(rdi, JSGlobalObject::kNativeContextOffset));
const int offset = Context::SlotOffset(Context::STRICT_ARGUMENTS_MAP_INDEX);
__ movp(rdi, Operand(rdi, offset));
@@ -1565,8 +1565,8 @@ void CompareICStub::GenerateGeneric(MacroAssembler* masm) {
// greater-equal. Return -1 for them, so the comparison yields
// false for all conditions except not-equal.
__ Set(rax, EQUAL);
- __ movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
- __ ucomisd(xmm0, xmm0);
+ __ Movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
+ __ Ucomisd(xmm0, xmm0);
__ setcc(parity_even, rax);
// rax is 0 for equal non-NaN heapnumbers, 1 for NaNs.
if (cc == greater_equal || cc == greater) {
@@ -1641,7 +1641,7 @@ void CompareICStub::GenerateGeneric(MacroAssembler* masm) {
FloatingPointHelper::LoadSSE2UnknownOperands(masm, &non_number_comparison);
__ xorl(rax, rax);
__ xorl(rcx, rcx);
- __ ucomisd(xmm0, xmm1);
+ __ Ucomisd(xmm0, xmm1);
// Don't base result on EFLAGS when a NaN is involved.
__ j(parity_even, &unordered, Label::kNear);
@@ -1875,104 +1875,6 @@ static void GenerateRecordCallTarget(MacroAssembler* masm, bool is_super) {
}
-static void EmitContinueIfStrictOrNative(MacroAssembler* masm, Label* cont) {
- // Do not transform the receiver for strict mode functions.
- __ movp(rcx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
- __ testb(FieldOperand(rcx, SharedFunctionInfo::kStrictModeByteOffset),
- Immediate(1 << SharedFunctionInfo::kStrictModeBitWithinByte));
- __ j(not_equal, cont);
-
- // Do not transform the receiver for natives.
- // SharedFunctionInfo is already loaded into rcx.
- __ testb(FieldOperand(rcx, SharedFunctionInfo::kNativeByteOffset),
- Immediate(1 << SharedFunctionInfo::kNativeBitWithinByte));
- __ j(not_equal, cont);
-}
-
-
-static void EmitSlowCase(MacroAssembler* masm, StackArgumentsAccessor* args,
- int argc) {
- __ Set(rax, argc);
- __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET);
-}
-
-
-static void EmitWrapCase(MacroAssembler* masm,
- StackArgumentsAccessor* args,
- Label* cont) {
- // Wrap the receiver and patch it back onto the stack.
- { FrameScope frame_scope(masm, StackFrame::INTERNAL);
- __ Push(rdi);
- ToObjectStub stub(masm->isolate());
- __ CallStub(&stub);
- __ Pop(rdi);
- }
- __ movp(args->GetReceiverOperand(), rax);
- __ jmp(cont);
-}
-
-
-static void CallFunctionNoFeedback(MacroAssembler* masm,
- int argc, bool needs_checks,
- bool call_as_method) {
- // rdi : the function to call
-
- // wrap_and_call can only be true if we are compiling a monomorphic method.
- Label slow, wrap, cont;
- StackArgumentsAccessor args(rsp, argc);
-
- if (needs_checks) {
- // Check that the function really is a JavaScript function.
- __ JumpIfSmi(rdi, &slow);
-
- // Goto slow case if we do not have a function.
- __ CmpObjectType(rdi, JS_FUNCTION_TYPE, rcx);
- __ j(not_equal, &slow);
- }
-
- // Fast-case: Just invoke the function.
- ParameterCount actual(argc);
-
- if (call_as_method) {
- if (needs_checks) {
- EmitContinueIfStrictOrNative(masm, &cont);
- }
-
- // Load the receiver from the stack.
- __ movp(rax, args.GetReceiverOperand());
-
- if (needs_checks) {
- __ JumpIfSmi(rax, &wrap);
-
- __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
- __ j(below, &wrap);
- } else {
- __ jmp(&wrap);
- }
-
- __ bind(&cont);
- }
-
- __ InvokeFunction(rdi, actual, JUMP_FUNCTION, NullCallWrapper());
-
- if (needs_checks) {
- // Slow-case: Non-function called.
- __ bind(&slow);
- EmitSlowCase(masm, &args, argc);
- }
-
- if (call_as_method) {
- __ bind(&wrap);
- EmitWrapCase(masm, &args, &cont);
- }
-}
-
-
-void CallFunctionStub::Generate(MacroAssembler* masm) {
- CallFunctionNoFeedback(masm, argc(), NeedsChecks(), CallAsMethod());
-}
-
-
void CallConstructStub::Generate(MacroAssembler* masm) {
// rax : number of arguments
// rbx : feedback vector
@@ -2047,17 +1949,17 @@ void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
void CallICStub::Generate(MacroAssembler* masm) {
- // rdi - function
- // rdx - slot id
- // rbx - vector
+ // ----------- S t a t e -------------
+ // -- rdi - function
+ // -- rdx - slot id
+ // -- rbx - vector
+ // -----------------------------------
Isolate* isolate = masm->isolate();
const int with_types_offset =
FixedArray::OffsetOfElementAt(TypeFeedbackVector::kWithTypesIndex);
const int generic_offset =
FixedArray::OffsetOfElementAt(TypeFeedbackVector::kGenericCountIndex);
- Label extra_checks_or_miss, slow_start;
- Label slow, wrap, cont;
- Label have_js_function;
+ Label extra_checks_or_miss, call;
int argc = arg_count();
StackArgumentsAccessor args(rsp, argc);
ParameterCount actual(argc);
@@ -2093,36 +1995,15 @@ void CallICStub::Generate(MacroAssembler* masm) {
FixedArray::kHeaderSize + kPointerSize),
Smi::FromInt(CallICNexus::kCallCountIncrement));
- __ bind(&have_js_function);
- if (CallAsMethod()) {
- EmitContinueIfStrictOrNative(masm, &cont);
-
- // Load the receiver from the stack.
- __ movp(rax, args.GetReceiverOperand());
-
- __ JumpIfSmi(rax, &wrap);
-
- __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
- __ j(below, &wrap);
-
- __ bind(&cont);
- }
-
- __ InvokeFunction(rdi, actual, JUMP_FUNCTION, NullCallWrapper());
-
- __ bind(&slow);
- EmitSlowCase(masm, &args, argc);
-
- if (CallAsMethod()) {
- __ bind(&wrap);
- EmitWrapCase(masm, &args, &cont);
- }
+ __ bind(&call);
+ __ Set(rax, argc);
+ __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET);
__ bind(&extra_checks_or_miss);
Label uninitialized, miss, not_allocation_site;
__ Cmp(rcx, TypeFeedbackVector::MegamorphicSentinel(isolate));
- __ j(equal, &slow_start);
+ __ j(equal, &call);
// Check if we have an allocation site.
__ CompareRoot(FieldOperand(rcx, HeapObject::kMapOffset),
@@ -2153,7 +2034,7 @@ void CallICStub::Generate(MacroAssembler* masm) {
// We have to update statistics for runtime profiling.
__ SmiAddConstant(FieldOperand(rbx, with_types_offset), Smi::FromInt(-1));
__ SmiAddConstant(FieldOperand(rbx, generic_offset), Smi::FromInt(1));
- __ jmp(&slow_start);
+ __ jmp(&call);
__ bind(&uninitialized);
@@ -2192,21 +2073,14 @@ void CallICStub::Generate(MacroAssembler* masm) {
__ Pop(rdi);
}
- __ jmp(&have_js_function);
+ __ jmp(&call);
// We are here because tracing is on or we encountered a MISS case we can't
// handle here.
__ bind(&miss);
GenerateMiss(masm);
- // the slow case
- __ bind(&slow_start);
- // Check that function is not a smi.
- __ JumpIfSmi(rdi, &slow);
- // Check that function is a JSFunction.
- __ CmpObjectType(rdi, JS_FUNCTION_TYPE, rcx);
- __ j(not_equal, &slow);
- __ jmp(&have_js_function);
+ __ jmp(&call);
// Unreachable
__ int3();
@@ -2268,6 +2142,9 @@ void CEntryStub::Generate(MacroAssembler* masm) {
// rbp: frame pointer of calling JS frame (restored after C call)
// rsp: stack pointer (restored after C call)
// rsi: current context (restored)
+ //
+ // If argv_in_register():
+ // r15: pointer to the first argument
ProfileEntryHookStub::MaybeCallEntryHook(masm);
@@ -2277,7 +2154,14 @@ void CEntryStub::Generate(MacroAssembler* masm) {
#else // _WIN64
int arg_stack_space = 0;
#endif // _WIN64
- __ EnterExitFrame(arg_stack_space, save_doubles());
+ if (argv_in_register()) {
+ DCHECK(!save_doubles());
+ __ EnterApiExitFrame(arg_stack_space);
+ // Move argc into r14 (argv is already in r15).
+ __ movp(r14, rax);
+ } else {
+ __ EnterExitFrame(arg_stack_space, save_doubles());
+ }
// rbx: pointer to builtin function (C callee-saved).
// rbp: frame pointer of exit frame (restored after C call).
@@ -2357,7 +2241,7 @@ void CEntryStub::Generate(MacroAssembler* masm) {
}
// Exit the JavaScript to C++ exit frame.
- __ LeaveExitFrame(save_doubles());
+ __ LeaveExitFrame(save_doubles(), !argv_in_register());
__ ret(0);
// Handling of exception.
@@ -2802,7 +2686,7 @@ void StringCharFromCodeGenerator::GenerateSlow(
__ bind(&slow_case_);
call_helper.BeforeCall(masm);
__ Push(code_);
- __ CallRuntime(Runtime::kCharFromCode, 1);
+ __ CallRuntime(Runtime::kStringCharFromCode, 1);
if (!result_.is(rax)) {
__ movp(result_, rax);
}
@@ -3112,6 +2996,25 @@ void ToNumberStub::Generate(MacroAssembler* masm) {
}
+void ToLengthStub::Generate(MacroAssembler* masm) {
+ // The ToLength stub takes on argument in rax.
+ Label not_smi, positive_smi;
+ __ JumpIfNotSmi(rax, &not_smi, Label::kNear);
+ STATIC_ASSERT(kSmiTag == 0);
+ __ testp(rax, rax);
+ __ j(greater_equal, &positive_smi, Label::kNear);
+ __ xorl(rax, rax);
+ __ bind(&positive_smi);
+ __ Ret();
+ __ bind(&not_smi);
+
+ __ PopReturnAddressTo(rcx); // Pop return address.
+ __ Push(rax); // Push argument.
+ __ PushReturnAddressFrom(rcx); // Push return address.
+ __ TailCallRuntime(Runtime::kToLength, 1, 1);
+}
+
+
void ToStringStub::Generate(MacroAssembler* masm) {
// The ToString stub takes one argument in rax.
Label is_number;
@@ -3424,7 +3327,7 @@ void CompareICStub::GenerateNumbers(MacroAssembler* masm) {
__ JumpIfSmi(rax, &right_smi, Label::kNear);
__ CompareMap(rax, isolate()->factory()->heap_number_map());
__ j(not_equal, &maybe_undefined1, Label::kNear);
- __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
+ __ Movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
__ jmp(&left, Label::kNear);
__ bind(&right_smi);
__ SmiToInteger32(rcx, rax); // Can't clobber rax yet.
@@ -3434,7 +3337,7 @@ void CompareICStub::GenerateNumbers(MacroAssembler* masm) {
__ JumpIfSmi(rdx, &left_smi, Label::kNear);
__ CompareMap(rdx, isolate()->factory()->heap_number_map());
__ j(not_equal, &maybe_undefined2, Label::kNear);
- __ movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
+ __ Movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
__ jmp(&done);
__ bind(&left_smi);
__ SmiToInteger32(rcx, rdx); // Can't clobber rdx yet.
@@ -3442,7 +3345,7 @@ void CompareICStub::GenerateNumbers(MacroAssembler* masm) {
__ bind(&done);
// Compare operands
- __ ucomisd(xmm0, xmm1);
+ __ Ucomisd(xmm0, xmm1);
// Don't base result on EFLAGS when a NaN is involved.
__ j(parity_even, &unordered, Label::kNear);
diff --git a/deps/v8/src/x64/code-stubs-x64.h b/deps/v8/src/x64/code-stubs-x64.h
index 1344400d48..d4f8b29dbc 100644
--- a/deps/v8/src/x64/code-stubs-x64.h
+++ b/deps/v8/src/x64/code-stubs-x64.h
@@ -294,13 +294,15 @@ class RecordWriteStub: public PlatformCodeStub {
Register GetRegThatIsNotRcxOr(Register r1,
Register r2,
Register r3) {
- for (int i = 0; i < Register::NumAllocatableRegisters(); i++) {
- Register candidate = Register::FromAllocationIndex(i);
- if (candidate.is(rcx)) continue;
- if (candidate.is(r1)) continue;
- if (candidate.is(r2)) continue;
- if (candidate.is(r3)) continue;
- return candidate;
+ for (int i = 0; i < Register::kNumRegisters; i++) {
+ Register candidate = Register::from_code(i);
+ if (candidate.IsAllocatable()) {
+ if (candidate.is(rcx)) continue;
+ if (candidate.is(r1)) continue;
+ if (candidate.is(r2)) continue;
+ if (candidate.is(r3)) continue;
+ return candidate;
+ }
}
UNREACHABLE();
return no_reg;
@@ -360,6 +362,7 @@ class RecordWriteStub: public PlatformCodeStub {
};
-} } // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_X64_CODE_STUBS_X64_H_
diff --git a/deps/v8/src/x64/codegen-x64.cc b/deps/v8/src/x64/codegen-x64.cc
index 4f08c7e7a6..5c297f1a07 100644
--- a/deps/v8/src/x64/codegen-x64.cc
+++ b/deps/v8/src/x64/codegen-x64.cc
@@ -51,7 +51,7 @@ UnaryMathFunction CreateExpFunction() {
__ popq(rbx);
__ popq(rax);
- __ movsd(xmm0, result);
+ __ Movsd(xmm0, result);
__ Ret();
CodeDesc desc;
@@ -74,7 +74,7 @@ UnaryMathFunction CreateSqrtFunction() {
MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
// xmm0: raw double input.
// Move double input into registers.
- __ sqrtsd(xmm0, xmm0);
+ __ Sqrtsd(xmm0, xmm0);
__ Ret();
CodeDesc desc;
@@ -95,7 +95,7 @@ ModuloFunction CreateModuloFunction() {
byte* buffer = static_cast<byte*>(
base::OS::Allocate(Assembler::kMinimalBufferSize, &actual_size, true));
CHECK(buffer);
- Assembler masm(NULL, buffer, static_cast<int>(actual_size));
+ MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
// Generated code is put into a fixed, unmovable, buffer, and not into
// the V8 heap. We can't, and don't, refer to any relocatable addresses
// (e.g. the JavaScript nan-object).
@@ -107,8 +107,8 @@ ModuloFunction CreateModuloFunction() {
// Compute x mod y.
// Load y and x (use argument backing store as temporary storage).
- __ movsd(Operand(rsp, kRegisterSize * 2), xmm1);
- __ movsd(Operand(rsp, kRegisterSize), xmm0);
+ __ Movsd(Operand(rsp, kRegisterSize * 2), xmm1);
+ __ Movsd(Operand(rsp, kRegisterSize), xmm0);
__ fld_d(Operand(rsp, kRegisterSize * 2));
__ fld_d(Operand(rsp, kRegisterSize));
@@ -147,13 +147,13 @@ ModuloFunction CreateModuloFunction() {
int64_t kNaNValue = V8_INT64_C(0x7ff8000000000000);
__ movq(rcx, kNaNValue);
__ movq(Operand(rsp, kRegisterSize), rcx);
- __ movsd(xmm0, Operand(rsp, kRegisterSize));
+ __ Movsd(xmm0, Operand(rsp, kRegisterSize));
__ jmp(&return_result);
// If result is valid, return that.
__ bind(&valid_result);
__ fstp_d(Operand(rsp, kRegisterSize));
- __ movsd(xmm0, Operand(rsp, kRegisterSize));
+ __ Movsd(xmm0, Operand(rsp, kRegisterSize));
// Clean up FPU stack and exceptions and return xmm0
__ bind(&return_result);
@@ -333,8 +333,7 @@ void ElementsTransitionGenerator::GenerateSmiToDouble(
__ JumpIfNotSmi(rbx, &convert_hole);
__ SmiToInteger32(rbx, rbx);
__ Cvtlsi2sd(xmm0, rbx);
- __ movsd(FieldOperand(r14, r9, times_8, FixedDoubleArray::kHeaderSize),
- xmm0);
+ __ Movsd(FieldOperand(r14, r9, times_8, FixedDoubleArray::kHeaderSize), xmm0);
__ jmp(&entry);
__ bind(&convert_hole);
@@ -604,38 +603,38 @@ void MathExpGenerator::EmitMathExp(MacroAssembler* masm,
Label done;
__ Move(kScratchRegister, ExternalReference::math_exp_constants(0));
- __ movsd(double_scratch, Operand(kScratchRegister, 0 * kDoubleSize));
- __ xorpd(result, result);
- __ ucomisd(double_scratch, input);
+ __ Movsd(double_scratch, Operand(kScratchRegister, 0 * kDoubleSize));
+ __ Xorpd(result, result);
+ __ Ucomisd(double_scratch, input);
__ j(above_equal, &done);
- __ ucomisd(input, Operand(kScratchRegister, 1 * kDoubleSize));
- __ movsd(result, Operand(kScratchRegister, 2 * kDoubleSize));
+ __ Ucomisd(input, Operand(kScratchRegister, 1 * kDoubleSize));
+ __ Movsd(result, Operand(kScratchRegister, 2 * kDoubleSize));
__ j(above_equal, &done);
- __ movsd(double_scratch, Operand(kScratchRegister, 3 * kDoubleSize));
- __ movsd(result, Operand(kScratchRegister, 4 * kDoubleSize));
- __ mulsd(double_scratch, input);
- __ addsd(double_scratch, result);
- __ movq(temp2, double_scratch);
- __ subsd(double_scratch, result);
- __ movsd(result, Operand(kScratchRegister, 6 * kDoubleSize));
+ __ Movsd(double_scratch, Operand(kScratchRegister, 3 * kDoubleSize));
+ __ Movsd(result, Operand(kScratchRegister, 4 * kDoubleSize));
+ __ Mulsd(double_scratch, input);
+ __ Addsd(double_scratch, result);
+ __ Movq(temp2, double_scratch);
+ __ Subsd(double_scratch, result);
+ __ Movsd(result, Operand(kScratchRegister, 6 * kDoubleSize));
__ leaq(temp1, Operand(temp2, 0x1ff800));
__ andq(temp2, Immediate(0x7ff));
__ shrq(temp1, Immediate(11));
- __ mulsd(double_scratch, Operand(kScratchRegister, 5 * kDoubleSize));
+ __ Mulsd(double_scratch, Operand(kScratchRegister, 5 * kDoubleSize));
__ Move(kScratchRegister, ExternalReference::math_exp_log_table());
__ shlq(temp1, Immediate(52));
__ orq(temp1, Operand(kScratchRegister, temp2, times_8, 0));
__ Move(kScratchRegister, ExternalReference::math_exp_constants(0));
- __ subsd(double_scratch, input);
- __ movsd(input, double_scratch);
- __ subsd(result, double_scratch);
- __ mulsd(input, double_scratch);
- __ mulsd(result, input);
- __ movq(input, temp1);
- __ mulsd(result, Operand(kScratchRegister, 7 * kDoubleSize));
- __ subsd(result, double_scratch);
- __ addsd(result, Operand(kScratchRegister, 8 * kDoubleSize));
- __ mulsd(result, input);
+ __ Subsd(double_scratch, input);
+ __ Movsd(input, double_scratch);
+ __ Subsd(result, double_scratch);
+ __ Mulsd(input, double_scratch);
+ __ Mulsd(result, input);
+ __ Movq(input, temp1);
+ __ Mulsd(result, Operand(kScratchRegister, 7 * kDoubleSize));
+ __ Subsd(result, double_scratch);
+ __ Addsd(result, Operand(kScratchRegister, 8 * kDoubleSize));
+ __ Mulsd(result, input);
__ bind(&done);
}
diff --git a/deps/v8/src/x64/codegen-x64.h b/deps/v8/src/x64/codegen-x64.h
index 728d04048e..09af38ddea 100644
--- a/deps/v8/src/x64/codegen-x64.h
+++ b/deps/v8/src/x64/codegen-x64.h
@@ -108,6 +108,7 @@ class StackArgumentsAccessor BASE_EMBEDDED {
};
-} } // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_X64_CODEGEN_X64_H_
diff --git a/deps/v8/src/x64/deoptimizer-x64.cc b/deps/v8/src/x64/deoptimizer-x64.cc
index 72c92f0a39..620f614aa5 100644
--- a/deps/v8/src/x64/deoptimizer-x64.cc
+++ b/deps/v8/src/x64/deoptimizer-x64.cc
@@ -7,6 +7,7 @@
#include "src/codegen.h"
#include "src/deoptimizer.h"
#include "src/full-codegen/full-codegen.h"
+#include "src/register-configuration.h"
#include "src/safepoint-table.h"
namespace v8 {
@@ -95,7 +96,7 @@ void Deoptimizer::FillInputFrame(Address tos, JavaScriptFrame* frame) {
}
input_->SetRegister(rsp.code(), reinterpret_cast<intptr_t>(frame->sp()));
input_->SetRegister(rbp.code(), reinterpret_cast<intptr_t>(frame->fp()));
- for (int i = 0; i < DoubleRegister::NumAllocatableRegisters(); i++) {
+ for (int i = 0; i < DoubleRegister::kMaxNumRegisters; i++) {
input_->SetDoubleRegister(i, 0.0);
}
@@ -117,7 +118,7 @@ void Deoptimizer::SetPlatformCompiledStubRegisters(
void Deoptimizer::CopyDoubleRegisters(FrameDescription* output_frame) {
- for (int i = 0; i < XMMRegister::NumAllocatableRegisters(); ++i) {
+ for (int i = 0; i < XMMRegister::kMaxNumRegisters; ++i) {
double double_value = input_->GetDoubleRegister(i);
output_frame->SetDoubleRegister(i, double_value);
}
@@ -138,14 +139,16 @@ void Deoptimizer::TableEntryGenerator::Generate() {
// Save all general purpose registers before messing with them.
const int kNumberOfRegisters = Register::kNumRegisters;
- const int kDoubleRegsSize = kDoubleSize *
- XMMRegister::NumAllocatableRegisters();
+ const int kDoubleRegsSize = kDoubleSize * XMMRegister::kMaxNumRegisters;
__ subp(rsp, Immediate(kDoubleRegsSize));
- for (int i = 0; i < XMMRegister::NumAllocatableRegisters(); ++i) {
- XMMRegister xmm_reg = XMMRegister::FromAllocationIndex(i);
- int offset = i * kDoubleSize;
- __ movsd(Operand(rsp, offset), xmm_reg);
+ const RegisterConfiguration* config =
+ RegisterConfiguration::ArchDefault(RegisterConfiguration::CRANKSHAFT);
+ for (int i = 0; i < config->num_allocatable_double_registers(); ++i) {
+ int code = config->GetAllocatableDoubleCode(i);
+ XMMRegister xmm_reg = XMMRegister::from_code(code);
+ int offset = code * kDoubleSize;
+ __ Movsd(Operand(rsp, offset), xmm_reg);
}
// We push all registers onto the stack, even though we do not need
@@ -210,7 +213,7 @@ void Deoptimizer::TableEntryGenerator::Generate() {
// Fill in the double input registers.
int double_regs_offset = FrameDescription::double_registers_offset();
- for (int i = 0; i < XMMRegister::NumAllocatableRegisters(); i++) {
+ for (int i = 0; i < XMMRegister::kMaxNumRegisters; i++) {
int dst_offset = i * kDoubleSize + double_regs_offset;
__ popq(Operand(rbx, dst_offset));
}
@@ -274,10 +277,11 @@ void Deoptimizer::TableEntryGenerator::Generate() {
__ cmpp(rax, rdx);
__ j(below, &outer_push_loop);
- for (int i = 0; i < XMMRegister::NumAllocatableRegisters(); ++i) {
- XMMRegister xmm_reg = XMMRegister::FromAllocationIndex(i);
- int src_offset = i * kDoubleSize + double_regs_offset;
- __ movsd(xmm_reg, Operand(rbx, src_offset));
+ for (int i = 0; i < config->num_allocatable_double_registers(); ++i) {
+ int code = config->GetAllocatableDoubleCode(i);
+ XMMRegister xmm_reg = XMMRegister::from_code(code);
+ int src_offset = code * kDoubleSize + double_regs_offset;
+ __ Movsd(xmm_reg, Operand(rbx, src_offset));
}
// Push state, pc, and continuation from the last output frame.
diff --git a/deps/v8/src/x64/disasm-x64.cc b/deps/v8/src/x64/disasm-x64.cc
index 5534887f5a..d6cf513392 100644
--- a/deps/v8/src/x64/disasm-x64.cc
+++ b/deps/v8/src/x64/disasm-x64.cc
@@ -351,6 +351,11 @@ class DisassemblerX64 {
bool rex_w() { return (rex_ & 0x08) != 0; }
+ bool vex_w() {
+ DCHECK(vex_byte0_ == VEX3_PREFIX || vex_byte0_ == VEX2_PREFIX);
+ return vex_byte0_ == VEX3_PREFIX ? (vex_byte2_ & 0x80) != 0 : false;
+ }
+
bool vex_128() {
DCHECK(vex_byte0_ == VEX3_PREFIX || vex_byte0_ == VEX2_PREFIX);
byte checked = vex_byte0_ == VEX3_PREFIX ? vex_byte2_ : vex_byte1_;
@@ -947,10 +952,43 @@ int DisassemblerX64::AVXInstruction(byte* data) {
default:
UnimplementedInstruction();
}
+ } else if (vex_66() && vex_0f3a()) {
+ int mod, regop, rm, vvvv = vex_vreg();
+ get_modrm(*current, &mod, &regop, &rm);
+ switch (opcode) {
+ case 0x0b:
+ AppendToBuffer("vroundsd %s,%s,", NameOfXMMRegister(regop),
+ NameOfXMMRegister(vvvv));
+ current += PrintRightXMMOperand(current);
+ AppendToBuffer(",0x%x", *current++);
+ break;
+ default:
+ UnimplementedInstruction();
+ }
} else if (vex_f3() && vex_0f()) {
int mod, regop, rm, vvvv = vex_vreg();
get_modrm(*current, &mod, &regop, &rm);
switch (opcode) {
+ case 0x10:
+ AppendToBuffer("vmovss %s,", NameOfXMMRegister(regop));
+ if (mod == 3) {
+ AppendToBuffer("%s,", NameOfXMMRegister(vvvv));
+ }
+ current += PrintRightXMMOperand(current);
+ break;
+ case 0x11:
+ AppendToBuffer("vmovss ");
+ current += PrintRightXMMOperand(current);
+ if (mod == 3) {
+ AppendToBuffer(",%s", NameOfXMMRegister(vvvv));
+ }
+ AppendToBuffer(",%s", NameOfXMMRegister(regop));
+ break;
+ case 0x2a:
+ AppendToBuffer("%s %s,%s,", vex_w() ? "vcvtqsi2ss" : "vcvtlsi2ss",
+ NameOfXMMRegister(regop), NameOfXMMRegister(vvvv));
+ current += PrintRightOperand(current);
+ break;
case 0x58:
AppendToBuffer("vaddss %s,%s,", NameOfXMMRegister(regop),
NameOfXMMRegister(vvvv));
@@ -961,6 +999,11 @@ int DisassemblerX64::AVXInstruction(byte* data) {
NameOfXMMRegister(vvvv));
current += PrintRightXMMOperand(current);
break;
+ case 0x5a:
+ AppendToBuffer("vcvtss2sd %s,%s,", NameOfXMMRegister(regop),
+ NameOfXMMRegister(vvvv));
+ current += PrintRightXMMOperand(current);
+ break;
case 0x5c:
AppendToBuffer("vsubss %s,%s,", NameOfXMMRegister(regop),
NameOfXMMRegister(vvvv));
@@ -988,6 +1031,41 @@ int DisassemblerX64::AVXInstruction(byte* data) {
int mod, regop, rm, vvvv = vex_vreg();
get_modrm(*current, &mod, &regop, &rm);
switch (opcode) {
+ case 0x10:
+ AppendToBuffer("vmovsd %s,", NameOfXMMRegister(regop));
+ if (mod == 3) {
+ AppendToBuffer("%s,", NameOfXMMRegister(vvvv));
+ }
+ current += PrintRightXMMOperand(current);
+ break;
+ case 0x11:
+ AppendToBuffer("vmovsd ");
+ current += PrintRightXMMOperand(current);
+ if (mod == 3) {
+ AppendToBuffer(",%s", NameOfXMMRegister(vvvv));
+ }
+ AppendToBuffer(",%s", NameOfXMMRegister(regop));
+ break;
+ case 0x2a:
+ AppendToBuffer("%s %s,%s,", vex_w() ? "vcvtqsi2sd" : "vcvtlsi2sd",
+ NameOfXMMRegister(regop), NameOfXMMRegister(vvvv));
+ current += PrintRightOperand(current);
+ break;
+ case 0x2c:
+ AppendToBuffer("vcvttsd2si%s %s,", vex_w() ? "q" : "",
+ NameOfCPURegister(regop));
+ current += PrintRightXMMOperand(current);
+ break;
+ case 0x2d:
+ AppendToBuffer("vcvtsd2si%s %s,", vex_w() ? "q" : "",
+ NameOfCPURegister(regop));
+ current += PrintRightXMMOperand(current);
+ break;
+ case 0x51:
+ AppendToBuffer("vsqrtsd %s,%s,", NameOfXMMRegister(regop),
+ NameOfXMMRegister(vvvv));
+ current += PrintRightXMMOperand(current);
+ break;
case 0x58:
AppendToBuffer("vaddsd %s,%s,", NameOfXMMRegister(regop),
NameOfXMMRegister(vvvv));
@@ -998,6 +1076,11 @@ int DisassemblerX64::AVXInstruction(byte* data) {
NameOfXMMRegister(vvvv));
current += PrintRightXMMOperand(current);
break;
+ case 0x5a:
+ AppendToBuffer("vcvtsd2ss %s,%s,", NameOfXMMRegister(regop),
+ NameOfXMMRegister(vvvv));
+ current += PrintRightXMMOperand(current);
+ break;
case 0x5c:
AppendToBuffer("vsubsd %s,%s,", NameOfXMMRegister(regop),
NameOfXMMRegister(vvvv));
@@ -1133,6 +1216,15 @@ int DisassemblerX64::AVXInstruction(byte* data) {
int mod, regop, rm, vvvv = vex_vreg();
get_modrm(*current, &mod, &regop, &rm);
switch (opcode) {
+ case 0x28:
+ AppendToBuffer("vmovaps %s,", NameOfXMMRegister(regop));
+ current += PrintRightXMMOperand(current);
+ break;
+ case 0x29:
+ AppendToBuffer("vmovaps ");
+ current += PrintRightXMMOperand(current);
+ AppendToBuffer(",%s", NameOfXMMRegister(regop));
+ break;
case 0x2e:
AppendToBuffer("vucomiss %s,", NameOfXMMRegister(regop));
current += PrintRightXMMOperand(current);
@@ -1154,20 +1246,59 @@ int DisassemblerX64::AVXInstruction(byte* data) {
int mod, regop, rm, vvvv = vex_vreg();
get_modrm(*current, &mod, &regop, &rm);
switch (opcode) {
+ case 0x28:
+ AppendToBuffer("vmovapd %s,", NameOfXMMRegister(regop));
+ current += PrintRightXMMOperand(current);
+ break;
+ case 0x29:
+ AppendToBuffer("vmovapd ");
+ current += PrintRightXMMOperand(current);
+ AppendToBuffer(",%s", NameOfXMMRegister(regop));
+ break;
case 0x2e:
AppendToBuffer("vucomisd %s,", NameOfXMMRegister(regop));
current += PrintRightXMMOperand(current);
break;
+ case 0x50:
+ AppendToBuffer("vmovmskpd %s,", NameOfCPURegister(regop));
+ current += PrintRightXMMOperand(current);
+ break;
case 0x54:
AppendToBuffer("vandpd %s,%s,", NameOfXMMRegister(regop),
NameOfXMMRegister(vvvv));
current += PrintRightXMMOperand(current);
break;
+ case 0x56:
+ AppendToBuffer("vorpd %s,%s,", NameOfXMMRegister(regop),
+ NameOfXMMRegister(vvvv));
+ current += PrintRightXMMOperand(current);
+ break;
case 0x57:
AppendToBuffer("vxorpd %s,%s,", NameOfXMMRegister(regop),
NameOfXMMRegister(vvvv));
current += PrintRightXMMOperand(current);
break;
+ case 0x6e:
+ AppendToBuffer("vmov%c %s,", vex_w() ? 'q' : 'd',
+ NameOfXMMRegister(regop));
+ current += PrintRightOperand(current);
+ break;
+ case 0x73:
+ AppendToBuffer("%s %s,", regop == 6 ? "vpsllq" : "vpsrlq",
+ NameOfXMMRegister(vvvv));
+ current += PrintRightXMMOperand(current);
+ AppendToBuffer(",%u", *current++);
+ break;
+ case 0x76:
+ AppendToBuffer("vpcmpeqd %s,%s,", NameOfXMMRegister(regop),
+ NameOfXMMRegister(vvvv));
+ current += PrintRightXMMOperand(current);
+ break;
+ case 0x7e:
+ AppendToBuffer("vmov%c ", vex_w() ? 'q' : 'd');
+ current += PrintRightOperand(current);
+ AppendToBuffer(",%s", NameOfXMMRegister(regop));
+ break;
default:
UnimplementedInstruction();
}
@@ -1385,7 +1516,7 @@ int DisassemblerX64::TwoByteOpcodeInstruction(byte* data) {
// roundsd xmm, xmm/m64, imm8
AppendToBuffer("roundsd %s,", NameOfXMMRegister(regop));
current += PrintRightXMMOperand(current);
- AppendToBuffer(",%d", (*current) & 3);
+ AppendToBuffer(",0x%x", (*current) & 3);
current += 1;
} else if (third_byte == 0x16) {
get_modrm(*current, &mod, &rm, &regop);
@@ -1726,7 +1857,8 @@ int DisassemblerX64::TwoByteOpcodeInstruction(byte* data) {
} else {
AppendToBuffer(",%s,cl", NameOfCPURegister(regop));
}
- } else if (opcode == 0xBD) {
+ } else if (opcode == 0xB8 || opcode == 0xBC || opcode == 0xBD) {
+ // POPCNT, CTZ, CLZ.
AppendToBuffer("%s%c ", mnemonic, operand_size_code());
int mod, regop, rm;
get_modrm(*current, &mod, &regop, &rm);
@@ -1780,6 +1912,8 @@ const char* DisassemblerX64::TwoByteMnemonic(byte opcode) {
return "movzxb";
case 0xB7:
return "movzxw";
+ case 0xBC:
+ return "bsf";
case 0xBD:
return "bsr";
case 0xBE:
diff --git a/deps/v8/src/x64/frames-x64.h b/deps/v8/src/x64/frames-x64.h
index 1d9cf1ec13..d213ecb7dc 100644
--- a/deps/v8/src/x64/frames-x64.h
+++ b/deps/v8/src/x64/frames-x64.h
@@ -71,6 +71,7 @@ class JavaScriptFrameConstants : public AllStatic {
};
-} } // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_X64_FRAMES_X64_H_
diff --git a/deps/v8/src/x64/interface-descriptors-x64.cc b/deps/v8/src/x64/interface-descriptors-x64.cc
index a062df590f..e69d38d1f3 100644
--- a/deps/v8/src/x64/interface-descriptors-x64.cc
+++ b/deps/v8/src/x64/interface-descriptors-x64.cc
@@ -78,14 +78,6 @@ const Register GrowArrayElementsDescriptor::ObjectRegister() { return rax; }
const Register GrowArrayElementsDescriptor::KeyRegister() { return rbx; }
-void VectorStoreTransitionDescriptor::InitializePlatformSpecific(
- CallInterfaceDescriptorData* data) {
- Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
- SlotRegister(), VectorRegister(), MapRegister()};
- data->InitializePlatformSpecific(arraysize(registers), registers);
-}
-
-
void FastNewClosureDescriptor::InitializePlatformSpecific(
CallInterfaceDescriptorData* data) {
Register registers[] = {rbx};
@@ -116,6 +108,10 @@ void ToNumberDescriptor::InitializePlatformSpecific(
// static
+const Register ToLengthDescriptor::ReceiverRegister() { return rax; }
+
+
+// static
const Register ToStringDescriptor::ReceiverRegister() { return rax; }
@@ -229,6 +225,13 @@ void AllocateHeapNumberDescriptor::InitializePlatformSpecific(
}
+void AllocateInNewSpaceDescriptor::InitializePlatformSpecific(
+ CallInterfaceDescriptorData* data) {
+ Register registers[] = {rax};
+ data->InitializePlatformSpecific(arraysize(registers), registers);
+}
+
+
void ArrayConstructorConstantArgCountDescriptor::InitializePlatformSpecific(
CallInterfaceDescriptorData* data) {
// register state
@@ -392,16 +395,39 @@ void MathRoundVariantCallFromOptimizedCodeDescriptor::
}
-void PushArgsAndCallDescriptor::InitializePlatformSpecific(
+void InterpreterPushArgsAndCallDescriptor::InitializePlatformSpecific(
CallInterfaceDescriptorData* data) {
Register registers[] = {
- rax, // argument count (including receiver)
+ rax, // argument count (not including receiver)
rbx, // address of first argument
rdi // the target callable to be call
};
data->InitializePlatformSpecific(arraysize(registers), registers);
}
+
+void InterpreterPushArgsAndConstructDescriptor::InitializePlatformSpecific(
+ CallInterfaceDescriptorData* data) {
+ Register registers[] = {
+ rax, // argument count (not including receiver)
+ rdx, // original constructor
+ rdi, // constructor
+ rbx, // address of first argument
+ };
+ data->InitializePlatformSpecific(arraysize(registers), registers);
+}
+
+
+void InterpreterCEntryDescriptor::InitializePlatformSpecific(
+ CallInterfaceDescriptorData* data) {
+ Register registers[] = {
+ rax, // argument count (argc)
+ r15, // address of first argument (argv)
+ rbx // the runtime function to call
+ };
+ data->InitializePlatformSpecific(arraysize(registers), registers);
+}
+
} // namespace internal
} // namespace v8
diff --git a/deps/v8/src/x64/lithium-codegen-x64.cc b/deps/v8/src/x64/lithium-codegen-x64.cc
deleted file mode 100644
index dbdd146a1e..0000000000
--- a/deps/v8/src/x64/lithium-codegen-x64.cc
+++ /dev/null
@@ -1,5923 +0,0 @@
-// Copyright 2013 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#if V8_TARGET_ARCH_X64
-
-#include "src/base/bits.h"
-#include "src/code-factory.h"
-#include "src/code-stubs.h"
-#include "src/hydrogen-osr.h"
-#include "src/ic/ic.h"
-#include "src/ic/stub-cache.h"
-#include "src/profiler/cpu-profiler.h"
-#include "src/x64/lithium-codegen-x64.h"
-
-namespace v8 {
-namespace internal {
-
-
-// When invoking builtins, we need to record the safepoint in the middle of
-// the invoke instruction sequence generated by the macro assembler.
-class SafepointGenerator final : public CallWrapper {
- public:
- SafepointGenerator(LCodeGen* codegen,
- LPointerMap* pointers,
- Safepoint::DeoptMode mode)
- : codegen_(codegen),
- pointers_(pointers),
- deopt_mode_(mode) { }
- virtual ~SafepointGenerator() {}
-
- void BeforeCall(int call_size) const override {}
-
- void AfterCall() const override {
- codegen_->RecordSafepoint(pointers_, deopt_mode_);
- }
-
- private:
- LCodeGen* codegen_;
- LPointerMap* pointers_;
- Safepoint::DeoptMode deopt_mode_;
-};
-
-
-#define __ masm()->
-
-bool LCodeGen::GenerateCode() {
- LPhase phase("Z_Code generation", chunk());
- DCHECK(is_unused());
- status_ = GENERATING;
-
- // Open a frame scope to indicate that there is a frame on the stack. The
- // MANUAL indicates that the scope shouldn't actually generate code to set up
- // the frame (that is done in GeneratePrologue).
- FrameScope frame_scope(masm_, StackFrame::MANUAL);
-
- return GeneratePrologue() &&
- GenerateBody() &&
- GenerateDeferredCode() &&
- GenerateJumpTable() &&
- GenerateSafepointTable();
-}
-
-
-void LCodeGen::FinishCode(Handle<Code> code) {
- DCHECK(is_done());
- code->set_stack_slots(GetStackSlotCount());
- code->set_safepoint_table_offset(safepoints_.GetCodeOffset());
- PopulateDeoptimizationData(code);
-}
-
-
-#ifdef _MSC_VER
-void LCodeGen::MakeSureStackPagesMapped(int offset) {
- const int kPageSize = 4 * KB;
- for (offset -= kPageSize; offset > 0; offset -= kPageSize) {
- __ movp(Operand(rsp, offset), rax);
- }
-}
-#endif
-
-
-void LCodeGen::SaveCallerDoubles() {
- DCHECK(info()->saves_caller_doubles());
- DCHECK(NeedsEagerFrame());
- Comment(";;; Save clobbered callee double registers");
- int count = 0;
- BitVector* doubles = chunk()->allocated_double_registers();
- BitVector::Iterator save_iterator(doubles);
- while (!save_iterator.Done()) {
- __ movsd(MemOperand(rsp, count * kDoubleSize),
- XMMRegister::FromAllocationIndex(save_iterator.Current()));
- save_iterator.Advance();
- count++;
- }
-}
-
-
-void LCodeGen::RestoreCallerDoubles() {
- DCHECK(info()->saves_caller_doubles());
- DCHECK(NeedsEagerFrame());
- Comment(";;; Restore clobbered callee double registers");
- BitVector* doubles = chunk()->allocated_double_registers();
- BitVector::Iterator save_iterator(doubles);
- int count = 0;
- while (!save_iterator.Done()) {
- __ movsd(XMMRegister::FromAllocationIndex(save_iterator.Current()),
- MemOperand(rsp, count * kDoubleSize));
- save_iterator.Advance();
- count++;
- }
-}
-
-
-bool LCodeGen::GeneratePrologue() {
- DCHECK(is_generating());
-
- if (info()->IsOptimizing()) {
- ProfileEntryHookStub::MaybeCallEntryHook(masm_);
-
-#ifdef DEBUG
- if (strlen(FLAG_stop_at) > 0 &&
- info_->literal()->name()->IsUtf8EqualTo(CStrVector(FLAG_stop_at))) {
- __ int3();
- }
-#endif
-
- // Sloppy mode functions need to replace the receiver with the global proxy
- // when called as functions (without an explicit receiver object).
- if (info()->MustReplaceUndefinedReceiverWithGlobalProxy()) {
- Label ok;
- StackArgumentsAccessor args(rsp, scope()->num_parameters());
- __ movp(rcx, args.GetReceiverOperand());
-
- __ CompareRoot(rcx, Heap::kUndefinedValueRootIndex);
- __ j(not_equal, &ok, Label::kNear);
-
- __ movp(rcx, GlobalObjectOperand());
- __ movp(rcx, FieldOperand(rcx, GlobalObject::kGlobalProxyOffset));
-
- __ movp(args.GetReceiverOperand(), rcx);
-
- __ bind(&ok);
- }
- }
-
- info()->set_prologue_offset(masm_->pc_offset());
- if (NeedsEagerFrame()) {
- DCHECK(!frame_is_built_);
- frame_is_built_ = true;
- if (info()->IsStub()) {
- __ StubPrologue();
- } else {
- __ Prologue(info()->IsCodePreAgingActive());
- }
- info()->AddNoFrameRange(0, masm_->pc_offset());
- }
-
- // Reserve space for the stack slots needed by the code.
- int slots = GetStackSlotCount();
- if (slots > 0) {
- if (FLAG_debug_code) {
- __ subp(rsp, Immediate(slots * kPointerSize));
-#ifdef _MSC_VER
- MakeSureStackPagesMapped(slots * kPointerSize);
-#endif
- __ Push(rax);
- __ Set(rax, slots);
- __ Set(kScratchRegister, kSlotsZapValue);
- Label loop;
- __ bind(&loop);
- __ movp(MemOperand(rsp, rax, times_pointer_size, 0),
- kScratchRegister);
- __ decl(rax);
- __ j(not_zero, &loop);
- __ Pop(rax);
- } else {
- __ subp(rsp, Immediate(slots * kPointerSize));
-#ifdef _MSC_VER
- MakeSureStackPagesMapped(slots * kPointerSize);
-#endif
- }
-
- if (info()->saves_caller_doubles()) {
- SaveCallerDoubles();
- }
- }
- return !is_aborted();
-}
-
-
-void LCodeGen::DoPrologue(LPrologue* instr) {
- Comment(";;; Prologue begin");
-
- // Possibly allocate a local context.
- if (info_->num_heap_slots() > 0) {
- Comment(";;; Allocate local context");
- bool need_write_barrier = true;
- // Argument to NewContext is the function, which is still in rdi.
- int slots = info_->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
- Safepoint::DeoptMode deopt_mode = Safepoint::kNoLazyDeopt;
- if (info()->scope()->is_script_scope()) {
- __ Push(rdi);
- __ Push(info()->scope()->GetScopeInfo(info()->isolate()));
- __ CallRuntime(Runtime::kNewScriptContext, 2);
- deopt_mode = Safepoint::kLazyDeopt;
- } else if (slots <= FastNewContextStub::kMaximumSlots) {
- FastNewContextStub stub(isolate(), slots);
- __ CallStub(&stub);
- // Result of FastNewContextStub is always in new space.
- need_write_barrier = false;
- } else {
- __ Push(rdi);
- __ CallRuntime(Runtime::kNewFunctionContext, 1);
- }
- RecordSafepoint(deopt_mode);
-
- // Context is returned in rax. It replaces the context passed to us.
- // It's saved in the stack and kept live in rsi.
- __ movp(rsi, rax);
- __ movp(Operand(rbp, StandardFrameConstants::kContextOffset), rax);
-
- // Copy any necessary parameters into the context.
- int num_parameters = scope()->num_parameters();
- int first_parameter = scope()->has_this_declaration() ? -1 : 0;
- for (int i = first_parameter; i < num_parameters; i++) {
- Variable* var = (i == -1) ? scope()->receiver() : scope()->parameter(i);
- if (var->IsContextSlot()) {
- int parameter_offset = StandardFrameConstants::kCallerSPOffset +
- (num_parameters - 1 - i) * kPointerSize;
- // Load parameter from stack.
- __ movp(rax, Operand(rbp, parameter_offset));
- // Store it in the context.
- int context_offset = Context::SlotOffset(var->index());
- __ movp(Operand(rsi, context_offset), rax);
- // Update the write barrier. This clobbers rax and rbx.
- if (need_write_barrier) {
- __ RecordWriteContextSlot(rsi, context_offset, rax, rbx, kSaveFPRegs);
- } else if (FLAG_debug_code) {
- Label done;
- __ JumpIfInNewSpace(rsi, rax, &done, Label::kNear);
- __ Abort(kExpectedNewSpaceObject);
- __ bind(&done);
- }
- }
- }
- Comment(";;; End allocate local context");
- }
-
- Comment(";;; Prologue end");
-}
-
-
-void LCodeGen::GenerateOsrPrologue() {
- // Generate the OSR entry prologue at the first unknown OSR value, or if there
- // are none, at the OSR entrypoint instruction.
- if (osr_pc_offset_ >= 0) return;
-
- osr_pc_offset_ = masm()->pc_offset();
-
- // Adjust the frame size, subsuming the unoptimized frame into the
- // optimized frame.
- int slots = GetStackSlotCount() - graph()->osr()->UnoptimizedFrameSlots();
- DCHECK(slots >= 0);
- __ subp(rsp, Immediate(slots * kPointerSize));
-}
-
-
-void LCodeGen::GenerateBodyInstructionPre(LInstruction* instr) {
- if (instr->IsCall()) {
- EnsureSpaceForLazyDeopt(Deoptimizer::patch_size());
- }
- if (!instr->IsLazyBailout() && !instr->IsGap()) {
- safepoints_.BumpLastLazySafepointIndex();
- }
-}
-
-
-void LCodeGen::GenerateBodyInstructionPost(LInstruction* instr) {
- if (FLAG_debug_code && FLAG_enable_slow_asserts && instr->HasResult() &&
- instr->hydrogen_value()->representation().IsInteger32() &&
- instr->result()->IsRegister()) {
- __ AssertZeroExtended(ToRegister(instr->result()));
- }
-
- if (instr->HasResult() && instr->MustSignExtendResult(chunk())) {
- // We sign extend the dehoisted key at the definition point when the pointer
- // size is 64-bit. For x32 port, we sign extend the dehoisted key at the use
- // points and MustSignExtendResult is always false. We can't use
- // STATIC_ASSERT here as the pointer size is 32-bit for x32.
- DCHECK(kPointerSize == kInt64Size);
- if (instr->result()->IsRegister()) {
- Register result_reg = ToRegister(instr->result());
- __ movsxlq(result_reg, result_reg);
- } else {
- // Sign extend the 32bit result in the stack slots.
- DCHECK(instr->result()->IsStackSlot());
- Operand src = ToOperand(instr->result());
- __ movsxlq(kScratchRegister, src);
- __ movq(src, kScratchRegister);
- }
- }
-}
-
-
-bool LCodeGen::GenerateJumpTable() {
- if (jump_table_.length() == 0) return !is_aborted();
-
- Label needs_frame;
- Comment(";;; -------------------- Jump table --------------------");
- for (int i = 0; i < jump_table_.length(); i++) {
- Deoptimizer::JumpTableEntry* table_entry = &jump_table_[i];
- __ bind(&table_entry->label);
- Address entry = table_entry->address;
- DeoptComment(table_entry->deopt_info);
- if (table_entry->needs_frame) {
- DCHECK(!info()->saves_caller_doubles());
- __ Move(kScratchRegister, ExternalReference::ForDeoptEntry(entry));
- __ call(&needs_frame);
- } else {
- if (info()->saves_caller_doubles()) {
- DCHECK(info()->IsStub());
- RestoreCallerDoubles();
- }
- __ call(entry, RelocInfo::RUNTIME_ENTRY);
- }
- info()->LogDeoptCallPosition(masm()->pc_offset(),
- table_entry->deopt_info.inlining_id);
- }
-
- if (needs_frame.is_linked()) {
- __ bind(&needs_frame);
- /* stack layout
- 4: return address <-- rsp
- 3: garbage
- 2: garbage
- 1: garbage
- 0: garbage
- */
- // Reserve space for context and stub marker.
- __ subp(rsp, Immediate(2 * kPointerSize));
- __ Push(MemOperand(rsp, 2 * kPointerSize)); // Copy return address.
- __ Push(kScratchRegister); // Save entry address for ret(0)
-
- /* stack layout
- 4: return address
- 3: garbage
- 2: garbage
- 1: return address
- 0: entry address <-- rsp
- */
-
- // Remember context pointer.
- __ movp(kScratchRegister,
- MemOperand(rbp, StandardFrameConstants::kContextOffset));
- // Save context pointer into the stack frame.
- __ movp(MemOperand(rsp, 3 * kPointerSize), kScratchRegister);
-
- // Create a stack frame.
- __ movp(MemOperand(rsp, 4 * kPointerSize), rbp);
- __ leap(rbp, MemOperand(rsp, 4 * kPointerSize));
-
- // This variant of deopt can only be used with stubs. Since we don't
- // have a function pointer to install in the stack frame that we're
- // building, install a special marker there instead.
- DCHECK(info()->IsStub());
- __ Move(MemOperand(rsp, 2 * kPointerSize), Smi::FromInt(StackFrame::STUB));
-
- /* stack layout
- 4: old rbp
- 3: context pointer
- 2: stub marker
- 1: return address
- 0: entry address <-- rsp
- */
- __ ret(0);
- }
-
- return !is_aborted();
-}
-
-
-bool LCodeGen::GenerateDeferredCode() {
- DCHECK(is_generating());
- if (deferred_.length() > 0) {
- for (int i = 0; !is_aborted() && i < deferred_.length(); i++) {
- LDeferredCode* code = deferred_[i];
-
- HValue* value =
- instructions_->at(code->instruction_index())->hydrogen_value();
- RecordAndWritePosition(
- chunk()->graph()->SourcePositionToScriptPosition(value->position()));
-
- Comment(";;; <@%d,#%d> "
- "-------------------- Deferred %s --------------------",
- code->instruction_index(),
- code->instr()->hydrogen_value()->id(),
- code->instr()->Mnemonic());
- __ bind(code->entry());
- if (NeedsDeferredFrame()) {
- Comment(";;; Build frame");
- DCHECK(!frame_is_built_);
- DCHECK(info()->IsStub());
- frame_is_built_ = true;
- // Build the frame in such a way that esi isn't trashed.
- __ pushq(rbp); // Caller's frame pointer.
- __ Push(Operand(rbp, StandardFrameConstants::kContextOffset));
- __ Push(Smi::FromInt(StackFrame::STUB));
- __ leap(rbp, Operand(rsp, 2 * kPointerSize));
- Comment(";;; Deferred code");
- }
- code->Generate();
- if (NeedsDeferredFrame()) {
- __ bind(code->done());
- Comment(";;; Destroy frame");
- DCHECK(frame_is_built_);
- frame_is_built_ = false;
- __ movp(rsp, rbp);
- __ popq(rbp);
- }
- __ jmp(code->exit());
- }
- }
-
- // Deferred code is the last part of the instruction sequence. Mark
- // the generated code as done unless we bailed out.
- if (!is_aborted()) status_ = DONE;
- return !is_aborted();
-}
-
-
-bool LCodeGen::GenerateSafepointTable() {
- DCHECK(is_done());
- safepoints_.Emit(masm(), GetStackSlotCount());
- return !is_aborted();
-}
-
-
-Register LCodeGen::ToRegister(int index) const {
- return Register::FromAllocationIndex(index);
-}
-
-
-XMMRegister LCodeGen::ToDoubleRegister(int index) const {
- return XMMRegister::FromAllocationIndex(index);
-}
-
-
-Register LCodeGen::ToRegister(LOperand* op) const {
- DCHECK(op->IsRegister());
- return ToRegister(op->index());
-}
-
-
-XMMRegister LCodeGen::ToDoubleRegister(LOperand* op) const {
- DCHECK(op->IsDoubleRegister());
- return ToDoubleRegister(op->index());
-}
-
-
-bool LCodeGen::IsInteger32Constant(LConstantOperand* op) const {
- return chunk_->LookupLiteralRepresentation(op).IsSmiOrInteger32();
-}
-
-
-bool LCodeGen::IsExternalConstant(LConstantOperand* op) const {
- return chunk_->LookupLiteralRepresentation(op).IsExternal();
-}
-
-
-bool LCodeGen::IsDehoistedKeyConstant(LConstantOperand* op) const {
- return op->IsConstantOperand() &&
- chunk_->IsDehoistedKey(chunk_->LookupConstant(op));
-}
-
-
-bool LCodeGen::IsSmiConstant(LConstantOperand* op) const {
- return chunk_->LookupLiteralRepresentation(op).IsSmi();
-}
-
-
-int32_t LCodeGen::ToInteger32(LConstantOperand* op) const {
- return ToRepresentation(op, Representation::Integer32());
-}
-
-
-int32_t LCodeGen::ToRepresentation(LConstantOperand* op,
- const Representation& r) const {
- HConstant* constant = chunk_->LookupConstant(op);
- int32_t value = constant->Integer32Value();
- if (r.IsInteger32()) return value;
- DCHECK(SmiValuesAre31Bits() && r.IsSmiOrTagged());
- return static_cast<int32_t>(reinterpret_cast<intptr_t>(Smi::FromInt(value)));
-}
-
-
-Smi* LCodeGen::ToSmi(LConstantOperand* op) const {
- HConstant* constant = chunk_->LookupConstant(op);
- return Smi::FromInt(constant->Integer32Value());
-}
-
-
-double LCodeGen::ToDouble(LConstantOperand* op) const {
- HConstant* constant = chunk_->LookupConstant(op);
- DCHECK(constant->HasDoubleValue());
- return constant->DoubleValue();
-}
-
-
-ExternalReference LCodeGen::ToExternalReference(LConstantOperand* op) const {
- HConstant* constant = chunk_->LookupConstant(op);
- DCHECK(constant->HasExternalReferenceValue());
- return constant->ExternalReferenceValue();
-}
-
-
-Handle<Object> LCodeGen::ToHandle(LConstantOperand* op) const {
- HConstant* constant = chunk_->LookupConstant(op);
- DCHECK(chunk_->LookupLiteralRepresentation(op).IsSmiOrTagged());
- return constant->handle(isolate());
-}
-
-
-static int ArgumentsOffsetWithoutFrame(int index) {
- DCHECK(index < 0);
- return -(index + 1) * kPointerSize + kPCOnStackSize;
-}
-
-
-Operand LCodeGen::ToOperand(LOperand* op) const {
- // Does not handle registers. In X64 assembler, plain registers are not
- // representable as an Operand.
- DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());
- if (NeedsEagerFrame()) {
- return Operand(rbp, StackSlotOffset(op->index()));
- } else {
- // Retrieve parameter without eager stack-frame relative to the
- // stack-pointer.
- return Operand(rsp, ArgumentsOffsetWithoutFrame(op->index()));
- }
-}
-
-
-void LCodeGen::WriteTranslation(LEnvironment* environment,
- Translation* translation) {
- if (environment == NULL) return;
-
- // The translation includes one command per value in the environment.
- int translation_size = environment->translation_size();
-
- WriteTranslation(environment->outer(), translation);
- WriteTranslationFrame(environment, translation);
-
- int object_index = 0;
- int dematerialized_index = 0;
- for (int i = 0; i < translation_size; ++i) {
- LOperand* value = environment->values()->at(i);
- AddToTranslation(
- environment, translation, value, environment->HasTaggedValueAt(i),
- environment->HasUint32ValueAt(i), &object_index, &dematerialized_index);
- }
-}
-
-
-void LCodeGen::AddToTranslation(LEnvironment* environment,
- Translation* translation,
- LOperand* op,
- bool is_tagged,
- bool is_uint32,
- int* object_index_pointer,
- int* dematerialized_index_pointer) {
- if (op == LEnvironment::materialization_marker()) {
- int object_index = (*object_index_pointer)++;
- if (environment->ObjectIsDuplicateAt(object_index)) {
- int dupe_of = environment->ObjectDuplicateOfAt(object_index);
- translation->DuplicateObject(dupe_of);
- return;
- }
- int object_length = environment->ObjectLengthAt(object_index);
- if (environment->ObjectIsArgumentsAt(object_index)) {
- translation->BeginArgumentsObject(object_length);
- } else {
- translation->BeginCapturedObject(object_length);
- }
- int dematerialized_index = *dematerialized_index_pointer;
- int env_offset = environment->translation_size() + dematerialized_index;
- *dematerialized_index_pointer += object_length;
- for (int i = 0; i < object_length; ++i) {
- LOperand* value = environment->values()->at(env_offset + i);
- AddToTranslation(environment,
- translation,
- value,
- environment->HasTaggedValueAt(env_offset + i),
- environment->HasUint32ValueAt(env_offset + i),
- object_index_pointer,
- dematerialized_index_pointer);
- }
- return;
- }
-
- if (op->IsStackSlot()) {
- int index = op->index();
- if (index >= 0) {
- index += StandardFrameConstants::kFixedFrameSize / kPointerSize;
- }
- if (is_tagged) {
- translation->StoreStackSlot(index);
- } else if (is_uint32) {
- translation->StoreUint32StackSlot(index);
- } else {
- translation->StoreInt32StackSlot(index);
- }
- } else if (op->IsDoubleStackSlot()) {
- int index = op->index();
- if (index >= 0) {
- index += StandardFrameConstants::kFixedFrameSize / kPointerSize;
- }
- translation->StoreDoubleStackSlot(index);
- } else if (op->IsRegister()) {
- Register reg = ToRegister(op);
- if (is_tagged) {
- translation->StoreRegister(reg);
- } else if (is_uint32) {
- translation->StoreUint32Register(reg);
- } else {
- translation->StoreInt32Register(reg);
- }
- } else if (op->IsDoubleRegister()) {
- XMMRegister reg = ToDoubleRegister(op);
- translation->StoreDoubleRegister(reg);
- } else if (op->IsConstantOperand()) {
- HConstant* constant = chunk()->LookupConstant(LConstantOperand::cast(op));
- int src_index = DefineDeoptimizationLiteral(constant->handle(isolate()));
- translation->StoreLiteral(src_index);
- } else {
- UNREACHABLE();
- }
-}
-
-
-void LCodeGen::CallCodeGeneric(Handle<Code> code,
- RelocInfo::Mode mode,
- LInstruction* instr,
- SafepointMode safepoint_mode,
- int argc) {
- DCHECK(instr != NULL);
- __ call(code, mode);
- RecordSafepointWithLazyDeopt(instr, safepoint_mode, argc);
-
- // Signal that we don't inline smi code before these stubs in the
- // optimizing code generator.
- if (code->kind() == Code::BINARY_OP_IC ||
- code->kind() == Code::COMPARE_IC) {
- __ nop();
- }
-}
-
-
-void LCodeGen::CallCode(Handle<Code> code,
- RelocInfo::Mode mode,
- LInstruction* instr) {
- CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT, 0);
-}
-
-
-void LCodeGen::CallRuntime(const Runtime::Function* function,
- int num_arguments,
- LInstruction* instr,
- SaveFPRegsMode save_doubles) {
- DCHECK(instr != NULL);
- DCHECK(instr->HasPointerMap());
-
- __ CallRuntime(function, num_arguments, save_doubles);
-
- RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT, 0);
-}
-
-
-void LCodeGen::LoadContextFromDeferred(LOperand* context) {
- if (context->IsRegister()) {
- if (!ToRegister(context).is(rsi)) {
- __ movp(rsi, ToRegister(context));
- }
- } else if (context->IsStackSlot()) {
- __ movp(rsi, ToOperand(context));
- } else if (context->IsConstantOperand()) {
- HConstant* constant =
- chunk_->LookupConstant(LConstantOperand::cast(context));
- __ Move(rsi, Handle<Object>::cast(constant->handle(isolate())));
- } else {
- UNREACHABLE();
- }
-}
-
-
-
-void LCodeGen::CallRuntimeFromDeferred(Runtime::FunctionId id,
- int argc,
- LInstruction* instr,
- LOperand* context) {
- LoadContextFromDeferred(context);
-
- __ CallRuntimeSaveDoubles(id);
- RecordSafepointWithRegisters(
- instr->pointer_map(), argc, Safepoint::kNoLazyDeopt);
-}
-
-
-void LCodeGen::RegisterEnvironmentForDeoptimization(LEnvironment* environment,
- Safepoint::DeoptMode mode) {
- environment->set_has_been_used();
- if (!environment->HasBeenRegistered()) {
- // Physical stack frame layout:
- // -x ............. -4 0 ..................................... y
- // [incoming arguments] [spill slots] [pushed outgoing arguments]
-
- // Layout of the environment:
- // 0 ..................................................... size-1
- // [parameters] [locals] [expression stack including arguments]
-
- // Layout of the translation:
- // 0 ........................................................ size - 1 + 4
- // [expression stack including arguments] [locals] [4 words] [parameters]
- // |>------------ translation_size ------------<|
-
- int frame_count = 0;
- int jsframe_count = 0;
- for (LEnvironment* e = environment; e != NULL; e = e->outer()) {
- ++frame_count;
- if (e->frame_type() == JS_FUNCTION) {
- ++jsframe_count;
- }
- }
- Translation translation(&translations_, frame_count, jsframe_count, zone());
- WriteTranslation(environment, &translation);
- int deoptimization_index = deoptimizations_.length();
- int pc_offset = masm()->pc_offset();
- environment->Register(deoptimization_index,
- translation.index(),
- (mode == Safepoint::kLazyDeopt) ? pc_offset : -1);
- deoptimizations_.Add(environment, environment->zone());
- }
-}
-
-
-void LCodeGen::DeoptimizeIf(Condition cc, LInstruction* instr,
- Deoptimizer::DeoptReason deopt_reason,
- Deoptimizer::BailoutType bailout_type) {
- LEnvironment* environment = instr->environment();
- RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);
- DCHECK(environment->HasBeenRegistered());
- int id = environment->deoptimization_index();
- Address entry =
- Deoptimizer::GetDeoptimizationEntry(isolate(), id, bailout_type);
- if (entry == NULL) {
- Abort(kBailoutWasNotPrepared);
- return;
- }
-
- if (DeoptEveryNTimes()) {
- ExternalReference count = ExternalReference::stress_deopt_count(isolate());
- Label no_deopt;
- __ pushfq();
- __ pushq(rax);
- Operand count_operand = masm()->ExternalOperand(count, kScratchRegister);
- __ movl(rax, count_operand);
- __ subl(rax, Immediate(1));
- __ j(not_zero, &no_deopt, Label::kNear);
- if (FLAG_trap_on_deopt) __ int3();
- __ movl(rax, Immediate(FLAG_deopt_every_n_times));
- __ movl(count_operand, rax);
- __ popq(rax);
- __ popfq();
- DCHECK(frame_is_built_);
- __ call(entry, RelocInfo::RUNTIME_ENTRY);
- __ bind(&no_deopt);
- __ movl(count_operand, rax);
- __ popq(rax);
- __ popfq();
- }
-
- if (info()->ShouldTrapOnDeopt()) {
- Label done;
- if (cc != no_condition) {
- __ j(NegateCondition(cc), &done, Label::kNear);
- }
- __ int3();
- __ bind(&done);
- }
-
- Deoptimizer::DeoptInfo deopt_info = MakeDeoptInfo(instr, deopt_reason);
-
- DCHECK(info()->IsStub() || frame_is_built_);
- // Go through jump table if we need to handle condition, build frame, or
- // restore caller doubles.
- if (cc == no_condition && frame_is_built_ &&
- !info()->saves_caller_doubles()) {
- DeoptComment(deopt_info);
- __ call(entry, RelocInfo::RUNTIME_ENTRY);
- info()->LogDeoptCallPosition(masm()->pc_offset(), deopt_info.inlining_id);
- } else {
- Deoptimizer::JumpTableEntry table_entry(entry, deopt_info, bailout_type,
- !frame_is_built_);
- // We often have several deopts to the same entry, reuse the last
- // jump entry if this is the case.
- if (FLAG_trace_deopt || isolate()->cpu_profiler()->is_profiling() ||
- jump_table_.is_empty() ||
- !table_entry.IsEquivalentTo(jump_table_.last())) {
- jump_table_.Add(table_entry, zone());
- }
- if (cc == no_condition) {
- __ jmp(&jump_table_.last().label);
- } else {
- __ j(cc, &jump_table_.last().label);
- }
- }
-}
-
-
-void LCodeGen::DeoptimizeIf(Condition cc, LInstruction* instr,
- Deoptimizer::DeoptReason deopt_reason) {
- Deoptimizer::BailoutType bailout_type = info()->IsStub()
- ? Deoptimizer::LAZY
- : Deoptimizer::EAGER;
- DeoptimizeIf(cc, instr, deopt_reason, bailout_type);
-}
-
-
-void LCodeGen::PopulateDeoptimizationData(Handle<Code> code) {
- int length = deoptimizations_.length();
- if (length == 0) return;
- Handle<DeoptimizationInputData> data =
- DeoptimizationInputData::New(isolate(), length, TENURED);
-
- Handle<ByteArray> translations =
- translations_.CreateByteArray(isolate()->factory());
- data->SetTranslationByteArray(*translations);
- data->SetInlinedFunctionCount(Smi::FromInt(inlined_function_count_));
- data->SetOptimizationId(Smi::FromInt(info_->optimization_id()));
- if (info_->IsOptimizing()) {
- // Reference to shared function info does not change between phases.
- AllowDeferredHandleDereference allow_handle_dereference;
- data->SetSharedFunctionInfo(*info_->shared_info());
- } else {
- data->SetSharedFunctionInfo(Smi::FromInt(0));
- }
- data->SetWeakCellCache(Smi::FromInt(0));
-
- Handle<FixedArray> literals =
- factory()->NewFixedArray(deoptimization_literals_.length(), TENURED);
- { AllowDeferredHandleDereference copy_handles;
- for (int i = 0; i < deoptimization_literals_.length(); i++) {
- literals->set(i, *deoptimization_literals_[i]);
- }
- data->SetLiteralArray(*literals);
- }
-
- data->SetOsrAstId(Smi::FromInt(info_->osr_ast_id().ToInt()));
- data->SetOsrPcOffset(Smi::FromInt(osr_pc_offset_));
-
- // Populate the deoptimization entries.
- for (int i = 0; i < length; i++) {
- LEnvironment* env = deoptimizations_[i];
- data->SetAstId(i, env->ast_id());
- data->SetTranslationIndex(i, Smi::FromInt(env->translation_index()));
- data->SetArgumentsStackHeight(i,
- Smi::FromInt(env->arguments_stack_height()));
- data->SetPc(i, Smi::FromInt(env->pc_offset()));
- }
- code->set_deoptimization_data(*data);
-}
-
-
-void LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions() {
- DCHECK_EQ(0, deoptimization_literals_.length());
- for (auto function : chunk()->inlined_functions()) {
- DefineDeoptimizationLiteral(function);
- }
- inlined_function_count_ = deoptimization_literals_.length();
-}
-
-
-void LCodeGen::RecordSafepointWithLazyDeopt(
- LInstruction* instr, SafepointMode safepoint_mode, int argc) {
- if (safepoint_mode == RECORD_SIMPLE_SAFEPOINT) {
- RecordSafepoint(instr->pointer_map(), Safepoint::kLazyDeopt);
- } else {
- DCHECK(safepoint_mode == RECORD_SAFEPOINT_WITH_REGISTERS);
- RecordSafepointWithRegisters(
- instr->pointer_map(), argc, Safepoint::kLazyDeopt);
- }
-}
-
-
-void LCodeGen::RecordSafepoint(
- LPointerMap* pointers,
- Safepoint::Kind kind,
- int arguments,
- Safepoint::DeoptMode deopt_mode) {
- DCHECK(kind == expected_safepoint_kind_);
-
- const ZoneList<LOperand*>* operands = pointers->GetNormalizedOperands();
-
- Safepoint safepoint = safepoints_.DefineSafepoint(masm(),
- kind, arguments, deopt_mode);
- for (int i = 0; i < operands->length(); i++) {
- LOperand* pointer = operands->at(i);
- if (pointer->IsStackSlot()) {
- safepoint.DefinePointerSlot(pointer->index(), zone());
- } else if (pointer->IsRegister() && (kind & Safepoint::kWithRegisters)) {
- safepoint.DefinePointerRegister(ToRegister(pointer), zone());
- }
- }
-}
-
-
-void LCodeGen::RecordSafepoint(LPointerMap* pointers,
- Safepoint::DeoptMode deopt_mode) {
- RecordSafepoint(pointers, Safepoint::kSimple, 0, deopt_mode);
-}
-
-
-void LCodeGen::RecordSafepoint(Safepoint::DeoptMode deopt_mode) {
- LPointerMap empty_pointers(zone());
- RecordSafepoint(&empty_pointers, deopt_mode);
-}
-
-
-void LCodeGen::RecordSafepointWithRegisters(LPointerMap* pointers,
- int arguments,
- Safepoint::DeoptMode deopt_mode) {
- RecordSafepoint(pointers, Safepoint::kWithRegisters, arguments, deopt_mode);
-}
-
-
-void LCodeGen::RecordAndWritePosition(int position) {
- if (position == RelocInfo::kNoPosition) return;
- masm()->positions_recorder()->RecordPosition(position);
- masm()->positions_recorder()->WriteRecordedPositions();
-}
-
-
-static const char* LabelType(LLabel* label) {
- if (label->is_loop_header()) return " (loop header)";
- if (label->is_osr_entry()) return " (OSR entry)";
- return "";
-}
-
-
-void LCodeGen::DoLabel(LLabel* label) {
- Comment(";;; <@%d,#%d> -------------------- B%d%s --------------------",
- current_instruction_,
- label->hydrogen_value()->id(),
- label->block_id(),
- LabelType(label));
- __ bind(label->label());
- current_block_ = label->block_id();
- DoGap(label);
-}
-
-
-void LCodeGen::DoParallelMove(LParallelMove* move) {
- resolver_.Resolve(move);
-}
-
-
-void LCodeGen::DoGap(LGap* gap) {
- for (int i = LGap::FIRST_INNER_POSITION;
- i <= LGap::LAST_INNER_POSITION;
- i++) {
- LGap::InnerPosition inner_pos = static_cast<LGap::InnerPosition>(i);
- LParallelMove* move = gap->GetParallelMove(inner_pos);
- if (move != NULL) DoParallelMove(move);
- }
-}
-
-
-void LCodeGen::DoInstructionGap(LInstructionGap* instr) {
- DoGap(instr);
-}
-
-
-void LCodeGen::DoParameter(LParameter* instr) {
- // Nothing to do.
-}
-
-
-void LCodeGen::DoCallStub(LCallStub* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->result()).is(rax));
- switch (instr->hydrogen()->major_key()) {
- case CodeStub::RegExpExec: {
- RegExpExecStub stub(isolate());
- CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
- break;
- }
- case CodeStub::SubString: {
- SubStringStub stub(isolate());
- CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
- break;
- }
- default:
- UNREACHABLE();
- }
-}
-
-
-void LCodeGen::DoUnknownOSRValue(LUnknownOSRValue* instr) {
- GenerateOsrPrologue();
-}
-
-
-void LCodeGen::DoModByPowerOf2I(LModByPowerOf2I* instr) {
- Register dividend = ToRegister(instr->dividend());
- int32_t divisor = instr->divisor();
- DCHECK(dividend.is(ToRegister(instr->result())));
-
- // Theoretically, a variation of the branch-free code for integer division by
- // a power of 2 (calculating the remainder via an additional multiplication
- // (which gets simplified to an 'and') and subtraction) should be faster, and
- // this is exactly what GCC and clang emit. Nevertheless, benchmarks seem to
- // indicate that positive dividends are heavily favored, so the branching
- // version performs better.
- HMod* hmod = instr->hydrogen();
- int32_t mask = divisor < 0 ? -(divisor + 1) : (divisor - 1);
- Label dividend_is_not_negative, done;
- if (hmod->CheckFlag(HValue::kLeftCanBeNegative)) {
- __ testl(dividend, dividend);
- __ j(not_sign, &dividend_is_not_negative, Label::kNear);
- // Note that this is correct even for kMinInt operands.
- __ negl(dividend);
- __ andl(dividend, Immediate(mask));
- __ negl(dividend);
- if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
- DeoptimizeIf(zero, instr, Deoptimizer::kMinusZero);
- }
- __ jmp(&done, Label::kNear);
- }
-
- __ bind(&dividend_is_not_negative);
- __ andl(dividend, Immediate(mask));
- __ bind(&done);
-}
-
-
-void LCodeGen::DoModByConstI(LModByConstI* instr) {
- Register dividend = ToRegister(instr->dividend());
- int32_t divisor = instr->divisor();
- DCHECK(ToRegister(instr->result()).is(rax));
-
- if (divisor == 0) {
- DeoptimizeIf(no_condition, instr, Deoptimizer::kDivisionByZero);
- return;
- }
-
- __ TruncatingDiv(dividend, Abs(divisor));
- __ imull(rdx, rdx, Immediate(Abs(divisor)));
- __ movl(rax, dividend);
- __ subl(rax, rdx);
-
- // Check for negative zero.
- HMod* hmod = instr->hydrogen();
- if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
- Label remainder_not_zero;
- __ j(not_zero, &remainder_not_zero, Label::kNear);
- __ cmpl(dividend, Immediate(0));
- DeoptimizeIf(less, instr, Deoptimizer::kMinusZero);
- __ bind(&remainder_not_zero);
- }
-}
-
-
-void LCodeGen::DoModI(LModI* instr) {
- HMod* hmod = instr->hydrogen();
-
- Register left_reg = ToRegister(instr->left());
- DCHECK(left_reg.is(rax));
- Register right_reg = ToRegister(instr->right());
- DCHECK(!right_reg.is(rax));
- DCHECK(!right_reg.is(rdx));
- Register result_reg = ToRegister(instr->result());
- DCHECK(result_reg.is(rdx));
-
- Label done;
- // Check for x % 0, idiv would signal a divide error. We have to
- // deopt in this case because we can't return a NaN.
- if (hmod->CheckFlag(HValue::kCanBeDivByZero)) {
- __ testl(right_reg, right_reg);
- DeoptimizeIf(zero, instr, Deoptimizer::kDivisionByZero);
- }
-
- // Check for kMinInt % -1, idiv would signal a divide error. We
- // have to deopt if we care about -0, because we can't return that.
- if (hmod->CheckFlag(HValue::kCanOverflow)) {
- Label no_overflow_possible;
- __ cmpl(left_reg, Immediate(kMinInt));
- __ j(not_zero, &no_overflow_possible, Label::kNear);
- __ cmpl(right_reg, Immediate(-1));
- if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
- DeoptimizeIf(equal, instr, Deoptimizer::kMinusZero);
- } else {
- __ j(not_equal, &no_overflow_possible, Label::kNear);
- __ Set(result_reg, 0);
- __ jmp(&done, Label::kNear);
- }
- __ bind(&no_overflow_possible);
- }
-
- // Sign extend dividend in eax into edx:eax, since we are using only the low
- // 32 bits of the values.
- __ cdq();
-
- // If we care about -0, test if the dividend is <0 and the result is 0.
- if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
- Label positive_left;
- __ testl(left_reg, left_reg);
- __ j(not_sign, &positive_left, Label::kNear);
- __ idivl(right_reg);
- __ testl(result_reg, result_reg);
- DeoptimizeIf(zero, instr, Deoptimizer::kMinusZero);
- __ jmp(&done, Label::kNear);
- __ bind(&positive_left);
- }
- __ idivl(right_reg);
- __ bind(&done);
-}
-
-
-void LCodeGen::DoFlooringDivByPowerOf2I(LFlooringDivByPowerOf2I* instr) {
- Register dividend = ToRegister(instr->dividend());
- int32_t divisor = instr->divisor();
- DCHECK(dividend.is(ToRegister(instr->result())));
-
- // If the divisor is positive, things are easy: There can be no deopts and we
- // can simply do an arithmetic right shift.
- if (divisor == 1) return;
- int32_t shift = WhichPowerOf2Abs(divisor);
- if (divisor > 1) {
- __ sarl(dividend, Immediate(shift));
- return;
- }
-
- // If the divisor is negative, we have to negate and handle edge cases.
- __ negl(dividend);
- if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
- DeoptimizeIf(zero, instr, Deoptimizer::kMinusZero);
- }
-
- // Dividing by -1 is basically negation, unless we overflow.
- if (divisor == -1) {
- if (instr->hydrogen()->CheckFlag(HValue::kLeftCanBeMinInt)) {
- DeoptimizeIf(overflow, instr, Deoptimizer::kOverflow);
- }
- return;
- }
-
- // If the negation could not overflow, simply shifting is OK.
- if (!instr->hydrogen()->CheckFlag(HValue::kLeftCanBeMinInt)) {
- __ sarl(dividend, Immediate(shift));
- return;
- }
-
- Label not_kmin_int, done;
- __ j(no_overflow, &not_kmin_int, Label::kNear);
- __ movl(dividend, Immediate(kMinInt / divisor));
- __ jmp(&done, Label::kNear);
- __ bind(&not_kmin_int);
- __ sarl(dividend, Immediate(shift));
- __ bind(&done);
-}
-
-
-void LCodeGen::DoFlooringDivByConstI(LFlooringDivByConstI* instr) {
- Register dividend = ToRegister(instr->dividend());
- int32_t divisor = instr->divisor();
- DCHECK(ToRegister(instr->result()).is(rdx));
-
- if (divisor == 0) {
- DeoptimizeIf(no_condition, instr, Deoptimizer::kDivisionByZero);
- return;
- }
-
- // Check for (0 / -x) that will produce negative zero.
- HMathFloorOfDiv* hdiv = instr->hydrogen();
- if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) {
- __ testl(dividend, dividend);
- DeoptimizeIf(zero, instr, Deoptimizer::kMinusZero);
- }
-
- // Easy case: We need no dynamic check for the dividend and the flooring
- // division is the same as the truncating division.
- if ((divisor > 0 && !hdiv->CheckFlag(HValue::kLeftCanBeNegative)) ||
- (divisor < 0 && !hdiv->CheckFlag(HValue::kLeftCanBePositive))) {
- __ TruncatingDiv(dividend, Abs(divisor));
- if (divisor < 0) __ negl(rdx);
- return;
- }
-
- // In the general case we may need to adjust before and after the truncating
- // division to get a flooring division.
- Register temp = ToRegister(instr->temp3());
- DCHECK(!temp.is(dividend) && !temp.is(rax) && !temp.is(rdx));
- Label needs_adjustment, done;
- __ cmpl(dividend, Immediate(0));
- __ j(divisor > 0 ? less : greater, &needs_adjustment, Label::kNear);
- __ TruncatingDiv(dividend, Abs(divisor));
- if (divisor < 0) __ negl(rdx);
- __ jmp(&done, Label::kNear);
- __ bind(&needs_adjustment);
- __ leal(temp, Operand(dividend, divisor > 0 ? 1 : -1));
- __ TruncatingDiv(temp, Abs(divisor));
- if (divisor < 0) __ negl(rdx);
- __ decl(rdx);
- __ bind(&done);
-}
-
-
-// TODO(svenpanne) Refactor this to avoid code duplication with DoDivI.
-void LCodeGen::DoFlooringDivI(LFlooringDivI* instr) {
- HBinaryOperation* hdiv = instr->hydrogen();
- Register dividend = ToRegister(instr->dividend());
- Register divisor = ToRegister(instr->divisor());
- Register remainder = ToRegister(instr->temp());
- Register result = ToRegister(instr->result());
- DCHECK(dividend.is(rax));
- DCHECK(remainder.is(rdx));
- DCHECK(result.is(rax));
- DCHECK(!divisor.is(rax));
- DCHECK(!divisor.is(rdx));
-
- // Check for x / 0.
- if (hdiv->CheckFlag(HValue::kCanBeDivByZero)) {
- __ testl(divisor, divisor);
- DeoptimizeIf(zero, instr, Deoptimizer::kDivisionByZero);
- }
-
- // Check for (0 / -x) that will produce negative zero.
- if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero)) {
- Label dividend_not_zero;
- __ testl(dividend, dividend);
- __ j(not_zero, &dividend_not_zero, Label::kNear);
- __ testl(divisor, divisor);
- DeoptimizeIf(sign, instr, Deoptimizer::kMinusZero);
- __ bind(&dividend_not_zero);
- }
-
- // Check for (kMinInt / -1).
- if (hdiv->CheckFlag(HValue::kCanOverflow)) {
- Label dividend_not_min_int;
- __ cmpl(dividend, Immediate(kMinInt));
- __ j(not_zero, &dividend_not_min_int, Label::kNear);
- __ cmpl(divisor, Immediate(-1));
- DeoptimizeIf(zero, instr, Deoptimizer::kOverflow);
- __ bind(&dividend_not_min_int);
- }
-
- // Sign extend to rdx (= remainder).
- __ cdq();
- __ idivl(divisor);
-
- Label done;
- __ testl(remainder, remainder);
- __ j(zero, &done, Label::kNear);
- __ xorl(remainder, divisor);
- __ sarl(remainder, Immediate(31));
- __ addl(result, remainder);
- __ bind(&done);
-}
-
-
-void LCodeGen::DoDivByPowerOf2I(LDivByPowerOf2I* instr) {
- Register dividend = ToRegister(instr->dividend());
- int32_t divisor = instr->divisor();
- Register result = ToRegister(instr->result());
- DCHECK(divisor == kMinInt || base::bits::IsPowerOfTwo32(Abs(divisor)));
- DCHECK(!result.is(dividend));
-
- // Check for (0 / -x) that will produce negative zero.
- HDiv* hdiv = instr->hydrogen();
- if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) {
- __ testl(dividend, dividend);
- DeoptimizeIf(zero, instr, Deoptimizer::kMinusZero);
- }
- // Check for (kMinInt / -1).
- if (hdiv->CheckFlag(HValue::kCanOverflow) && divisor == -1) {
- __ cmpl(dividend, Immediate(kMinInt));
- DeoptimizeIf(zero, instr, Deoptimizer::kOverflow);
- }
- // Deoptimize if remainder will not be 0.
- if (!hdiv->CheckFlag(HInstruction::kAllUsesTruncatingToInt32) &&
- divisor != 1 && divisor != -1) {
- int32_t mask = divisor < 0 ? -(divisor + 1) : (divisor - 1);
- __ testl(dividend, Immediate(mask));
- DeoptimizeIf(not_zero, instr, Deoptimizer::kLostPrecision);
- }
- __ Move(result, dividend);
- int32_t shift = WhichPowerOf2Abs(divisor);
- if (shift > 0) {
- // The arithmetic shift is always OK, the 'if' is an optimization only.
- if (shift > 1) __ sarl(result, Immediate(31));
- __ shrl(result, Immediate(32 - shift));
- __ addl(result, dividend);
- __ sarl(result, Immediate(shift));
- }
- if (divisor < 0) __ negl(result);
-}
-
-
-void LCodeGen::DoDivByConstI(LDivByConstI* instr) {
- Register dividend = ToRegister(instr->dividend());
- int32_t divisor = instr->divisor();
- DCHECK(ToRegister(instr->result()).is(rdx));
-
- if (divisor == 0) {
- DeoptimizeIf(no_condition, instr, Deoptimizer::kDivisionByZero);
- return;
- }
-
- // Check for (0 / -x) that will produce negative zero.
- HDiv* hdiv = instr->hydrogen();
- if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) {
- __ testl(dividend, dividend);
- DeoptimizeIf(zero, instr, Deoptimizer::kMinusZero);
- }
-
- __ TruncatingDiv(dividend, Abs(divisor));
- if (divisor < 0) __ negl(rdx);
-
- if (!hdiv->CheckFlag(HInstruction::kAllUsesTruncatingToInt32)) {
- __ movl(rax, rdx);
- __ imull(rax, rax, Immediate(divisor));
- __ subl(rax, dividend);
- DeoptimizeIf(not_equal, instr, Deoptimizer::kLostPrecision);
- }
-}
-
-
-// TODO(svenpanne) Refactor this to avoid code duplication with DoFlooringDivI.
-void LCodeGen::DoDivI(LDivI* instr) {
- HBinaryOperation* hdiv = instr->hydrogen();
- Register dividend = ToRegister(instr->dividend());
- Register divisor = ToRegister(instr->divisor());
- Register remainder = ToRegister(instr->temp());
- DCHECK(dividend.is(rax));
- DCHECK(remainder.is(rdx));
- DCHECK(ToRegister(instr->result()).is(rax));
- DCHECK(!divisor.is(rax));
- DCHECK(!divisor.is(rdx));
-
- // Check for x / 0.
- if (hdiv->CheckFlag(HValue::kCanBeDivByZero)) {
- __ testl(divisor, divisor);
- DeoptimizeIf(zero, instr, Deoptimizer::kDivisionByZero);
- }
-
- // Check for (0 / -x) that will produce negative zero.
- if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero)) {
- Label dividend_not_zero;
- __ testl(dividend, dividend);
- __ j(not_zero, &dividend_not_zero, Label::kNear);
- __ testl(divisor, divisor);
- DeoptimizeIf(sign, instr, Deoptimizer::kMinusZero);
- __ bind(&dividend_not_zero);
- }
-
- // Check for (kMinInt / -1).
- if (hdiv->CheckFlag(HValue::kCanOverflow)) {
- Label dividend_not_min_int;
- __ cmpl(dividend, Immediate(kMinInt));
- __ j(not_zero, &dividend_not_min_int, Label::kNear);
- __ cmpl(divisor, Immediate(-1));
- DeoptimizeIf(zero, instr, Deoptimizer::kOverflow);
- __ bind(&dividend_not_min_int);
- }
-
- // Sign extend to rdx (= remainder).
- __ cdq();
- __ idivl(divisor);
-
- if (!hdiv->CheckFlag(HValue::kAllUsesTruncatingToInt32)) {
- // Deoptimize if remainder is not 0.
- __ testl(remainder, remainder);
- DeoptimizeIf(not_zero, instr, Deoptimizer::kLostPrecision);
- }
-}
-
-
-void LCodeGen::DoMulI(LMulI* instr) {
- Register left = ToRegister(instr->left());
- LOperand* right = instr->right();
-
- if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
- if (instr->hydrogen_value()->representation().IsSmi()) {
- __ movp(kScratchRegister, left);
- } else {
- __ movl(kScratchRegister, left);
- }
- }
-
- bool can_overflow =
- instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
- if (right->IsConstantOperand()) {
- int32_t right_value = ToInteger32(LConstantOperand::cast(right));
- if (right_value == -1) {
- __ negl(left);
- } else if (right_value == 0) {
- __ xorl(left, left);
- } else if (right_value == 2) {
- __ addl(left, left);
- } else if (!can_overflow) {
- // If the multiplication is known to not overflow, we
- // can use operations that don't set the overflow flag
- // correctly.
- switch (right_value) {
- case 1:
- // Do nothing.
- break;
- case 3:
- __ leal(left, Operand(left, left, times_2, 0));
- break;
- case 4:
- __ shll(left, Immediate(2));
- break;
- case 5:
- __ leal(left, Operand(left, left, times_4, 0));
- break;
- case 8:
- __ shll(left, Immediate(3));
- break;
- case 9:
- __ leal(left, Operand(left, left, times_8, 0));
- break;
- case 16:
- __ shll(left, Immediate(4));
- break;
- default:
- __ imull(left, left, Immediate(right_value));
- break;
- }
- } else {
- __ imull(left, left, Immediate(right_value));
- }
- } else if (right->IsStackSlot()) {
- if (instr->hydrogen_value()->representation().IsSmi()) {
- __ SmiToInteger64(left, left);
- __ imulp(left, ToOperand(right));
- } else {
- __ imull(left, ToOperand(right));
- }
- } else {
- if (instr->hydrogen_value()->representation().IsSmi()) {
- __ SmiToInteger64(left, left);
- __ imulp(left, ToRegister(right));
- } else {
- __ imull(left, ToRegister(right));
- }
- }
-
- if (can_overflow) {
- DeoptimizeIf(overflow, instr, Deoptimizer::kOverflow);
- }
-
- if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
- // Bail out if the result is supposed to be negative zero.
- Label done;
- if (instr->hydrogen_value()->representation().IsSmi()) {
- __ testp(left, left);
- } else {
- __ testl(left, left);
- }
- __ j(not_zero, &done, Label::kNear);
- if (right->IsConstantOperand()) {
- // Constant can't be represented as 32-bit Smi due to immediate size
- // limit.
- DCHECK(SmiValuesAre32Bits()
- ? !instr->hydrogen_value()->representation().IsSmi()
- : SmiValuesAre31Bits());
- if (ToInteger32(LConstantOperand::cast(right)) < 0) {
- DeoptimizeIf(no_condition, instr, Deoptimizer::kMinusZero);
- } else if (ToInteger32(LConstantOperand::cast(right)) == 0) {
- __ cmpl(kScratchRegister, Immediate(0));
- DeoptimizeIf(less, instr, Deoptimizer::kMinusZero);
- }
- } else if (right->IsStackSlot()) {
- if (instr->hydrogen_value()->representation().IsSmi()) {
- __ orp(kScratchRegister, ToOperand(right));
- } else {
- __ orl(kScratchRegister, ToOperand(right));
- }
- DeoptimizeIf(sign, instr, Deoptimizer::kMinusZero);
- } else {
- // Test the non-zero operand for negative sign.
- if (instr->hydrogen_value()->representation().IsSmi()) {
- __ orp(kScratchRegister, ToRegister(right));
- } else {
- __ orl(kScratchRegister, ToRegister(right));
- }
- DeoptimizeIf(sign, instr, Deoptimizer::kMinusZero);
- }
- __ bind(&done);
- }
-}
-
-
-void LCodeGen::DoBitI(LBitI* instr) {
- LOperand* left = instr->left();
- LOperand* right = instr->right();
- DCHECK(left->Equals(instr->result()));
- DCHECK(left->IsRegister());
-
- if (right->IsConstantOperand()) {
- int32_t right_operand =
- ToRepresentation(LConstantOperand::cast(right),
- instr->hydrogen()->right()->representation());
- switch (instr->op()) {
- case Token::BIT_AND:
- __ andl(ToRegister(left), Immediate(right_operand));
- break;
- case Token::BIT_OR:
- __ orl(ToRegister(left), Immediate(right_operand));
- break;
- case Token::BIT_XOR:
- if (right_operand == int32_t(~0)) {
- __ notl(ToRegister(left));
- } else {
- __ xorl(ToRegister(left), Immediate(right_operand));
- }
- break;
- default:
- UNREACHABLE();
- break;
- }
- } else if (right->IsStackSlot()) {
- switch (instr->op()) {
- case Token::BIT_AND:
- if (instr->IsInteger32()) {
- __ andl(ToRegister(left), ToOperand(right));
- } else {
- __ andp(ToRegister(left), ToOperand(right));
- }
- break;
- case Token::BIT_OR:
- if (instr->IsInteger32()) {
- __ orl(ToRegister(left), ToOperand(right));
- } else {
- __ orp(ToRegister(left), ToOperand(right));
- }
- break;
- case Token::BIT_XOR:
- if (instr->IsInteger32()) {
- __ xorl(ToRegister(left), ToOperand(right));
- } else {
- __ xorp(ToRegister(left), ToOperand(right));
- }
- break;
- default:
- UNREACHABLE();
- break;
- }
- } else {
- DCHECK(right->IsRegister());
- switch (instr->op()) {
- case Token::BIT_AND:
- if (instr->IsInteger32()) {
- __ andl(ToRegister(left), ToRegister(right));
- } else {
- __ andp(ToRegister(left), ToRegister(right));
- }
- break;
- case Token::BIT_OR:
- if (instr->IsInteger32()) {
- __ orl(ToRegister(left), ToRegister(right));
- } else {
- __ orp(ToRegister(left), ToRegister(right));
- }
- break;
- case Token::BIT_XOR:
- if (instr->IsInteger32()) {
- __ xorl(ToRegister(left), ToRegister(right));
- } else {
- __ xorp(ToRegister(left), ToRegister(right));
- }
- break;
- default:
- UNREACHABLE();
- break;
- }
- }
-}
-
-
-void LCodeGen::DoShiftI(LShiftI* instr) {
- LOperand* left = instr->left();
- LOperand* right = instr->right();
- DCHECK(left->Equals(instr->result()));
- DCHECK(left->IsRegister());
- if (right->IsRegister()) {
- DCHECK(ToRegister(right).is(rcx));
-
- switch (instr->op()) {
- case Token::ROR:
- __ rorl_cl(ToRegister(left));
- break;
- case Token::SAR:
- __ sarl_cl(ToRegister(left));
- break;
- case Token::SHR:
- __ shrl_cl(ToRegister(left));
- if (instr->can_deopt()) {
- __ testl(ToRegister(left), ToRegister(left));
- DeoptimizeIf(negative, instr, Deoptimizer::kNegativeValue);
- }
- break;
- case Token::SHL:
- __ shll_cl(ToRegister(left));
- break;
- default:
- UNREACHABLE();
- break;
- }
- } else {
- int32_t value = ToInteger32(LConstantOperand::cast(right));
- uint8_t shift_count = static_cast<uint8_t>(value & 0x1F);
- switch (instr->op()) {
- case Token::ROR:
- if (shift_count != 0) {
- __ rorl(ToRegister(left), Immediate(shift_count));
- }
- break;
- case Token::SAR:
- if (shift_count != 0) {
- __ sarl(ToRegister(left), Immediate(shift_count));
- }
- break;
- case Token::SHR:
- if (shift_count != 0) {
- __ shrl(ToRegister(left), Immediate(shift_count));
- } else if (instr->can_deopt()) {
- __ testl(ToRegister(left), ToRegister(left));
- DeoptimizeIf(negative, instr, Deoptimizer::kNegativeValue);
- }
- break;
- case Token::SHL:
- if (shift_count != 0) {
- if (instr->hydrogen_value()->representation().IsSmi()) {
- if (SmiValuesAre32Bits()) {
- __ shlp(ToRegister(left), Immediate(shift_count));
- } else {
- DCHECK(SmiValuesAre31Bits());
- if (instr->can_deopt()) {
- if (shift_count != 1) {
- __ shll(ToRegister(left), Immediate(shift_count - 1));
- }
- __ Integer32ToSmi(ToRegister(left), ToRegister(left));
- DeoptimizeIf(overflow, instr, Deoptimizer::kOverflow);
- } else {
- __ shll(ToRegister(left), Immediate(shift_count));
- }
- }
- } else {
- __ shll(ToRegister(left), Immediate(shift_count));
- }
- }
- break;
- default:
- UNREACHABLE();
- break;
- }
- }
-}
-
-
-void LCodeGen::DoSubI(LSubI* instr) {
- LOperand* left = instr->left();
- LOperand* right = instr->right();
- DCHECK(left->Equals(instr->result()));
-
- if (right->IsConstantOperand()) {
- int32_t right_operand =
- ToRepresentation(LConstantOperand::cast(right),
- instr->hydrogen()->right()->representation());
- __ subl(ToRegister(left), Immediate(right_operand));
- } else if (right->IsRegister()) {
- if (instr->hydrogen_value()->representation().IsSmi()) {
- __ subp(ToRegister(left), ToRegister(right));
- } else {
- __ subl(ToRegister(left), ToRegister(right));
- }
- } else {
- if (instr->hydrogen_value()->representation().IsSmi()) {
- __ subp(ToRegister(left), ToOperand(right));
- } else {
- __ subl(ToRegister(left), ToOperand(right));
- }
- }
-
- if (instr->hydrogen()->CheckFlag(HValue::kCanOverflow)) {
- DeoptimizeIf(overflow, instr, Deoptimizer::kOverflow);
- }
-}
-
-
-void LCodeGen::DoConstantI(LConstantI* instr) {
- Register dst = ToRegister(instr->result());
- if (instr->value() == 0) {
- __ xorl(dst, dst);
- } else {
- __ movl(dst, Immediate(instr->value()));
- }
-}
-
-
-void LCodeGen::DoConstantS(LConstantS* instr) {
- __ Move(ToRegister(instr->result()), instr->value());
-}
-
-
-void LCodeGen::DoConstantD(LConstantD* instr) {
- __ Move(ToDoubleRegister(instr->result()), instr->bits());
-}
-
-
-void LCodeGen::DoConstantE(LConstantE* instr) {
- __ LoadAddress(ToRegister(instr->result()), instr->value());
-}
-
-
-void LCodeGen::DoConstantT(LConstantT* instr) {
- Handle<Object> object = instr->value(isolate());
- AllowDeferredHandleDereference smi_check;
- __ Move(ToRegister(instr->result()), object);
-}
-
-
-void LCodeGen::DoMapEnumLength(LMapEnumLength* instr) {
- Register result = ToRegister(instr->result());
- Register map = ToRegister(instr->value());
- __ EnumLength(result, map);
-}
-
-
-void LCodeGen::DoDateField(LDateField* instr) {
- Register object = ToRegister(instr->date());
- Register result = ToRegister(instr->result());
- Smi* index = instr->index();
- DCHECK(object.is(result));
- DCHECK(object.is(rax));
-
- if (FLAG_debug_code) {
- __ AssertNotSmi(object);
- __ CmpObjectType(object, JS_DATE_TYPE, kScratchRegister);
- __ Check(equal, kOperandIsNotADate);
- }
-
- if (index->value() == 0) {
- __ movp(result, FieldOperand(object, JSDate::kValueOffset));
- } else {
- Label runtime, done;
- if (index->value() < JSDate::kFirstUncachedField) {
- ExternalReference stamp = ExternalReference::date_cache_stamp(isolate());
- Operand stamp_operand = __ ExternalOperand(stamp);
- __ movp(kScratchRegister, stamp_operand);
- __ cmpp(kScratchRegister, FieldOperand(object,
- JSDate::kCacheStampOffset));
- __ j(not_equal, &runtime, Label::kNear);
- __ movp(result, FieldOperand(object, JSDate::kValueOffset +
- kPointerSize * index->value()));
- __ jmp(&done, Label::kNear);
- }
- __ bind(&runtime);
- __ PrepareCallCFunction(2);
- __ movp(arg_reg_1, object);
- __ Move(arg_reg_2, index, Assembler::RelocInfoNone());
- __ CallCFunction(ExternalReference::get_date_field_function(isolate()), 2);
- __ bind(&done);
- }
-}
-
-
-Operand LCodeGen::BuildSeqStringOperand(Register string,
- LOperand* index,
- String::Encoding encoding) {
- if (index->IsConstantOperand()) {
- int offset = ToInteger32(LConstantOperand::cast(index));
- if (encoding == String::TWO_BYTE_ENCODING) {
- offset *= kUC16Size;
- }
- STATIC_ASSERT(kCharSize == 1);
- return FieldOperand(string, SeqString::kHeaderSize + offset);
- }
- return FieldOperand(
- string, ToRegister(index),
- encoding == String::ONE_BYTE_ENCODING ? times_1 : times_2,
- SeqString::kHeaderSize);
-}
-
-
-void LCodeGen::DoSeqStringGetChar(LSeqStringGetChar* instr) {
- String::Encoding encoding = instr->hydrogen()->encoding();
- Register result = ToRegister(instr->result());
- Register string = ToRegister(instr->string());
-
- if (FLAG_debug_code) {
- __ Push(string);
- __ movp(string, FieldOperand(string, HeapObject::kMapOffset));
- __ movzxbp(string, FieldOperand(string, Map::kInstanceTypeOffset));
-
- __ andb(string, Immediate(kStringRepresentationMask | kStringEncodingMask));
- static const uint32_t one_byte_seq_type = kSeqStringTag | kOneByteStringTag;
- static const uint32_t two_byte_seq_type = kSeqStringTag | kTwoByteStringTag;
- __ cmpp(string, Immediate(encoding == String::ONE_BYTE_ENCODING
- ? one_byte_seq_type : two_byte_seq_type));
- __ Check(equal, kUnexpectedStringType);
- __ Pop(string);
- }
-
- Operand operand = BuildSeqStringOperand(string, instr->index(), encoding);
- if (encoding == String::ONE_BYTE_ENCODING) {
- __ movzxbl(result, operand);
- } else {
- __ movzxwl(result, operand);
- }
-}
-
-
-void LCodeGen::DoSeqStringSetChar(LSeqStringSetChar* instr) {
- String::Encoding encoding = instr->hydrogen()->encoding();
- Register string = ToRegister(instr->string());
-
- if (FLAG_debug_code) {
- Register value = ToRegister(instr->value());
- Register index = ToRegister(instr->index());
- static const uint32_t one_byte_seq_type = kSeqStringTag | kOneByteStringTag;
- static const uint32_t two_byte_seq_type = kSeqStringTag | kTwoByteStringTag;
- int encoding_mask =
- instr->hydrogen()->encoding() == String::ONE_BYTE_ENCODING
- ? one_byte_seq_type : two_byte_seq_type;
- __ EmitSeqStringSetCharCheck(string, index, value, encoding_mask);
- }
-
- Operand operand = BuildSeqStringOperand(string, instr->index(), encoding);
- if (instr->value()->IsConstantOperand()) {
- int value = ToInteger32(LConstantOperand::cast(instr->value()));
- DCHECK_LE(0, value);
- if (encoding == String::ONE_BYTE_ENCODING) {
- DCHECK_LE(value, String::kMaxOneByteCharCode);
- __ movb(operand, Immediate(value));
- } else {
- DCHECK_LE(value, String::kMaxUtf16CodeUnit);
- __ movw(operand, Immediate(value));
- }
- } else {
- Register value = ToRegister(instr->value());
- if (encoding == String::ONE_BYTE_ENCODING) {
- __ movb(operand, value);
- } else {
- __ movw(operand, value);
- }
- }
-}
-
-
-void LCodeGen::DoAddI(LAddI* instr) {
- LOperand* left = instr->left();
- LOperand* right = instr->right();
-
- Representation target_rep = instr->hydrogen()->representation();
- bool is_p = target_rep.IsSmi() || target_rep.IsExternal();
-
- if (LAddI::UseLea(instr->hydrogen()) && !left->Equals(instr->result())) {
- if (right->IsConstantOperand()) {
- // No support for smi-immediates for 32-bit SMI.
- DCHECK(SmiValuesAre32Bits() ? !target_rep.IsSmi() : SmiValuesAre31Bits());
- int32_t offset =
- ToRepresentation(LConstantOperand::cast(right),
- instr->hydrogen()->right()->representation());
- if (is_p) {
- __ leap(ToRegister(instr->result()),
- MemOperand(ToRegister(left), offset));
- } else {
- __ leal(ToRegister(instr->result()),
- MemOperand(ToRegister(left), offset));
- }
- } else {
- Operand address(ToRegister(left), ToRegister(right), times_1, 0);
- if (is_p) {
- __ leap(ToRegister(instr->result()), address);
- } else {
- __ leal(ToRegister(instr->result()), address);
- }
- }
- } else {
- if (right->IsConstantOperand()) {
- // No support for smi-immediates for 32-bit SMI.
- DCHECK(SmiValuesAre32Bits() ? !target_rep.IsSmi() : SmiValuesAre31Bits());
- int32_t right_operand =
- ToRepresentation(LConstantOperand::cast(right),
- instr->hydrogen()->right()->representation());
- if (is_p) {
- __ addp(ToRegister(left), Immediate(right_operand));
- } else {
- __ addl(ToRegister(left), Immediate(right_operand));
- }
- } else if (right->IsRegister()) {
- if (is_p) {
- __ addp(ToRegister(left), ToRegister(right));
- } else {
- __ addl(ToRegister(left), ToRegister(right));
- }
- } else {
- if (is_p) {
- __ addp(ToRegister(left), ToOperand(right));
- } else {
- __ addl(ToRegister(left), ToOperand(right));
- }
- }
- if (instr->hydrogen()->CheckFlag(HValue::kCanOverflow)) {
- DeoptimizeIf(overflow, instr, Deoptimizer::kOverflow);
- }
- }
-}
-
-
-void LCodeGen::DoMathMinMax(LMathMinMax* instr) {
- LOperand* left = instr->left();
- LOperand* right = instr->right();
- DCHECK(left->Equals(instr->result()));
- HMathMinMax::Operation operation = instr->hydrogen()->operation();
- if (instr->hydrogen()->representation().IsSmiOrInteger32()) {
- Label return_left;
- Condition condition = (operation == HMathMinMax::kMathMin)
- ? less_equal
- : greater_equal;
- Register left_reg = ToRegister(left);
- if (right->IsConstantOperand()) {
- Immediate right_imm = Immediate(
- ToRepresentation(LConstantOperand::cast(right),
- instr->hydrogen()->right()->representation()));
- DCHECK(SmiValuesAre32Bits()
- ? !instr->hydrogen()->representation().IsSmi()
- : SmiValuesAre31Bits());
- __ cmpl(left_reg, right_imm);
- __ j(condition, &return_left, Label::kNear);
- __ movp(left_reg, right_imm);
- } else if (right->IsRegister()) {
- Register right_reg = ToRegister(right);
- if (instr->hydrogen_value()->representation().IsSmi()) {
- __ cmpp(left_reg, right_reg);
- } else {
- __ cmpl(left_reg, right_reg);
- }
- __ j(condition, &return_left, Label::kNear);
- __ movp(left_reg, right_reg);
- } else {
- Operand right_op = ToOperand(right);
- if (instr->hydrogen_value()->representation().IsSmi()) {
- __ cmpp(left_reg, right_op);
- } else {
- __ cmpl(left_reg, right_op);
- }
- __ j(condition, &return_left, Label::kNear);
- __ movp(left_reg, right_op);
- }
- __ bind(&return_left);
- } else {
- DCHECK(instr->hydrogen()->representation().IsDouble());
- Label check_nan_left, check_zero, return_left, return_right;
- Condition condition = (operation == HMathMinMax::kMathMin) ? below : above;
- XMMRegister left_reg = ToDoubleRegister(left);
- XMMRegister right_reg = ToDoubleRegister(right);
- __ ucomisd(left_reg, right_reg);
- __ j(parity_even, &check_nan_left, Label::kNear); // At least one NaN.
- __ j(equal, &check_zero, Label::kNear); // left == right.
- __ j(condition, &return_left, Label::kNear);
- __ jmp(&return_right, Label::kNear);
-
- __ bind(&check_zero);
- XMMRegister xmm_scratch = double_scratch0();
- __ xorps(xmm_scratch, xmm_scratch);
- __ ucomisd(left_reg, xmm_scratch);
- __ j(not_equal, &return_left, Label::kNear); // left == right != 0.
- // At this point, both left and right are either 0 or -0.
- if (operation == HMathMinMax::kMathMin) {
- __ orps(left_reg, right_reg);
- } else {
- // Since we operate on +0 and/or -0, addsd and andsd have the same effect.
- __ addsd(left_reg, right_reg);
- }
- __ jmp(&return_left, Label::kNear);
-
- __ bind(&check_nan_left);
- __ ucomisd(left_reg, left_reg); // NaN check.
- __ j(parity_even, &return_left, Label::kNear);
- __ bind(&return_right);
- __ movaps(left_reg, right_reg);
-
- __ bind(&return_left);
- }
-}
-
-
-void LCodeGen::DoArithmeticD(LArithmeticD* instr) {
- XMMRegister left = ToDoubleRegister(instr->left());
- XMMRegister right = ToDoubleRegister(instr->right());
- XMMRegister result = ToDoubleRegister(instr->result());
- switch (instr->op()) {
- case Token::ADD:
- if (CpuFeatures::IsSupported(AVX)) {
- CpuFeatureScope scope(masm(), AVX);
- __ vaddsd(result, left, right);
- } else {
- DCHECK(result.is(left));
- __ addsd(left, right);
- }
- break;
- case Token::SUB:
- if (CpuFeatures::IsSupported(AVX)) {
- CpuFeatureScope scope(masm(), AVX);
- __ vsubsd(result, left, right);
- } else {
- DCHECK(result.is(left));
- __ subsd(left, right);
- }
- break;
- case Token::MUL:
- if (CpuFeatures::IsSupported(AVX)) {
- CpuFeatureScope scope(masm(), AVX);
- __ vmulsd(result, left, right);
- } else {
- DCHECK(result.is(left));
- __ mulsd(left, right);
- }
- break;
- case Token::DIV:
- if (CpuFeatures::IsSupported(AVX)) {
- CpuFeatureScope scope(masm(), AVX);
- __ vdivsd(result, left, right);
- } else {
- DCHECK(result.is(left));
- __ divsd(left, right);
- }
- // Don't delete this mov. It may improve performance on some CPUs,
- // when there is a (v)mulsd depending on the result
- __ movaps(result, result);
- break;
- case Token::MOD: {
- XMMRegister xmm_scratch = double_scratch0();
- __ PrepareCallCFunction(2);
- __ movaps(xmm_scratch, left);
- DCHECK(right.is(xmm1));
- __ CallCFunction(
- ExternalReference::mod_two_doubles_operation(isolate()), 2);
- __ movaps(result, xmm_scratch);
- break;
- }
- default:
- UNREACHABLE();
- break;
- }
-}
-
-
-void LCodeGen::DoArithmeticT(LArithmeticT* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->left()).is(rdx));
- DCHECK(ToRegister(instr->right()).is(rax));
- DCHECK(ToRegister(instr->result()).is(rax));
-
- Handle<Code> code =
- CodeFactory::BinaryOpIC(isolate(), instr->op(), instr->strength()).code();
- CallCode(code, RelocInfo::CODE_TARGET, instr);
-}
-
-
-template<class InstrType>
-void LCodeGen::EmitBranch(InstrType instr, Condition cc) {
- int left_block = instr->TrueDestination(chunk_);
- int right_block = instr->FalseDestination(chunk_);
-
- int next_block = GetNextEmittedBlock();
-
- if (right_block == left_block || cc == no_condition) {
- EmitGoto(left_block);
- } else if (left_block == next_block) {
- __ j(NegateCondition(cc), chunk_->GetAssemblyLabel(right_block));
- } else if (right_block == next_block) {
- __ j(cc, chunk_->GetAssemblyLabel(left_block));
- } else {
- __ j(cc, chunk_->GetAssemblyLabel(left_block));
- if (cc != always) {
- __ jmp(chunk_->GetAssemblyLabel(right_block));
- }
- }
-}
-
-
-template <class InstrType>
-void LCodeGen::EmitTrueBranch(InstrType instr, Condition cc) {
- int true_block = instr->TrueDestination(chunk_);
- __ j(cc, chunk_->GetAssemblyLabel(true_block));
-}
-
-
-template <class InstrType>
-void LCodeGen::EmitFalseBranch(InstrType instr, Condition cc) {
- int false_block = instr->FalseDestination(chunk_);
- __ j(cc, chunk_->GetAssemblyLabel(false_block));
-}
-
-
-void LCodeGen::DoDebugBreak(LDebugBreak* instr) {
- __ int3();
-}
-
-
-void LCodeGen::DoBranch(LBranch* instr) {
- Representation r = instr->hydrogen()->value()->representation();
- if (r.IsInteger32()) {
- DCHECK(!info()->IsStub());
- Register reg = ToRegister(instr->value());
- __ testl(reg, reg);
- EmitBranch(instr, not_zero);
- } else if (r.IsSmi()) {
- DCHECK(!info()->IsStub());
- Register reg = ToRegister(instr->value());
- __ testp(reg, reg);
- EmitBranch(instr, not_zero);
- } else if (r.IsDouble()) {
- DCHECK(!info()->IsStub());
- XMMRegister reg = ToDoubleRegister(instr->value());
- XMMRegister xmm_scratch = double_scratch0();
- __ xorps(xmm_scratch, xmm_scratch);
- __ ucomisd(reg, xmm_scratch);
- EmitBranch(instr, not_equal);
- } else {
- DCHECK(r.IsTagged());
- Register reg = ToRegister(instr->value());
- HType type = instr->hydrogen()->value()->type();
- if (type.IsBoolean()) {
- DCHECK(!info()->IsStub());
- __ CompareRoot(reg, Heap::kTrueValueRootIndex);
- EmitBranch(instr, equal);
- } else if (type.IsSmi()) {
- DCHECK(!info()->IsStub());
- __ SmiCompare(reg, Smi::FromInt(0));
- EmitBranch(instr, not_equal);
- } else if (type.IsJSArray()) {
- DCHECK(!info()->IsStub());
- EmitBranch(instr, no_condition);
- } else if (type.IsHeapNumber()) {
- DCHECK(!info()->IsStub());
- XMMRegister xmm_scratch = double_scratch0();
- __ xorps(xmm_scratch, xmm_scratch);
- __ ucomisd(xmm_scratch, FieldOperand(reg, HeapNumber::kValueOffset));
- EmitBranch(instr, not_equal);
- } else if (type.IsString()) {
- DCHECK(!info()->IsStub());
- __ cmpp(FieldOperand(reg, String::kLengthOffset), Immediate(0));
- EmitBranch(instr, not_equal);
- } else {
- ToBooleanStub::Types expected = instr->hydrogen()->expected_input_types();
- // Avoid deopts in the case where we've never executed this path before.
- if (expected.IsEmpty()) expected = ToBooleanStub::Types::Generic();
-
- if (expected.Contains(ToBooleanStub::UNDEFINED)) {
- // undefined -> false.
- __ CompareRoot(reg, Heap::kUndefinedValueRootIndex);
- __ j(equal, instr->FalseLabel(chunk_));
- }
- if (expected.Contains(ToBooleanStub::BOOLEAN)) {
- // true -> true.
- __ CompareRoot(reg, Heap::kTrueValueRootIndex);
- __ j(equal, instr->TrueLabel(chunk_));
- // false -> false.
- __ CompareRoot(reg, Heap::kFalseValueRootIndex);
- __ j(equal, instr->FalseLabel(chunk_));
- }
- if (expected.Contains(ToBooleanStub::NULL_TYPE)) {
- // 'null' -> false.
- __ CompareRoot(reg, Heap::kNullValueRootIndex);
- __ j(equal, instr->FalseLabel(chunk_));
- }
-
- if (expected.Contains(ToBooleanStub::SMI)) {
- // Smis: 0 -> false, all other -> true.
- __ Cmp(reg, Smi::FromInt(0));
- __ j(equal, instr->FalseLabel(chunk_));
- __ JumpIfSmi(reg, instr->TrueLabel(chunk_));
- } else if (expected.NeedsMap()) {
- // If we need a map later and have a Smi -> deopt.
- __ testb(reg, Immediate(kSmiTagMask));
- DeoptimizeIf(zero, instr, Deoptimizer::kSmi);
- }
-
- const Register map = kScratchRegister;
- if (expected.NeedsMap()) {
- __ movp(map, FieldOperand(reg, HeapObject::kMapOffset));
-
- if (expected.CanBeUndetectable()) {
- // Undetectable -> false.
- __ testb(FieldOperand(map, Map::kBitFieldOffset),
- Immediate(1 << Map::kIsUndetectable));
- __ j(not_zero, instr->FalseLabel(chunk_));
- }
- }
-
- if (expected.Contains(ToBooleanStub::SPEC_OBJECT)) {
- // spec object -> true.
- __ CmpInstanceType(map, FIRST_SPEC_OBJECT_TYPE);
- __ j(above_equal, instr->TrueLabel(chunk_));
- }
-
- if (expected.Contains(ToBooleanStub::STRING)) {
- // String value -> false iff empty.
- Label not_string;
- __ CmpInstanceType(map, FIRST_NONSTRING_TYPE);
- __ j(above_equal, &not_string, Label::kNear);
- __ cmpp(FieldOperand(reg, String::kLengthOffset), Immediate(0));
- __ j(not_zero, instr->TrueLabel(chunk_));
- __ jmp(instr->FalseLabel(chunk_));
- __ bind(&not_string);
- }
-
- if (expected.Contains(ToBooleanStub::SYMBOL)) {
- // Symbol value -> true.
- __ CmpInstanceType(map, SYMBOL_TYPE);
- __ j(equal, instr->TrueLabel(chunk_));
- }
-
- if (expected.Contains(ToBooleanStub::SIMD_VALUE)) {
- // SIMD value -> true.
- __ CmpInstanceType(map, SIMD128_VALUE_TYPE);
- __ j(equal, instr->TrueLabel(chunk_));
- }
-
- if (expected.Contains(ToBooleanStub::HEAP_NUMBER)) {
- // heap number -> false iff +0, -0, or NaN.
- Label not_heap_number;
- __ CompareRoot(map, Heap::kHeapNumberMapRootIndex);
- __ j(not_equal, &not_heap_number, Label::kNear);
- XMMRegister xmm_scratch = double_scratch0();
- __ xorps(xmm_scratch, xmm_scratch);
- __ ucomisd(xmm_scratch, FieldOperand(reg, HeapNumber::kValueOffset));
- __ j(zero, instr->FalseLabel(chunk_));
- __ jmp(instr->TrueLabel(chunk_));
- __ bind(&not_heap_number);
- }
-
- if (!expected.IsGeneric()) {
- // We've seen something for the first time -> deopt.
- // This can only happen if we are not generic already.
- DeoptimizeIf(no_condition, instr, Deoptimizer::kUnexpectedObject);
- }
- }
- }
-}
-
-
-void LCodeGen::EmitGoto(int block) {
- if (!IsNextEmittedBlock(block)) {
- __ jmp(chunk_->GetAssemblyLabel(chunk_->LookupDestination(block)));
- }
-}
-
-
-void LCodeGen::DoGoto(LGoto* instr) {
- EmitGoto(instr->block_id());
-}
-
-
-inline Condition LCodeGen::TokenToCondition(Token::Value op, bool is_unsigned) {
- Condition cond = no_condition;
- switch (op) {
- case Token::EQ:
- case Token::EQ_STRICT:
- cond = equal;
- break;
- case Token::NE:
- case Token::NE_STRICT:
- cond = not_equal;
- break;
- case Token::LT:
- cond = is_unsigned ? below : less;
- break;
- case Token::GT:
- cond = is_unsigned ? above : greater;
- break;
- case Token::LTE:
- cond = is_unsigned ? below_equal : less_equal;
- break;
- case Token::GTE:
- cond = is_unsigned ? above_equal : greater_equal;
- break;
- case Token::IN:
- case Token::INSTANCEOF:
- default:
- UNREACHABLE();
- }
- return cond;
-}
-
-
-void LCodeGen::DoCompareNumericAndBranch(LCompareNumericAndBranch* instr) {
- LOperand* left = instr->left();
- LOperand* right = instr->right();
- bool is_unsigned =
- instr->is_double() ||
- instr->hydrogen()->left()->CheckFlag(HInstruction::kUint32) ||
- instr->hydrogen()->right()->CheckFlag(HInstruction::kUint32);
- Condition cc = TokenToCondition(instr->op(), is_unsigned);
-
- if (left->IsConstantOperand() && right->IsConstantOperand()) {
- // We can statically evaluate the comparison.
- double left_val = ToDouble(LConstantOperand::cast(left));
- double right_val = ToDouble(LConstantOperand::cast(right));
- int next_block = EvalComparison(instr->op(), left_val, right_val) ?
- instr->TrueDestination(chunk_) : instr->FalseDestination(chunk_);
- EmitGoto(next_block);
- } else {
- if (instr->is_double()) {
- // Don't base result on EFLAGS when a NaN is involved. Instead
- // jump to the false block.
- __ ucomisd(ToDoubleRegister(left), ToDoubleRegister(right));
- __ j(parity_even, instr->FalseLabel(chunk_));
- } else {
- int32_t value;
- if (right->IsConstantOperand()) {
- value = ToInteger32(LConstantOperand::cast(right));
- if (instr->hydrogen_value()->representation().IsSmi()) {
- __ Cmp(ToRegister(left), Smi::FromInt(value));
- } else {
- __ cmpl(ToRegister(left), Immediate(value));
- }
- } else if (left->IsConstantOperand()) {
- value = ToInteger32(LConstantOperand::cast(left));
- if (instr->hydrogen_value()->representation().IsSmi()) {
- if (right->IsRegister()) {
- __ Cmp(ToRegister(right), Smi::FromInt(value));
- } else {
- __ Cmp(ToOperand(right), Smi::FromInt(value));
- }
- } else if (right->IsRegister()) {
- __ cmpl(ToRegister(right), Immediate(value));
- } else {
- __ cmpl(ToOperand(right), Immediate(value));
- }
- // We commuted the operands, so commute the condition.
- cc = CommuteCondition(cc);
- } else if (instr->hydrogen_value()->representation().IsSmi()) {
- if (right->IsRegister()) {
- __ cmpp(ToRegister(left), ToRegister(right));
- } else {
- __ cmpp(ToRegister(left), ToOperand(right));
- }
- } else {
- if (right->IsRegister()) {
- __ cmpl(ToRegister(left), ToRegister(right));
- } else {
- __ cmpl(ToRegister(left), ToOperand(right));
- }
- }
- }
- EmitBranch(instr, cc);
- }
-}
-
-
-void LCodeGen::DoCmpObjectEqAndBranch(LCmpObjectEqAndBranch* instr) {
- Register left = ToRegister(instr->left());
-
- if (instr->right()->IsConstantOperand()) {
- Handle<Object> right = ToHandle(LConstantOperand::cast(instr->right()));
- __ Cmp(left, right);
- } else {
- Register right = ToRegister(instr->right());
- __ cmpp(left, right);
- }
- EmitBranch(instr, equal);
-}
-
-
-void LCodeGen::DoCmpHoleAndBranch(LCmpHoleAndBranch* instr) {
- if (instr->hydrogen()->representation().IsTagged()) {
- Register input_reg = ToRegister(instr->object());
- __ Cmp(input_reg, factory()->the_hole_value());
- EmitBranch(instr, equal);
- return;
- }
-
- XMMRegister input_reg = ToDoubleRegister(instr->object());
- __ ucomisd(input_reg, input_reg);
- EmitFalseBranch(instr, parity_odd);
-
- __ subp(rsp, Immediate(kDoubleSize));
- __ movsd(MemOperand(rsp, 0), input_reg);
- __ addp(rsp, Immediate(kDoubleSize));
-
- int offset = sizeof(kHoleNanUpper32);
- __ cmpl(MemOperand(rsp, -offset), Immediate(kHoleNanUpper32));
- EmitBranch(instr, equal);
-}
-
-
-void LCodeGen::DoCompareMinusZeroAndBranch(LCompareMinusZeroAndBranch* instr) {
- Representation rep = instr->hydrogen()->value()->representation();
- DCHECK(!rep.IsInteger32());
-
- if (rep.IsDouble()) {
- XMMRegister value = ToDoubleRegister(instr->value());
- XMMRegister xmm_scratch = double_scratch0();
- __ xorps(xmm_scratch, xmm_scratch);
- __ ucomisd(xmm_scratch, value);
- EmitFalseBranch(instr, not_equal);
- __ movmskpd(kScratchRegister, value);
- __ testl(kScratchRegister, Immediate(1));
- EmitBranch(instr, not_zero);
- } else {
- Register value = ToRegister(instr->value());
- Handle<Map> map = masm()->isolate()->factory()->heap_number_map();
- __ CheckMap(value, map, instr->FalseLabel(chunk()), DO_SMI_CHECK);
- __ cmpl(FieldOperand(value, HeapNumber::kExponentOffset),
- Immediate(0x1));
- EmitFalseBranch(instr, no_overflow);
- __ cmpl(FieldOperand(value, HeapNumber::kMantissaOffset),
- Immediate(0x00000000));
- EmitBranch(instr, equal);
- }
-}
-
-
-Condition LCodeGen::EmitIsString(Register input,
- Register temp1,
- Label* is_not_string,
- SmiCheck check_needed = INLINE_SMI_CHECK) {
- if (check_needed == INLINE_SMI_CHECK) {
- __ JumpIfSmi(input, is_not_string);
- }
-
- Condition cond = masm_->IsObjectStringType(input, temp1, temp1);
-
- return cond;
-}
-
-
-void LCodeGen::DoIsStringAndBranch(LIsStringAndBranch* instr) {
- Register reg = ToRegister(instr->value());
- Register temp = ToRegister(instr->temp());
-
- SmiCheck check_needed =
- instr->hydrogen()->value()->type().IsHeapObject()
- ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
-
- Condition true_cond = EmitIsString(
- reg, temp, instr->FalseLabel(chunk_), check_needed);
-
- EmitBranch(instr, true_cond);
-}
-
-
-void LCodeGen::DoIsSmiAndBranch(LIsSmiAndBranch* instr) {
- Condition is_smi;
- if (instr->value()->IsRegister()) {
- Register input = ToRegister(instr->value());
- is_smi = masm()->CheckSmi(input);
- } else {
- Operand input = ToOperand(instr->value());
- is_smi = masm()->CheckSmi(input);
- }
- EmitBranch(instr, is_smi);
-}
-
-
-void LCodeGen::DoIsUndetectableAndBranch(LIsUndetectableAndBranch* instr) {
- Register input = ToRegister(instr->value());
- Register temp = ToRegister(instr->temp());
-
- if (!instr->hydrogen()->value()->type().IsHeapObject()) {
- __ JumpIfSmi(input, instr->FalseLabel(chunk_));
- }
- __ movp(temp, FieldOperand(input, HeapObject::kMapOffset));
- __ testb(FieldOperand(temp, Map::kBitFieldOffset),
- Immediate(1 << Map::kIsUndetectable));
- EmitBranch(instr, not_zero);
-}
-
-
-void LCodeGen::DoStringCompareAndBranch(LStringCompareAndBranch* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->left()).is(rdx));
- DCHECK(ToRegister(instr->right()).is(rax));
-
- Handle<Code> code = CodeFactory::StringCompare(isolate()).code();
- CallCode(code, RelocInfo::CODE_TARGET, instr);
- __ testp(rax, rax);
-
- EmitBranch(instr, TokenToCondition(instr->op(), false));
-}
-
-
-static InstanceType TestType(HHasInstanceTypeAndBranch* instr) {
- InstanceType from = instr->from();
- InstanceType to = instr->to();
- if (from == FIRST_TYPE) return to;
- DCHECK(from == to || to == LAST_TYPE);
- return from;
-}
-
-
-static Condition BranchCondition(HHasInstanceTypeAndBranch* instr) {
- InstanceType from = instr->from();
- InstanceType to = instr->to();
- if (from == to) return equal;
- if (to == LAST_TYPE) return above_equal;
- if (from == FIRST_TYPE) return below_equal;
- UNREACHABLE();
- return equal;
-}
-
-
-void LCodeGen::DoHasInstanceTypeAndBranch(LHasInstanceTypeAndBranch* instr) {
- Register input = ToRegister(instr->value());
-
- if (!instr->hydrogen()->value()->type().IsHeapObject()) {
- __ JumpIfSmi(input, instr->FalseLabel(chunk_));
- }
-
- __ CmpObjectType(input, TestType(instr->hydrogen()), kScratchRegister);
- EmitBranch(instr, BranchCondition(instr->hydrogen()));
-}
-
-
-void LCodeGen::DoGetCachedArrayIndex(LGetCachedArrayIndex* instr) {
- Register input = ToRegister(instr->value());
- Register result = ToRegister(instr->result());
-
- __ AssertString(input);
-
- __ movl(result, FieldOperand(input, String::kHashFieldOffset));
- DCHECK(String::kHashShift >= kSmiTagSize);
- __ IndexFromHash(result, result);
-}
-
-
-void LCodeGen::DoHasCachedArrayIndexAndBranch(
- LHasCachedArrayIndexAndBranch* instr) {
- Register input = ToRegister(instr->value());
-
- __ testl(FieldOperand(input, String::kHashFieldOffset),
- Immediate(String::kContainsCachedArrayIndexMask));
- EmitBranch(instr, equal);
-}
-
-
-// Branches to a label or falls through with the answer in the z flag.
-// Trashes the temp register.
-void LCodeGen::EmitClassOfTest(Label* is_true,
- Label* is_false,
- Handle<String> class_name,
- Register input,
- Register temp,
- Register temp2) {
- DCHECK(!input.is(temp));
- DCHECK(!input.is(temp2));
- DCHECK(!temp.is(temp2));
-
- __ JumpIfSmi(input, is_false);
-
- if (String::Equals(isolate()->factory()->Function_string(), class_name)) {
- // Assuming the following assertions, we can use the same compares to test
- // for both being a function type and being in the object type range.
- STATIC_ASSERT(NUM_OF_CALLABLE_SPEC_OBJECT_TYPES == 2);
- STATIC_ASSERT(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE ==
- FIRST_SPEC_OBJECT_TYPE + 1);
- STATIC_ASSERT(LAST_NONCALLABLE_SPEC_OBJECT_TYPE ==
- LAST_SPEC_OBJECT_TYPE - 1);
- STATIC_ASSERT(LAST_SPEC_OBJECT_TYPE == LAST_TYPE);
- __ CmpObjectType(input, FIRST_SPEC_OBJECT_TYPE, temp);
- __ j(below, is_false);
- __ j(equal, is_true);
- __ CmpInstanceType(temp, LAST_SPEC_OBJECT_TYPE);
- __ j(equal, is_true);
- } else {
- // Faster code path to avoid two compares: subtract lower bound from the
- // actual type and do a signed compare with the width of the type range.
- __ movp(temp, FieldOperand(input, HeapObject::kMapOffset));
- __ movzxbl(temp2, FieldOperand(temp, Map::kInstanceTypeOffset));
- __ subp(temp2, Immediate(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
- __ cmpp(temp2, Immediate(LAST_NONCALLABLE_SPEC_OBJECT_TYPE -
- FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
- __ j(above, is_false);
- }
-
- // Now we are in the FIRST-LAST_NONCALLABLE_SPEC_OBJECT_TYPE range.
- // Check if the constructor in the map is a function.
- __ GetMapConstructor(temp, temp, kScratchRegister);
-
- // Objects with a non-function constructor have class 'Object'.
- __ CmpInstanceType(kScratchRegister, JS_FUNCTION_TYPE);
- if (String::Equals(class_name, isolate()->factory()->Object_string())) {
- __ j(not_equal, is_true);
- } else {
- __ j(not_equal, is_false);
- }
-
- // temp now contains the constructor function. Grab the
- // instance class name from there.
- __ movp(temp, FieldOperand(temp, JSFunction::kSharedFunctionInfoOffset));
- __ movp(temp, FieldOperand(temp,
- SharedFunctionInfo::kInstanceClassNameOffset));
- // The class name we are testing against is internalized since it's a literal.
- // The name in the constructor is internalized because of the way the context
- // is booted. This routine isn't expected to work for random API-created
- // classes and it doesn't have to because you can't access it with natives
- // syntax. Since both sides are internalized it is sufficient to use an
- // identity comparison.
- DCHECK(class_name->IsInternalizedString());
- __ Cmp(temp, class_name);
- // End with the answer in the z flag.
-}
-
-
-void LCodeGen::DoClassOfTestAndBranch(LClassOfTestAndBranch* instr) {
- Register input = ToRegister(instr->value());
- Register temp = ToRegister(instr->temp());
- Register temp2 = ToRegister(instr->temp2());
- Handle<String> class_name = instr->hydrogen()->class_name();
-
- EmitClassOfTest(instr->TrueLabel(chunk_), instr->FalseLabel(chunk_),
- class_name, input, temp, temp2);
-
- EmitBranch(instr, equal);
-}
-
-
-void LCodeGen::DoCmpMapAndBranch(LCmpMapAndBranch* instr) {
- Register reg = ToRegister(instr->value());
-
- __ Cmp(FieldOperand(reg, HeapObject::kMapOffset), instr->map());
- EmitBranch(instr, equal);
-}
-
-
-void LCodeGen::DoInstanceOf(LInstanceOf* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->left()).is(InstanceOfDescriptor::LeftRegister()));
- DCHECK(ToRegister(instr->right()).is(InstanceOfDescriptor::RightRegister()));
- DCHECK(ToRegister(instr->result()).is(rax));
- InstanceOfStub stub(isolate());
- CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
-}
-
-
-void LCodeGen::DoHasInPrototypeChainAndBranch(
- LHasInPrototypeChainAndBranch* instr) {
- Register const object = ToRegister(instr->object());
- Register const object_map = kScratchRegister;
- Register const object_prototype = object_map;
- Register const prototype = ToRegister(instr->prototype());
-
- // The {object} must be a spec object. It's sufficient to know that {object}
- // is not a smi, since all other non-spec objects have {null} prototypes and
- // will be ruled out below.
- if (instr->hydrogen()->ObjectNeedsSmiCheck()) {
- Condition is_smi = __ CheckSmi(object);
- EmitFalseBranch(instr, is_smi);
- }
-
- // Loop through the {object}s prototype chain looking for the {prototype}.
- __ movp(object_map, FieldOperand(object, HeapObject::kMapOffset));
- Label loop;
- __ bind(&loop);
- __ movp(object_prototype, FieldOperand(object_map, Map::kPrototypeOffset));
- __ cmpp(object_prototype, prototype);
- EmitTrueBranch(instr, equal);
- __ CompareRoot(object_prototype, Heap::kNullValueRootIndex);
- EmitFalseBranch(instr, equal);
- __ movp(object_map, FieldOperand(object_prototype, HeapObject::kMapOffset));
- __ jmp(&loop);
-}
-
-
-void LCodeGen::DoCmpT(LCmpT* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- Token::Value op = instr->op();
-
- Handle<Code> ic =
- CodeFactory::CompareIC(isolate(), op, instr->strength()).code();
- CallCode(ic, RelocInfo::CODE_TARGET, instr);
-
- Condition condition = TokenToCondition(op, false);
- Label true_value, done;
- __ testp(rax, rax);
- __ j(condition, &true_value, Label::kNear);
- __ LoadRoot(ToRegister(instr->result()), Heap::kFalseValueRootIndex);
- __ jmp(&done, Label::kNear);
- __ bind(&true_value);
- __ LoadRoot(ToRegister(instr->result()), Heap::kTrueValueRootIndex);
- __ bind(&done);
-}
-
-
-void LCodeGen::DoReturn(LReturn* instr) {
- if (FLAG_trace && info()->IsOptimizing()) {
- // Preserve the return value on the stack and rely on the runtime call
- // to return the value in the same register. We're leaving the code
- // managed by the register allocator and tearing down the frame, it's
- // safe to write to the context register.
- __ Push(rax);
- __ movp(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
- __ CallRuntime(Runtime::kTraceExit, 1);
- }
- if (info()->saves_caller_doubles()) {
- RestoreCallerDoubles();
- }
- int no_frame_start = -1;
- if (NeedsEagerFrame()) {
- __ movp(rsp, rbp);
- __ popq(rbp);
- no_frame_start = masm_->pc_offset();
- }
- if (instr->has_constant_parameter_count()) {
- __ Ret((ToInteger32(instr->constant_parameter_count()) + 1) * kPointerSize,
- rcx);
- } else {
- DCHECK(info()->IsStub()); // Functions would need to drop one more value.
- Register reg = ToRegister(instr->parameter_count());
- // The argument count parameter is a smi
- __ SmiToInteger32(reg, reg);
- Register return_addr_reg = reg.is(rcx) ? rbx : rcx;
- __ PopReturnAddressTo(return_addr_reg);
- __ shlp(reg, Immediate(kPointerSizeLog2));
- __ addp(rsp, reg);
- __ jmp(return_addr_reg);
- }
- if (no_frame_start != -1) {
- info_->AddNoFrameRange(no_frame_start, masm_->pc_offset());
- }
-}
-
-
-template <class T>
-void LCodeGen::EmitVectorLoadICRegisters(T* instr) {
- Register vector_register = ToRegister(instr->temp_vector());
- Register slot_register = LoadWithVectorDescriptor::SlotRegister();
- DCHECK(vector_register.is(LoadWithVectorDescriptor::VectorRegister()));
- DCHECK(slot_register.is(rax));
-
- AllowDeferredHandleDereference vector_structure_check;
- Handle<TypeFeedbackVector> vector = instr->hydrogen()->feedback_vector();
- __ Move(vector_register, vector);
- // No need to allocate this register.
- FeedbackVectorICSlot slot = instr->hydrogen()->slot();
- int index = vector->GetIndex(slot);
- __ Move(slot_register, Smi::FromInt(index));
-}
-
-
-template <class T>
-void LCodeGen::EmitVectorStoreICRegisters(T* instr) {
- Register vector_register = ToRegister(instr->temp_vector());
- Register slot_register = ToRegister(instr->temp_slot());
-
- AllowDeferredHandleDereference vector_structure_check;
- Handle<TypeFeedbackVector> vector = instr->hydrogen()->feedback_vector();
- __ Move(vector_register, vector);
- FeedbackVectorICSlot slot = instr->hydrogen()->slot();
- int index = vector->GetIndex(slot);
- __ Move(slot_register, Smi::FromInt(index));
-}
-
-
-void LCodeGen::DoLoadGlobalGeneric(LLoadGlobalGeneric* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->global_object())
- .is(LoadDescriptor::ReceiverRegister()));
- DCHECK(ToRegister(instr->result()).is(rax));
-
- __ Move(LoadDescriptor::NameRegister(), instr->name());
- EmitVectorLoadICRegisters<LLoadGlobalGeneric>(instr);
- Handle<Code> ic =
- CodeFactory::LoadICInOptimizedCode(isolate(), instr->typeof_mode(),
- SLOPPY, PREMONOMORPHIC).code();
- CallCode(ic, RelocInfo::CODE_TARGET, instr);
-}
-
-
-void LCodeGen::DoLoadGlobalViaContext(LLoadGlobalViaContext* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->result()).is(rax));
- int const slot = instr->slot_index();
- int const depth = instr->depth();
- if (depth <= LoadGlobalViaContextStub::kMaximumDepth) {
- __ Set(LoadGlobalViaContextDescriptor::SlotRegister(), slot);
- Handle<Code> stub =
- CodeFactory::LoadGlobalViaContext(isolate(), depth).code();
- CallCode(stub, RelocInfo::CODE_TARGET, instr);
- } else {
- __ Push(Smi::FromInt(slot));
- __ CallRuntime(Runtime::kLoadGlobalViaContext, 1);
- }
-}
-
-
-void LCodeGen::DoLoadContextSlot(LLoadContextSlot* instr) {
- Register context = ToRegister(instr->context());
- Register result = ToRegister(instr->result());
- __ movp(result, ContextOperand(context, instr->slot_index()));
- if (instr->hydrogen()->RequiresHoleCheck()) {
- __ CompareRoot(result, Heap::kTheHoleValueRootIndex);
- if (instr->hydrogen()->DeoptimizesOnHole()) {
- DeoptimizeIf(equal, instr, Deoptimizer::kHole);
- } else {
- Label is_not_hole;
- __ j(not_equal, &is_not_hole, Label::kNear);
- __ LoadRoot(result, Heap::kUndefinedValueRootIndex);
- __ bind(&is_not_hole);
- }
- }
-}
-
-
-void LCodeGen::DoStoreContextSlot(LStoreContextSlot* instr) {
- Register context = ToRegister(instr->context());
- Register value = ToRegister(instr->value());
-
- Operand target = ContextOperand(context, instr->slot_index());
-
- Label skip_assignment;
- if (instr->hydrogen()->RequiresHoleCheck()) {
- __ CompareRoot(target, Heap::kTheHoleValueRootIndex);
- if (instr->hydrogen()->DeoptimizesOnHole()) {
- DeoptimizeIf(equal, instr, Deoptimizer::kHole);
- } else {
- __ j(not_equal, &skip_assignment);
- }
- }
- __ movp(target, value);
-
- if (instr->hydrogen()->NeedsWriteBarrier()) {
- SmiCheck check_needed =
- instr->hydrogen()->value()->type().IsHeapObject()
- ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
- int offset = Context::SlotOffset(instr->slot_index());
- Register scratch = ToRegister(instr->temp());
- __ RecordWriteContextSlot(context,
- offset,
- value,
- scratch,
- kSaveFPRegs,
- EMIT_REMEMBERED_SET,
- check_needed);
- }
-
- __ bind(&skip_assignment);
-}
-
-
-void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
- HObjectAccess access = instr->hydrogen()->access();
- int offset = access.offset();
-
- if (access.IsExternalMemory()) {
- Register result = ToRegister(instr->result());
- if (instr->object()->IsConstantOperand()) {
- DCHECK(result.is(rax));
- __ load_rax(ToExternalReference(LConstantOperand::cast(instr->object())));
- } else {
- Register object = ToRegister(instr->object());
- __ Load(result, MemOperand(object, offset), access.representation());
- }
- return;
- }
-
- Register object = ToRegister(instr->object());
- if (instr->hydrogen()->representation().IsDouble()) {
- DCHECK(access.IsInobject());
- XMMRegister result = ToDoubleRegister(instr->result());
- __ movsd(result, FieldOperand(object, offset));
- return;
- }
-
- Register result = ToRegister(instr->result());
- if (!access.IsInobject()) {
- __ movp(result, FieldOperand(object, JSObject::kPropertiesOffset));
- object = result;
- }
-
- Representation representation = access.representation();
- if (representation.IsSmi() && SmiValuesAre32Bits() &&
- instr->hydrogen()->representation().IsInteger32()) {
- if (FLAG_debug_code) {
- Register scratch = kScratchRegister;
- __ Load(scratch, FieldOperand(object, offset), representation);
- __ AssertSmi(scratch);
- }
-
- // Read int value directly from upper half of the smi.
- STATIC_ASSERT(kSmiTag == 0);
- DCHECK(kSmiTagSize + kSmiShiftSize == 32);
- offset += kPointerSize / 2;
- representation = Representation::Integer32();
- }
- __ Load(result, FieldOperand(object, offset), representation);
-}
-
-
-void LCodeGen::DoLoadNamedGeneric(LLoadNamedGeneric* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->object()).is(LoadDescriptor::ReceiverRegister()));
- DCHECK(ToRegister(instr->result()).is(rax));
-
- __ Move(LoadDescriptor::NameRegister(), instr->name());
- EmitVectorLoadICRegisters<LLoadNamedGeneric>(instr);
- Handle<Code> ic =
- CodeFactory::LoadICInOptimizedCode(
- isolate(), NOT_INSIDE_TYPEOF, instr->hydrogen()->language_mode(),
- instr->hydrogen()->initialization_state()).code();
- CallCode(ic, RelocInfo::CODE_TARGET, instr);
-}
-
-
-void LCodeGen::DoLoadFunctionPrototype(LLoadFunctionPrototype* instr) {
- Register function = ToRegister(instr->function());
- Register result = ToRegister(instr->result());
-
- // Get the prototype or initial map from the function.
- __ movp(result,
- FieldOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
-
- // Check that the function has a prototype or an initial map.
- __ CompareRoot(result, Heap::kTheHoleValueRootIndex);
- DeoptimizeIf(equal, instr, Deoptimizer::kHole);
-
- // If the function does not have an initial map, we're done.
- Label done;
- __ CmpObjectType(result, MAP_TYPE, kScratchRegister);
- __ j(not_equal, &done, Label::kNear);
-
- // Get the prototype from the initial map.
- __ movp(result, FieldOperand(result, Map::kPrototypeOffset));
-
- // All done.
- __ bind(&done);
-}
-
-
-void LCodeGen::DoLoadRoot(LLoadRoot* instr) {
- Register result = ToRegister(instr->result());
- __ LoadRoot(result, instr->index());
-}
-
-
-void LCodeGen::DoAccessArgumentsAt(LAccessArgumentsAt* instr) {
- Register arguments = ToRegister(instr->arguments());
- Register result = ToRegister(instr->result());
-
- if (instr->length()->IsConstantOperand() &&
- instr->index()->IsConstantOperand()) {
- int32_t const_index = ToInteger32(LConstantOperand::cast(instr->index()));
- int32_t const_length = ToInteger32(LConstantOperand::cast(instr->length()));
- if (const_index >= 0 && const_index < const_length) {
- StackArgumentsAccessor args(arguments, const_length,
- ARGUMENTS_DONT_CONTAIN_RECEIVER);
- __ movp(result, args.GetArgumentOperand(const_index));
- } else if (FLAG_debug_code) {
- __ int3();
- }
- } else {
- Register length = ToRegister(instr->length());
- // There are two words between the frame pointer and the last argument.
- // Subtracting from length accounts for one of them add one more.
- if (instr->index()->IsRegister()) {
- __ subl(length, ToRegister(instr->index()));
- } else {
- __ subl(length, ToOperand(instr->index()));
- }
- StackArgumentsAccessor args(arguments, length,
- ARGUMENTS_DONT_CONTAIN_RECEIVER);
- __ movp(result, args.GetArgumentOperand(0));
- }
-}
-
-
-void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
- ElementsKind elements_kind = instr->elements_kind();
- LOperand* key = instr->key();
- if (kPointerSize == kInt32Size && !key->IsConstantOperand()) {
- Register key_reg = ToRegister(key);
- Representation key_representation =
- instr->hydrogen()->key()->representation();
- if (ExternalArrayOpRequiresTemp(key_representation, elements_kind)) {
- __ SmiToInteger64(key_reg, key_reg);
- } else if (instr->hydrogen()->IsDehoisted()) {
- // Sign extend key because it could be a 32 bit negative value
- // and the dehoisted address computation happens in 64 bits
- __ movsxlq(key_reg, key_reg);
- }
- }
- Operand operand(BuildFastArrayOperand(
- instr->elements(),
- key,
- instr->hydrogen()->key()->representation(),
- elements_kind,
- instr->base_offset()));
-
- if (elements_kind == FLOAT32_ELEMENTS) {
- XMMRegister result(ToDoubleRegister(instr->result()));
- __ movss(result, operand);
- __ cvtss2sd(result, result);
- } else if (elements_kind == FLOAT64_ELEMENTS) {
- __ movsd(ToDoubleRegister(instr->result()), operand);
- } else {
- Register result(ToRegister(instr->result()));
- switch (elements_kind) {
- case INT8_ELEMENTS:
- __ movsxbl(result, operand);
- break;
- case UINT8_ELEMENTS:
- case UINT8_CLAMPED_ELEMENTS:
- __ movzxbl(result, operand);
- break;
- case INT16_ELEMENTS:
- __ movsxwl(result, operand);
- break;
- case UINT16_ELEMENTS:
- __ movzxwl(result, operand);
- break;
- case INT32_ELEMENTS:
- __ movl(result, operand);
- break;
- case UINT32_ELEMENTS:
- __ movl(result, operand);
- if (!instr->hydrogen()->CheckFlag(HInstruction::kUint32)) {
- __ testl(result, result);
- DeoptimizeIf(negative, instr, Deoptimizer::kNegativeValue);
- }
- break;
- case FLOAT32_ELEMENTS:
- case FLOAT64_ELEMENTS:
- case FAST_ELEMENTS:
- case FAST_SMI_ELEMENTS:
- case FAST_DOUBLE_ELEMENTS:
- case FAST_HOLEY_ELEMENTS:
- case FAST_HOLEY_SMI_ELEMENTS:
- case FAST_HOLEY_DOUBLE_ELEMENTS:
- case DICTIONARY_ELEMENTS:
- case FAST_SLOPPY_ARGUMENTS_ELEMENTS:
- case SLOW_SLOPPY_ARGUMENTS_ELEMENTS:
- UNREACHABLE();
- break;
- }
- }
-}
-
-
-void LCodeGen::DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr) {
- XMMRegister result(ToDoubleRegister(instr->result()));
- LOperand* key = instr->key();
- if (kPointerSize == kInt32Size && !key->IsConstantOperand() &&
- instr->hydrogen()->IsDehoisted()) {
- // Sign extend key because it could be a 32 bit negative value
- // and the dehoisted address computation happens in 64 bits
- __ movsxlq(ToRegister(key), ToRegister(key));
- }
- if (instr->hydrogen()->RequiresHoleCheck()) {
- Operand hole_check_operand = BuildFastArrayOperand(
- instr->elements(),
- key,
- instr->hydrogen()->key()->representation(),
- FAST_DOUBLE_ELEMENTS,
- instr->base_offset() + sizeof(kHoleNanLower32));
- __ cmpl(hole_check_operand, Immediate(kHoleNanUpper32));
- DeoptimizeIf(equal, instr, Deoptimizer::kHole);
- }
-
- Operand double_load_operand = BuildFastArrayOperand(
- instr->elements(),
- key,
- instr->hydrogen()->key()->representation(),
- FAST_DOUBLE_ELEMENTS,
- instr->base_offset());
- __ movsd(result, double_load_operand);
-}
-
-
-void LCodeGen::DoLoadKeyedFixedArray(LLoadKeyed* instr) {
- HLoadKeyed* hinstr = instr->hydrogen();
- Register result = ToRegister(instr->result());
- LOperand* key = instr->key();
- bool requires_hole_check = hinstr->RequiresHoleCheck();
- Representation representation = hinstr->representation();
- int offset = instr->base_offset();
-
- if (kPointerSize == kInt32Size && !key->IsConstantOperand() &&
- instr->hydrogen()->IsDehoisted()) {
- // Sign extend key because it could be a 32 bit negative value
- // and the dehoisted address computation happens in 64 bits
- __ movsxlq(ToRegister(key), ToRegister(key));
- }
- if (representation.IsInteger32() && SmiValuesAre32Bits() &&
- hinstr->elements_kind() == FAST_SMI_ELEMENTS) {
- DCHECK(!requires_hole_check);
- if (FLAG_debug_code) {
- Register scratch = kScratchRegister;
- __ Load(scratch,
- BuildFastArrayOperand(instr->elements(),
- key,
- instr->hydrogen()->key()->representation(),
- FAST_ELEMENTS,
- offset),
- Representation::Smi());
- __ AssertSmi(scratch);
- }
- // Read int value directly from upper half of the smi.
- STATIC_ASSERT(kSmiTag == 0);
- DCHECK(kSmiTagSize + kSmiShiftSize == 32);
- offset += kPointerSize / 2;
- }
-
- __ Load(result,
- BuildFastArrayOperand(instr->elements(), key,
- instr->hydrogen()->key()->representation(),
- FAST_ELEMENTS, offset),
- representation);
-
- // Check for the hole value.
- if (requires_hole_check) {
- if (IsFastSmiElementsKind(hinstr->elements_kind())) {
- Condition smi = __ CheckSmi(result);
- DeoptimizeIf(NegateCondition(smi), instr, Deoptimizer::kNotASmi);
- } else {
- __ CompareRoot(result, Heap::kTheHoleValueRootIndex);
- DeoptimizeIf(equal, instr, Deoptimizer::kHole);
- }
- } else if (hinstr->hole_mode() == CONVERT_HOLE_TO_UNDEFINED) {
- DCHECK(hinstr->elements_kind() == FAST_HOLEY_ELEMENTS);
- Label done;
- __ CompareRoot(result, Heap::kTheHoleValueRootIndex);
- __ j(not_equal, &done);
- if (info()->IsStub()) {
- // A stub can safely convert the hole to undefined only if the array
- // protector cell contains (Smi) Isolate::kArrayProtectorValid. Otherwise
- // it needs to bail out.
- __ LoadRoot(result, Heap::kArrayProtectorRootIndex);
- __ Cmp(FieldOperand(result, Cell::kValueOffset),
- Smi::FromInt(Isolate::kArrayProtectorValid));
- DeoptimizeIf(not_equal, instr, Deoptimizer::kHole);
- }
- __ Move(result, isolate()->factory()->undefined_value());
- __ bind(&done);
- }
-}
-
-
-void LCodeGen::DoLoadKeyed(LLoadKeyed* instr) {
- if (instr->is_fixed_typed_array()) {
- DoLoadKeyedExternalArray(instr);
- } else if (instr->hydrogen()->representation().IsDouble()) {
- DoLoadKeyedFixedDoubleArray(instr);
- } else {
- DoLoadKeyedFixedArray(instr);
- }
-}
-
-
-Operand LCodeGen::BuildFastArrayOperand(
- LOperand* elements_pointer,
- LOperand* key,
- Representation key_representation,
- ElementsKind elements_kind,
- uint32_t offset) {
- Register elements_pointer_reg = ToRegister(elements_pointer);
- int shift_size = ElementsKindToShiftSize(elements_kind);
- if (key->IsConstantOperand()) {
- int32_t constant_value = ToInteger32(LConstantOperand::cast(key));
- if (constant_value & 0xF0000000) {
- Abort(kArrayIndexConstantValueTooBig);
- }
- return Operand(elements_pointer_reg,
- (constant_value << shift_size) + offset);
- } else {
- // Guaranteed by ArrayInstructionInterface::KeyedAccessIndexRequirement().
- DCHECK(key_representation.IsInteger32());
-
- ScaleFactor scale_factor = static_cast<ScaleFactor>(shift_size);
- return Operand(elements_pointer_reg,
- ToRegister(key),
- scale_factor,
- offset);
- }
-}
-
-
-void LCodeGen::DoLoadKeyedGeneric(LLoadKeyedGeneric* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->object()).is(LoadDescriptor::ReceiverRegister()));
- DCHECK(ToRegister(instr->key()).is(LoadDescriptor::NameRegister()));
-
- if (instr->hydrogen()->HasVectorAndSlot()) {
- EmitVectorLoadICRegisters<LLoadKeyedGeneric>(instr);
- }
-
- Handle<Code> ic = CodeFactory::KeyedLoadICInOptimizedCode(
- isolate(), instr->hydrogen()->language_mode(),
- instr->hydrogen()->initialization_state()).code();
- CallCode(ic, RelocInfo::CODE_TARGET, instr);
-}
-
-
-void LCodeGen::DoArgumentsElements(LArgumentsElements* instr) {
- Register result = ToRegister(instr->result());
-
- if (instr->hydrogen()->from_inlined()) {
- __ leap(result, Operand(rsp, -kFPOnStackSize + -kPCOnStackSize));
- } else {
- // Check for arguments adapter frame.
- Label done, adapted;
- __ movp(result, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
- __ Cmp(Operand(result, StandardFrameConstants::kContextOffset),
- Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
- __ j(equal, &adapted, Label::kNear);
-
- // No arguments adaptor frame.
- __ movp(result, rbp);
- __ jmp(&done, Label::kNear);
-
- // Arguments adaptor frame present.
- __ bind(&adapted);
- __ movp(result, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
-
- // Result is the frame pointer for the frame if not adapted and for the real
- // frame below the adaptor frame if adapted.
- __ bind(&done);
- }
-}
-
-
-void LCodeGen::DoArgumentsLength(LArgumentsLength* instr) {
- Register result = ToRegister(instr->result());
-
- Label done;
-
- // If no arguments adaptor frame the number of arguments is fixed.
- if (instr->elements()->IsRegister()) {
- __ cmpp(rbp, ToRegister(instr->elements()));
- } else {
- __ cmpp(rbp, ToOperand(instr->elements()));
- }
- __ movl(result, Immediate(scope()->num_parameters()));
- __ j(equal, &done, Label::kNear);
-
- // Arguments adaptor frame present. Get argument length from there.
- __ movp(result, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
- __ SmiToInteger32(result,
- Operand(result,
- ArgumentsAdaptorFrameConstants::kLengthOffset));
-
- // Argument length is in result register.
- __ bind(&done);
-}
-
-
-void LCodeGen::DoWrapReceiver(LWrapReceiver* instr) {
- Register receiver = ToRegister(instr->receiver());
- Register function = ToRegister(instr->function());
-
- // If the receiver is null or undefined, we have to pass the global
- // object as a receiver to normal functions. Values have to be
- // passed unchanged to builtins and strict-mode functions.
- Label global_object, receiver_ok;
- Label::Distance dist = DeoptEveryNTimes() ? Label::kFar : Label::kNear;
-
- if (!instr->hydrogen()->known_function()) {
- // Do not transform the receiver to object for strict mode
- // functions.
- __ movp(kScratchRegister,
- FieldOperand(function, JSFunction::kSharedFunctionInfoOffset));
- __ testb(FieldOperand(kScratchRegister,
- SharedFunctionInfo::kStrictModeByteOffset),
- Immediate(1 << SharedFunctionInfo::kStrictModeBitWithinByte));
- __ j(not_equal, &receiver_ok, dist);
-
- // Do not transform the receiver to object for builtins.
- __ testb(FieldOperand(kScratchRegister,
- SharedFunctionInfo::kNativeByteOffset),
- Immediate(1 << SharedFunctionInfo::kNativeBitWithinByte));
- __ j(not_equal, &receiver_ok, dist);
- }
-
- // Normal function. Replace undefined or null with global receiver.
- __ CompareRoot(receiver, Heap::kNullValueRootIndex);
- __ j(equal, &global_object, Label::kNear);
- __ CompareRoot(receiver, Heap::kUndefinedValueRootIndex);
- __ j(equal, &global_object, Label::kNear);
-
- // The receiver should be a JS object.
- Condition is_smi = __ CheckSmi(receiver);
- DeoptimizeIf(is_smi, instr, Deoptimizer::kSmi);
- __ CmpObjectType(receiver, FIRST_SPEC_OBJECT_TYPE, kScratchRegister);
- DeoptimizeIf(below, instr, Deoptimizer::kNotAJavaScriptObject);
-
- __ jmp(&receiver_ok, Label::kNear);
- __ bind(&global_object);
- __ movp(receiver, FieldOperand(function, JSFunction::kContextOffset));
- __ movp(receiver,
- Operand(receiver,
- Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
- __ movp(receiver, FieldOperand(receiver, GlobalObject::kGlobalProxyOffset));
-
- __ bind(&receiver_ok);
-}
-
-
-void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
- Register receiver = ToRegister(instr->receiver());
- Register function = ToRegister(instr->function());
- Register length = ToRegister(instr->length());
- Register elements = ToRegister(instr->elements());
- DCHECK(receiver.is(rax)); // Used for parameter count.
- DCHECK(function.is(rdi)); // Required by InvokeFunction.
- DCHECK(ToRegister(instr->result()).is(rax));
-
- // Copy the arguments to this function possibly from the
- // adaptor frame below it.
- const uint32_t kArgumentsLimit = 1 * KB;
- __ cmpp(length, Immediate(kArgumentsLimit));
- DeoptimizeIf(above, instr, Deoptimizer::kTooManyArguments);
-
- __ Push(receiver);
- __ movp(receiver, length);
-
- // Loop through the arguments pushing them onto the execution
- // stack.
- Label invoke, loop;
- // length is a small non-negative integer, due to the test above.
- __ testl(length, length);
- __ j(zero, &invoke, Label::kNear);
- __ bind(&loop);
- StackArgumentsAccessor args(elements, length,
- ARGUMENTS_DONT_CONTAIN_RECEIVER);
- __ Push(args.GetArgumentOperand(0));
- __ decl(length);
- __ j(not_zero, &loop);
-
- // Invoke the function.
- __ bind(&invoke);
- DCHECK(instr->HasPointerMap());
- LPointerMap* pointers = instr->pointer_map();
- SafepointGenerator safepoint_generator(
- this, pointers, Safepoint::kLazyDeopt);
- ParameterCount actual(rax);
- __ InvokeFunction(function, actual, CALL_FUNCTION, safepoint_generator);
-}
-
-
-void LCodeGen::DoPushArgument(LPushArgument* instr) {
- LOperand* argument = instr->value();
- EmitPushTaggedOperand(argument);
-}
-
-
-void LCodeGen::DoDrop(LDrop* instr) {
- __ Drop(instr->count());
-}
-
-
-void LCodeGen::DoThisFunction(LThisFunction* instr) {
- Register result = ToRegister(instr->result());
- __ movp(result, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
-}
-
-
-void LCodeGen::DoContext(LContext* instr) {
- Register result = ToRegister(instr->result());
- if (info()->IsOptimizing()) {
- __ movp(result, Operand(rbp, StandardFrameConstants::kContextOffset));
- } else {
- // If there is no frame, the context must be in rsi.
- DCHECK(result.is(rsi));
- }
-}
-
-
-void LCodeGen::DoDeclareGlobals(LDeclareGlobals* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- __ Push(instr->hydrogen()->pairs());
- __ Push(Smi::FromInt(instr->hydrogen()->flags()));
- CallRuntime(Runtime::kDeclareGlobals, 2, instr);
-}
-
-
-void LCodeGen::CallKnownFunction(Handle<JSFunction> function,
- int formal_parameter_count, int arity,
- LInstruction* instr) {
- bool dont_adapt_arguments =
- formal_parameter_count == SharedFunctionInfo::kDontAdaptArgumentsSentinel;
- bool can_invoke_directly =
- dont_adapt_arguments || formal_parameter_count == arity;
-
- Register function_reg = rdi;
- LPointerMap* pointers = instr->pointer_map();
-
- if (can_invoke_directly) {
- // Change context.
- __ movp(rsi, FieldOperand(function_reg, JSFunction::kContextOffset));
-
- // Always initialize rax to the number of actual arguments.
- __ Set(rax, arity);
-
- // Invoke function.
- if (function.is_identical_to(info()->closure())) {
- __ CallSelf();
- } else {
- __ Call(FieldOperand(function_reg, JSFunction::kCodeEntryOffset));
- }
-
- // Set up deoptimization.
- RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT, 0);
- } else {
- // We need to adapt arguments.
- SafepointGenerator generator(
- this, pointers, Safepoint::kLazyDeopt);
- ParameterCount count(arity);
- ParameterCount expected(formal_parameter_count);
- __ InvokeFunction(function_reg, expected, count, CALL_FUNCTION, generator);
- }
-}
-
-
-void LCodeGen::DoCallWithDescriptor(LCallWithDescriptor* instr) {
- DCHECK(ToRegister(instr->result()).is(rax));
-
- if (instr->hydrogen()->IsTailCall()) {
- if (NeedsEagerFrame()) __ leave();
-
- if (instr->target()->IsConstantOperand()) {
- LConstantOperand* target = LConstantOperand::cast(instr->target());
- Handle<Code> code = Handle<Code>::cast(ToHandle(target));
- __ jmp(code, RelocInfo::CODE_TARGET);
- } else {
- DCHECK(instr->target()->IsRegister());
- Register target = ToRegister(instr->target());
- __ addp(target, Immediate(Code::kHeaderSize - kHeapObjectTag));
- __ jmp(target);
- }
- } else {
- LPointerMap* pointers = instr->pointer_map();
- SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
-
- if (instr->target()->IsConstantOperand()) {
- LConstantOperand* target = LConstantOperand::cast(instr->target());
- Handle<Code> code = Handle<Code>::cast(ToHandle(target));
- generator.BeforeCall(__ CallSize(code));
- __ call(code, RelocInfo::CODE_TARGET);
- } else {
- DCHECK(instr->target()->IsRegister());
- Register target = ToRegister(instr->target());
- generator.BeforeCall(__ CallSize(target));
- __ addp(target, Immediate(Code::kHeaderSize - kHeapObjectTag));
- __ call(target);
- }
- generator.AfterCall();
- }
-}
-
-
-void LCodeGen::DoCallJSFunction(LCallJSFunction* instr) {
- DCHECK(ToRegister(instr->function()).is(rdi));
- DCHECK(ToRegister(instr->result()).is(rax));
-
- __ Set(rax, instr->arity());
-
- // Change context.
- __ movp(rsi, FieldOperand(rdi, JSFunction::kContextOffset));
-
- LPointerMap* pointers = instr->pointer_map();
- SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
-
- bool is_self_call = false;
- if (instr->hydrogen()->function()->IsConstant()) {
- Handle<JSFunction> jsfun = Handle<JSFunction>::null();
- HConstant* fun_const = HConstant::cast(instr->hydrogen()->function());
- jsfun = Handle<JSFunction>::cast(fun_const->handle(isolate()));
- is_self_call = jsfun.is_identical_to(info()->closure());
- }
-
- if (is_self_call) {
- __ CallSelf();
- } else {
- Operand target = FieldOperand(rdi, JSFunction::kCodeEntryOffset);
- generator.BeforeCall(__ CallSize(target));
- __ Call(target);
- }
- generator.AfterCall();
-}
-
-
-void LCodeGen::DoDeferredMathAbsTaggedHeapNumber(LMathAbs* instr) {
- Register input_reg = ToRegister(instr->value());
- __ CompareRoot(FieldOperand(input_reg, HeapObject::kMapOffset),
- Heap::kHeapNumberMapRootIndex);
- DeoptimizeIf(not_equal, instr, Deoptimizer::kNotAHeapNumber);
-
- Label slow, allocated, done;
- Register tmp = input_reg.is(rax) ? rcx : rax;
- Register tmp2 = tmp.is(rcx) ? rdx : input_reg.is(rcx) ? rdx : rcx;
-
- // Preserve the value of all registers.
- PushSafepointRegistersScope scope(this);
-
- __ movl(tmp, FieldOperand(input_reg, HeapNumber::kExponentOffset));
- // Check the sign of the argument. If the argument is positive, just
- // return it. We do not need to patch the stack since |input| and
- // |result| are the same register and |input| will be restored
- // unchanged by popping safepoint registers.
- __ testl(tmp, Immediate(HeapNumber::kSignMask));
- __ j(zero, &done);
-
- __ AllocateHeapNumber(tmp, tmp2, &slow);
- __ jmp(&allocated, Label::kNear);
-
- // Slow case: Call the runtime system to do the number allocation.
- __ bind(&slow);
- CallRuntimeFromDeferred(
- Runtime::kAllocateHeapNumber, 0, instr, instr->context());
- // Set the pointer to the new heap number in tmp.
- if (!tmp.is(rax)) __ movp(tmp, rax);
- // Restore input_reg after call to runtime.
- __ LoadFromSafepointRegisterSlot(input_reg, input_reg);
-
- __ bind(&allocated);
- __ movq(tmp2, FieldOperand(input_reg, HeapNumber::kValueOffset));
- __ shlq(tmp2, Immediate(1));
- __ shrq(tmp2, Immediate(1));
- __ movq(FieldOperand(tmp, HeapNumber::kValueOffset), tmp2);
- __ StoreToSafepointRegisterSlot(input_reg, tmp);
-
- __ bind(&done);
-}
-
-
-void LCodeGen::EmitIntegerMathAbs(LMathAbs* instr) {
- Register input_reg = ToRegister(instr->value());
- __ testl(input_reg, input_reg);
- Label is_positive;
- __ j(not_sign, &is_positive, Label::kNear);
- __ negl(input_reg); // Sets flags.
- DeoptimizeIf(negative, instr, Deoptimizer::kOverflow);
- __ bind(&is_positive);
-}
-
-
-void LCodeGen::EmitSmiMathAbs(LMathAbs* instr) {
- Register input_reg = ToRegister(instr->value());
- __ testp(input_reg, input_reg);
- Label is_positive;
- __ j(not_sign, &is_positive, Label::kNear);
- __ negp(input_reg); // Sets flags.
- DeoptimizeIf(negative, instr, Deoptimizer::kOverflow);
- __ bind(&is_positive);
-}
-
-
-void LCodeGen::DoMathAbs(LMathAbs* instr) {
- // Class for deferred case.
- class DeferredMathAbsTaggedHeapNumber final : public LDeferredCode {
- public:
- DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen, LMathAbs* instr)
- : LDeferredCode(codegen), instr_(instr) { }
- void Generate() override {
- codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_);
- }
- LInstruction* instr() override { return instr_; }
-
- private:
- LMathAbs* instr_;
- };
-
- DCHECK(instr->value()->Equals(instr->result()));
- Representation r = instr->hydrogen()->value()->representation();
-
- if (r.IsDouble()) {
- XMMRegister scratch = double_scratch0();
- XMMRegister input_reg = ToDoubleRegister(instr->value());
- __ xorps(scratch, scratch);
- __ subsd(scratch, input_reg);
- __ andps(input_reg, scratch);
- } else if (r.IsInteger32()) {
- EmitIntegerMathAbs(instr);
- } else if (r.IsSmi()) {
- EmitSmiMathAbs(instr);
- } else { // Tagged case.
- DeferredMathAbsTaggedHeapNumber* deferred =
- new(zone()) DeferredMathAbsTaggedHeapNumber(this, instr);
- Register input_reg = ToRegister(instr->value());
- // Smi check.
- __ JumpIfNotSmi(input_reg, deferred->entry());
- EmitSmiMathAbs(instr);
- __ bind(deferred->exit());
- }
-}
-
-
-void LCodeGen::DoMathFloor(LMathFloor* instr) {
- XMMRegister xmm_scratch = double_scratch0();
- Register output_reg = ToRegister(instr->result());
- XMMRegister input_reg = ToDoubleRegister(instr->value());
-
- if (CpuFeatures::IsSupported(SSE4_1)) {
- CpuFeatureScope scope(masm(), SSE4_1);
- if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
- // Deoptimize if minus zero.
- __ movq(output_reg, input_reg);
- __ subq(output_reg, Immediate(1));
- DeoptimizeIf(overflow, instr, Deoptimizer::kMinusZero);
- }
- __ roundsd(xmm_scratch, input_reg, kRoundDown);
- __ cvttsd2si(output_reg, xmm_scratch);
- __ cmpl(output_reg, Immediate(0x1));
- DeoptimizeIf(overflow, instr, Deoptimizer::kOverflow);
- } else {
- Label negative_sign, done;
- // Deoptimize on unordered.
- __ xorps(xmm_scratch, xmm_scratch); // Zero the register.
- __ ucomisd(input_reg, xmm_scratch);
- DeoptimizeIf(parity_even, instr, Deoptimizer::kNaN);
- __ j(below, &negative_sign, Label::kNear);
-
- if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
- // Check for negative zero.
- Label positive_sign;
- __ j(above, &positive_sign, Label::kNear);
- __ movmskpd(output_reg, input_reg);
- __ testq(output_reg, Immediate(1));
- DeoptimizeIf(not_zero, instr, Deoptimizer::kMinusZero);
- __ Set(output_reg, 0);
- __ jmp(&done);
- __ bind(&positive_sign);
- }
-
- // Use truncating instruction (OK because input is positive).
- __ cvttsd2si(output_reg, input_reg);
- // Overflow is signalled with minint.
- __ cmpl(output_reg, Immediate(0x1));
- DeoptimizeIf(overflow, instr, Deoptimizer::kOverflow);
- __ jmp(&done, Label::kNear);
-
- // Non-zero negative reaches here.
- __ bind(&negative_sign);
- // Truncate, then compare and compensate.
- __ cvttsd2si(output_reg, input_reg);
- __ Cvtlsi2sd(xmm_scratch, output_reg);
- __ ucomisd(input_reg, xmm_scratch);
- __ j(equal, &done, Label::kNear);
- __ subl(output_reg, Immediate(1));
- DeoptimizeIf(overflow, instr, Deoptimizer::kOverflow);
-
- __ bind(&done);
- }
-}
-
-
-void LCodeGen::DoMathRound(LMathRound* instr) {
- const XMMRegister xmm_scratch = double_scratch0();
- Register output_reg = ToRegister(instr->result());
- XMMRegister input_reg = ToDoubleRegister(instr->value());
- XMMRegister input_temp = ToDoubleRegister(instr->temp());
- static int64_t one_half = V8_INT64_C(0x3FE0000000000000); // 0.5
- static int64_t minus_one_half = V8_INT64_C(0xBFE0000000000000); // -0.5
-
- Label done, round_to_zero, below_one_half;
- Label::Distance dist = DeoptEveryNTimes() ? Label::kFar : Label::kNear;
- __ movq(kScratchRegister, one_half);
- __ movq(xmm_scratch, kScratchRegister);
- __ ucomisd(xmm_scratch, input_reg);
- __ j(above, &below_one_half, Label::kNear);
-
- // CVTTSD2SI rounds towards zero, since 0.5 <= x, we use floor(0.5 + x).
- __ addsd(xmm_scratch, input_reg);
- __ cvttsd2si(output_reg, xmm_scratch);
- // Overflow is signalled with minint.
- __ cmpl(output_reg, Immediate(0x1));
- DeoptimizeIf(overflow, instr, Deoptimizer::kOverflow);
- __ jmp(&done, dist);
-
- __ bind(&below_one_half);
- __ movq(kScratchRegister, minus_one_half);
- __ movq(xmm_scratch, kScratchRegister);
- __ ucomisd(xmm_scratch, input_reg);
- __ j(below_equal, &round_to_zero, Label::kNear);
-
- // CVTTSD2SI rounds towards zero, we use ceil(x - (-0.5)) and then
- // compare and compensate.
- __ movq(input_temp, input_reg); // Do not alter input_reg.
- __ subsd(input_temp, xmm_scratch);
- __ cvttsd2si(output_reg, input_temp);
- // Catch minint due to overflow, and to prevent overflow when compensating.
- __ cmpl(output_reg, Immediate(0x1));
- DeoptimizeIf(overflow, instr, Deoptimizer::kOverflow);
-
- __ Cvtlsi2sd(xmm_scratch, output_reg);
- __ ucomisd(xmm_scratch, input_temp);
- __ j(equal, &done, dist);
- __ subl(output_reg, Immediate(1));
- // No overflow because we already ruled out minint.
- __ jmp(&done, dist);
-
- __ bind(&round_to_zero);
- // We return 0 for the input range [+0, 0.5[, or [-0.5, 0.5[ if
- // we can ignore the difference between a result of -0 and +0.
- if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
- __ movq(output_reg, input_reg);
- __ testq(output_reg, output_reg);
- DeoptimizeIf(negative, instr, Deoptimizer::kMinusZero);
- }
- __ Set(output_reg, 0);
- __ bind(&done);
-}
-
-
-void LCodeGen::DoMathFround(LMathFround* instr) {
- XMMRegister input_reg = ToDoubleRegister(instr->value());
- XMMRegister output_reg = ToDoubleRegister(instr->result());
- __ cvtsd2ss(output_reg, input_reg);
- __ cvtss2sd(output_reg, output_reg);
-}
-
-
-void LCodeGen::DoMathSqrt(LMathSqrt* instr) {
- XMMRegister output = ToDoubleRegister(instr->result());
- if (instr->value()->IsDoubleRegister()) {
- XMMRegister input = ToDoubleRegister(instr->value());
- __ sqrtsd(output, input);
- } else {
- Operand input = ToOperand(instr->value());
- __ sqrtsd(output, input);
- }
-}
-
-
-void LCodeGen::DoMathPowHalf(LMathPowHalf* instr) {
- XMMRegister xmm_scratch = double_scratch0();
- XMMRegister input_reg = ToDoubleRegister(instr->value());
- DCHECK(ToDoubleRegister(instr->result()).is(input_reg));
-
- // Note that according to ECMA-262 15.8.2.13:
- // Math.pow(-Infinity, 0.5) == Infinity
- // Math.sqrt(-Infinity) == NaN
- Label done, sqrt;
- // Check base for -Infinity. According to IEEE-754, double-precision
- // -Infinity has the highest 12 bits set and the lowest 52 bits cleared.
- __ movq(kScratchRegister, V8_INT64_C(0xFFF0000000000000));
- __ movq(xmm_scratch, kScratchRegister);
- __ ucomisd(xmm_scratch, input_reg);
- // Comparing -Infinity with NaN results in "unordered", which sets the
- // zero flag as if both were equal. However, it also sets the carry flag.
- __ j(not_equal, &sqrt, Label::kNear);
- __ j(carry, &sqrt, Label::kNear);
- // If input is -Infinity, return Infinity.
- __ xorps(input_reg, input_reg);
- __ subsd(input_reg, xmm_scratch);
- __ jmp(&done, Label::kNear);
-
- // Square root.
- __ bind(&sqrt);
- __ xorps(xmm_scratch, xmm_scratch);
- __ addsd(input_reg, xmm_scratch); // Convert -0 to +0.
- __ sqrtsd(input_reg, input_reg);
- __ bind(&done);
-}
-
-
-void LCodeGen::DoPower(LPower* instr) {
- Representation exponent_type = instr->hydrogen()->right()->representation();
- // Having marked this as a call, we can use any registers.
- // Just make sure that the input/output registers are the expected ones.
-
- Register tagged_exponent = MathPowTaggedDescriptor::exponent();
- DCHECK(!instr->right()->IsRegister() ||
- ToRegister(instr->right()).is(tagged_exponent));
- DCHECK(!instr->right()->IsDoubleRegister() ||
- ToDoubleRegister(instr->right()).is(xmm1));
- DCHECK(ToDoubleRegister(instr->left()).is(xmm2));
- DCHECK(ToDoubleRegister(instr->result()).is(xmm3));
-
- if (exponent_type.IsSmi()) {
- MathPowStub stub(isolate(), MathPowStub::TAGGED);
- __ CallStub(&stub);
- } else if (exponent_type.IsTagged()) {
- Label no_deopt;
- __ JumpIfSmi(tagged_exponent, &no_deopt, Label::kNear);
- __ CmpObjectType(tagged_exponent, HEAP_NUMBER_TYPE, rcx);
- DeoptimizeIf(not_equal, instr, Deoptimizer::kNotAHeapNumber);
- __ bind(&no_deopt);
- MathPowStub stub(isolate(), MathPowStub::TAGGED);
- __ CallStub(&stub);
- } else if (exponent_type.IsInteger32()) {
- MathPowStub stub(isolate(), MathPowStub::INTEGER);
- __ CallStub(&stub);
- } else {
- DCHECK(exponent_type.IsDouble());
- MathPowStub stub(isolate(), MathPowStub::DOUBLE);
- __ CallStub(&stub);
- }
-}
-
-
-void LCodeGen::DoMathExp(LMathExp* instr) {
- XMMRegister input = ToDoubleRegister(instr->value());
- XMMRegister result = ToDoubleRegister(instr->result());
- XMMRegister temp0 = double_scratch0();
- Register temp1 = ToRegister(instr->temp1());
- Register temp2 = ToRegister(instr->temp2());
-
- MathExpGenerator::EmitMathExp(masm(), input, result, temp0, temp1, temp2);
-}
-
-
-void LCodeGen::DoMathLog(LMathLog* instr) {
- DCHECK(instr->value()->Equals(instr->result()));
- XMMRegister input_reg = ToDoubleRegister(instr->value());
- XMMRegister xmm_scratch = double_scratch0();
- Label positive, done, zero;
- __ xorps(xmm_scratch, xmm_scratch);
- __ ucomisd(input_reg, xmm_scratch);
- __ j(above, &positive, Label::kNear);
- __ j(not_carry, &zero, Label::kNear);
- __ pcmpeqd(input_reg, input_reg);
- __ jmp(&done, Label::kNear);
- __ bind(&zero);
- ExternalReference ninf =
- ExternalReference::address_of_negative_infinity();
- Operand ninf_operand = masm()->ExternalOperand(ninf);
- __ movsd(input_reg, ninf_operand);
- __ jmp(&done, Label::kNear);
- __ bind(&positive);
- __ fldln2();
- __ subp(rsp, Immediate(kDoubleSize));
- __ movsd(Operand(rsp, 0), input_reg);
- __ fld_d(Operand(rsp, 0));
- __ fyl2x();
- __ fstp_d(Operand(rsp, 0));
- __ movsd(input_reg, Operand(rsp, 0));
- __ addp(rsp, Immediate(kDoubleSize));
- __ bind(&done);
-}
-
-
-void LCodeGen::DoMathClz32(LMathClz32* instr) {
- Register input = ToRegister(instr->value());
- Register result = ToRegister(instr->result());
-
- __ Lzcntl(result, input);
-}
-
-
-void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->function()).is(rdi));
- DCHECK(instr->HasPointerMap());
-
- Handle<JSFunction> known_function = instr->hydrogen()->known_function();
- if (known_function.is_null()) {
- LPointerMap* pointers = instr->pointer_map();
- SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
- ParameterCount count(instr->arity());
- __ InvokeFunction(rdi, count, CALL_FUNCTION, generator);
- } else {
- CallKnownFunction(known_function,
- instr->hydrogen()->formal_parameter_count(),
- instr->arity(), instr);
- }
-}
-
-
-void LCodeGen::DoCallFunction(LCallFunction* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->function()).is(rdi));
- DCHECK(ToRegister(instr->result()).is(rax));
-
- int arity = instr->arity();
- CallFunctionFlags flags = instr->hydrogen()->function_flags();
- if (instr->hydrogen()->HasVectorAndSlot()) {
- Register slot_register = ToRegister(instr->temp_slot());
- Register vector_register = ToRegister(instr->temp_vector());
- DCHECK(slot_register.is(rdx));
- DCHECK(vector_register.is(rbx));
-
- AllowDeferredHandleDereference vector_structure_check;
- Handle<TypeFeedbackVector> vector = instr->hydrogen()->feedback_vector();
- int index = vector->GetIndex(instr->hydrogen()->slot());
-
- __ Move(vector_register, vector);
- __ Move(slot_register, Smi::FromInt(index));
-
- CallICState::CallType call_type =
- (flags & CALL_AS_METHOD) ? CallICState::METHOD : CallICState::FUNCTION;
-
- Handle<Code> ic =
- CodeFactory::CallICInOptimizedCode(isolate(), arity, call_type).code();
- CallCode(ic, RelocInfo::CODE_TARGET, instr);
- } else {
- CallFunctionStub stub(isolate(), arity, flags);
- CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
- }
-}
-
-
-void LCodeGen::DoCallNew(LCallNew* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->constructor()).is(rdi));
- DCHECK(ToRegister(instr->result()).is(rax));
-
- __ Set(rax, instr->arity());
- // No cell in ebx for construct type feedback in optimized code
- __ LoadRoot(rbx, Heap::kUndefinedValueRootIndex);
- CallConstructStub stub(isolate(), NO_CALL_CONSTRUCTOR_FLAGS);
- CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
-}
-
-
-void LCodeGen::DoCallNewArray(LCallNewArray* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->constructor()).is(rdi));
- DCHECK(ToRegister(instr->result()).is(rax));
-
- __ Set(rax, instr->arity());
- if (instr->arity() == 1) {
- // We only need the allocation site for the case we have a length argument.
- // The case may bail out to the runtime, which will determine the correct
- // elements kind with the site.
- __ Move(rbx, instr->hydrogen()->site());
- } else {
- __ LoadRoot(rbx, Heap::kUndefinedValueRootIndex);
- }
-
- ElementsKind kind = instr->hydrogen()->elements_kind();
- AllocationSiteOverrideMode override_mode =
- (AllocationSite::GetMode(kind) == TRACK_ALLOCATION_SITE)
- ? DISABLE_ALLOCATION_SITES
- : DONT_OVERRIDE;
-
- if (instr->arity() == 0) {
- ArrayNoArgumentConstructorStub stub(isolate(), kind, override_mode);
- CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
- } else if (instr->arity() == 1) {
- Label done;
- if (IsFastPackedElementsKind(kind)) {
- Label packed_case;
- // We might need a change here
- // look at the first argument
- __ movp(rcx, Operand(rsp, 0));
- __ testp(rcx, rcx);
- __ j(zero, &packed_case, Label::kNear);
-
- ElementsKind holey_kind = GetHoleyElementsKind(kind);
- ArraySingleArgumentConstructorStub stub(isolate(),
- holey_kind,
- override_mode);
- CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
- __ jmp(&done, Label::kNear);
- __ bind(&packed_case);
- }
-
- ArraySingleArgumentConstructorStub stub(isolate(), kind, override_mode);
- CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
- __ bind(&done);
- } else {
- ArrayNArgumentsConstructorStub stub(isolate(), kind, override_mode);
- CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
- }
-}
-
-
-void LCodeGen::DoCallRuntime(LCallRuntime* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- CallRuntime(instr->function(), instr->arity(), instr, instr->save_doubles());
-}
-
-
-void LCodeGen::DoStoreCodeEntry(LStoreCodeEntry* instr) {
- Register function = ToRegister(instr->function());
- Register code_object = ToRegister(instr->code_object());
- __ leap(code_object, FieldOperand(code_object, Code::kHeaderSize));
- __ movp(FieldOperand(function, JSFunction::kCodeEntryOffset), code_object);
-}
-
-
-void LCodeGen::DoInnerAllocatedObject(LInnerAllocatedObject* instr) {
- Register result = ToRegister(instr->result());
- Register base = ToRegister(instr->base_object());
- if (instr->offset()->IsConstantOperand()) {
- LConstantOperand* offset = LConstantOperand::cast(instr->offset());
- __ leap(result, Operand(base, ToInteger32(offset)));
- } else {
- Register offset = ToRegister(instr->offset());
- __ leap(result, Operand(base, offset, times_1, 0));
- }
-}
-
-
-void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
- HStoreNamedField* hinstr = instr->hydrogen();
- Representation representation = instr->representation();
-
- HObjectAccess access = hinstr->access();
- int offset = access.offset();
-
- if (access.IsExternalMemory()) {
- DCHECK(!hinstr->NeedsWriteBarrier());
- Register value = ToRegister(instr->value());
- if (instr->object()->IsConstantOperand()) {
- DCHECK(value.is(rax));
- LConstantOperand* object = LConstantOperand::cast(instr->object());
- __ store_rax(ToExternalReference(object));
- } else {
- Register object = ToRegister(instr->object());
- __ Store(MemOperand(object, offset), value, representation);
- }
- return;
- }
-
- Register object = ToRegister(instr->object());
- __ AssertNotSmi(object);
-
- DCHECK(!representation.IsSmi() ||
- !instr->value()->IsConstantOperand() ||
- IsInteger32Constant(LConstantOperand::cast(instr->value())));
- if (!FLAG_unbox_double_fields && representation.IsDouble()) {
- DCHECK(access.IsInobject());
- DCHECK(!hinstr->has_transition());
- DCHECK(!hinstr->NeedsWriteBarrier());
- XMMRegister value = ToDoubleRegister(instr->value());
- __ movsd(FieldOperand(object, offset), value);
- return;
- }
-
- if (hinstr->has_transition()) {
- Handle<Map> transition = hinstr->transition_map();
- AddDeprecationDependency(transition);
- if (!hinstr->NeedsWriteBarrierForMap()) {
- __ Move(FieldOperand(object, HeapObject::kMapOffset), transition);
- } else {
- Register temp = ToRegister(instr->temp());
- __ Move(kScratchRegister, transition);
- __ movp(FieldOperand(object, HeapObject::kMapOffset), kScratchRegister);
- // Update the write barrier for the map field.
- __ RecordWriteForMap(object,
- kScratchRegister,
- temp,
- kSaveFPRegs);
- }
- }
-
- // Do the store.
- Register write_register = object;
- if (!access.IsInobject()) {
- write_register = ToRegister(instr->temp());
- __ movp(write_register, FieldOperand(object, JSObject::kPropertiesOffset));
- }
-
- if (representation.IsSmi() && SmiValuesAre32Bits() &&
- hinstr->value()->representation().IsInteger32()) {
- DCHECK(hinstr->store_mode() == STORE_TO_INITIALIZED_ENTRY);
- if (FLAG_debug_code) {
- Register scratch = kScratchRegister;
- __ Load(scratch, FieldOperand(write_register, offset), representation);
- __ AssertSmi(scratch);
- }
- // Store int value directly to upper half of the smi.
- STATIC_ASSERT(kSmiTag == 0);
- DCHECK(kSmiTagSize + kSmiShiftSize == 32);
- offset += kPointerSize / 2;
- representation = Representation::Integer32();
- }
-
- Operand operand = FieldOperand(write_register, offset);
-
- if (FLAG_unbox_double_fields && representation.IsDouble()) {
- DCHECK(access.IsInobject());
- XMMRegister value = ToDoubleRegister(instr->value());
- __ movsd(operand, value);
-
- } else if (instr->value()->IsRegister()) {
- Register value = ToRegister(instr->value());
- __ Store(operand, value, representation);
- } else {
- LConstantOperand* operand_value = LConstantOperand::cast(instr->value());
- if (IsInteger32Constant(operand_value)) {
- DCHECK(!hinstr->NeedsWriteBarrier());
- int32_t value = ToInteger32(operand_value);
- if (representation.IsSmi()) {
- __ Move(operand, Smi::FromInt(value));
-
- } else {
- __ movl(operand, Immediate(value));
- }
-
- } else if (IsExternalConstant(operand_value)) {
- DCHECK(!hinstr->NeedsWriteBarrier());
- ExternalReference ptr = ToExternalReference(operand_value);
- __ Move(kScratchRegister, ptr);
- __ movp(operand, kScratchRegister);
- } else {
- Handle<Object> handle_value = ToHandle(operand_value);
- DCHECK(!hinstr->NeedsWriteBarrier());
- __ Move(operand, handle_value);
- }
- }
-
- if (hinstr->NeedsWriteBarrier()) {
- Register value = ToRegister(instr->value());
- Register temp = access.IsInobject() ? ToRegister(instr->temp()) : object;
- // Update the write barrier for the object for in-object properties.
- __ RecordWriteField(write_register,
- offset,
- value,
- temp,
- kSaveFPRegs,
- EMIT_REMEMBERED_SET,
- hinstr->SmiCheckForWriteBarrier(),
- hinstr->PointersToHereCheckForValue());
- }
-}
-
-
-void LCodeGen::DoStoreNamedGeneric(LStoreNamedGeneric* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->object()).is(StoreDescriptor::ReceiverRegister()));
- DCHECK(ToRegister(instr->value()).is(StoreDescriptor::ValueRegister()));
-
- if (instr->hydrogen()->HasVectorAndSlot()) {
- EmitVectorStoreICRegisters<LStoreNamedGeneric>(instr);
- }
-
- __ Move(StoreDescriptor::NameRegister(), instr->hydrogen()->name());
- Handle<Code> ic = CodeFactory::StoreICInOptimizedCode(
- isolate(), instr->language_mode(),
- instr->hydrogen()->initialization_state()).code();
- CallCode(ic, RelocInfo::CODE_TARGET, instr);
-}
-
-
-void LCodeGen::DoStoreGlobalViaContext(LStoreGlobalViaContext* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->value())
- .is(StoreGlobalViaContextDescriptor::ValueRegister()));
- int const slot = instr->slot_index();
- int const depth = instr->depth();
- if (depth <= StoreGlobalViaContextStub::kMaximumDepth) {
- __ Set(StoreGlobalViaContextDescriptor::SlotRegister(), slot);
- Handle<Code> stub = CodeFactory::StoreGlobalViaContext(
- isolate(), depth, instr->language_mode())
- .code();
- CallCode(stub, RelocInfo::CODE_TARGET, instr);
- } else {
- __ Push(Smi::FromInt(slot));
- __ Push(StoreGlobalViaContextDescriptor::ValueRegister());
- __ CallRuntime(is_strict(instr->language_mode())
- ? Runtime::kStoreGlobalViaContext_Strict
- : Runtime::kStoreGlobalViaContext_Sloppy,
- 2);
- }
-}
-
-
-void LCodeGen::DoBoundsCheck(LBoundsCheck* instr) {
- Representation representation = instr->hydrogen()->length()->representation();
- DCHECK(representation.Equals(instr->hydrogen()->index()->representation()));
- DCHECK(representation.IsSmiOrInteger32());
-
- Condition cc = instr->hydrogen()->allow_equality() ? below : below_equal;
- if (instr->length()->IsConstantOperand()) {
- int32_t length = ToInteger32(LConstantOperand::cast(instr->length()));
- Register index = ToRegister(instr->index());
- if (representation.IsSmi()) {
- __ Cmp(index, Smi::FromInt(length));
- } else {
- __ cmpl(index, Immediate(length));
- }
- cc = CommuteCondition(cc);
- } else if (instr->index()->IsConstantOperand()) {
- int32_t index = ToInteger32(LConstantOperand::cast(instr->index()));
- if (instr->length()->IsRegister()) {
- Register length = ToRegister(instr->length());
- if (representation.IsSmi()) {
- __ Cmp(length, Smi::FromInt(index));
- } else {
- __ cmpl(length, Immediate(index));
- }
- } else {
- Operand length = ToOperand(instr->length());
- if (representation.IsSmi()) {
- __ Cmp(length, Smi::FromInt(index));
- } else {
- __ cmpl(length, Immediate(index));
- }
- }
- } else {
- Register index = ToRegister(instr->index());
- if (instr->length()->IsRegister()) {
- Register length = ToRegister(instr->length());
- if (representation.IsSmi()) {
- __ cmpp(length, index);
- } else {
- __ cmpl(length, index);
- }
- } else {
- Operand length = ToOperand(instr->length());
- if (representation.IsSmi()) {
- __ cmpp(length, index);
- } else {
- __ cmpl(length, index);
- }
- }
- }
- if (FLAG_debug_code && instr->hydrogen()->skip_check()) {
- Label done;
- __ j(NegateCondition(cc), &done, Label::kNear);
- __ int3();
- __ bind(&done);
- } else {
- DeoptimizeIf(cc, instr, Deoptimizer::kOutOfBounds);
- }
-}
-
-
-void LCodeGen::DoStoreKeyedExternalArray(LStoreKeyed* instr) {
- ElementsKind elements_kind = instr->elements_kind();
- LOperand* key = instr->key();
- if (kPointerSize == kInt32Size && !key->IsConstantOperand()) {
- Register key_reg = ToRegister(key);
- Representation key_representation =
- instr->hydrogen()->key()->representation();
- if (ExternalArrayOpRequiresTemp(key_representation, elements_kind)) {
- __ SmiToInteger64(key_reg, key_reg);
- } else if (instr->hydrogen()->IsDehoisted()) {
- // Sign extend key because it could be a 32 bit negative value
- // and the dehoisted address computation happens in 64 bits
- __ movsxlq(key_reg, key_reg);
- }
- }
- Operand operand(BuildFastArrayOperand(
- instr->elements(),
- key,
- instr->hydrogen()->key()->representation(),
- elements_kind,
- instr->base_offset()));
-
- if (elements_kind == FLOAT32_ELEMENTS) {
- XMMRegister value(ToDoubleRegister(instr->value()));
- __ cvtsd2ss(value, value);
- __ movss(operand, value);
- } else if (elements_kind == FLOAT64_ELEMENTS) {
- __ movsd(operand, ToDoubleRegister(instr->value()));
- } else {
- Register value(ToRegister(instr->value()));
- switch (elements_kind) {
- case INT8_ELEMENTS:
- case UINT8_ELEMENTS:
- case UINT8_CLAMPED_ELEMENTS:
- __ movb(operand, value);
- break;
- case INT16_ELEMENTS:
- case UINT16_ELEMENTS:
- __ movw(operand, value);
- break;
- case INT32_ELEMENTS:
- case UINT32_ELEMENTS:
- __ movl(operand, value);
- break;
- case FLOAT32_ELEMENTS:
- case FLOAT64_ELEMENTS:
- case FAST_ELEMENTS:
- case FAST_SMI_ELEMENTS:
- case FAST_DOUBLE_ELEMENTS:
- case FAST_HOLEY_ELEMENTS:
- case FAST_HOLEY_SMI_ELEMENTS:
- case FAST_HOLEY_DOUBLE_ELEMENTS:
- case DICTIONARY_ELEMENTS:
- case FAST_SLOPPY_ARGUMENTS_ELEMENTS:
- case SLOW_SLOPPY_ARGUMENTS_ELEMENTS:
- UNREACHABLE();
- break;
- }
- }
-}
-
-
-void LCodeGen::DoStoreKeyedFixedDoubleArray(LStoreKeyed* instr) {
- XMMRegister value = ToDoubleRegister(instr->value());
- LOperand* key = instr->key();
- if (kPointerSize == kInt32Size && !key->IsConstantOperand() &&
- instr->hydrogen()->IsDehoisted()) {
- // Sign extend key because it could be a 32 bit negative value
- // and the dehoisted address computation happens in 64 bits
- __ movsxlq(ToRegister(key), ToRegister(key));
- }
- if (instr->NeedsCanonicalization()) {
- XMMRegister xmm_scratch = double_scratch0();
- // Turn potential sNaN value into qNaN.
- __ xorps(xmm_scratch, xmm_scratch);
- __ subsd(value, xmm_scratch);
- }
-
- Operand double_store_operand = BuildFastArrayOperand(
- instr->elements(),
- key,
- instr->hydrogen()->key()->representation(),
- FAST_DOUBLE_ELEMENTS,
- instr->base_offset());
-
- __ movsd(double_store_operand, value);
-}
-
-
-void LCodeGen::DoStoreKeyedFixedArray(LStoreKeyed* instr) {
- HStoreKeyed* hinstr = instr->hydrogen();
- LOperand* key = instr->key();
- int offset = instr->base_offset();
- Representation representation = hinstr->value()->representation();
-
- if (kPointerSize == kInt32Size && !key->IsConstantOperand() &&
- instr->hydrogen()->IsDehoisted()) {
- // Sign extend key because it could be a 32 bit negative value
- // and the dehoisted address computation happens in 64 bits
- __ movsxlq(ToRegister(key), ToRegister(key));
- }
- if (representation.IsInteger32() && SmiValuesAre32Bits()) {
- DCHECK(hinstr->store_mode() == STORE_TO_INITIALIZED_ENTRY);
- DCHECK(hinstr->elements_kind() == FAST_SMI_ELEMENTS);
- if (FLAG_debug_code) {
- Register scratch = kScratchRegister;
- __ Load(scratch,
- BuildFastArrayOperand(instr->elements(),
- key,
- instr->hydrogen()->key()->representation(),
- FAST_ELEMENTS,
- offset),
- Representation::Smi());
- __ AssertSmi(scratch);
- }
- // Store int value directly to upper half of the smi.
- STATIC_ASSERT(kSmiTag == 0);
- DCHECK(kSmiTagSize + kSmiShiftSize == 32);
- offset += kPointerSize / 2;
- }
-
- Operand operand =
- BuildFastArrayOperand(instr->elements(),
- key,
- instr->hydrogen()->key()->representation(),
- FAST_ELEMENTS,
- offset);
- if (instr->value()->IsRegister()) {
- __ Store(operand, ToRegister(instr->value()), representation);
- } else {
- LConstantOperand* operand_value = LConstantOperand::cast(instr->value());
- if (IsInteger32Constant(operand_value)) {
- int32_t value = ToInteger32(operand_value);
- if (representation.IsSmi()) {
- __ Move(operand, Smi::FromInt(value));
-
- } else {
- __ movl(operand, Immediate(value));
- }
- } else {
- Handle<Object> handle_value = ToHandle(operand_value);
- __ Move(operand, handle_value);
- }
- }
-
- if (hinstr->NeedsWriteBarrier()) {
- Register elements = ToRegister(instr->elements());
- DCHECK(instr->value()->IsRegister());
- Register value = ToRegister(instr->value());
- DCHECK(!key->IsConstantOperand());
- SmiCheck check_needed = hinstr->value()->type().IsHeapObject()
- ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
- // Compute address of modified element and store it into key register.
- Register key_reg(ToRegister(key));
- __ leap(key_reg, operand);
- __ RecordWrite(elements,
- key_reg,
- value,
- kSaveFPRegs,
- EMIT_REMEMBERED_SET,
- check_needed,
- hinstr->PointersToHereCheckForValue());
- }
-}
-
-
-void LCodeGen::DoStoreKeyed(LStoreKeyed* instr) {
- if (instr->is_fixed_typed_array()) {
- DoStoreKeyedExternalArray(instr);
- } else if (instr->hydrogen()->value()->representation().IsDouble()) {
- DoStoreKeyedFixedDoubleArray(instr);
- } else {
- DoStoreKeyedFixedArray(instr);
- }
-}
-
-
-void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->object()).is(StoreDescriptor::ReceiverRegister()));
- DCHECK(ToRegister(instr->key()).is(StoreDescriptor::NameRegister()));
- DCHECK(ToRegister(instr->value()).is(StoreDescriptor::ValueRegister()));
-
- if (instr->hydrogen()->HasVectorAndSlot()) {
- EmitVectorStoreICRegisters<LStoreKeyedGeneric>(instr);
- }
-
- Handle<Code> ic = CodeFactory::KeyedStoreICInOptimizedCode(
- isolate(), instr->language_mode(),
- instr->hydrogen()->initialization_state()).code();
- CallCode(ic, RelocInfo::CODE_TARGET, instr);
-}
-
-
-void LCodeGen::DoMaybeGrowElements(LMaybeGrowElements* instr) {
- class DeferredMaybeGrowElements final : public LDeferredCode {
- public:
- DeferredMaybeGrowElements(LCodeGen* codegen, LMaybeGrowElements* instr)
- : LDeferredCode(codegen), instr_(instr) {}
- void Generate() override { codegen()->DoDeferredMaybeGrowElements(instr_); }
- LInstruction* instr() override { return instr_; }
-
- private:
- LMaybeGrowElements* instr_;
- };
-
- Register result = rax;
- DeferredMaybeGrowElements* deferred =
- new (zone()) DeferredMaybeGrowElements(this, instr);
- LOperand* key = instr->key();
- LOperand* current_capacity = instr->current_capacity();
-
- DCHECK(instr->hydrogen()->key()->representation().IsInteger32());
- DCHECK(instr->hydrogen()->current_capacity()->representation().IsInteger32());
- DCHECK(key->IsConstantOperand() || key->IsRegister());
- DCHECK(current_capacity->IsConstantOperand() ||
- current_capacity->IsRegister());
-
- if (key->IsConstantOperand() && current_capacity->IsConstantOperand()) {
- int32_t constant_key = ToInteger32(LConstantOperand::cast(key));
- int32_t constant_capacity =
- ToInteger32(LConstantOperand::cast(current_capacity));
- if (constant_key >= constant_capacity) {
- // Deferred case.
- __ jmp(deferred->entry());
- }
- } else if (key->IsConstantOperand()) {
- int32_t constant_key = ToInteger32(LConstantOperand::cast(key));
- __ cmpl(ToRegister(current_capacity), Immediate(constant_key));
- __ j(less_equal, deferred->entry());
- } else if (current_capacity->IsConstantOperand()) {
- int32_t constant_capacity =
- ToInteger32(LConstantOperand::cast(current_capacity));
- __ cmpl(ToRegister(key), Immediate(constant_capacity));
- __ j(greater_equal, deferred->entry());
- } else {
- __ cmpl(ToRegister(key), ToRegister(current_capacity));
- __ j(greater_equal, deferred->entry());
- }
-
- if (instr->elements()->IsRegister()) {
- __ movp(result, ToRegister(instr->elements()));
- } else {
- __ movp(result, ToOperand(instr->elements()));
- }
-
- __ bind(deferred->exit());
-}
-
-
-void LCodeGen::DoDeferredMaybeGrowElements(LMaybeGrowElements* instr) {
- // TODO(3095996): Get rid of this. For now, we need to make the
- // result register contain a valid pointer because it is already
- // contained in the register pointer map.
- Register result = rax;
- __ Move(result, Smi::FromInt(0));
-
- // We have to call a stub.
- {
- PushSafepointRegistersScope scope(this);
- if (instr->object()->IsConstantOperand()) {
- LConstantOperand* constant_object =
- LConstantOperand::cast(instr->object());
- if (IsSmiConstant(constant_object)) {
- Smi* immediate = ToSmi(constant_object);
- __ Move(result, immediate);
- } else {
- Handle<Object> handle_value = ToHandle(constant_object);
- __ Move(result, handle_value);
- }
- } else if (instr->object()->IsRegister()) {
- __ Move(result, ToRegister(instr->object()));
- } else {
- __ movp(result, ToOperand(instr->object()));
- }
-
- LOperand* key = instr->key();
- if (key->IsConstantOperand()) {
- __ Move(rbx, ToSmi(LConstantOperand::cast(key)));
- } else {
- __ Move(rbx, ToRegister(key));
- __ Integer32ToSmi(rbx, rbx);
- }
-
- GrowArrayElementsStub stub(isolate(), instr->hydrogen()->is_js_array(),
- instr->hydrogen()->kind());
- __ CallStub(&stub);
- RecordSafepointWithLazyDeopt(instr, RECORD_SAFEPOINT_WITH_REGISTERS, 0);
- __ StoreToSafepointRegisterSlot(result, result);
- }
-
- // Deopt on smi, which means the elements array changed to dictionary mode.
- Condition is_smi = __ CheckSmi(result);
- DeoptimizeIf(is_smi, instr, Deoptimizer::kSmi);
-}
-
-
-void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {
- Register object_reg = ToRegister(instr->object());
-
- Handle<Map> from_map = instr->original_map();
- Handle<Map> to_map = instr->transitioned_map();
- ElementsKind from_kind = instr->from_kind();
- ElementsKind to_kind = instr->to_kind();
-
- Label not_applicable;
- __ Cmp(FieldOperand(object_reg, HeapObject::kMapOffset), from_map);
- __ j(not_equal, &not_applicable);
- if (IsSimpleMapChangeTransition(from_kind, to_kind)) {
- Register new_map_reg = ToRegister(instr->new_map_temp());
- __ Move(new_map_reg, to_map, RelocInfo::EMBEDDED_OBJECT);
- __ movp(FieldOperand(object_reg, HeapObject::kMapOffset), new_map_reg);
- // Write barrier.
- __ RecordWriteForMap(object_reg, new_map_reg, ToRegister(instr->temp()),
- kDontSaveFPRegs);
- } else {
- DCHECK(object_reg.is(rax));
- DCHECK(ToRegister(instr->context()).is(rsi));
- PushSafepointRegistersScope scope(this);
- __ Move(rbx, to_map);
- bool is_js_array = from_map->instance_type() == JS_ARRAY_TYPE;
- TransitionElementsKindStub stub(isolate(), from_kind, to_kind, is_js_array);
- __ CallStub(&stub);
- RecordSafepointWithLazyDeopt(instr, RECORD_SAFEPOINT_WITH_REGISTERS, 0);
- }
- __ bind(&not_applicable);
-}
-
-
-void LCodeGen::DoTrapAllocationMemento(LTrapAllocationMemento* instr) {
- Register object = ToRegister(instr->object());
- Register temp = ToRegister(instr->temp());
- Label no_memento_found;
- __ TestJSArrayForAllocationMemento(object, temp, &no_memento_found);
- DeoptimizeIf(equal, instr, Deoptimizer::kMementoFound);
- __ bind(&no_memento_found);
-}
-
-
-void LCodeGen::DoStringAdd(LStringAdd* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->left()).is(rdx));
- DCHECK(ToRegister(instr->right()).is(rax));
- StringAddStub stub(isolate(),
- instr->hydrogen()->flags(),
- instr->hydrogen()->pretenure_flag());
- CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
-}
-
-
-void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
- class DeferredStringCharCodeAt final : public LDeferredCode {
- public:
- DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr)
- : LDeferredCode(codegen), instr_(instr) { }
- void Generate() override { codegen()->DoDeferredStringCharCodeAt(instr_); }
- LInstruction* instr() override { return instr_; }
-
- private:
- LStringCharCodeAt* instr_;
- };
-
- DeferredStringCharCodeAt* deferred =
- new(zone()) DeferredStringCharCodeAt(this, instr);
-
- StringCharLoadGenerator::Generate(masm(),
- ToRegister(instr->string()),
- ToRegister(instr->index()),
- ToRegister(instr->result()),
- deferred->entry());
- __ bind(deferred->exit());
-}
-
-
-void LCodeGen::DoDeferredStringCharCodeAt(LStringCharCodeAt* instr) {
- Register string = ToRegister(instr->string());
- Register result = ToRegister(instr->result());
-
- // TODO(3095996): Get rid of this. For now, we need to make the
- // result register contain a valid pointer because it is already
- // contained in the register pointer map.
- __ Set(result, 0);
-
- PushSafepointRegistersScope scope(this);
- __ Push(string);
- // Push the index as a smi. This is safe because of the checks in
- // DoStringCharCodeAt above.
- STATIC_ASSERT(String::kMaxLength <= Smi::kMaxValue);
- if (instr->index()->IsConstantOperand()) {
- int32_t const_index = ToInteger32(LConstantOperand::cast(instr->index()));
- __ Push(Smi::FromInt(const_index));
- } else {
- Register index = ToRegister(instr->index());
- __ Integer32ToSmi(index, index);
- __ Push(index);
- }
- CallRuntimeFromDeferred(
- Runtime::kStringCharCodeAtRT, 2, instr, instr->context());
- __ AssertSmi(rax);
- __ SmiToInteger32(rax, rax);
- __ StoreToSafepointRegisterSlot(result, rax);
-}
-
-
-void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
- class DeferredStringCharFromCode final : public LDeferredCode {
- public:
- DeferredStringCharFromCode(LCodeGen* codegen, LStringCharFromCode* instr)
- : LDeferredCode(codegen), instr_(instr) { }
- void Generate() override {
- codegen()->DoDeferredStringCharFromCode(instr_);
- }
- LInstruction* instr() override { return instr_; }
-
- private:
- LStringCharFromCode* instr_;
- };
-
- DeferredStringCharFromCode* deferred =
- new(zone()) DeferredStringCharFromCode(this, instr);
-
- DCHECK(instr->hydrogen()->value()->representation().IsInteger32());
- Register char_code = ToRegister(instr->char_code());
- Register result = ToRegister(instr->result());
- DCHECK(!char_code.is(result));
-
- __ cmpl(char_code, Immediate(String::kMaxOneByteCharCode));
- __ j(above, deferred->entry());
- __ movsxlq(char_code, char_code);
- __ LoadRoot(result, Heap::kSingleCharacterStringCacheRootIndex);
- __ movp(result, FieldOperand(result,
- char_code, times_pointer_size,
- FixedArray::kHeaderSize));
- __ CompareRoot(result, Heap::kUndefinedValueRootIndex);
- __ j(equal, deferred->entry());
- __ bind(deferred->exit());
-}
-
-
-void LCodeGen::DoDeferredStringCharFromCode(LStringCharFromCode* instr) {
- Register char_code = ToRegister(instr->char_code());
- Register result = ToRegister(instr->result());
-
- // TODO(3095996): Get rid of this. For now, we need to make the
- // result register contain a valid pointer because it is already
- // contained in the register pointer map.
- __ Set(result, 0);
-
- PushSafepointRegistersScope scope(this);
- __ Integer32ToSmi(char_code, char_code);
- __ Push(char_code);
- CallRuntimeFromDeferred(Runtime::kCharFromCode, 1, instr, instr->context());
- __ StoreToSafepointRegisterSlot(result, rax);
-}
-
-
-void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) {
- LOperand* input = instr->value();
- DCHECK(input->IsRegister() || input->IsStackSlot());
- LOperand* output = instr->result();
- DCHECK(output->IsDoubleRegister());
- if (input->IsRegister()) {
- __ Cvtlsi2sd(ToDoubleRegister(output), ToRegister(input));
- } else {
- __ Cvtlsi2sd(ToDoubleRegister(output), ToOperand(input));
- }
-}
-
-
-void LCodeGen::DoUint32ToDouble(LUint32ToDouble* instr) {
- LOperand* input = instr->value();
- LOperand* output = instr->result();
-
- __ LoadUint32(ToDoubleRegister(output), ToRegister(input));
-}
-
-
-void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
- class DeferredNumberTagI final : public LDeferredCode {
- public:
- DeferredNumberTagI(LCodeGen* codegen, LNumberTagI* instr)
- : LDeferredCode(codegen), instr_(instr) { }
- void Generate() override {
- codegen()->DoDeferredNumberTagIU(instr_, instr_->value(), instr_->temp1(),
- instr_->temp2(), SIGNED_INT32);
- }
- LInstruction* instr() override { return instr_; }
-
- private:
- LNumberTagI* instr_;
- };
-
- LOperand* input = instr->value();
- DCHECK(input->IsRegister() && input->Equals(instr->result()));
- Register reg = ToRegister(input);
-
- if (SmiValuesAre32Bits()) {
- __ Integer32ToSmi(reg, reg);
- } else {
- DCHECK(SmiValuesAre31Bits());
- DeferredNumberTagI* deferred = new(zone()) DeferredNumberTagI(this, instr);
- __ Integer32ToSmi(reg, reg);
- __ j(overflow, deferred->entry());
- __ bind(deferred->exit());
- }
-}
-
-
-void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
- class DeferredNumberTagU final : public LDeferredCode {
- public:
- DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr)
- : LDeferredCode(codegen), instr_(instr) { }
- void Generate() override {
- codegen()->DoDeferredNumberTagIU(instr_, instr_->value(), instr_->temp1(),
- instr_->temp2(), UNSIGNED_INT32);
- }
- LInstruction* instr() override { return instr_; }
-
- private:
- LNumberTagU* instr_;
- };
-
- LOperand* input = instr->value();
- DCHECK(input->IsRegister() && input->Equals(instr->result()));
- Register reg = ToRegister(input);
-
- DeferredNumberTagU* deferred = new(zone()) DeferredNumberTagU(this, instr);
- __ cmpl(reg, Immediate(Smi::kMaxValue));
- __ j(above, deferred->entry());
- __ Integer32ToSmi(reg, reg);
- __ bind(deferred->exit());
-}
-
-
-void LCodeGen::DoDeferredNumberTagIU(LInstruction* instr,
- LOperand* value,
- LOperand* temp1,
- LOperand* temp2,
- IntegerSignedness signedness) {
- Label done, slow;
- Register reg = ToRegister(value);
- Register tmp = ToRegister(temp1);
- XMMRegister temp_xmm = ToDoubleRegister(temp2);
-
- // Load value into temp_xmm which will be preserved across potential call to
- // runtime (MacroAssembler::EnterExitFrameEpilogue preserves only allocatable
- // XMM registers on x64).
- if (signedness == SIGNED_INT32) {
- DCHECK(SmiValuesAre31Bits());
- // There was overflow, so bits 30 and 31 of the original integer
- // disagree. Try to allocate a heap number in new space and store
- // the value in there. If that fails, call the runtime system.
- __ SmiToInteger32(reg, reg);
- __ xorl(reg, Immediate(0x80000000));
- __ cvtlsi2sd(temp_xmm, reg);
- } else {
- DCHECK(signedness == UNSIGNED_INT32);
- __ LoadUint32(temp_xmm, reg);
- }
-
- if (FLAG_inline_new) {
- __ AllocateHeapNumber(reg, tmp, &slow);
- __ jmp(&done, kPointerSize == kInt64Size ? Label::kNear : Label::kFar);
- }
-
- // Slow case: Call the runtime system to do the number allocation.
- __ bind(&slow);
- {
- // Put a valid pointer value in the stack slot where the result
- // register is stored, as this register is in the pointer map, but contains
- // an integer value.
- __ Set(reg, 0);
-
- // Preserve the value of all registers.
- PushSafepointRegistersScope scope(this);
-
- // NumberTagIU uses the context from the frame, rather than
- // the environment's HContext or HInlinedContext value.
- // They only call Runtime::kAllocateHeapNumber.
- // The corresponding HChange instructions are added in a phase that does
- // not have easy access to the local context.
- __ movp(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
- __ CallRuntimeSaveDoubles(Runtime::kAllocateHeapNumber);
- RecordSafepointWithRegisters(
- instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
- __ StoreToSafepointRegisterSlot(reg, rax);
- }
-
- // Done. Put the value in temp_xmm into the value of the allocated heap
- // number.
- __ bind(&done);
- __ movsd(FieldOperand(reg, HeapNumber::kValueOffset), temp_xmm);
-}
-
-
-void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
- class DeferredNumberTagD final : public LDeferredCode {
- public:
- DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr)
- : LDeferredCode(codegen), instr_(instr) { }
- void Generate() override { codegen()->DoDeferredNumberTagD(instr_); }
- LInstruction* instr() override { return instr_; }
-
- private:
- LNumberTagD* instr_;
- };
-
- XMMRegister input_reg = ToDoubleRegister(instr->value());
- Register reg = ToRegister(instr->result());
- Register tmp = ToRegister(instr->temp());
-
- DeferredNumberTagD* deferred = new(zone()) DeferredNumberTagD(this, instr);
- if (FLAG_inline_new) {
- __ AllocateHeapNumber(reg, tmp, deferred->entry());
- } else {
- __ jmp(deferred->entry());
- }
- __ bind(deferred->exit());
- __ movsd(FieldOperand(reg, HeapNumber::kValueOffset), input_reg);
-}
-
-
-void LCodeGen::DoDeferredNumberTagD(LNumberTagD* instr) {
- // TODO(3095996): Get rid of this. For now, we need to make the
- // result register contain a valid pointer because it is already
- // contained in the register pointer map.
- Register reg = ToRegister(instr->result());
- __ Move(reg, Smi::FromInt(0));
-
- {
- PushSafepointRegistersScope scope(this);
- // NumberTagD uses the context from the frame, rather than
- // the environment's HContext or HInlinedContext value.
- // They only call Runtime::kAllocateHeapNumber.
- // The corresponding HChange instructions are added in a phase that does
- // not have easy access to the local context.
- __ movp(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
- __ CallRuntimeSaveDoubles(Runtime::kAllocateHeapNumber);
- RecordSafepointWithRegisters(
- instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
- __ movp(kScratchRegister, rax);
- }
- __ movp(reg, kScratchRegister);
-}
-
-
-void LCodeGen::DoSmiTag(LSmiTag* instr) {
- HChange* hchange = instr->hydrogen();
- Register input = ToRegister(instr->value());
- Register output = ToRegister(instr->result());
- if (hchange->CheckFlag(HValue::kCanOverflow) &&
- hchange->value()->CheckFlag(HValue::kUint32)) {
- Condition is_smi = __ CheckUInteger32ValidSmiValue(input);
- DeoptimizeIf(NegateCondition(is_smi), instr, Deoptimizer::kOverflow);
- }
- __ Integer32ToSmi(output, input);
- if (hchange->CheckFlag(HValue::kCanOverflow) &&
- !hchange->value()->CheckFlag(HValue::kUint32)) {
- DeoptimizeIf(overflow, instr, Deoptimizer::kOverflow);
- }
-}
-
-
-void LCodeGen::DoSmiUntag(LSmiUntag* instr) {
- DCHECK(instr->value()->Equals(instr->result()));
- Register input = ToRegister(instr->value());
- if (instr->needs_check()) {
- Condition is_smi = __ CheckSmi(input);
- DeoptimizeIf(NegateCondition(is_smi), instr, Deoptimizer::kNotASmi);
- } else {
- __ AssertSmi(input);
- }
- __ SmiToInteger32(input, input);
-}
-
-
-void LCodeGen::EmitNumberUntagD(LNumberUntagD* instr, Register input_reg,
- XMMRegister result_reg, NumberUntagDMode mode) {
- bool can_convert_undefined_to_nan =
- instr->hydrogen()->can_convert_undefined_to_nan();
- bool deoptimize_on_minus_zero = instr->hydrogen()->deoptimize_on_minus_zero();
-
- Label convert, load_smi, done;
-
- if (mode == NUMBER_CANDIDATE_IS_ANY_TAGGED) {
- // Smi check.
- __ JumpIfSmi(input_reg, &load_smi, Label::kNear);
-
- // Heap number map check.
- __ CompareRoot(FieldOperand(input_reg, HeapObject::kMapOffset),
- Heap::kHeapNumberMapRootIndex);
-
- // On x64 it is safe to load at heap number offset before evaluating the map
- // check, since all heap objects are at least two words long.
- __ movsd(result_reg, FieldOperand(input_reg, HeapNumber::kValueOffset));
-
- if (can_convert_undefined_to_nan) {
- __ j(not_equal, &convert, Label::kNear);
- } else {
- DeoptimizeIf(not_equal, instr, Deoptimizer::kNotAHeapNumber);
- }
-
- if (deoptimize_on_minus_zero) {
- XMMRegister xmm_scratch = double_scratch0();
- __ xorps(xmm_scratch, xmm_scratch);
- __ ucomisd(xmm_scratch, result_reg);
- __ j(not_equal, &done, Label::kNear);
- __ movmskpd(kScratchRegister, result_reg);
- __ testq(kScratchRegister, Immediate(1));
- DeoptimizeIf(not_zero, instr, Deoptimizer::kMinusZero);
- }
- __ jmp(&done, Label::kNear);
-
- if (can_convert_undefined_to_nan) {
- __ bind(&convert);
-
- // Convert undefined (and hole) to NaN. Compute NaN as 0/0.
- __ CompareRoot(input_reg, Heap::kUndefinedValueRootIndex);
- DeoptimizeIf(not_equal, instr, Deoptimizer::kNotAHeapNumberUndefined);
-
- __ pcmpeqd(result_reg, result_reg);
- __ jmp(&done, Label::kNear);
- }
- } else {
- DCHECK(mode == NUMBER_CANDIDATE_IS_SMI);
- }
-
- // Smi to XMM conversion
- __ bind(&load_smi);
- __ SmiToInteger32(kScratchRegister, input_reg);
- __ Cvtlsi2sd(result_reg, kScratchRegister);
- __ bind(&done);
-}
-
-
-void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr, Label* done) {
- Register input_reg = ToRegister(instr->value());
-
- if (instr->truncating()) {
- Label no_heap_number, check_bools, check_false;
-
- // Heap number map check.
- __ CompareRoot(FieldOperand(input_reg, HeapObject::kMapOffset),
- Heap::kHeapNumberMapRootIndex);
- __ j(not_equal, &no_heap_number, Label::kNear);
- __ TruncateHeapNumberToI(input_reg, input_reg);
- __ jmp(done);
-
- __ bind(&no_heap_number);
- // Check for Oddballs. Undefined/False is converted to zero and True to one
- // for truncating conversions.
- __ CompareRoot(input_reg, Heap::kUndefinedValueRootIndex);
- __ j(not_equal, &check_bools, Label::kNear);
- __ Set(input_reg, 0);
- __ jmp(done);
-
- __ bind(&check_bools);
- __ CompareRoot(input_reg, Heap::kTrueValueRootIndex);
- __ j(not_equal, &check_false, Label::kNear);
- __ Set(input_reg, 1);
- __ jmp(done);
-
- __ bind(&check_false);
- __ CompareRoot(input_reg, Heap::kFalseValueRootIndex);
- DeoptimizeIf(not_equal, instr,
- Deoptimizer::kNotAHeapNumberUndefinedBoolean);
- __ Set(input_reg, 0);
- } else {
- XMMRegister scratch = ToDoubleRegister(instr->temp());
- DCHECK(!scratch.is(xmm0));
- __ CompareRoot(FieldOperand(input_reg, HeapObject::kMapOffset),
- Heap::kHeapNumberMapRootIndex);
- DeoptimizeIf(not_equal, instr, Deoptimizer::kNotAHeapNumber);
- __ movsd(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset));
- __ cvttsd2si(input_reg, xmm0);
- __ Cvtlsi2sd(scratch, input_reg);
- __ ucomisd(xmm0, scratch);
- DeoptimizeIf(not_equal, instr, Deoptimizer::kLostPrecision);
- DeoptimizeIf(parity_even, instr, Deoptimizer::kNaN);
- if (instr->hydrogen()->GetMinusZeroMode() == FAIL_ON_MINUS_ZERO) {
- __ testl(input_reg, input_reg);
- __ j(not_zero, done);
- __ movmskpd(input_reg, xmm0);
- __ andl(input_reg, Immediate(1));
- DeoptimizeIf(not_zero, instr, Deoptimizer::kMinusZero);
- }
- }
-}
-
-
-void LCodeGen::DoTaggedToI(LTaggedToI* instr) {
- class DeferredTaggedToI final : public LDeferredCode {
- public:
- DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr)
- : LDeferredCode(codegen), instr_(instr) { }
- void Generate() override { codegen()->DoDeferredTaggedToI(instr_, done()); }
- LInstruction* instr() override { return instr_; }
-
- private:
- LTaggedToI* instr_;
- };
-
- LOperand* input = instr->value();
- DCHECK(input->IsRegister());
- DCHECK(input->Equals(instr->result()));
- Register input_reg = ToRegister(input);
-
- if (instr->hydrogen()->value()->representation().IsSmi()) {
- __ SmiToInteger32(input_reg, input_reg);
- } else {
- DeferredTaggedToI* deferred = new(zone()) DeferredTaggedToI(this, instr);
- __ JumpIfNotSmi(input_reg, deferred->entry());
- __ SmiToInteger32(input_reg, input_reg);
- __ bind(deferred->exit());
- }
-}
-
-
-void LCodeGen::DoNumberUntagD(LNumberUntagD* instr) {
- LOperand* input = instr->value();
- DCHECK(input->IsRegister());
- LOperand* result = instr->result();
- DCHECK(result->IsDoubleRegister());
-
- Register input_reg = ToRegister(input);
- XMMRegister result_reg = ToDoubleRegister(result);
-
- HValue* value = instr->hydrogen()->value();
- NumberUntagDMode mode = value->representation().IsSmi()
- ? NUMBER_CANDIDATE_IS_SMI : NUMBER_CANDIDATE_IS_ANY_TAGGED;
-
- EmitNumberUntagD(instr, input_reg, result_reg, mode);
-}
-
-
-void LCodeGen::DoDoubleToI(LDoubleToI* instr) {
- LOperand* input = instr->value();
- DCHECK(input->IsDoubleRegister());
- LOperand* result = instr->result();
- DCHECK(result->IsRegister());
-
- XMMRegister input_reg = ToDoubleRegister(input);
- Register result_reg = ToRegister(result);
-
- if (instr->truncating()) {
- __ TruncateDoubleToI(result_reg, input_reg);
- } else {
- Label lost_precision, is_nan, minus_zero, done;
- XMMRegister xmm_scratch = double_scratch0();
- Label::Distance dist = DeoptEveryNTimes() ? Label::kFar : Label::kNear;
- __ DoubleToI(result_reg, input_reg, xmm_scratch,
- instr->hydrogen()->GetMinusZeroMode(), &lost_precision,
- &is_nan, &minus_zero, dist);
- __ jmp(&done, dist);
- __ bind(&lost_precision);
- DeoptimizeIf(no_condition, instr, Deoptimizer::kLostPrecision);
- __ bind(&is_nan);
- DeoptimizeIf(no_condition, instr, Deoptimizer::kNaN);
- __ bind(&minus_zero);
- DeoptimizeIf(no_condition, instr, Deoptimizer::kMinusZero);
- __ bind(&done);
- }
-}
-
-
-void LCodeGen::DoDoubleToSmi(LDoubleToSmi* instr) {
- LOperand* input = instr->value();
- DCHECK(input->IsDoubleRegister());
- LOperand* result = instr->result();
- DCHECK(result->IsRegister());
-
- XMMRegister input_reg = ToDoubleRegister(input);
- Register result_reg = ToRegister(result);
-
- Label lost_precision, is_nan, minus_zero, done;
- XMMRegister xmm_scratch = double_scratch0();
- Label::Distance dist = DeoptEveryNTimes() ? Label::kFar : Label::kNear;
- __ DoubleToI(result_reg, input_reg, xmm_scratch,
- instr->hydrogen()->GetMinusZeroMode(), &lost_precision, &is_nan,
- &minus_zero, dist);
- __ jmp(&done, dist);
- __ bind(&lost_precision);
- DeoptimizeIf(no_condition, instr, Deoptimizer::kLostPrecision);
- __ bind(&is_nan);
- DeoptimizeIf(no_condition, instr, Deoptimizer::kNaN);
- __ bind(&minus_zero);
- DeoptimizeIf(no_condition, instr, Deoptimizer::kMinusZero);
- __ bind(&done);
- __ Integer32ToSmi(result_reg, result_reg);
- DeoptimizeIf(overflow, instr, Deoptimizer::kOverflow);
-}
-
-
-void LCodeGen::DoCheckSmi(LCheckSmi* instr) {
- LOperand* input = instr->value();
- Condition cc = masm()->CheckSmi(ToRegister(input));
- DeoptimizeIf(NegateCondition(cc), instr, Deoptimizer::kNotASmi);
-}
-
-
-void LCodeGen::DoCheckNonSmi(LCheckNonSmi* instr) {
- if (!instr->hydrogen()->value()->type().IsHeapObject()) {
- LOperand* input = instr->value();
- Condition cc = masm()->CheckSmi(ToRegister(input));
- DeoptimizeIf(cc, instr, Deoptimizer::kSmi);
- }
-}
-
-
-void LCodeGen::DoCheckArrayBufferNotNeutered(
- LCheckArrayBufferNotNeutered* instr) {
- Register view = ToRegister(instr->view());
-
- __ movp(kScratchRegister,
- FieldOperand(view, JSArrayBufferView::kBufferOffset));
- __ testb(FieldOperand(kScratchRegister, JSArrayBuffer::kBitFieldOffset),
- Immediate(1 << JSArrayBuffer::WasNeutered::kShift));
- DeoptimizeIf(not_zero, instr, Deoptimizer::kOutOfBounds);
-}
-
-
-void LCodeGen::DoCheckInstanceType(LCheckInstanceType* instr) {
- Register input = ToRegister(instr->value());
-
- __ movp(kScratchRegister, FieldOperand(input, HeapObject::kMapOffset));
-
- if (instr->hydrogen()->is_interval_check()) {
- InstanceType first;
- InstanceType last;
- instr->hydrogen()->GetCheckInterval(&first, &last);
-
- __ cmpb(FieldOperand(kScratchRegister, Map::kInstanceTypeOffset),
- Immediate(static_cast<int8_t>(first)));
-
- // If there is only one type in the interval check for equality.
- if (first == last) {
- DeoptimizeIf(not_equal, instr, Deoptimizer::kWrongInstanceType);
- } else {
- DeoptimizeIf(below, instr, Deoptimizer::kWrongInstanceType);
- // Omit check for the last type.
- if (last != LAST_TYPE) {
- __ cmpb(FieldOperand(kScratchRegister, Map::kInstanceTypeOffset),
- Immediate(static_cast<int8_t>(last)));
- DeoptimizeIf(above, instr, Deoptimizer::kWrongInstanceType);
- }
- }
- } else {
- uint8_t mask;
- uint8_t tag;
- instr->hydrogen()->GetCheckMaskAndTag(&mask, &tag);
-
- if (base::bits::IsPowerOfTwo32(mask)) {
- DCHECK(tag == 0 || base::bits::IsPowerOfTwo32(tag));
- __ testb(FieldOperand(kScratchRegister, Map::kInstanceTypeOffset),
- Immediate(mask));
- DeoptimizeIf(tag == 0 ? not_zero : zero, instr,
- Deoptimizer::kWrongInstanceType);
- } else {
- __ movzxbl(kScratchRegister,
- FieldOperand(kScratchRegister, Map::kInstanceTypeOffset));
- __ andb(kScratchRegister, Immediate(mask));
- __ cmpb(kScratchRegister, Immediate(tag));
- DeoptimizeIf(not_equal, instr, Deoptimizer::kWrongInstanceType);
- }
- }
-}
-
-
-void LCodeGen::DoCheckValue(LCheckValue* instr) {
- Register reg = ToRegister(instr->value());
- __ Cmp(reg, instr->hydrogen()->object().handle());
- DeoptimizeIf(not_equal, instr, Deoptimizer::kValueMismatch);
-}
-
-
-void LCodeGen::DoDeferredInstanceMigration(LCheckMaps* instr, Register object) {
- {
- PushSafepointRegistersScope scope(this);
- __ Push(object);
- __ Set(rsi, 0);
- __ CallRuntimeSaveDoubles(Runtime::kTryMigrateInstance);
- RecordSafepointWithRegisters(
- instr->pointer_map(), 1, Safepoint::kNoLazyDeopt);
-
- __ testp(rax, Immediate(kSmiTagMask));
- }
- DeoptimizeIf(zero, instr, Deoptimizer::kInstanceMigrationFailed);
-}
-
-
-void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
- class DeferredCheckMaps final : public LDeferredCode {
- public:
- DeferredCheckMaps(LCodeGen* codegen, LCheckMaps* instr, Register object)
- : LDeferredCode(codegen), instr_(instr), object_(object) {
- SetExit(check_maps());
- }
- void Generate() override {
- codegen()->DoDeferredInstanceMigration(instr_, object_);
- }
- Label* check_maps() { return &check_maps_; }
- LInstruction* instr() override { return instr_; }
-
- private:
- LCheckMaps* instr_;
- Label check_maps_;
- Register object_;
- };
-
- if (instr->hydrogen()->IsStabilityCheck()) {
- const UniqueSet<Map>* maps = instr->hydrogen()->maps();
- for (int i = 0; i < maps->size(); ++i) {
- AddStabilityDependency(maps->at(i).handle());
- }
- return;
- }
-
- LOperand* input = instr->value();
- DCHECK(input->IsRegister());
- Register reg = ToRegister(input);
-
- DeferredCheckMaps* deferred = NULL;
- if (instr->hydrogen()->HasMigrationTarget()) {
- deferred = new(zone()) DeferredCheckMaps(this, instr, reg);
- __ bind(deferred->check_maps());
- }
-
- const UniqueSet<Map>* maps = instr->hydrogen()->maps();
- Label success;
- for (int i = 0; i < maps->size() - 1; i++) {
- Handle<Map> map = maps->at(i).handle();
- __ CompareMap(reg, map);
- __ j(equal, &success, Label::kNear);
- }
-
- Handle<Map> map = maps->at(maps->size() - 1).handle();
- __ CompareMap(reg, map);
- if (instr->hydrogen()->HasMigrationTarget()) {
- __ j(not_equal, deferred->entry());
- } else {
- DeoptimizeIf(not_equal, instr, Deoptimizer::kWrongMap);
- }
-
- __ bind(&success);
-}
-
-
-void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) {
- XMMRegister value_reg = ToDoubleRegister(instr->unclamped());
- XMMRegister xmm_scratch = double_scratch0();
- Register result_reg = ToRegister(instr->result());
- __ ClampDoubleToUint8(value_reg, xmm_scratch, result_reg);
-}
-
-
-void LCodeGen::DoClampIToUint8(LClampIToUint8* instr) {
- DCHECK(instr->unclamped()->Equals(instr->result()));
- Register value_reg = ToRegister(instr->result());
- __ ClampUint8(value_reg);
-}
-
-
-void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
- DCHECK(instr->unclamped()->Equals(instr->result()));
- Register input_reg = ToRegister(instr->unclamped());
- XMMRegister temp_xmm_reg = ToDoubleRegister(instr->temp_xmm());
- XMMRegister xmm_scratch = double_scratch0();
- Label is_smi, done, heap_number;
- Label::Distance dist = DeoptEveryNTimes() ? Label::kFar : Label::kNear;
- __ JumpIfSmi(input_reg, &is_smi, dist);
-
- // Check for heap number
- __ Cmp(FieldOperand(input_reg, HeapObject::kMapOffset),
- factory()->heap_number_map());
- __ j(equal, &heap_number, Label::kNear);
-
- // Check for undefined. Undefined is converted to zero for clamping
- // conversions.
- __ Cmp(input_reg, factory()->undefined_value());
- DeoptimizeIf(not_equal, instr, Deoptimizer::kNotAHeapNumberUndefined);
- __ xorl(input_reg, input_reg);
- __ jmp(&done, Label::kNear);
-
- // Heap number
- __ bind(&heap_number);
- __ movsd(xmm_scratch, FieldOperand(input_reg, HeapNumber::kValueOffset));
- __ ClampDoubleToUint8(xmm_scratch, temp_xmm_reg, input_reg);
- __ jmp(&done, Label::kNear);
-
- // smi
- __ bind(&is_smi);
- __ SmiToInteger32(input_reg, input_reg);
- __ ClampUint8(input_reg);
-
- __ bind(&done);
-}
-
-
-void LCodeGen::DoDoubleBits(LDoubleBits* instr) {
- XMMRegister value_reg = ToDoubleRegister(instr->value());
- Register result_reg = ToRegister(instr->result());
- if (instr->hydrogen()->bits() == HDoubleBits::HIGH) {
- __ movq(result_reg, value_reg);
- __ shrq(result_reg, Immediate(32));
- } else {
- __ movd(result_reg, value_reg);
- }
-}
-
-
-void LCodeGen::DoConstructDouble(LConstructDouble* instr) {
- Register hi_reg = ToRegister(instr->hi());
- Register lo_reg = ToRegister(instr->lo());
- XMMRegister result_reg = ToDoubleRegister(instr->result());
- XMMRegister xmm_scratch = double_scratch0();
- __ movd(result_reg, hi_reg);
- __ psllq(result_reg, 32);
- __ movd(xmm_scratch, lo_reg);
- __ orps(result_reg, xmm_scratch);
-}
-
-
-void LCodeGen::DoAllocate(LAllocate* instr) {
- class DeferredAllocate final : public LDeferredCode {
- public:
- DeferredAllocate(LCodeGen* codegen, LAllocate* instr)
- : LDeferredCode(codegen), instr_(instr) { }
- void Generate() override { codegen()->DoDeferredAllocate(instr_); }
- LInstruction* instr() override { return instr_; }
-
- private:
- LAllocate* instr_;
- };
-
- DeferredAllocate* deferred =
- new(zone()) DeferredAllocate(this, instr);
-
- Register result = ToRegister(instr->result());
- Register temp = ToRegister(instr->temp());
-
- // Allocate memory for the object.
- AllocationFlags flags = TAG_OBJECT;
- if (instr->hydrogen()->MustAllocateDoubleAligned()) {
- flags = static_cast<AllocationFlags>(flags | DOUBLE_ALIGNMENT);
- }
- if (instr->hydrogen()->IsOldSpaceAllocation()) {
- DCHECK(!instr->hydrogen()->IsNewSpaceAllocation());
- flags = static_cast<AllocationFlags>(flags | PRETENURE);
- }
-
- if (instr->size()->IsConstantOperand()) {
- int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
- if (size <= Page::kMaxRegularHeapObjectSize) {
- __ Allocate(size, result, temp, no_reg, deferred->entry(), flags);
- } else {
- __ jmp(deferred->entry());
- }
- } else {
- Register size = ToRegister(instr->size());
- __ Allocate(size, result, temp, no_reg, deferred->entry(), flags);
- }
-
- __ bind(deferred->exit());
-
- if (instr->hydrogen()->MustPrefillWithFiller()) {
- if (instr->size()->IsConstantOperand()) {
- int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
- __ movl(temp, Immediate((size / kPointerSize) - 1));
- } else {
- temp = ToRegister(instr->size());
- __ sarp(temp, Immediate(kPointerSizeLog2));
- __ decl(temp);
- }
- Label loop;
- __ bind(&loop);
- __ Move(FieldOperand(result, temp, times_pointer_size, 0),
- isolate()->factory()->one_pointer_filler_map());
- __ decl(temp);
- __ j(not_zero, &loop);
- }
-}
-
-
-void LCodeGen::DoDeferredAllocate(LAllocate* instr) {
- Register result = ToRegister(instr->result());
-
- // TODO(3095996): Get rid of this. For now, we need to make the
- // result register contain a valid pointer because it is already
- // contained in the register pointer map.
- __ Move(result, Smi::FromInt(0));
-
- PushSafepointRegistersScope scope(this);
- if (instr->size()->IsRegister()) {
- Register size = ToRegister(instr->size());
- DCHECK(!size.is(result));
- __ Integer32ToSmi(size, size);
- __ Push(size);
- } else {
- int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
- __ Push(Smi::FromInt(size));
- }
-
- int flags = 0;
- if (instr->hydrogen()->IsOldSpaceAllocation()) {
- DCHECK(!instr->hydrogen()->IsNewSpaceAllocation());
- flags = AllocateTargetSpace::update(flags, OLD_SPACE);
- } else {
- flags = AllocateTargetSpace::update(flags, NEW_SPACE);
- }
- __ Push(Smi::FromInt(flags));
-
- CallRuntimeFromDeferred(
- Runtime::kAllocateInTargetSpace, 2, instr, instr->context());
- __ StoreToSafepointRegisterSlot(result, rax);
-}
-
-
-void LCodeGen::DoToFastProperties(LToFastProperties* instr) {
- DCHECK(ToRegister(instr->value()).is(rax));
- __ Push(rax);
- CallRuntime(Runtime::kToFastProperties, 1, instr);
-}
-
-
-void LCodeGen::DoRegExpLiteral(LRegExpLiteral* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- Label materialized;
- // Registers will be used as follows:
- // rcx = literals array.
- // rbx = regexp literal.
- // rax = regexp literal clone.
- int literal_offset =
- LiteralsArray::OffsetOfLiteralAt(instr->hydrogen()->literal_index());
- __ Move(rcx, instr->hydrogen()->literals());
- __ movp(rbx, FieldOperand(rcx, literal_offset));
- __ CompareRoot(rbx, Heap::kUndefinedValueRootIndex);
- __ j(not_equal, &materialized, Label::kNear);
-
- // Create regexp literal using runtime function
- // Result will be in rax.
- __ Push(rcx);
- __ Push(Smi::FromInt(instr->hydrogen()->literal_index()));
- __ Push(instr->hydrogen()->pattern());
- __ Push(instr->hydrogen()->flags());
- CallRuntime(Runtime::kMaterializeRegExpLiteral, 4, instr);
- __ movp(rbx, rax);
-
- __ bind(&materialized);
- int size = JSRegExp::kSize + JSRegExp::kInObjectFieldCount * kPointerSize;
- Label allocated, runtime_allocate;
- __ Allocate(size, rax, rcx, rdx, &runtime_allocate, TAG_OBJECT);
- __ jmp(&allocated, Label::kNear);
-
- __ bind(&runtime_allocate);
- __ Push(rbx);
- __ Push(Smi::FromInt(size));
- CallRuntime(Runtime::kAllocateInNewSpace, 1, instr);
- __ Pop(rbx);
-
- __ bind(&allocated);
- // Copy the content into the newly allocated memory.
- // (Unroll copy loop once for better throughput).
- for (int i = 0; i < size - kPointerSize; i += 2 * kPointerSize) {
- __ movp(rdx, FieldOperand(rbx, i));
- __ movp(rcx, FieldOperand(rbx, i + kPointerSize));
- __ movp(FieldOperand(rax, i), rdx);
- __ movp(FieldOperand(rax, i + kPointerSize), rcx);
- }
- if ((size % (2 * kPointerSize)) != 0) {
- __ movp(rdx, FieldOperand(rbx, size - kPointerSize));
- __ movp(FieldOperand(rax, size - kPointerSize), rdx);
- }
-}
-
-
-void LCodeGen::DoTypeof(LTypeof* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
- DCHECK(ToRegister(instr->value()).is(rbx));
- Label end, do_call;
- Register value_register = ToRegister(instr->value());
- __ JumpIfNotSmi(value_register, &do_call);
- __ Move(rax, isolate()->factory()->number_string());
- __ jmp(&end);
- __ bind(&do_call);
- TypeofStub stub(isolate());
- CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
- __ bind(&end);
-}
-
-
-void LCodeGen::EmitPushTaggedOperand(LOperand* operand) {
- DCHECK(!operand->IsDoubleRegister());
- if (operand->IsConstantOperand()) {
- __ Push(ToHandle(LConstantOperand::cast(operand)));
- } else if (operand->IsRegister()) {
- __ Push(ToRegister(operand));
- } else {
- __ Push(ToOperand(operand));
- }
-}
-
-
-void LCodeGen::DoTypeofIsAndBranch(LTypeofIsAndBranch* instr) {
- Register input = ToRegister(instr->value());
- Condition final_branch_condition = EmitTypeofIs(instr, input);
- if (final_branch_condition != no_condition) {
- EmitBranch(instr, final_branch_condition);
- }
-}
-
-
-Condition LCodeGen::EmitTypeofIs(LTypeofIsAndBranch* instr, Register input) {
- Label* true_label = instr->TrueLabel(chunk_);
- Label* false_label = instr->FalseLabel(chunk_);
- Handle<String> type_name = instr->type_literal();
- int left_block = instr->TrueDestination(chunk_);
- int right_block = instr->FalseDestination(chunk_);
- int next_block = GetNextEmittedBlock();
-
- Label::Distance true_distance = left_block == next_block ? Label::kNear
- : Label::kFar;
- Label::Distance false_distance = right_block == next_block ? Label::kNear
- : Label::kFar;
- Condition final_branch_condition = no_condition;
- Factory* factory = isolate()->factory();
- if (String::Equals(type_name, factory->number_string())) {
- __ JumpIfSmi(input, true_label, true_distance);
- __ CompareRoot(FieldOperand(input, HeapObject::kMapOffset),
- Heap::kHeapNumberMapRootIndex);
-
- final_branch_condition = equal;
-
- } else if (String::Equals(type_name, factory->string_string())) {
- __ JumpIfSmi(input, false_label, false_distance);
- __ CmpObjectType(input, FIRST_NONSTRING_TYPE, input);
- final_branch_condition = below;
-
- } else if (String::Equals(type_name, factory->symbol_string())) {
- __ JumpIfSmi(input, false_label, false_distance);
- __ CmpObjectType(input, SYMBOL_TYPE, input);
- final_branch_condition = equal;
-
- } else if (String::Equals(type_name, factory->boolean_string())) {
- __ CompareRoot(input, Heap::kTrueValueRootIndex);
- __ j(equal, true_label, true_distance);
- __ CompareRoot(input, Heap::kFalseValueRootIndex);
- final_branch_condition = equal;
-
- } else if (String::Equals(type_name, factory->undefined_string())) {
- __ CompareRoot(input, Heap::kUndefinedValueRootIndex);
- __ j(equal, true_label, true_distance);
- __ JumpIfSmi(input, false_label, false_distance);
- // Check for undetectable objects => true.
- __ movp(input, FieldOperand(input, HeapObject::kMapOffset));
- __ testb(FieldOperand(input, Map::kBitFieldOffset),
- Immediate(1 << Map::kIsUndetectable));
- final_branch_condition = not_zero;
-
- } else if (String::Equals(type_name, factory->function_string())) {
- __ JumpIfSmi(input, false_label, false_distance);
- // Check for callable and not undetectable objects => true.
- __ movp(input, FieldOperand(input, HeapObject::kMapOffset));
- __ movzxbl(input, FieldOperand(input, Map::kBitFieldOffset));
- __ andb(input,
- Immediate((1 << Map::kIsCallable) | (1 << Map::kIsUndetectable)));
- __ cmpb(input, Immediate(1 << Map::kIsCallable));
- final_branch_condition = equal;
-
- } else if (String::Equals(type_name, factory->object_string())) {
- __ JumpIfSmi(input, false_label, false_distance);
- __ CompareRoot(input, Heap::kNullValueRootIndex);
- __ j(equal, true_label, true_distance);
- STATIC_ASSERT(LAST_SPEC_OBJECT_TYPE == LAST_TYPE);
- __ CmpObjectType(input, FIRST_SPEC_OBJECT_TYPE, input);
- __ j(below, false_label, false_distance);
- // Check for callable or undetectable objects => false.
- __ testb(FieldOperand(input, Map::kBitFieldOffset),
- Immediate((1 << Map::kIsCallable) | (1 << Map::kIsUndetectable)));
- final_branch_condition = zero;
-
-// clang-format off
-#define SIMD128_TYPE(TYPE, Type, type, lane_count, lane_type) \
- } else if (String::Equals(type_name, factory->type##_string())) { \
- __ JumpIfSmi(input, false_label, false_distance); \
- __ CompareRoot(FieldOperand(input, HeapObject::kMapOffset), \
- Heap::k##Type##MapRootIndex); \
- final_branch_condition = equal;
- SIMD128_TYPES(SIMD128_TYPE)
-#undef SIMD128_TYPE
- // clang-format on
-
- } else {
- __ jmp(false_label, false_distance);
- }
-
- return final_branch_condition;
-}
-
-
-void LCodeGen::DoIsConstructCallAndBranch(LIsConstructCallAndBranch* instr) {
- Register temp = ToRegister(instr->temp());
-
- EmitIsConstructCall(temp);
- EmitBranch(instr, equal);
-}
-
-
-void LCodeGen::EmitIsConstructCall(Register temp) {
- // Get the frame pointer for the calling frame.
- __ movp(temp, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
-
- // Skip the arguments adaptor frame if it exists.
- Label check_frame_marker;
- __ Cmp(Operand(temp, StandardFrameConstants::kContextOffset),
- Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
- __ j(not_equal, &check_frame_marker, Label::kNear);
- __ movp(temp, Operand(temp, StandardFrameConstants::kCallerFPOffset));
-
- // Check the marker in the calling frame.
- __ bind(&check_frame_marker);
- __ Cmp(Operand(temp, StandardFrameConstants::kMarkerOffset),
- Smi::FromInt(StackFrame::CONSTRUCT));
-}
-
-
-void LCodeGen::EnsureSpaceForLazyDeopt(int space_needed) {
- if (info()->ShouldEnsureSpaceForLazyDeopt()) {
- // Ensure that we have enough space after the previous lazy-bailout
- // instruction for patching the code here.
- int current_pc = masm()->pc_offset();
- if (current_pc < last_lazy_deopt_pc_ + space_needed) {
- int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
- __ Nop(padding_size);
- }
- }
- last_lazy_deopt_pc_ = masm()->pc_offset();
-}
-
-
-void LCodeGen::DoLazyBailout(LLazyBailout* instr) {
- last_lazy_deopt_pc_ = masm()->pc_offset();
- DCHECK(instr->HasEnvironment());
- LEnvironment* env = instr->environment();
- RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt);
- safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
-}
-
-
-void LCodeGen::DoDeoptimize(LDeoptimize* instr) {
- Deoptimizer::BailoutType type = instr->hydrogen()->type();
- // TODO(danno): Stubs expect all deopts to be lazy for historical reasons (the
- // needed return address), even though the implementation of LAZY and EAGER is
- // now identical. When LAZY is eventually completely folded into EAGER, remove
- // the special case below.
- if (info()->IsStub() && type == Deoptimizer::EAGER) {
- type = Deoptimizer::LAZY;
- }
- DeoptimizeIf(no_condition, instr, instr->hydrogen()->reason(), type);
-}
-
-
-void LCodeGen::DoDummy(LDummy* instr) {
- // Nothing to see here, move on!
-}
-
-
-void LCodeGen::DoDummyUse(LDummyUse* instr) {
- // Nothing to see here, move on!
-}
-
-
-void LCodeGen::DoDeferredStackCheck(LStackCheck* instr) {
- PushSafepointRegistersScope scope(this);
- __ movp(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
- __ CallRuntimeSaveDoubles(Runtime::kStackGuard);
- RecordSafepointWithLazyDeopt(instr, RECORD_SAFEPOINT_WITH_REGISTERS, 0);
- DCHECK(instr->HasEnvironment());
- LEnvironment* env = instr->environment();
- safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
-}
-
-
-void LCodeGen::DoStackCheck(LStackCheck* instr) {
- class DeferredStackCheck final : public LDeferredCode {
- public:
- DeferredStackCheck(LCodeGen* codegen, LStackCheck* instr)
- : LDeferredCode(codegen), instr_(instr) { }
- void Generate() override { codegen()->DoDeferredStackCheck(instr_); }
- LInstruction* instr() override { return instr_; }
-
- private:
- LStackCheck* instr_;
- };
-
- DCHECK(instr->HasEnvironment());
- LEnvironment* env = instr->environment();
- // There is no LLazyBailout instruction for stack-checks. We have to
- // prepare for lazy deoptimization explicitly here.
- if (instr->hydrogen()->is_function_entry()) {
- // Perform stack overflow check.
- Label done;
- __ CompareRoot(rsp, Heap::kStackLimitRootIndex);
- __ j(above_equal, &done, Label::kNear);
-
- DCHECK(instr->context()->IsRegister());
- DCHECK(ToRegister(instr->context()).is(rsi));
- CallCode(isolate()->builtins()->StackCheck(),
- RelocInfo::CODE_TARGET,
- instr);
- __ bind(&done);
- } else {
- DCHECK(instr->hydrogen()->is_backwards_branch());
- // Perform stack overflow check if this goto needs it before jumping.
- DeferredStackCheck* deferred_stack_check =
- new(zone()) DeferredStackCheck(this, instr);
- __ CompareRoot(rsp, Heap::kStackLimitRootIndex);
- __ j(below, deferred_stack_check->entry());
- EnsureSpaceForLazyDeopt(Deoptimizer::patch_size());
- __ bind(instr->done_label());
- deferred_stack_check->SetExit(instr->done_label());
- RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt);
- // Don't record a deoptimization index for the safepoint here.
- // This will be done explicitly when emitting call and the safepoint in
- // the deferred code.
- }
-}
-
-
-void LCodeGen::DoOsrEntry(LOsrEntry* instr) {
- // This is a pseudo-instruction that ensures that the environment here is
- // properly registered for deoptimization and records the assembler's PC
- // offset.
- LEnvironment* environment = instr->environment();
-
- // If the environment were already registered, we would have no way of
- // backpatching it with the spill slot operands.
- DCHECK(!environment->HasBeenRegistered());
- RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);
-
- GenerateOsrPrologue();
-}
-
-
-void LCodeGen::DoForInPrepareMap(LForInPrepareMap* instr) {
- DCHECK(ToRegister(instr->context()).is(rsi));
-
- Condition cc = masm()->CheckSmi(rax);
- DeoptimizeIf(cc, instr, Deoptimizer::kSmi);
-
- STATIC_ASSERT(FIRST_JS_PROXY_TYPE == FIRST_SPEC_OBJECT_TYPE);
- __ CmpObjectType(rax, LAST_JS_PROXY_TYPE, rcx);
- DeoptimizeIf(below_equal, instr, Deoptimizer::kWrongInstanceType);
-
- Label use_cache, call_runtime;
- Register null_value = rdi;
- __ LoadRoot(null_value, Heap::kNullValueRootIndex);
- __ CheckEnumCache(null_value, &call_runtime);
-
- __ movp(rax, FieldOperand(rax, HeapObject::kMapOffset));
- __ jmp(&use_cache, Label::kNear);
-
- // Get the set of properties to enumerate.
- __ bind(&call_runtime);
- __ Push(rax);
- CallRuntime(Runtime::kGetPropertyNamesFast, 1, instr);
-
- __ CompareRoot(FieldOperand(rax, HeapObject::kMapOffset),
- Heap::kMetaMapRootIndex);
- DeoptimizeIf(not_equal, instr, Deoptimizer::kWrongMap);
- __ bind(&use_cache);
-}
-
-
-void LCodeGen::DoForInCacheArray(LForInCacheArray* instr) {
- Register map = ToRegister(instr->map());
- Register result = ToRegister(instr->result());
- Label load_cache, done;
- __ EnumLength(result, map);
- __ Cmp(result, Smi::FromInt(0));
- __ j(not_equal, &load_cache, Label::kNear);
- __ LoadRoot(result, Heap::kEmptyFixedArrayRootIndex);
- __ jmp(&done, Label::kNear);
- __ bind(&load_cache);
- __ LoadInstanceDescriptors(map, result);
- __ movp(result,
- FieldOperand(result, DescriptorArray::kEnumCacheOffset));
- __ movp(result,
- FieldOperand(result, FixedArray::SizeFor(instr->idx())));
- __ bind(&done);
- Condition cc = masm()->CheckSmi(result);
- DeoptimizeIf(cc, instr, Deoptimizer::kNoCache);
-}
-
-
-void LCodeGen::DoCheckMapValue(LCheckMapValue* instr) {
- Register object = ToRegister(instr->value());
- __ cmpp(ToRegister(instr->map()),
- FieldOperand(object, HeapObject::kMapOffset));
- DeoptimizeIf(not_equal, instr, Deoptimizer::kWrongMap);
-}
-
-
-void LCodeGen::DoDeferredLoadMutableDouble(LLoadFieldByIndex* instr,
- Register object,
- Register index) {
- PushSafepointRegistersScope scope(this);
- __ Push(object);
- __ Push(index);
- __ xorp(rsi, rsi);
- __ CallRuntimeSaveDoubles(Runtime::kLoadMutableDouble);
- RecordSafepointWithRegisters(
- instr->pointer_map(), 2, Safepoint::kNoLazyDeopt);
- __ StoreToSafepointRegisterSlot(object, rax);
-}
-
-
-void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
- class DeferredLoadMutableDouble final : public LDeferredCode {
- public:
- DeferredLoadMutableDouble(LCodeGen* codegen,
- LLoadFieldByIndex* instr,
- Register object,
- Register index)
- : LDeferredCode(codegen),
- instr_(instr),
- object_(object),
- index_(index) {
- }
- void Generate() override {
- codegen()->DoDeferredLoadMutableDouble(instr_, object_, index_);
- }
- LInstruction* instr() override { return instr_; }
-
- private:
- LLoadFieldByIndex* instr_;
- Register object_;
- Register index_;
- };
-
- Register object = ToRegister(instr->object());
- Register index = ToRegister(instr->index());
-
- DeferredLoadMutableDouble* deferred;
- deferred = new(zone()) DeferredLoadMutableDouble(this, instr, object, index);
-
- Label out_of_object, done;
- __ Move(kScratchRegister, Smi::FromInt(1));
- __ testp(index, kScratchRegister);
- __ j(not_zero, deferred->entry());
-
- __ sarp(index, Immediate(1));
-
- __ SmiToInteger32(index, index);
- __ cmpl(index, Immediate(0));
- __ j(less, &out_of_object, Label::kNear);
- __ movp(object, FieldOperand(object,
- index,
- times_pointer_size,
- JSObject::kHeaderSize));
- __ jmp(&done, Label::kNear);
-
- __ bind(&out_of_object);
- __ movp(object, FieldOperand(object, JSObject::kPropertiesOffset));
- __ negl(index);
- // Index is now equal to out of object property index plus 1.
- __ movp(object, FieldOperand(object,
- index,
- times_pointer_size,
- FixedArray::kHeaderSize - kPointerSize));
- __ bind(deferred->exit());
- __ bind(&done);
-}
-
-
-void LCodeGen::DoStoreFrameContext(LStoreFrameContext* instr) {
- Register context = ToRegister(instr->context());
- __ movp(Operand(rbp, StandardFrameConstants::kContextOffset), context);
-}
-
-
-void LCodeGen::DoAllocateBlockContext(LAllocateBlockContext* instr) {
- Handle<ScopeInfo> scope_info = instr->scope_info();
- __ Push(scope_info);
- __ Push(ToRegister(instr->function()));
- CallRuntime(Runtime::kPushBlockContext, 2, instr);
- RecordSafepoint(Safepoint::kNoLazyDeopt);
-}
-
-
-#undef __
-
-} // namespace internal
-} // namespace v8
-
-#endif // V8_TARGET_ARCH_X64
diff --git a/deps/v8/src/x64/lithium-codegen-x64.h b/deps/v8/src/x64/lithium-codegen-x64.h
deleted file mode 100644
index e05b310dec..0000000000
--- a/deps/v8/src/x64/lithium-codegen-x64.h
+++ /dev/null
@@ -1,392 +0,0 @@
-// Copyright 2012 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_X64_LITHIUM_CODEGEN_X64_H_
-#define V8_X64_LITHIUM_CODEGEN_X64_H_
-
-#include "src/x64/lithium-x64.h"
-
-#include "src/base/logging.h"
-#include "src/deoptimizer.h"
-#include "src/lithium-codegen.h"
-#include "src/safepoint-table.h"
-#include "src/scopes.h"
-#include "src/utils.h"
-#include "src/x64/lithium-gap-resolver-x64.h"
-
-namespace v8 {
-namespace internal {
-
-// Forward declarations.
-class LDeferredCode;
-class SafepointGenerator;
-
-class LCodeGen: public LCodeGenBase {
- public:
- LCodeGen(LChunk* chunk, MacroAssembler* assembler, CompilationInfo* info)
- : LCodeGenBase(chunk, assembler, info),
- deoptimizations_(4, info->zone()),
- jump_table_(4, info->zone()),
- inlined_function_count_(0),
- scope_(info->scope()),
- translations_(info->zone()),
- deferred_(8, info->zone()),
- osr_pc_offset_(-1),
- frame_is_built_(false),
- safepoints_(info->zone()),
- resolver_(this),
- expected_safepoint_kind_(Safepoint::kSimple) {
- PopulateDeoptimizationLiteralsWithInlinedFunctions();
- }
-
- int LookupDestination(int block_id) const {
- return chunk()->LookupDestination(block_id);
- }
-
- bool IsNextEmittedBlock(int block_id) const {
- return LookupDestination(block_id) == GetNextEmittedBlock();
- }
-
- bool NeedsEagerFrame() const {
- return GetStackSlotCount() > 0 ||
- info()->is_non_deferred_calling() ||
- !info()->IsStub() ||
- info()->requires_frame();
- }
- bool NeedsDeferredFrame() const {
- return !NeedsEagerFrame() && info()->is_deferred_calling();
- }
-
- // Support for converting LOperands to assembler types.
- Register ToRegister(LOperand* op) const;
- XMMRegister ToDoubleRegister(LOperand* op) const;
- bool IsInteger32Constant(LConstantOperand* op) const;
- bool IsExternalConstant(LConstantOperand* op) const;
- bool IsDehoistedKeyConstant(LConstantOperand* op) const;
- bool IsSmiConstant(LConstantOperand* op) const;
- int32_t ToRepresentation(LConstantOperand* op, const Representation& r) const;
- int32_t ToInteger32(LConstantOperand* op) const;
- Smi* ToSmi(LConstantOperand* op) const;
- double ToDouble(LConstantOperand* op) const;
- ExternalReference ToExternalReference(LConstantOperand* op) const;
- Handle<Object> ToHandle(LConstantOperand* op) const;
- Operand ToOperand(LOperand* op) const;
-
- // Try to generate code for the entire chunk, but it may fail if the
- // chunk contains constructs we cannot handle. Returns true if the
- // code generation attempt succeeded.
- bool GenerateCode();
-
- // Finish the code by setting stack height, safepoint, and bailout
- // information on it.
- void FinishCode(Handle<Code> code);
-
- // Deferred code support.
- void DoDeferredNumberTagD(LNumberTagD* instr);
-
- enum IntegerSignedness { SIGNED_INT32, UNSIGNED_INT32 };
- void DoDeferredNumberTagIU(LInstruction* instr,
- LOperand* value,
- LOperand* temp1,
- LOperand* temp2,
- IntegerSignedness signedness);
-
- void DoDeferredTaggedToI(LTaggedToI* instr, Label* done);
- void DoDeferredMathAbsTaggedHeapNumber(LMathAbs* instr);
- void DoDeferredStackCheck(LStackCheck* instr);
- void DoDeferredMaybeGrowElements(LMaybeGrowElements* instr);
- void DoDeferredStringCharCodeAt(LStringCharCodeAt* instr);
- void DoDeferredStringCharFromCode(LStringCharFromCode* instr);
- void DoDeferredAllocate(LAllocate* instr);
- void DoDeferredInstanceMigration(LCheckMaps* instr, Register object);
- void DoDeferredLoadMutableDouble(LLoadFieldByIndex* instr,
- Register object,
- Register index);
-
-// Parallel move support.
- void DoParallelMove(LParallelMove* move);
- void DoGap(LGap* instr);
-
- // Emit frame translation commands for an environment.
- void WriteTranslation(LEnvironment* environment, Translation* translation);
-
- // Declare methods that deal with the individual node types.
-#define DECLARE_DO(type) void Do##type(L##type* node);
- LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_DO)
-#undef DECLARE_DO
-
- private:
- LanguageMode language_mode() const { return info()->language_mode(); }
-
- LPlatformChunk* chunk() const { return chunk_; }
- Scope* scope() const { return scope_; }
- HGraph* graph() const { return chunk()->graph(); }
-
- XMMRegister double_scratch0() const { return xmm0; }
-
- void EmitClassOfTest(Label* if_true,
- Label* if_false,
- Handle<String> class_name,
- Register input,
- Register temporary,
- Register scratch);
-
- int GetStackSlotCount() const { return chunk()->spill_slot_count(); }
-
- void AddDeferredCode(LDeferredCode* code) { deferred_.Add(code, zone()); }
-
-
- void SaveCallerDoubles();
- void RestoreCallerDoubles();
-
- // Code generation passes. Returns true if code generation should
- // continue.
- void GenerateBodyInstructionPre(LInstruction* instr) override;
- void GenerateBodyInstructionPost(LInstruction* instr) override;
- bool GeneratePrologue();
- bool GenerateDeferredCode();
- bool GenerateJumpTable();
- bool GenerateSafepointTable();
-
- // Generates the custom OSR entrypoint and sets the osr_pc_offset.
- void GenerateOsrPrologue();
-
- enum SafepointMode {
- RECORD_SIMPLE_SAFEPOINT,
- RECORD_SAFEPOINT_WITH_REGISTERS
- };
-
- void CallCodeGeneric(Handle<Code> code,
- RelocInfo::Mode mode,
- LInstruction* instr,
- SafepointMode safepoint_mode,
- int argc);
-
-
- void CallCode(Handle<Code> code,
- RelocInfo::Mode mode,
- LInstruction* instr);
-
- void CallRuntime(const Runtime::Function* function,
- int num_arguments,
- LInstruction* instr,
- SaveFPRegsMode save_doubles = kDontSaveFPRegs);
-
- void CallRuntime(Runtime::FunctionId id,
- int num_arguments,
- LInstruction* instr) {
- const Runtime::Function* function = Runtime::FunctionForId(id);
- CallRuntime(function, num_arguments, instr);
- }
-
- void CallRuntimeFromDeferred(Runtime::FunctionId id,
- int argc,
- LInstruction* instr,
- LOperand* context);
-
- void LoadContextFromDeferred(LOperand* context);
-
- // Generate a direct call to a known function. Expects the function
- // to be in rdi.
- void CallKnownFunction(Handle<JSFunction> function,
- int formal_parameter_count, int arity,
- LInstruction* instr);
-
- void RecordSafepointWithLazyDeopt(LInstruction* instr,
- SafepointMode safepoint_mode,
- int argc);
- void RegisterEnvironmentForDeoptimization(LEnvironment* environment,
- Safepoint::DeoptMode mode);
- void DeoptimizeIf(Condition cc, LInstruction* instr,
- Deoptimizer::DeoptReason deopt_reason,
- Deoptimizer::BailoutType bailout_type);
- void DeoptimizeIf(Condition cc, LInstruction* instr,
- Deoptimizer::DeoptReason deopt_reason);
-
- bool DeoptEveryNTimes() {
- return FLAG_deopt_every_n_times != 0 && !info()->IsStub();
- }
-
- void AddToTranslation(LEnvironment* environment,
- Translation* translation,
- LOperand* op,
- bool is_tagged,
- bool is_uint32,
- int* object_index_pointer,
- int* dematerialized_index_pointer);
- void PopulateDeoptimizationData(Handle<Code> code);
-
- void PopulateDeoptimizationLiteralsWithInlinedFunctions();
-
- Register ToRegister(int index) const;
- XMMRegister ToDoubleRegister(int index) const;
- Operand BuildFastArrayOperand(
- LOperand* elements_pointer,
- LOperand* key,
- Representation key_representation,
- ElementsKind elements_kind,
- uint32_t base_offset);
-
- Operand BuildSeqStringOperand(Register string,
- LOperand* index,
- String::Encoding encoding);
-
- void EmitIntegerMathAbs(LMathAbs* instr);
- void EmitSmiMathAbs(LMathAbs* instr);
-
- // Support for recording safepoint and position information.
- void RecordSafepoint(LPointerMap* pointers,
- Safepoint::Kind kind,
- int arguments,
- Safepoint::DeoptMode mode);
- void RecordSafepoint(LPointerMap* pointers, Safepoint::DeoptMode mode);
- void RecordSafepoint(Safepoint::DeoptMode mode);
- void RecordSafepointWithRegisters(LPointerMap* pointers,
- int arguments,
- Safepoint::DeoptMode mode);
- void RecordAndWritePosition(int position) override;
-
- static Condition TokenToCondition(Token::Value op, bool is_unsigned);
- void EmitGoto(int block);
-
- // EmitBranch expects to be the last instruction of a block.
- template<class InstrType>
- void EmitBranch(InstrType instr, Condition cc);
- template <class InstrType>
- void EmitTrueBranch(InstrType instr, Condition cc);
- template <class InstrType>
- void EmitFalseBranch(InstrType instr, Condition cc);
- void EmitNumberUntagD(LNumberUntagD* instr, Register input,
- XMMRegister result, NumberUntagDMode mode);
-
- // Emits optimized code for typeof x == "y". Modifies input register.
- // Returns the condition on which a final split to
- // true and false label should be made, to optimize fallthrough.
- Condition EmitTypeofIs(LTypeofIsAndBranch* instr, Register input);
-
- // Emits optimized code for %_IsString(x). Preserves input register.
- // Returns the condition on which a final split to
- // true and false label should be made, to optimize fallthrough.
- Condition EmitIsString(Register input,
- Register temp1,
- Label* is_not_string,
- SmiCheck check_needed);
-
- // Emits optimized code for %_IsConstructCall().
- // Caller should branch on equal condition.
- void EmitIsConstructCall(Register temp);
-
- // Emits code for pushing either a tagged constant, a (non-double)
- // register, or a stack slot operand.
- void EmitPushTaggedOperand(LOperand* operand);
-
- // Emits optimized code to deep-copy the contents of statically known
- // object graphs (e.g. object literal boilerplate).
- void EmitDeepCopy(Handle<JSObject> object,
- Register result,
- Register source,
- int* offset,
- AllocationSiteMode mode);
-
- void EnsureSpaceForLazyDeopt(int space_needed) override;
- void DoLoadKeyedExternalArray(LLoadKeyed* instr);
- void DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr);
- void DoLoadKeyedFixedArray(LLoadKeyed* instr);
- void DoStoreKeyedExternalArray(LStoreKeyed* instr);
- void DoStoreKeyedFixedDoubleArray(LStoreKeyed* instr);
- void DoStoreKeyedFixedArray(LStoreKeyed* instr);
-
- template <class T>
- void EmitVectorLoadICRegisters(T* instr);
- template <class T>
- void EmitVectorStoreICRegisters(T* instr);
-
-#ifdef _MSC_VER
- // On windows, you may not access the stack more than one page below
- // the most recently mapped page. To make the allocated area randomly
- // accessible, we write an arbitrary value to each page in range
- // rsp + offset - page_size .. rsp in turn.
- void MakeSureStackPagesMapped(int offset);
-#endif
-
- ZoneList<LEnvironment*> deoptimizations_;
- ZoneList<Deoptimizer::JumpTableEntry> jump_table_;
- int inlined_function_count_;
- Scope* const scope_;
- TranslationBuffer translations_;
- ZoneList<LDeferredCode*> deferred_;
- int osr_pc_offset_;
- bool frame_is_built_;
-
- // Builder that keeps track of safepoints in the code. The table
- // itself is emitted at the end of the generated code.
- SafepointTableBuilder safepoints_;
-
- // Compiler from a set of parallel moves to a sequential list of moves.
- LGapResolver resolver_;
-
- Safepoint::Kind expected_safepoint_kind_;
-
- class PushSafepointRegistersScope final BASE_EMBEDDED {
- public:
- explicit PushSafepointRegistersScope(LCodeGen* codegen)
- : codegen_(codegen) {
- DCHECK(codegen_->info()->is_calling());
- DCHECK(codegen_->expected_safepoint_kind_ == Safepoint::kSimple);
- codegen_->masm_->PushSafepointRegisters();
- codegen_->expected_safepoint_kind_ = Safepoint::kWithRegisters;
- }
-
- ~PushSafepointRegistersScope() {
- DCHECK(codegen_->expected_safepoint_kind_ == Safepoint::kWithRegisters);
- codegen_->masm_->PopSafepointRegisters();
- codegen_->expected_safepoint_kind_ = Safepoint::kSimple;
- }
-
- private:
- LCodeGen* codegen_;
- };
-
- friend class LDeferredCode;
- friend class LEnvironment;
- friend class SafepointGenerator;
- DISALLOW_COPY_AND_ASSIGN(LCodeGen);
-};
-
-
-class LDeferredCode: public ZoneObject {
- public:
- explicit LDeferredCode(LCodeGen* codegen)
- : codegen_(codegen),
- external_exit_(NULL),
- instruction_index_(codegen->current_instruction_) {
- codegen->AddDeferredCode(this);
- }
-
- virtual ~LDeferredCode() {}
- virtual void Generate() = 0;
- virtual LInstruction* instr() = 0;
-
- void SetExit(Label* exit) { external_exit_ = exit; }
- Label* entry() { return &entry_; }
- Label* exit() { return external_exit_ != NULL ? external_exit_ : &exit_; }
- Label* done() { return codegen_->NeedsDeferredFrame() ? &done_ : exit(); }
- int instruction_index() const { return instruction_index_; }
-
- protected:
- LCodeGen* codegen() const { return codegen_; }
- MacroAssembler* masm() const { return codegen_->masm(); }
-
- private:
- LCodeGen* codegen_;
- Label entry_;
- Label exit_;
- Label done_;
- Label* external_exit_;
- int instruction_index_;
-};
-
-} } // namespace v8::internal
-
-#endif // V8_X64_LITHIUM_CODEGEN_X64_H_
diff --git a/deps/v8/src/x64/lithium-gap-resolver-x64.cc b/deps/v8/src/x64/lithium-gap-resolver-x64.cc
deleted file mode 100644
index 800fb3f61c..0000000000
--- a/deps/v8/src/x64/lithium-gap-resolver-x64.cc
+++ /dev/null
@@ -1,318 +0,0 @@
-// Copyright 2011 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#if V8_TARGET_ARCH_X64
-
-#include "src/x64/lithium-codegen-x64.h"
-#include "src/x64/lithium-gap-resolver-x64.h"
-
-namespace v8 {
-namespace internal {
-
-LGapResolver::LGapResolver(LCodeGen* owner)
- : cgen_(owner), moves_(32, owner->zone()) {}
-
-
-void LGapResolver::Resolve(LParallelMove* parallel_move) {
- DCHECK(moves_.is_empty());
- // Build up a worklist of moves.
- BuildInitialMoveList(parallel_move);
-
- for (int i = 0; i < moves_.length(); ++i) {
- LMoveOperands move = moves_[i];
- // Skip constants to perform them last. They don't block other moves
- // and skipping such moves with register destinations keeps those
- // registers free for the whole algorithm.
- if (!move.IsEliminated() && !move.source()->IsConstantOperand()) {
- PerformMove(i);
- }
- }
-
- // Perform the moves with constant sources.
- for (int i = 0; i < moves_.length(); ++i) {
- if (!moves_[i].IsEliminated()) {
- DCHECK(moves_[i].source()->IsConstantOperand());
- EmitMove(i);
- }
- }
-
- moves_.Rewind(0);
-}
-
-
-void LGapResolver::BuildInitialMoveList(LParallelMove* parallel_move) {
- // Perform a linear sweep of the moves to add them to the initial list of
- // moves to perform, ignoring any move that is redundant (the source is
- // the same as the destination, the destination is ignored and
- // unallocated, or the move was already eliminated).
- const ZoneList<LMoveOperands>* moves = parallel_move->move_operands();
- for (int i = 0; i < moves->length(); ++i) {
- LMoveOperands move = moves->at(i);
- if (!move.IsRedundant()) moves_.Add(move, cgen_->zone());
- }
- Verify();
-}
-
-
-void LGapResolver::PerformMove(int index) {
- // Each call to this function performs a move and deletes it from the move
- // graph. We first recursively perform any move blocking this one. We
- // mark a move as "pending" on entry to PerformMove in order to detect
- // cycles in the move graph. We use operand swaps to resolve cycles,
- // which means that a call to PerformMove could change any source operand
- // in the move graph.
-
- DCHECK(!moves_[index].IsPending());
- DCHECK(!moves_[index].IsRedundant());
-
- // Clear this move's destination to indicate a pending move. The actual
- // destination is saved in a stack-allocated local. Recursion may allow
- // multiple moves to be pending.
- DCHECK(moves_[index].source() != NULL); // Or else it will look eliminated.
- LOperand* destination = moves_[index].destination();
- moves_[index].set_destination(NULL);
-
- // Perform a depth-first traversal of the move graph to resolve
- // dependencies. Any unperformed, unpending move with a source the same
- // as this one's destination blocks this one so recursively perform all
- // such moves.
- for (int i = 0; i < moves_.length(); ++i) {
- LMoveOperands other_move = moves_[i];
- if (other_move.Blocks(destination) && !other_move.IsPending()) {
- // Though PerformMove can change any source operand in the move graph,
- // this call cannot create a blocking move via a swap (this loop does
- // not miss any). Assume there is a non-blocking move with source A
- // and this move is blocked on source B and there is a swap of A and
- // B. Then A and B must be involved in the same cycle (or they would
- // not be swapped). Since this move's destination is B and there is
- // only a single incoming edge to an operand, this move must also be
- // involved in the same cycle. In that case, the blocking move will
- // be created but will be "pending" when we return from PerformMove.
- PerformMove(i);
- }
- }
-
- // We are about to resolve this move and don't need it marked as
- // pending, so restore its destination.
- moves_[index].set_destination(destination);
-
- // This move's source may have changed due to swaps to resolve cycles and
- // so it may now be the last move in the cycle. If so remove it.
- if (moves_[index].source()->Equals(destination)) {
- moves_[index].Eliminate();
- return;
- }
-
- // The move may be blocked on a (at most one) pending move, in which case
- // we have a cycle. Search for such a blocking move and perform a swap to
- // resolve it.
- for (int i = 0; i < moves_.length(); ++i) {
- LMoveOperands other_move = moves_[i];
- if (other_move.Blocks(destination)) {
- DCHECK(other_move.IsPending());
- EmitSwap(index);
- return;
- }
- }
-
- // This move is not blocked.
- EmitMove(index);
-}
-
-
-void LGapResolver::Verify() {
-#ifdef ENABLE_SLOW_DCHECKS
- // No operand should be the destination for more than one move.
- for (int i = 0; i < moves_.length(); ++i) {
- LOperand* destination = moves_[i].destination();
- for (int j = i + 1; j < moves_.length(); ++j) {
- SLOW_DCHECK(!destination->Equals(moves_[j].destination()));
- }
- }
-#endif
-}
-
-
-#define __ ACCESS_MASM(cgen_->masm())
-
-
-void LGapResolver::EmitMove(int index) {
- LOperand* source = moves_[index].source();
- LOperand* destination = moves_[index].destination();
-
- // Dispatch on the source and destination operand kinds. Not all
- // combinations are possible.
- if (source->IsRegister()) {
- Register src = cgen_->ToRegister(source);
- if (destination->IsRegister()) {
- Register dst = cgen_->ToRegister(destination);
- __ movp(dst, src);
- } else {
- DCHECK(destination->IsStackSlot());
- Operand dst = cgen_->ToOperand(destination);
- __ movp(dst, src);
- }
-
- } else if (source->IsStackSlot()) {
- Operand src = cgen_->ToOperand(source);
- if (destination->IsRegister()) {
- Register dst = cgen_->ToRegister(destination);
- __ movp(dst, src);
- } else {
- DCHECK(destination->IsStackSlot());
- Operand dst = cgen_->ToOperand(destination);
- __ movp(kScratchRegister, src);
- __ movp(dst, kScratchRegister);
- }
-
- } else if (source->IsConstantOperand()) {
- LConstantOperand* constant_source = LConstantOperand::cast(source);
- if (destination->IsRegister()) {
- Register dst = cgen_->ToRegister(destination);
- if (cgen_->IsSmiConstant(constant_source)) {
- __ Move(dst, cgen_->ToSmi(constant_source));
- } else if (cgen_->IsInteger32Constant(constant_source)) {
- int32_t constant = cgen_->ToInteger32(constant_source);
- // Do sign extension only for constant used as de-hoisted array key.
- // Others only need zero extension, which saves 2 bytes.
- if (cgen_->IsDehoistedKeyConstant(constant_source)) {
- __ Set(dst, constant);
- } else {
- __ Set(dst, static_cast<uint32_t>(constant));
- }
- } else {
- __ Move(dst, cgen_->ToHandle(constant_source));
- }
- } else if (destination->IsDoubleRegister()) {
- double v = cgen_->ToDouble(constant_source);
- uint64_t int_val = bit_cast<uint64_t, double>(v);
- XMMRegister dst = cgen_->ToDoubleRegister(destination);
- if (int_val == 0) {
- __ xorps(dst, dst);
- } else {
- __ Set(kScratchRegister, int_val);
- __ movq(dst, kScratchRegister);
- }
- } else {
- DCHECK(destination->IsStackSlot());
- Operand dst = cgen_->ToOperand(destination);
- if (cgen_->IsSmiConstant(constant_source)) {
- __ Move(dst, cgen_->ToSmi(constant_source));
- } else if (cgen_->IsInteger32Constant(constant_source)) {
- // Do sign extension to 64 bits when stored into stack slot.
- __ movp(dst, Immediate(cgen_->ToInteger32(constant_source)));
- } else {
- __ Move(kScratchRegister, cgen_->ToHandle(constant_source));
- __ movp(dst, kScratchRegister);
- }
- }
-
- } else if (source->IsDoubleRegister()) {
- XMMRegister src = cgen_->ToDoubleRegister(source);
- if (destination->IsDoubleRegister()) {
- __ movaps(cgen_->ToDoubleRegister(destination), src);
- } else {
- DCHECK(destination->IsDoubleStackSlot());
- __ movsd(cgen_->ToOperand(destination), src);
- }
- } else if (source->IsDoubleStackSlot()) {
- Operand src = cgen_->ToOperand(source);
- if (destination->IsDoubleRegister()) {
- __ movsd(cgen_->ToDoubleRegister(destination), src);
- } else {
- DCHECK(destination->IsDoubleStackSlot());
- __ movsd(xmm0, src);
- __ movsd(cgen_->ToOperand(destination), xmm0);
- }
- } else {
- UNREACHABLE();
- }
-
- moves_[index].Eliminate();
-}
-
-
-void LGapResolver::EmitSwap(int index) {
- LOperand* source = moves_[index].source();
- LOperand* destination = moves_[index].destination();
-
- // Dispatch on the source and destination operand kinds. Not all
- // combinations are possible.
- if (source->IsRegister() && destination->IsRegister()) {
- // Swap two general-purpose registers.
- Register src = cgen_->ToRegister(source);
- Register dst = cgen_->ToRegister(destination);
- __ xchgq(dst, src);
-
- } else if ((source->IsRegister() && destination->IsStackSlot()) ||
- (source->IsStackSlot() && destination->IsRegister())) {
- // Swap a general-purpose register and a stack slot.
- Register reg =
- cgen_->ToRegister(source->IsRegister() ? source : destination);
- Operand mem =
- cgen_->ToOperand(source->IsRegister() ? destination : source);
- __ movp(kScratchRegister, mem);
- __ movp(mem, reg);
- __ movp(reg, kScratchRegister);
-
- } else if ((source->IsStackSlot() && destination->IsStackSlot()) ||
- (source->IsDoubleStackSlot() && destination->IsDoubleStackSlot())) {
- // Swap two stack slots or two double stack slots.
- Operand src = cgen_->ToOperand(source);
- Operand dst = cgen_->ToOperand(destination);
- __ movsd(xmm0, src);
- __ movp(kScratchRegister, dst);
- __ movsd(dst, xmm0);
- __ movp(src, kScratchRegister);
-
- } else if (source->IsDoubleRegister() && destination->IsDoubleRegister()) {
- // Swap two double registers.
- XMMRegister source_reg = cgen_->ToDoubleRegister(source);
- XMMRegister destination_reg = cgen_->ToDoubleRegister(destination);
- __ movaps(xmm0, source_reg);
- __ movaps(source_reg, destination_reg);
- __ movaps(destination_reg, xmm0);
-
- } else if (source->IsDoubleRegister() || destination->IsDoubleRegister()) {
- // Swap a double register and a double stack slot.
- DCHECK((source->IsDoubleRegister() && destination->IsDoubleStackSlot()) ||
- (source->IsDoubleStackSlot() && destination->IsDoubleRegister()));
- XMMRegister reg = cgen_->ToDoubleRegister(source->IsDoubleRegister()
- ? source
- : destination);
- LOperand* other = source->IsDoubleRegister() ? destination : source;
- DCHECK(other->IsDoubleStackSlot());
- Operand other_operand = cgen_->ToOperand(other);
- __ movsd(xmm0, other_operand);
- __ movsd(other_operand, reg);
- __ movaps(reg, xmm0);
-
- } else {
- // No other combinations are possible.
- UNREACHABLE();
- }
-
- // The swap of source and destination has executed a move from source to
- // destination.
- moves_[index].Eliminate();
-
- // Any unperformed (including pending) move with a source of either
- // this move's source or destination needs to have their source
- // changed to reflect the state of affairs after the swap.
- for (int i = 0; i < moves_.length(); ++i) {
- LMoveOperands other_move = moves_[i];
- if (other_move.Blocks(source)) {
- moves_[i].set_source(destination);
- } else if (other_move.Blocks(destination)) {
- moves_[i].set_source(source);
- }
- }
-}
-
-#undef __
-
-} // namespace internal
-} // namespace v8
-
-#endif // V8_TARGET_ARCH_X64
diff --git a/deps/v8/src/x64/lithium-gap-resolver-x64.h b/deps/v8/src/x64/lithium-gap-resolver-x64.h
deleted file mode 100644
index 7882da56e0..0000000000
--- a/deps/v8/src/x64/lithium-gap-resolver-x64.h
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2011 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_X64_LITHIUM_GAP_RESOLVER_X64_H_
-#define V8_X64_LITHIUM_GAP_RESOLVER_X64_H_
-
-#include "src/lithium.h"
-
-namespace v8 {
-namespace internal {
-
-class LCodeGen;
-class LGapResolver;
-
-class LGapResolver final BASE_EMBEDDED {
- public:
- explicit LGapResolver(LCodeGen* owner);
-
- // Resolve a set of parallel moves, emitting assembler instructions.
- void Resolve(LParallelMove* parallel_move);
-
- private:
- // Build the initial list of moves.
- void BuildInitialMoveList(LParallelMove* parallel_move);
-
- // Perform the move at the moves_ index in question (possibly requiring
- // other moves to satisfy dependencies).
- void PerformMove(int index);
-
- // Emit a move and remove it from the move graph.
- void EmitMove(int index);
-
- // Execute a move by emitting a swap of two operands. The move from
- // source to destination is removed from the move graph.
- void EmitSwap(int index);
-
- // Verify the move list before performing moves.
- void Verify();
-
- LCodeGen* cgen_;
-
- // List of moves not yet resolved.
- ZoneList<LMoveOperands> moves_;
-};
-
-} } // namespace v8::internal
-
-#endif // V8_X64_LITHIUM_GAP_RESOLVER_X64_H_
diff --git a/deps/v8/src/x64/lithium-x64.cc b/deps/v8/src/x64/lithium-x64.cc
deleted file mode 100644
index 9df3a7dabf..0000000000
--- a/deps/v8/src/x64/lithium-x64.cc
+++ /dev/null
@@ -1,2749 +0,0 @@
-// Copyright 2012 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "src/x64/lithium-x64.h"
-
-#include <sstream>
-
-#if V8_TARGET_ARCH_X64
-
-#include "src/hydrogen-osr.h"
-#include "src/lithium-inl.h"
-#include "src/x64/lithium-codegen-x64.h"
-
-namespace v8 {
-namespace internal {
-
-#define DEFINE_COMPILE(type) \
- void L##type::CompileToNative(LCodeGen* generator) { \
- generator->Do##type(this); \
- }
-LITHIUM_CONCRETE_INSTRUCTION_LIST(DEFINE_COMPILE)
-#undef DEFINE_COMPILE
-
-
-#ifdef DEBUG
-void LInstruction::VerifyCall() {
- // Call instructions can use only fixed registers as temporaries and
- // outputs because all registers are blocked by the calling convention.
- // Inputs operands must use a fixed register or use-at-start policy or
- // a non-register policy.
- DCHECK(Output() == NULL ||
- LUnallocated::cast(Output())->HasFixedPolicy() ||
- !LUnallocated::cast(Output())->HasRegisterPolicy());
- for (UseIterator it(this); !it.Done(); it.Advance()) {
- LUnallocated* operand = LUnallocated::cast(it.Current());
- DCHECK(operand->HasFixedPolicy() ||
- operand->IsUsedAtStart());
- }
- for (TempIterator it(this); !it.Done(); it.Advance()) {
- LUnallocated* operand = LUnallocated::cast(it.Current());
- DCHECK(operand->HasFixedPolicy() ||!operand->HasRegisterPolicy());
- }
-}
-#endif
-
-
-void LInstruction::PrintTo(StringStream* stream) {
- stream->Add("%s ", this->Mnemonic());
-
- PrintOutputOperandTo(stream);
-
- PrintDataTo(stream);
-
- if (HasEnvironment()) {
- stream->Add(" ");
- environment()->PrintTo(stream);
- }
-
- if (HasPointerMap()) {
- stream->Add(" ");
- pointer_map()->PrintTo(stream);
- }
-}
-
-
-void LInstruction::PrintDataTo(StringStream* stream) {
- stream->Add("= ");
- for (int i = 0; i < InputCount(); i++) {
- if (i > 0) stream->Add(" ");
- if (InputAt(i) == NULL) {
- stream->Add("NULL");
- } else {
- InputAt(i)->PrintTo(stream);
- }
- }
-}
-
-
-void LInstruction::PrintOutputOperandTo(StringStream* stream) {
- if (HasResult()) result()->PrintTo(stream);
-}
-
-
-void LLabel::PrintDataTo(StringStream* stream) {
- LGap::PrintDataTo(stream);
- LLabel* rep = replacement();
- if (rep != NULL) {
- stream->Add(" Dead block replaced with B%d", rep->block_id());
- }
-}
-
-
-bool LGap::IsRedundant() const {
- for (int i = 0; i < 4; i++) {
- if (parallel_moves_[i] != NULL && !parallel_moves_[i]->IsRedundant()) {
- return false;
- }
- }
-
- return true;
-}
-
-
-void LGap::PrintDataTo(StringStream* stream) {
- for (int i = 0; i < 4; i++) {
- stream->Add("(");
- if (parallel_moves_[i] != NULL) {
- parallel_moves_[i]->PrintDataTo(stream);
- }
- stream->Add(") ");
- }
-}
-
-
-const char* LArithmeticD::Mnemonic() const {
- switch (op()) {
- case Token::ADD: return "add-d";
- case Token::SUB: return "sub-d";
- case Token::MUL: return "mul-d";
- case Token::DIV: return "div-d";
- case Token::MOD: return "mod-d";
- default:
- UNREACHABLE();
- return NULL;
- }
-}
-
-
-const char* LArithmeticT::Mnemonic() const {
- switch (op()) {
- case Token::ADD: return "add-t";
- case Token::SUB: return "sub-t";
- case Token::MUL: return "mul-t";
- case Token::MOD: return "mod-t";
- case Token::DIV: return "div-t";
- case Token::BIT_AND: return "bit-and-t";
- case Token::BIT_OR: return "bit-or-t";
- case Token::BIT_XOR: return "bit-xor-t";
- case Token::ROR: return "ror-t";
- case Token::SHL: return "sal-t";
- case Token::SAR: return "sar-t";
- case Token::SHR: return "shr-t";
- default:
- UNREACHABLE();
- return NULL;
- }
-}
-
-
-bool LGoto::HasInterestingComment(LCodeGen* gen) const {
- return !gen->IsNextEmittedBlock(block_id());
-}
-
-
-template<int R>
-bool LTemplateResultInstruction<R>::MustSignExtendResult(
- LPlatformChunk* chunk) const {
- HValue* hvalue = this->hydrogen_value();
- return hvalue != NULL &&
- hvalue->representation().IsInteger32() &&
- chunk->GetDehoistedKeyIds()->Contains(hvalue->id());
-}
-
-
-void LGoto::PrintDataTo(StringStream* stream) {
- stream->Add("B%d", block_id());
-}
-
-
-void LBranch::PrintDataTo(StringStream* stream) {
- stream->Add("B%d | B%d on ", true_block_id(), false_block_id());
- value()->PrintTo(stream);
-}
-
-
-void LCompareNumericAndBranch::PrintDataTo(StringStream* stream) {
- stream->Add("if ");
- left()->PrintTo(stream);
- stream->Add(" %s ", Token::String(op()));
- right()->PrintTo(stream);
- stream->Add(" then B%d else B%d", true_block_id(), false_block_id());
-}
-
-
-void LIsStringAndBranch::PrintDataTo(StringStream* stream) {
- stream->Add("if is_string(");
- value()->PrintTo(stream);
- stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
-}
-
-
-void LIsSmiAndBranch::PrintDataTo(StringStream* stream) {
- stream->Add("if is_smi(");
- value()->PrintTo(stream);
- stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
-}
-
-
-void LIsUndetectableAndBranch::PrintDataTo(StringStream* stream) {
- stream->Add("if is_undetectable(");
- value()->PrintTo(stream);
- stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
-}
-
-
-void LStringCompareAndBranch::PrintDataTo(StringStream* stream) {
- stream->Add("if string_compare(");
- left()->PrintTo(stream);
- right()->PrintTo(stream);
- stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
-}
-
-
-void LHasInstanceTypeAndBranch::PrintDataTo(StringStream* stream) {
- stream->Add("if has_instance_type(");
- value()->PrintTo(stream);
- stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
-}
-
-
-void LHasCachedArrayIndexAndBranch::PrintDataTo(StringStream* stream) {
- stream->Add("if has_cached_array_index(");
- value()->PrintTo(stream);
- stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
-}
-
-
-void LClassOfTestAndBranch::PrintDataTo(StringStream* stream) {
- stream->Add("if class_of_test(");
- value()->PrintTo(stream);
- stream->Add(", \"%o\") then B%d else B%d",
- *hydrogen()->class_name(),
- true_block_id(),
- false_block_id());
-}
-
-
-void LTypeofIsAndBranch::PrintDataTo(StringStream* stream) {
- stream->Add("if typeof ");
- value()->PrintTo(stream);
- stream->Add(" == \"%s\" then B%d else B%d",
- hydrogen()->type_literal()->ToCString().get(),
- true_block_id(), false_block_id());
-}
-
-
-void LStoreCodeEntry::PrintDataTo(StringStream* stream) {
- stream->Add(" = ");
- function()->PrintTo(stream);
- stream->Add(".code_entry = ");
- code_object()->PrintTo(stream);
-}
-
-
-void LInnerAllocatedObject::PrintDataTo(StringStream* stream) {
- stream->Add(" = ");
- base_object()->PrintTo(stream);
- stream->Add(" + ");
- offset()->PrintTo(stream);
-}
-
-
-void LCallFunction::PrintDataTo(StringStream* stream) {
- context()->PrintTo(stream);
- stream->Add(" ");
- function()->PrintTo(stream);
- if (hydrogen()->HasVectorAndSlot()) {
- stream->Add(" (type-feedback-vector ");
- temp_vector()->PrintTo(stream);
- stream->Add(" ");
- temp_slot()->PrintTo(stream);
- stream->Add(")");
- }
-}
-
-
-void LCallJSFunction::PrintDataTo(StringStream* stream) {
- stream->Add("= ");
- function()->PrintTo(stream);
- stream->Add("#%d / ", arity());
-}
-
-
-void LCallWithDescriptor::PrintDataTo(StringStream* stream) {
- for (int i = 0; i < InputCount(); i++) {
- InputAt(i)->PrintTo(stream);
- stream->Add(" ");
- }
- stream->Add("#%d / ", arity());
-}
-
-
-void LLoadContextSlot::PrintDataTo(StringStream* stream) {
- context()->PrintTo(stream);
- stream->Add("[%d]", slot_index());
-}
-
-
-void LStoreContextSlot::PrintDataTo(StringStream* stream) {
- context()->PrintTo(stream);
- stream->Add("[%d] <- ", slot_index());
- value()->PrintTo(stream);
-}
-
-
-void LInvokeFunction::PrintDataTo(StringStream* stream) {
- stream->Add("= ");
- function()->PrintTo(stream);
- stream->Add(" #%d / ", arity());
-}
-
-
-void LCallNew::PrintDataTo(StringStream* stream) {
- stream->Add("= ");
- constructor()->PrintTo(stream);
- stream->Add(" #%d / ", arity());
-}
-
-
-void LCallNewArray::PrintDataTo(StringStream* stream) {
- stream->Add("= ");
- constructor()->PrintTo(stream);
- stream->Add(" #%d / ", arity());
- ElementsKind kind = hydrogen()->elements_kind();
- stream->Add(" (%s) ", ElementsKindToString(kind));
-}
-
-
-void LAccessArgumentsAt::PrintDataTo(StringStream* stream) {
- arguments()->PrintTo(stream);
-
- stream->Add(" length ");
- length()->PrintTo(stream);
-
- stream->Add(" index ");
- index()->PrintTo(stream);
-}
-
-
-int LPlatformChunk::GetNextSpillIndex(RegisterKind kind) {
- if (kind == DOUBLE_REGISTERS && kDoubleSize == 2 * kPointerSize) {
- // Skip a slot if for a double-width slot for x32 port.
- spill_slot_count_++;
- // The spill slot's address is at rbp - (index + 1) * kPointerSize -
- // StandardFrameConstants::kFixedFrameSizeFromFp. kFixedFrameSizeFromFp is
- // 2 * kPointerSize, if rbp is aligned at 8-byte boundary, the below "|= 1"
- // will make sure the spilled doubles are aligned at 8-byte boundary.
- // TODO(haitao): make sure rbp is aligned at 8-byte boundary for x32 port.
- spill_slot_count_ |= 1;
- }
- return spill_slot_count_++;
-}
-
-
-LOperand* LPlatformChunk::GetNextSpillSlot(RegisterKind kind) {
- // All stack slots are Double stack slots on x64.
- // Alternatively, at some point, start using half-size
- // stack slots for int32 values.
- int index = GetNextSpillIndex(kind);
- if (kind == DOUBLE_REGISTERS) {
- return LDoubleStackSlot::Create(index, zone());
- } else {
- DCHECK(kind == GENERAL_REGISTERS);
- return LStackSlot::Create(index, zone());
- }
-}
-
-
-void LLoadGlobalViaContext::PrintDataTo(StringStream* stream) {
- stream->Add("depth:%d slot:%d", depth(), slot_index());
-}
-
-
-void LStoreNamedField::PrintDataTo(StringStream* stream) {
- object()->PrintTo(stream);
- std::ostringstream os;
- os << hydrogen()->access() << " <- ";
- stream->Add(os.str().c_str());
- value()->PrintTo(stream);
-}
-
-
-void LStoreNamedGeneric::PrintDataTo(StringStream* stream) {
- object()->PrintTo(stream);
- stream->Add(".");
- stream->Add(String::cast(*name())->ToCString().get());
- stream->Add(" <- ");
- value()->PrintTo(stream);
-}
-
-
-void LStoreGlobalViaContext::PrintDataTo(StringStream* stream) {
- stream->Add("depth:%d slot:%d <- ", depth(), slot_index());
- value()->PrintTo(stream);
-}
-
-
-void LLoadKeyed::PrintDataTo(StringStream* stream) {
- elements()->PrintTo(stream);
- stream->Add("[");
- key()->PrintTo(stream);
- if (hydrogen()->IsDehoisted()) {
- stream->Add(" + %d]", base_offset());
- } else {
- stream->Add("]");
- }
-}
-
-
-void LStoreKeyed::PrintDataTo(StringStream* stream) {
- elements()->PrintTo(stream);
- stream->Add("[");
- key()->PrintTo(stream);
- if (hydrogen()->IsDehoisted()) {
- stream->Add(" + %d] <-", base_offset());
- } else {
- stream->Add("] <- ");
- }
-
- if (value() == NULL) {
- DCHECK(hydrogen()->IsConstantHoleStore() &&
- hydrogen()->value()->representation().IsDouble());
- stream->Add("<the hole(nan)>");
- } else {
- value()->PrintTo(stream);
- }
-}
-
-
-void LStoreKeyedGeneric::PrintDataTo(StringStream* stream) {
- object()->PrintTo(stream);
- stream->Add("[");
- key()->PrintTo(stream);
- stream->Add("] <- ");
- value()->PrintTo(stream);
-}
-
-
-void LTransitionElementsKind::PrintDataTo(StringStream* stream) {
- object()->PrintTo(stream);
- stream->Add(" %p -> %p", *original_map(), *transitioned_map());
-}
-
-
-LPlatformChunk* LChunkBuilder::Build() {
- DCHECK(is_unused());
- chunk_ = new(zone()) LPlatformChunk(info(), graph());
- LPhase phase("L_Building chunk", chunk_);
- status_ = BUILDING;
-
- // If compiling for OSR, reserve space for the unoptimized frame,
- // which will be subsumed into this frame.
- if (graph()->has_osr()) {
- for (int i = graph()->osr()->UnoptimizedFrameSlots(); i > 0; i--) {
- chunk_->GetNextSpillIndex(GENERAL_REGISTERS);
- }
- }
-
- const ZoneList<HBasicBlock*>* blocks = graph()->blocks();
- for (int i = 0; i < blocks->length(); i++) {
- HBasicBlock* next = NULL;
- if (i < blocks->length() - 1) next = blocks->at(i + 1);
- DoBasicBlock(blocks->at(i), next);
- if (is_aborted()) return NULL;
- }
- status_ = DONE;
- return chunk_;
-}
-
-
-LUnallocated* LChunkBuilder::ToUnallocated(Register reg) {
- return new(zone()) LUnallocated(LUnallocated::FIXED_REGISTER,
- Register::ToAllocationIndex(reg));
-}
-
-
-LUnallocated* LChunkBuilder::ToUnallocated(XMMRegister reg) {
- return new(zone()) LUnallocated(LUnallocated::FIXED_DOUBLE_REGISTER,
- XMMRegister::ToAllocationIndex(reg));
-}
-
-
-LOperand* LChunkBuilder::UseFixed(HValue* value, Register fixed_register) {
- return Use(value, ToUnallocated(fixed_register));
-}
-
-
-LOperand* LChunkBuilder::UseFixedDouble(HValue* value, XMMRegister reg) {
- return Use(value, ToUnallocated(reg));
-}
-
-
-LOperand* LChunkBuilder::UseRegister(HValue* value) {
- return Use(value, new(zone()) LUnallocated(LUnallocated::MUST_HAVE_REGISTER));
-}
-
-
-LOperand* LChunkBuilder::UseRegisterAtStart(HValue* value) {
- return Use(value,
- new(zone()) LUnallocated(LUnallocated::MUST_HAVE_REGISTER,
- LUnallocated::USED_AT_START));
-}
-
-
-LOperand* LChunkBuilder::UseTempRegister(HValue* value) {
- return Use(value, new(zone()) LUnallocated(LUnallocated::WRITABLE_REGISTER));
-}
-
-
-LOperand* LChunkBuilder::UseTempRegisterOrConstant(HValue* value) {
- return value->IsConstant()
- ? chunk_->DefineConstantOperand(HConstant::cast(value))
- : UseTempRegister(value);
-}
-
-
-LOperand* LChunkBuilder::Use(HValue* value) {
- return Use(value, new(zone()) LUnallocated(LUnallocated::NONE));
-}
-
-
-LOperand* LChunkBuilder::UseAtStart(HValue* value) {
- return Use(value, new(zone()) LUnallocated(LUnallocated::NONE,
- LUnallocated::USED_AT_START));
-}
-
-
-LOperand* LChunkBuilder::UseOrConstant(HValue* value) {
- return value->IsConstant()
- ? chunk_->DefineConstantOperand(HConstant::cast(value))
- : Use(value);
-}
-
-
-LOperand* LChunkBuilder::UseOrConstantAtStart(HValue* value) {
- return value->IsConstant()
- ? chunk_->DefineConstantOperand(HConstant::cast(value))
- : UseAtStart(value);
-}
-
-
-LOperand* LChunkBuilder::UseRegisterOrConstant(HValue* value) {
- return value->IsConstant()
- ? chunk_->DefineConstantOperand(HConstant::cast(value))
- : UseRegister(value);
-}
-
-
-LOperand* LChunkBuilder::UseRegisterOrConstantAtStart(HValue* value) {
- return value->IsConstant()
- ? chunk_->DefineConstantOperand(HConstant::cast(value))
- : UseRegisterAtStart(value);
-}
-
-
-LOperand* LChunkBuilder::UseConstant(HValue* value) {
- return chunk_->DefineConstantOperand(HConstant::cast(value));
-}
-
-
-LOperand* LChunkBuilder::UseAny(HValue* value) {
- return value->IsConstant()
- ? chunk_->DefineConstantOperand(HConstant::cast(value))
- : Use(value, new(zone()) LUnallocated(LUnallocated::ANY));
-}
-
-
-LOperand* LChunkBuilder::Use(HValue* value, LUnallocated* operand) {
- if (value->EmitAtUses()) {
- HInstruction* instr = HInstruction::cast(value);
- VisitInstruction(instr);
- }
- operand->set_virtual_register(value->id());
- return operand;
-}
-
-
-LInstruction* LChunkBuilder::Define(LTemplateResultInstruction<1>* instr,
- LUnallocated* result) {
- result->set_virtual_register(current_instruction_->id());
- instr->set_result(result);
- return instr;
-}
-
-
-LInstruction* LChunkBuilder::DefineAsRegister(
- LTemplateResultInstruction<1>* instr) {
- return Define(instr,
- new(zone()) LUnallocated(LUnallocated::MUST_HAVE_REGISTER));
-}
-
-
-LInstruction* LChunkBuilder::DefineAsSpilled(
- LTemplateResultInstruction<1>* instr,
- int index) {
- return Define(instr,
- new(zone()) LUnallocated(LUnallocated::FIXED_SLOT, index));
-}
-
-
-LInstruction* LChunkBuilder::DefineSameAsFirst(
- LTemplateResultInstruction<1>* instr) {
- return Define(instr,
- new(zone()) LUnallocated(LUnallocated::SAME_AS_FIRST_INPUT));
-}
-
-
-LInstruction* LChunkBuilder::DefineFixed(LTemplateResultInstruction<1>* instr,
- Register reg) {
- return Define(instr, ToUnallocated(reg));
-}
-
-
-LInstruction* LChunkBuilder::DefineFixedDouble(
- LTemplateResultInstruction<1>* instr,
- XMMRegister reg) {
- return Define(instr, ToUnallocated(reg));
-}
-
-
-LInstruction* LChunkBuilder::AssignEnvironment(LInstruction* instr) {
- HEnvironment* hydrogen_env = current_block_->last_environment();
- int argument_index_accumulator = 0;
- ZoneList<HValue*> objects_to_materialize(0, zone());
- instr->set_environment(CreateEnvironment(
- hydrogen_env, &argument_index_accumulator, &objects_to_materialize));
- return instr;
-}
-
-
-LInstruction* LChunkBuilder::MarkAsCall(LInstruction* instr,
- HInstruction* hinstr,
- CanDeoptimize can_deoptimize) {
- info()->MarkAsNonDeferredCalling();
-
-#ifdef DEBUG
- instr->VerifyCall();
-#endif
- instr->MarkAsCall();
- instr = AssignPointerMap(instr);
-
- // If instruction does not have side-effects lazy deoptimization
- // after the call will try to deoptimize to the point before the call.
- // Thus we still need to attach environment to this call even if
- // call sequence can not deoptimize eagerly.
- bool needs_environment =
- (can_deoptimize == CAN_DEOPTIMIZE_EAGERLY) ||
- !hinstr->HasObservableSideEffects();
- if (needs_environment && !instr->HasEnvironment()) {
- instr = AssignEnvironment(instr);
- // We can't really figure out if the environment is needed or not.
- instr->environment()->set_has_been_used();
- }
-
- return instr;
-}
-
-
-LInstruction* LChunkBuilder::AssignPointerMap(LInstruction* instr) {
- DCHECK(!instr->HasPointerMap());
- instr->set_pointer_map(new(zone()) LPointerMap(zone()));
- return instr;
-}
-
-
-LUnallocated* LChunkBuilder::TempRegister() {
- LUnallocated* operand =
- new(zone()) LUnallocated(LUnallocated::MUST_HAVE_REGISTER);
- int vreg = allocator_->GetVirtualRegister();
- if (!allocator_->AllocationOk()) {
- Abort(kOutOfVirtualRegistersWhileTryingToAllocateTempRegister);
- vreg = 0;
- }
- operand->set_virtual_register(vreg);
- return operand;
-}
-
-
-LOperand* LChunkBuilder::FixedTemp(Register reg) {
- LUnallocated* operand = ToUnallocated(reg);
- DCHECK(operand->HasFixedPolicy());
- return operand;
-}
-
-
-LOperand* LChunkBuilder::FixedTemp(XMMRegister reg) {
- LUnallocated* operand = ToUnallocated(reg);
- DCHECK(operand->HasFixedPolicy());
- return operand;
-}
-
-
-LInstruction* LChunkBuilder::DoBlockEntry(HBlockEntry* instr) {
- return new(zone()) LLabel(instr->block());
-}
-
-
-LInstruction* LChunkBuilder::DoDummyUse(HDummyUse* instr) {
- return DefineAsRegister(new(zone()) LDummyUse(UseAny(instr->value())));
-}
-
-
-LInstruction* LChunkBuilder::DoEnvironmentMarker(HEnvironmentMarker* instr) {
- UNREACHABLE();
- return NULL;
-}
-
-
-LInstruction* LChunkBuilder::DoDeoptimize(HDeoptimize* instr) {
- return AssignEnvironment(new(zone()) LDeoptimize);
-}
-
-
-LInstruction* LChunkBuilder::DoShift(Token::Value op,
- HBitwiseBinaryOperation* instr) {
- if (instr->representation().IsSmiOrInteger32()) {
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- LOperand* left = UseRegisterAtStart(instr->left());
-
- HValue* right_value = instr->right();
- LOperand* right = NULL;
- int constant_value = 0;
- bool does_deopt = false;
- if (right_value->IsConstant()) {
- HConstant* constant = HConstant::cast(right_value);
- right = chunk_->DefineConstantOperand(constant);
- constant_value = constant->Integer32Value() & 0x1f;
- if (SmiValuesAre31Bits() && instr->representation().IsSmi() &&
- constant_value > 0) {
- // Left shift can deoptimize if we shift by > 0 and the result
- // cannot be truncated to smi.
- does_deopt = !instr->CheckUsesForFlag(HValue::kTruncatingToSmi);
- }
- } else {
- right = UseFixed(right_value, rcx);
- }
-
- // Shift operations can only deoptimize if we do a logical shift by 0 and
- // the result cannot be truncated to int32.
- if (op == Token::SHR && constant_value == 0) {
- does_deopt = !instr->CheckFlag(HInstruction::kUint32);
- }
-
- LInstruction* result =
- DefineSameAsFirst(new(zone()) LShiftI(op, left, right, does_deopt));
- return does_deopt ? AssignEnvironment(result) : result;
- } else {
- return DoArithmeticT(op, instr);
- }
-}
-
-
-LInstruction* LChunkBuilder::DoArithmeticD(Token::Value op,
- HArithmeticBinaryOperation* instr) {
- DCHECK(instr->representation().IsDouble());
- DCHECK(instr->left()->representation().IsDouble());
- DCHECK(instr->right()->representation().IsDouble());
- if (op == Token::MOD) {
- LOperand* left = UseRegisterAtStart(instr->BetterLeftOperand());
- LOperand* right = UseFixedDouble(instr->BetterRightOperand(), xmm1);
- LArithmeticD* result = new(zone()) LArithmeticD(op, left, right);
- return MarkAsCall(DefineSameAsFirst(result), instr);
- } else {
- LOperand* left = UseRegisterAtStart(instr->BetterLeftOperand());
- LOperand* right = UseRegisterAtStart(instr->BetterRightOperand());
- LArithmeticD* result = new(zone()) LArithmeticD(op, left, right);
- return CpuFeatures::IsSupported(AVX) ? DefineAsRegister(result)
- : DefineSameAsFirst(result);
- }
-}
-
-
-LInstruction* LChunkBuilder::DoArithmeticT(Token::Value op,
- HBinaryOperation* instr) {
- HValue* left = instr->left();
- HValue* right = instr->right();
- DCHECK(left->representation().IsTagged());
- DCHECK(right->representation().IsTagged());
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* left_operand = UseFixed(left, rdx);
- LOperand* right_operand = UseFixed(right, rax);
- LArithmeticT* result =
- new(zone()) LArithmeticT(op, context, left_operand, right_operand);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-void LChunkBuilder::DoBasicBlock(HBasicBlock* block, HBasicBlock* next_block) {
- DCHECK(is_building());
- current_block_ = block;
- next_block_ = next_block;
- if (block->IsStartBlock()) {
- block->UpdateEnvironment(graph_->start_environment());
- argument_count_ = 0;
- } else if (block->predecessors()->length() == 1) {
- // We have a single predecessor => copy environment and outgoing
- // argument count from the predecessor.
- DCHECK(block->phis()->length() == 0);
- HBasicBlock* pred = block->predecessors()->at(0);
- HEnvironment* last_environment = pred->last_environment();
- DCHECK(last_environment != NULL);
- // Only copy the environment, if it is later used again.
- if (pred->end()->SecondSuccessor() == NULL) {
- DCHECK(pred->end()->FirstSuccessor() == block);
- } else {
- if (pred->end()->FirstSuccessor()->block_id() > block->block_id() ||
- pred->end()->SecondSuccessor()->block_id() > block->block_id()) {
- last_environment = last_environment->Copy();
- }
- }
- block->UpdateEnvironment(last_environment);
- DCHECK(pred->argument_count() >= 0);
- argument_count_ = pred->argument_count();
- } else {
- // We are at a state join => process phis.
- HBasicBlock* pred = block->predecessors()->at(0);
- // No need to copy the environment, it cannot be used later.
- HEnvironment* last_environment = pred->last_environment();
- for (int i = 0; i < block->phis()->length(); ++i) {
- HPhi* phi = block->phis()->at(i);
- if (phi->HasMergedIndex()) {
- last_environment->SetValueAt(phi->merged_index(), phi);
- }
- }
- for (int i = 0; i < block->deleted_phis()->length(); ++i) {
- if (block->deleted_phis()->at(i) < last_environment->length()) {
- last_environment->SetValueAt(block->deleted_phis()->at(i),
- graph_->GetConstantUndefined());
- }
- }
- block->UpdateEnvironment(last_environment);
- // Pick up the outgoing argument count of one of the predecessors.
- argument_count_ = pred->argument_count();
- }
- HInstruction* current = block->first();
- int start = chunk_->instructions()->length();
- while (current != NULL && !is_aborted()) {
- // Code for constants in registers is generated lazily.
- if (!current->EmitAtUses()) {
- VisitInstruction(current);
- }
- current = current->next();
- }
- int end = chunk_->instructions()->length() - 1;
- if (end >= start) {
- block->set_first_instruction_index(start);
- block->set_last_instruction_index(end);
- }
- block->set_argument_count(argument_count_);
- next_block_ = NULL;
- current_block_ = NULL;
-}
-
-
-void LChunkBuilder::VisitInstruction(HInstruction* current) {
- HInstruction* old_current = current_instruction_;
- current_instruction_ = current;
-
- LInstruction* instr = NULL;
- if (current->CanReplaceWithDummyUses()) {
- if (current->OperandCount() == 0) {
- instr = DefineAsRegister(new(zone()) LDummy());
- } else {
- DCHECK(!current->OperandAt(0)->IsControlInstruction());
- instr = DefineAsRegister(new(zone())
- LDummyUse(UseAny(current->OperandAt(0))));
- }
- for (int i = 1; i < current->OperandCount(); ++i) {
- if (current->OperandAt(i)->IsControlInstruction()) continue;
- LInstruction* dummy =
- new(zone()) LDummyUse(UseAny(current->OperandAt(i)));
- dummy->set_hydrogen_value(current);
- chunk_->AddInstruction(dummy, current_block_);
- }
- } else {
- HBasicBlock* successor;
- if (current->IsControlInstruction() &&
- HControlInstruction::cast(current)->KnownSuccessorBlock(&successor) &&
- successor != NULL) {
- instr = new(zone()) LGoto(successor);
- } else {
- instr = current->CompileToLithium(this);
- }
- }
-
- argument_count_ += current->argument_delta();
- DCHECK(argument_count_ >= 0);
-
- if (instr != NULL) {
- AddInstruction(instr, current);
- }
-
- current_instruction_ = old_current;
-}
-
-
-void LChunkBuilder::AddInstruction(LInstruction* instr,
- HInstruction* hydrogen_val) {
- // Associate the hydrogen instruction first, since we may need it for
- // the ClobbersRegisters() or ClobbersDoubleRegisters() calls below.
- instr->set_hydrogen_value(hydrogen_val);
-
-#if DEBUG
- // Make sure that the lithium instruction has either no fixed register
- // constraints in temps or the result OR no uses that are only used at
- // start. If this invariant doesn't hold, the register allocator can decide
- // to insert a split of a range immediately before the instruction due to an
- // already allocated register needing to be used for the instruction's fixed
- // register constraint. In this case, The register allocator won't see an
- // interference between the split child and the use-at-start (it would if
- // the it was just a plain use), so it is free to move the split child into
- // the same register that is used for the use-at-start.
- // See https://code.google.com/p/chromium/issues/detail?id=201590
- if (!(instr->ClobbersRegisters() &&
- instr->ClobbersDoubleRegisters(isolate()))) {
- int fixed = 0;
- int used_at_start = 0;
- for (UseIterator it(instr); !it.Done(); it.Advance()) {
- LUnallocated* operand = LUnallocated::cast(it.Current());
- if (operand->IsUsedAtStart()) ++used_at_start;
- }
- if (instr->Output() != NULL) {
- if (LUnallocated::cast(instr->Output())->HasFixedPolicy()) ++fixed;
- }
- for (TempIterator it(instr); !it.Done(); it.Advance()) {
- LUnallocated* operand = LUnallocated::cast(it.Current());
- if (operand->HasFixedPolicy()) ++fixed;
- }
- DCHECK(fixed == 0 || used_at_start == 0);
- }
-#endif
-
- if (FLAG_stress_pointer_maps && !instr->HasPointerMap()) {
- instr = AssignPointerMap(instr);
- }
- if (FLAG_stress_environments && !instr->HasEnvironment()) {
- instr = AssignEnvironment(instr);
- }
- chunk_->AddInstruction(instr, current_block_);
-
- if (instr->IsCall() || instr->IsPrologue()) {
- HValue* hydrogen_value_for_lazy_bailout = hydrogen_val;
- if (hydrogen_val->HasObservableSideEffects()) {
- HSimulate* sim = HSimulate::cast(hydrogen_val->next());
- sim->ReplayEnvironment(current_block_->last_environment());
- hydrogen_value_for_lazy_bailout = sim;
- }
- LInstruction* bailout = AssignEnvironment(new(zone()) LLazyBailout());
- bailout->set_hydrogen_value(hydrogen_value_for_lazy_bailout);
- chunk_->AddInstruction(bailout, current_block_);
- }
-}
-
-
-LInstruction* LChunkBuilder::DoGoto(HGoto* instr) {
- return new(zone()) LGoto(instr->FirstSuccessor());
-}
-
-
-LInstruction* LChunkBuilder::DoPrologue(HPrologue* instr) {
- return new (zone()) LPrologue();
-}
-
-
-LInstruction* LChunkBuilder::DoDebugBreak(HDebugBreak* instr) {
- return new(zone()) LDebugBreak();
-}
-
-
-LInstruction* LChunkBuilder::DoBranch(HBranch* instr) {
- HValue* value = instr->value();
- Representation r = value->representation();
- HType type = value->type();
- ToBooleanStub::Types expected = instr->expected_input_types();
- if (expected.IsEmpty()) expected = ToBooleanStub::Types::Generic();
-
- bool easy_case = !r.IsTagged() || type.IsBoolean() || type.IsSmi() ||
- type.IsJSArray() || type.IsHeapNumber() || type.IsString();
- LInstruction* branch = new(zone()) LBranch(UseRegister(value));
- if (!easy_case &&
- ((!expected.Contains(ToBooleanStub::SMI) && expected.NeedsMap()) ||
- !expected.IsGeneric())) {
- branch = AssignEnvironment(branch);
- }
- return branch;
-}
-
-
-LInstruction* LChunkBuilder::DoCompareMap(HCompareMap* instr) {
- DCHECK(instr->value()->representation().IsTagged());
- LOperand* value = UseRegisterAtStart(instr->value());
- return new(zone()) LCmpMapAndBranch(value);
-}
-
-
-LInstruction* LChunkBuilder::DoArgumentsLength(HArgumentsLength* length) {
- info()->MarkAsRequiresFrame();
- return DefineAsRegister(new(zone()) LArgumentsLength(Use(length->value())));
-}
-
-
-LInstruction* LChunkBuilder::DoArgumentsElements(HArgumentsElements* elems) {
- info()->MarkAsRequiresFrame();
- return DefineAsRegister(new(zone()) LArgumentsElements);
-}
-
-
-LInstruction* LChunkBuilder::DoInstanceOf(HInstanceOf* instr) {
- LOperand* left =
- UseFixed(instr->left(), InstanceOfDescriptor::LeftRegister());
- LOperand* right =
- UseFixed(instr->right(), InstanceOfDescriptor::RightRegister());
- LOperand* context = UseFixed(instr->context(), rsi);
- LInstanceOf* result = new (zone()) LInstanceOf(context, left, right);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoHasInPrototypeChainAndBranch(
- HHasInPrototypeChainAndBranch* instr) {
- LOperand* object = UseRegister(instr->object());
- LOperand* prototype = UseRegister(instr->prototype());
- return new (zone()) LHasInPrototypeChainAndBranch(object, prototype);
-}
-
-
-LInstruction* LChunkBuilder::DoWrapReceiver(HWrapReceiver* instr) {
- LOperand* receiver = UseRegister(instr->receiver());
- LOperand* function = UseRegisterAtStart(instr->function());
- LWrapReceiver* result = new(zone()) LWrapReceiver(receiver, function);
- return AssignEnvironment(DefineSameAsFirst(result));
-}
-
-
-LInstruction* LChunkBuilder::DoApplyArguments(HApplyArguments* instr) {
- LOperand* function = UseFixed(instr->function(), rdi);
- LOperand* receiver = UseFixed(instr->receiver(), rax);
- LOperand* length = UseFixed(instr->length(), rbx);
- LOperand* elements = UseFixed(instr->elements(), rcx);
- LApplyArguments* result = new(zone()) LApplyArguments(function,
- receiver,
- length,
- elements);
- return MarkAsCall(DefineFixed(result, rax), instr, CAN_DEOPTIMIZE_EAGERLY);
-}
-
-
-LInstruction* LChunkBuilder::DoPushArguments(HPushArguments* instr) {
- int argc = instr->OperandCount();
- for (int i = 0; i < argc; ++i) {
- LOperand* argument = UseOrConstant(instr->argument(i));
- AddInstruction(new(zone()) LPushArgument(argument), instr);
- }
- return NULL;
-}
-
-
-LInstruction* LChunkBuilder::DoStoreCodeEntry(
- HStoreCodeEntry* store_code_entry) {
- LOperand* function = UseRegister(store_code_entry->function());
- LOperand* code_object = UseTempRegister(store_code_entry->code_object());
- return new(zone()) LStoreCodeEntry(function, code_object);
-}
-
-
-LInstruction* LChunkBuilder::DoInnerAllocatedObject(
- HInnerAllocatedObject* instr) {
- LOperand* base_object = UseRegisterAtStart(instr->base_object());
- LOperand* offset = UseRegisterOrConstantAtStart(instr->offset());
- return DefineAsRegister(
- new(zone()) LInnerAllocatedObject(base_object, offset));
-}
-
-
-LInstruction* LChunkBuilder::DoThisFunction(HThisFunction* instr) {
- return instr->HasNoUses()
- ? NULL
- : DefineAsRegister(new(zone()) LThisFunction);
-}
-
-
-LInstruction* LChunkBuilder::DoContext(HContext* instr) {
- if (instr->HasNoUses()) return NULL;
-
- if (info()->IsStub()) {
- return DefineFixed(new(zone()) LContext, rsi);
- }
-
- return DefineAsRegister(new(zone()) LContext);
-}
-
-
-LInstruction* LChunkBuilder::DoDeclareGlobals(HDeclareGlobals* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- return MarkAsCall(new(zone()) LDeclareGlobals(context), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoCallJSFunction(
- HCallJSFunction* instr) {
- LOperand* function = UseFixed(instr->function(), rdi);
-
- LCallJSFunction* result = new(zone()) LCallJSFunction(function);
-
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoCallWithDescriptor(
- HCallWithDescriptor* instr) {
- CallInterfaceDescriptor descriptor = instr->descriptor();
-
- LOperand* target = UseRegisterOrConstantAtStart(instr->target());
- ZoneList<LOperand*> ops(instr->OperandCount(), zone());
- // Target
- ops.Add(target, zone());
- // Context
- LOperand* op = UseFixed(instr->OperandAt(1), rsi);
- ops.Add(op, zone());
- // Other register parameters
- for (int i = LCallWithDescriptor::kImplicitRegisterParameterCount;
- i < instr->OperandCount(); i++) {
- op =
- UseFixed(instr->OperandAt(i),
- descriptor.GetRegisterParameter(
- i - LCallWithDescriptor::kImplicitRegisterParameterCount));
- ops.Add(op, zone());
- }
-
- LCallWithDescriptor* result = new(zone()) LCallWithDescriptor(
- descriptor, ops, zone());
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoInvokeFunction(HInvokeFunction* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* function = UseFixed(instr->function(), rdi);
- LInvokeFunction* result = new(zone()) LInvokeFunction(context, function);
- return MarkAsCall(DefineFixed(result, rax), instr, CANNOT_DEOPTIMIZE_EAGERLY);
-}
-
-
-LInstruction* LChunkBuilder::DoUnaryMathOperation(HUnaryMathOperation* instr) {
- switch (instr->op()) {
- case kMathFloor:
- return DoMathFloor(instr);
- case kMathRound:
- return DoMathRound(instr);
- case kMathFround:
- return DoMathFround(instr);
- case kMathAbs:
- return DoMathAbs(instr);
- case kMathLog:
- return DoMathLog(instr);
- case kMathExp:
- return DoMathExp(instr);
- case kMathSqrt:
- return DoMathSqrt(instr);
- case kMathPowHalf:
- return DoMathPowHalf(instr);
- case kMathClz32:
- return DoMathClz32(instr);
- default:
- UNREACHABLE();
- return NULL;
- }
-}
-
-
-LInstruction* LChunkBuilder::DoMathFloor(HUnaryMathOperation* instr) {
- LOperand* input = UseRegisterAtStart(instr->value());
- LMathFloor* result = new(zone()) LMathFloor(input);
- return AssignEnvironment(DefineAsRegister(result));
-}
-
-
-LInstruction* LChunkBuilder::DoMathRound(HUnaryMathOperation* instr) {
- LOperand* input = UseRegister(instr->value());
- LOperand* temp = FixedTemp(xmm4);
- LMathRound* result = new(zone()) LMathRound(input, temp);
- return AssignEnvironment(DefineAsRegister(result));
-}
-
-
-LInstruction* LChunkBuilder::DoMathFround(HUnaryMathOperation* instr) {
- LOperand* input = UseRegister(instr->value());
- LMathFround* result = new (zone()) LMathFround(input);
- return DefineAsRegister(result);
-}
-
-
-LInstruction* LChunkBuilder::DoMathAbs(HUnaryMathOperation* instr) {
- LOperand* context = UseAny(instr->context());
- LOperand* input = UseRegisterAtStart(instr->value());
- LInstruction* result =
- DefineSameAsFirst(new(zone()) LMathAbs(context, input));
- Representation r = instr->value()->representation();
- if (!r.IsDouble() && !r.IsSmiOrInteger32()) result = AssignPointerMap(result);
- if (!r.IsDouble()) result = AssignEnvironment(result);
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoMathLog(HUnaryMathOperation* instr) {
- DCHECK(instr->representation().IsDouble());
- DCHECK(instr->value()->representation().IsDouble());
- LOperand* input = UseRegisterAtStart(instr->value());
- return MarkAsCall(DefineSameAsFirst(new(zone()) LMathLog(input)), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoMathClz32(HUnaryMathOperation* instr) {
- LOperand* input = UseRegisterAtStart(instr->value());
- LMathClz32* result = new(zone()) LMathClz32(input);
- return DefineAsRegister(result);
-}
-
-
-LInstruction* LChunkBuilder::DoMathExp(HUnaryMathOperation* instr) {
- DCHECK(instr->representation().IsDouble());
- DCHECK(instr->value()->representation().IsDouble());
- LOperand* value = UseTempRegister(instr->value());
- LOperand* temp1 = TempRegister();
- LOperand* temp2 = TempRegister();
- LMathExp* result = new(zone()) LMathExp(value, temp1, temp2);
- return DefineAsRegister(result);
-}
-
-
-LInstruction* LChunkBuilder::DoMathSqrt(HUnaryMathOperation* instr) {
- LOperand* input = UseAtStart(instr->value());
- return DefineAsRegister(new(zone()) LMathSqrt(input));
-}
-
-
-LInstruction* LChunkBuilder::DoMathPowHalf(HUnaryMathOperation* instr) {
- LOperand* input = UseRegisterAtStart(instr->value());
- LMathPowHalf* result = new(zone()) LMathPowHalf(input);
- return DefineSameAsFirst(result);
-}
-
-
-LInstruction* LChunkBuilder::DoCallNew(HCallNew* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* constructor = UseFixed(instr->constructor(), rdi);
- LCallNew* result = new(zone()) LCallNew(context, constructor);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoCallNewArray(HCallNewArray* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* constructor = UseFixed(instr->constructor(), rdi);
- LCallNewArray* result = new(zone()) LCallNewArray(context, constructor);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoCallFunction(HCallFunction* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* function = UseFixed(instr->function(), rdi);
- LOperand* slot = NULL;
- LOperand* vector = NULL;
- if (instr->HasVectorAndSlot()) {
- slot = FixedTemp(rdx);
- vector = FixedTemp(rbx);
- }
- LCallFunction* call =
- new (zone()) LCallFunction(context, function, slot, vector);
- return MarkAsCall(DefineFixed(call, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoCallRuntime(HCallRuntime* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LCallRuntime* result = new(zone()) LCallRuntime(context);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoRor(HRor* instr) {
- return DoShift(Token::ROR, instr);
-}
-
-
-LInstruction* LChunkBuilder::DoShr(HShr* instr) {
- return DoShift(Token::SHR, instr);
-}
-
-
-LInstruction* LChunkBuilder::DoSar(HSar* instr) {
- return DoShift(Token::SAR, instr);
-}
-
-
-LInstruction* LChunkBuilder::DoShl(HShl* instr) {
- return DoShift(Token::SHL, instr);
-}
-
-
-LInstruction* LChunkBuilder::DoBitwise(HBitwise* instr) {
- if (instr->representation().IsSmiOrInteger32()) {
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- DCHECK(instr->CheckFlag(HValue::kTruncatingToInt32));
-
- LOperand* left = UseRegisterAtStart(instr->BetterLeftOperand());
- LOperand* right;
- if (SmiValuesAre32Bits() && instr->representation().IsSmi()) {
- // We don't support tagged immediates, so we request it in a register.
- right = UseRegisterAtStart(instr->BetterRightOperand());
- } else {
- right = UseOrConstantAtStart(instr->BetterRightOperand());
- }
- return DefineSameAsFirst(new(zone()) LBitI(left, right));
- } else {
- return DoArithmeticT(instr->op(), instr);
- }
-}
-
-
-LInstruction* LChunkBuilder::DoDivByPowerOf2I(HDiv* instr) {
- DCHECK(instr->representation().IsSmiOrInteger32());
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- LOperand* dividend = UseRegister(instr->left());
- int32_t divisor = instr->right()->GetInteger32Constant();
- LInstruction* result = DefineAsRegister(new(zone()) LDivByPowerOf2I(
- dividend, divisor));
- if ((instr->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) ||
- (instr->CheckFlag(HValue::kCanOverflow) && divisor == -1) ||
- (!instr->CheckFlag(HInstruction::kAllUsesTruncatingToInt32) &&
- divisor != 1 && divisor != -1)) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoDivByConstI(HDiv* instr) {
- DCHECK(instr->representation().IsInteger32());
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- LOperand* dividend = UseRegister(instr->left());
- int32_t divisor = instr->right()->GetInteger32Constant();
- LOperand* temp1 = FixedTemp(rax);
- LOperand* temp2 = FixedTemp(rdx);
- LInstruction* result = DefineFixed(new(zone()) LDivByConstI(
- dividend, divisor, temp1, temp2), rdx);
- if (divisor == 0 ||
- (instr->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) ||
- !instr->CheckFlag(HInstruction::kAllUsesTruncatingToInt32)) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoDivI(HDiv* instr) {
- DCHECK(instr->representation().IsSmiOrInteger32());
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- LOperand* dividend = UseFixed(instr->left(), rax);
- LOperand* divisor = UseRegister(instr->right());
- LOperand* temp = FixedTemp(rdx);
- LInstruction* result = DefineFixed(new(zone()) LDivI(
- dividend, divisor, temp), rax);
- if (instr->CheckFlag(HValue::kCanBeDivByZero) ||
- instr->CheckFlag(HValue::kBailoutOnMinusZero) ||
- instr->CheckFlag(HValue::kCanOverflow) ||
- !instr->CheckFlag(HValue::kAllUsesTruncatingToInt32)) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoDiv(HDiv* instr) {
- if (instr->representation().IsSmiOrInteger32()) {
- if (instr->RightIsPowerOf2()) {
- return DoDivByPowerOf2I(instr);
- } else if (instr->right()->IsConstant()) {
- return DoDivByConstI(instr);
- } else {
- return DoDivI(instr);
- }
- } else if (instr->representation().IsDouble()) {
- return DoArithmeticD(Token::DIV, instr);
- } else {
- return DoArithmeticT(Token::DIV, instr);
- }
-}
-
-
-LInstruction* LChunkBuilder::DoFlooringDivByPowerOf2I(HMathFloorOfDiv* instr) {
- LOperand* dividend = UseRegisterAtStart(instr->left());
- int32_t divisor = instr->right()->GetInteger32Constant();
- LInstruction* result = DefineSameAsFirst(new(zone()) LFlooringDivByPowerOf2I(
- dividend, divisor));
- if ((instr->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) ||
- (instr->CheckFlag(HValue::kLeftCanBeMinInt) && divisor == -1)) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoFlooringDivByConstI(HMathFloorOfDiv* instr) {
- DCHECK(instr->representation().IsInteger32());
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- LOperand* dividend = UseRegister(instr->left());
- int32_t divisor = instr->right()->GetInteger32Constant();
- LOperand* temp1 = FixedTemp(rax);
- LOperand* temp2 = FixedTemp(rdx);
- LOperand* temp3 =
- ((divisor > 0 && !instr->CheckFlag(HValue::kLeftCanBeNegative)) ||
- (divisor < 0 && !instr->CheckFlag(HValue::kLeftCanBePositive))) ?
- NULL : TempRegister();
- LInstruction* result =
- DefineFixed(new(zone()) LFlooringDivByConstI(dividend,
- divisor,
- temp1,
- temp2,
- temp3),
- rdx);
- if (divisor == 0 ||
- (instr->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0)) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoFlooringDivI(HMathFloorOfDiv* instr) {
- DCHECK(instr->representation().IsSmiOrInteger32());
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- LOperand* dividend = UseFixed(instr->left(), rax);
- LOperand* divisor = UseRegister(instr->right());
- LOperand* temp = FixedTemp(rdx);
- LInstruction* result = DefineFixed(new(zone()) LFlooringDivI(
- dividend, divisor, temp), rax);
- if (instr->CheckFlag(HValue::kCanBeDivByZero) ||
- instr->CheckFlag(HValue::kBailoutOnMinusZero) ||
- instr->CheckFlag(HValue::kCanOverflow)) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoMathFloorOfDiv(HMathFloorOfDiv* instr) {
- if (instr->RightIsPowerOf2()) {
- return DoFlooringDivByPowerOf2I(instr);
- } else if (instr->right()->IsConstant()) {
- return DoFlooringDivByConstI(instr);
- } else {
- return DoFlooringDivI(instr);
- }
-}
-
-
-LInstruction* LChunkBuilder::DoModByPowerOf2I(HMod* instr) {
- DCHECK(instr->representation().IsSmiOrInteger32());
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- LOperand* dividend = UseRegisterAtStart(instr->left());
- int32_t divisor = instr->right()->GetInteger32Constant();
- LInstruction* result = DefineSameAsFirst(new(zone()) LModByPowerOf2I(
- dividend, divisor));
- if (instr->CheckFlag(HValue::kLeftCanBeNegative) &&
- instr->CheckFlag(HValue::kBailoutOnMinusZero)) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoModByConstI(HMod* instr) {
- DCHECK(instr->representation().IsSmiOrInteger32());
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- LOperand* dividend = UseRegister(instr->left());
- int32_t divisor = instr->right()->GetInteger32Constant();
- LOperand* temp1 = FixedTemp(rax);
- LOperand* temp2 = FixedTemp(rdx);
- LInstruction* result = DefineFixed(new(zone()) LModByConstI(
- dividend, divisor, temp1, temp2), rax);
- if (divisor == 0 || instr->CheckFlag(HValue::kBailoutOnMinusZero)) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoModI(HMod* instr) {
- DCHECK(instr->representation().IsSmiOrInteger32());
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- LOperand* dividend = UseFixed(instr->left(), rax);
- LOperand* divisor = UseRegister(instr->right());
- LOperand* temp = FixedTemp(rdx);
- LInstruction* result = DefineFixed(new(zone()) LModI(
- dividend, divisor, temp), rdx);
- if (instr->CheckFlag(HValue::kCanBeDivByZero) ||
- instr->CheckFlag(HValue::kBailoutOnMinusZero)) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoMod(HMod* instr) {
- if (instr->representation().IsSmiOrInteger32()) {
- if (instr->RightIsPowerOf2()) {
- return DoModByPowerOf2I(instr);
- } else if (instr->right()->IsConstant()) {
- return DoModByConstI(instr);
- } else {
- return DoModI(instr);
- }
- } else if (instr->representation().IsDouble()) {
- return DoArithmeticD(Token::MOD, instr);
- } else {
- return DoArithmeticT(Token::MOD, instr);
- }
-}
-
-
-LInstruction* LChunkBuilder::DoMul(HMul* instr) {
- if (instr->representation().IsSmiOrInteger32()) {
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- LOperand* left = UseRegisterAtStart(instr->BetterLeftOperand());
- LOperand* right = UseOrConstant(instr->BetterRightOperand());
- LMulI* mul = new(zone()) LMulI(left, right);
- if (instr->CheckFlag(HValue::kCanOverflow) ||
- instr->CheckFlag(HValue::kBailoutOnMinusZero)) {
- AssignEnvironment(mul);
- }
- return DefineSameAsFirst(mul);
- } else if (instr->representation().IsDouble()) {
- return DoArithmeticD(Token::MUL, instr);
- } else {
- return DoArithmeticT(Token::MUL, instr);
- }
-}
-
-
-LInstruction* LChunkBuilder::DoSub(HSub* instr) {
- if (instr->representation().IsSmiOrInteger32()) {
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- LOperand* left = UseRegisterAtStart(instr->left());
- LOperand* right;
- if (SmiValuesAre32Bits() && instr->representation().IsSmi()) {
- // We don't support tagged immediates, so we request it in a register.
- right = UseRegisterAtStart(instr->right());
- } else {
- right = UseOrConstantAtStart(instr->right());
- }
- LSubI* sub = new(zone()) LSubI(left, right);
- LInstruction* result = DefineSameAsFirst(sub);
- if (instr->CheckFlag(HValue::kCanOverflow)) {
- result = AssignEnvironment(result);
- }
- return result;
- } else if (instr->representation().IsDouble()) {
- return DoArithmeticD(Token::SUB, instr);
- } else {
- return DoArithmeticT(Token::SUB, instr);
- }
-}
-
-
-LInstruction* LChunkBuilder::DoAdd(HAdd* instr) {
- if (instr->representation().IsSmiOrInteger32()) {
- // Check to see if it would be advantageous to use an lea instruction rather
- // than an add. This is the case when no overflow check is needed and there
- // are multiple uses of the add's inputs, so using a 3-register add will
- // preserve all input values for later uses.
- bool use_lea = LAddI::UseLea(instr);
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- LOperand* left = UseRegisterAtStart(instr->BetterLeftOperand());
- HValue* right_candidate = instr->BetterRightOperand();
- LOperand* right;
- if (SmiValuesAre32Bits() && instr->representation().IsSmi()) {
- // We cannot add a tagged immediate to a tagged value,
- // so we request it in a register.
- right = UseRegisterAtStart(right_candidate);
- } else {
- right = use_lea ? UseRegisterOrConstantAtStart(right_candidate)
- : UseOrConstantAtStart(right_candidate);
- }
- LAddI* add = new(zone()) LAddI(left, right);
- bool can_overflow = instr->CheckFlag(HValue::kCanOverflow);
- LInstruction* result = use_lea ? DefineAsRegister(add)
- : DefineSameAsFirst(add);
- if (can_overflow) {
- result = AssignEnvironment(result);
- }
- return result;
- } else if (instr->representation().IsExternal()) {
- DCHECK(instr->IsConsistentExternalRepresentation());
- DCHECK(!instr->CheckFlag(HValue::kCanOverflow));
- bool use_lea = LAddI::UseLea(instr);
- LOperand* left = UseRegisterAtStart(instr->left());
- HValue* right_candidate = instr->right();
- LOperand* right = use_lea
- ? UseRegisterOrConstantAtStart(right_candidate)
- : UseOrConstantAtStart(right_candidate);
- LAddI* add = new(zone()) LAddI(left, right);
- LInstruction* result = use_lea
- ? DefineAsRegister(add)
- : DefineSameAsFirst(add);
- return result;
- } else if (instr->representation().IsDouble()) {
- return DoArithmeticD(Token::ADD, instr);
- } else {
- return DoArithmeticT(Token::ADD, instr);
- }
- return NULL;
-}
-
-
-LInstruction* LChunkBuilder::DoMathMinMax(HMathMinMax* instr) {
- LOperand* left = NULL;
- LOperand* right = NULL;
- DCHECK(instr->left()->representation().Equals(instr->representation()));
- DCHECK(instr->right()->representation().Equals(instr->representation()));
- if (instr->representation().IsSmi()) {
- left = UseRegisterAtStart(instr->BetterLeftOperand());
- right = UseAtStart(instr->BetterRightOperand());
- } else if (instr->representation().IsInteger32()) {
- left = UseRegisterAtStart(instr->BetterLeftOperand());
- right = UseOrConstantAtStart(instr->BetterRightOperand());
- } else {
- DCHECK(instr->representation().IsDouble());
- left = UseRegisterAtStart(instr->left());
- right = UseRegisterAtStart(instr->right());
- }
- LMathMinMax* minmax = new(zone()) LMathMinMax(left, right);
- return DefineSameAsFirst(minmax);
-}
-
-
-LInstruction* LChunkBuilder::DoPower(HPower* instr) {
- DCHECK(instr->representation().IsDouble());
- // We call a C function for double power. It can't trigger a GC.
- // We need to use fixed result register for the call.
- Representation exponent_type = instr->right()->representation();
- DCHECK(instr->left()->representation().IsDouble());
- LOperand* left = UseFixedDouble(instr->left(), xmm2);
- LOperand* right =
- exponent_type.IsDouble()
- ? UseFixedDouble(instr->right(), xmm1)
- : UseFixed(instr->right(), MathPowTaggedDescriptor::exponent());
- LPower* result = new(zone()) LPower(left, right);
- return MarkAsCall(DefineFixedDouble(result, xmm3), instr,
- CAN_DEOPTIMIZE_EAGERLY);
-}
-
-
-LInstruction* LChunkBuilder::DoCompareGeneric(HCompareGeneric* instr) {
- DCHECK(instr->left()->representation().IsTagged());
- DCHECK(instr->right()->representation().IsTagged());
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* left = UseFixed(instr->left(), rdx);
- LOperand* right = UseFixed(instr->right(), rax);
- LCmpT* result = new(zone()) LCmpT(context, left, right);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoCompareNumericAndBranch(
- HCompareNumericAndBranch* instr) {
- Representation r = instr->representation();
- if (r.IsSmiOrInteger32()) {
- DCHECK(instr->left()->representation().Equals(r));
- DCHECK(instr->right()->representation().Equals(r));
- LOperand* left = UseRegisterOrConstantAtStart(instr->left());
- LOperand* right = UseOrConstantAtStart(instr->right());
- return new(zone()) LCompareNumericAndBranch(left, right);
- } else {
- DCHECK(r.IsDouble());
- DCHECK(instr->left()->representation().IsDouble());
- DCHECK(instr->right()->representation().IsDouble());
- LOperand* left;
- LOperand* right;
- if (instr->left()->IsConstant() && instr->right()->IsConstant()) {
- left = UseRegisterOrConstantAtStart(instr->left());
- right = UseRegisterOrConstantAtStart(instr->right());
- } else {
- left = UseRegisterAtStart(instr->left());
- right = UseRegisterAtStart(instr->right());
- }
- return new(zone()) LCompareNumericAndBranch(left, right);
- }
-}
-
-
-LInstruction* LChunkBuilder::DoCompareObjectEqAndBranch(
- HCompareObjectEqAndBranch* instr) {
- LOperand* left = UseRegisterAtStart(instr->left());
- LOperand* right = UseRegisterOrConstantAtStart(instr->right());
- return new(zone()) LCmpObjectEqAndBranch(left, right);
-}
-
-
-LInstruction* LChunkBuilder::DoCompareHoleAndBranch(
- HCompareHoleAndBranch* instr) {
- LOperand* value = UseRegisterAtStart(instr->value());
- return new(zone()) LCmpHoleAndBranch(value);
-}
-
-
-LInstruction* LChunkBuilder::DoCompareMinusZeroAndBranch(
- HCompareMinusZeroAndBranch* instr) {
- LOperand* value = UseRegister(instr->value());
- return new(zone()) LCompareMinusZeroAndBranch(value);
-}
-
-
-LInstruction* LChunkBuilder::DoIsStringAndBranch(HIsStringAndBranch* instr) {
- DCHECK(instr->value()->representation().IsTagged());
- LOperand* value = UseRegisterAtStart(instr->value());
- LOperand* temp = TempRegister();
- return new(zone()) LIsStringAndBranch(value, temp);
-}
-
-
-LInstruction* LChunkBuilder::DoIsSmiAndBranch(HIsSmiAndBranch* instr) {
- DCHECK(instr->value()->representation().IsTagged());
- return new(zone()) LIsSmiAndBranch(Use(instr->value()));
-}
-
-
-LInstruction* LChunkBuilder::DoIsUndetectableAndBranch(
- HIsUndetectableAndBranch* instr) {
- DCHECK(instr->value()->representation().IsTagged());
- LOperand* value = UseRegisterAtStart(instr->value());
- LOperand* temp = TempRegister();
- return new(zone()) LIsUndetectableAndBranch(value, temp);
-}
-
-
-LInstruction* LChunkBuilder::DoStringCompareAndBranch(
- HStringCompareAndBranch* instr) {
-
- DCHECK(instr->left()->representation().IsTagged());
- DCHECK(instr->right()->representation().IsTagged());
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* left = UseFixed(instr->left(), rdx);
- LOperand* right = UseFixed(instr->right(), rax);
- LStringCompareAndBranch* result =
- new(zone()) LStringCompareAndBranch(context, left, right);
-
- return MarkAsCall(result, instr);
-}
-
-
-LInstruction* LChunkBuilder::DoHasInstanceTypeAndBranch(
- HHasInstanceTypeAndBranch* instr) {
- DCHECK(instr->value()->representation().IsTagged());
- LOperand* value = UseRegisterAtStart(instr->value());
- return new(zone()) LHasInstanceTypeAndBranch(value);
-}
-
-
-LInstruction* LChunkBuilder::DoGetCachedArrayIndex(
- HGetCachedArrayIndex* instr) {
- DCHECK(instr->value()->representation().IsTagged());
- LOperand* value = UseRegisterAtStart(instr->value());
-
- return DefineAsRegister(new(zone()) LGetCachedArrayIndex(value));
-}
-
-
-LInstruction* LChunkBuilder::DoHasCachedArrayIndexAndBranch(
- HHasCachedArrayIndexAndBranch* instr) {
- DCHECK(instr->value()->representation().IsTagged());
- LOperand* value = UseRegisterAtStart(instr->value());
- return new(zone()) LHasCachedArrayIndexAndBranch(value);
-}
-
-
-LInstruction* LChunkBuilder::DoClassOfTestAndBranch(
- HClassOfTestAndBranch* instr) {
- LOperand* value = UseRegister(instr->value());
- return new(zone()) LClassOfTestAndBranch(value,
- TempRegister(),
- TempRegister());
-}
-
-
-LInstruction* LChunkBuilder::DoMapEnumLength(HMapEnumLength* instr) {
- LOperand* map = UseRegisterAtStart(instr->value());
- return DefineAsRegister(new(zone()) LMapEnumLength(map));
-}
-
-
-LInstruction* LChunkBuilder::DoDateField(HDateField* instr) {
- LOperand* object = UseFixed(instr->value(), rax);
- LDateField* result = new(zone()) LDateField(object, instr->index());
- return MarkAsCall(DefineFixed(result, rax), instr, CANNOT_DEOPTIMIZE_EAGERLY);
-}
-
-
-LInstruction* LChunkBuilder::DoSeqStringGetChar(HSeqStringGetChar* instr) {
- LOperand* string = UseRegisterAtStart(instr->string());
- LOperand* index = UseRegisterOrConstantAtStart(instr->index());
- return DefineAsRegister(new(zone()) LSeqStringGetChar(string, index));
-}
-
-
-LInstruction* LChunkBuilder::DoSeqStringSetChar(HSeqStringSetChar* instr) {
- LOperand* string = UseRegisterAtStart(instr->string());
- LOperand* index = FLAG_debug_code
- ? UseRegisterAtStart(instr->index())
- : UseRegisterOrConstantAtStart(instr->index());
- LOperand* value = FLAG_debug_code
- ? UseRegisterAtStart(instr->value())
- : UseRegisterOrConstantAtStart(instr->value());
- LOperand* context = FLAG_debug_code ? UseFixed(instr->context(), rsi) : NULL;
- LInstruction* result = new(zone()) LSeqStringSetChar(context, string,
- index, value);
- if (FLAG_debug_code) {
- result = MarkAsCall(result, instr);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoBoundsCheck(HBoundsCheck* instr) {
- if (!FLAG_debug_code && instr->skip_check()) return NULL;
- LOperand* index = UseRegisterOrConstantAtStart(instr->index());
- LOperand* length = !index->IsConstantOperand()
- ? UseOrConstantAtStart(instr->length())
- : UseAtStart(instr->length());
- LInstruction* result = new(zone()) LBoundsCheck(index, length);
- if (!FLAG_debug_code || !instr->skip_check()) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoBoundsCheckBaseIndexInformation(
- HBoundsCheckBaseIndexInformation* instr) {
- UNREACHABLE();
- return NULL;
-}
-
-
-LInstruction* LChunkBuilder::DoAbnormalExit(HAbnormalExit* instr) {
- // The control instruction marking the end of a block that completed
- // abruptly (e.g., threw an exception). There is nothing specific to do.
- return NULL;
-}
-
-
-LInstruction* LChunkBuilder::DoUseConst(HUseConst* instr) {
- return NULL;
-}
-
-
-LInstruction* LChunkBuilder::DoForceRepresentation(HForceRepresentation* bad) {
- // All HForceRepresentation instructions should be eliminated in the
- // representation change phase of Hydrogen.
- UNREACHABLE();
- return NULL;
-}
-
-
-LInstruction* LChunkBuilder::DoChange(HChange* instr) {
- Representation from = instr->from();
- Representation to = instr->to();
- HValue* val = instr->value();
- if (from.IsSmi()) {
- if (to.IsTagged()) {
- LOperand* value = UseRegister(val);
- return DefineSameAsFirst(new(zone()) LDummyUse(value));
- }
- from = Representation::Tagged();
- }
- if (from.IsTagged()) {
- if (to.IsDouble()) {
- LOperand* value = UseRegister(val);
- LInstruction* result = DefineAsRegister(new(zone()) LNumberUntagD(value));
- if (!val->representation().IsSmi()) result = AssignEnvironment(result);
- return result;
- } else if (to.IsSmi()) {
- LOperand* value = UseRegister(val);
- if (val->type().IsSmi()) {
- return DefineSameAsFirst(new(zone()) LDummyUse(value));
- }
- return AssignEnvironment(DefineSameAsFirst(new(zone()) LCheckSmi(value)));
- } else {
- DCHECK(to.IsInteger32());
- if (val->type().IsSmi() || val->representation().IsSmi()) {
- LOperand* value = UseRegister(val);
- return DefineSameAsFirst(new(zone()) LSmiUntag(value, false));
- } else {
- LOperand* value = UseRegister(val);
- bool truncating = instr->CanTruncateToInt32();
- LOperand* xmm_temp = truncating ? NULL : FixedTemp(xmm1);
- LInstruction* result =
- DefineSameAsFirst(new(zone()) LTaggedToI(value, xmm_temp));
- if (!val->representation().IsSmi()) result = AssignEnvironment(result);
- return result;
- }
- }
- } else if (from.IsDouble()) {
- if (to.IsTagged()) {
- info()->MarkAsDeferredCalling();
- LOperand* value = UseRegister(val);
- LOperand* temp = TempRegister();
- LUnallocated* result_temp = TempRegister();
- LNumberTagD* result = new(zone()) LNumberTagD(value, temp);
- return AssignPointerMap(Define(result, result_temp));
- } else if (to.IsSmi()) {
- LOperand* value = UseRegister(val);
- return AssignEnvironment(
- DefineAsRegister(new(zone()) LDoubleToSmi(value)));
- } else {
- DCHECK(to.IsInteger32());
- LOperand* value = UseRegister(val);
- LInstruction* result = DefineAsRegister(new(zone()) LDoubleToI(value));
- if (!instr->CanTruncateToInt32()) result = AssignEnvironment(result);
- return result;
- }
- } else if (from.IsInteger32()) {
- info()->MarkAsDeferredCalling();
- if (to.IsTagged()) {
- if (!instr->CheckFlag(HValue::kCanOverflow)) {
- LOperand* value = UseRegister(val);
- return DefineAsRegister(new(zone()) LSmiTag(value));
- } else if (val->CheckFlag(HInstruction::kUint32)) {
- LOperand* value = UseRegister(val);
- LOperand* temp1 = TempRegister();
- LOperand* temp2 = FixedTemp(xmm1);
- LNumberTagU* result = new(zone()) LNumberTagU(value, temp1, temp2);
- return AssignPointerMap(DefineSameAsFirst(result));
- } else {
- LOperand* value = UseRegister(val);
- LOperand* temp1 = SmiValuesAre32Bits() ? NULL : TempRegister();
- LOperand* temp2 = SmiValuesAre32Bits() ? NULL : FixedTemp(xmm1);
- LNumberTagI* result = new(zone()) LNumberTagI(value, temp1, temp2);
- return AssignPointerMap(DefineSameAsFirst(result));
- }
- } else if (to.IsSmi()) {
- LOperand* value = UseRegister(val);
- LInstruction* result = DefineAsRegister(new(zone()) LSmiTag(value));
- if (instr->CheckFlag(HValue::kCanOverflow)) {
- result = AssignEnvironment(result);
- }
- return result;
- } else {
- DCHECK(to.IsDouble());
- if (val->CheckFlag(HInstruction::kUint32)) {
- return DefineAsRegister(new(zone()) LUint32ToDouble(UseRegister(val)));
- } else {
- LOperand* value = Use(val);
- return DefineAsRegister(new(zone()) LInteger32ToDouble(value));
- }
- }
- }
- UNREACHABLE();
- return NULL;
-}
-
-
-LInstruction* LChunkBuilder::DoCheckHeapObject(HCheckHeapObject* instr) {
- LOperand* value = UseRegisterAtStart(instr->value());
- LInstruction* result = new(zone()) LCheckNonSmi(value);
- if (!instr->value()->type().IsHeapObject()) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoCheckSmi(HCheckSmi* instr) {
- LOperand* value = UseRegisterAtStart(instr->value());
- return AssignEnvironment(new(zone()) LCheckSmi(value));
-}
-
-
-LInstruction* LChunkBuilder::DoCheckArrayBufferNotNeutered(
- HCheckArrayBufferNotNeutered* instr) {
- LOperand* view = UseRegisterAtStart(instr->value());
- LCheckArrayBufferNotNeutered* result =
- new (zone()) LCheckArrayBufferNotNeutered(view);
- return AssignEnvironment(result);
-}
-
-
-LInstruction* LChunkBuilder::DoCheckInstanceType(HCheckInstanceType* instr) {
- LOperand* value = UseRegisterAtStart(instr->value());
- LCheckInstanceType* result = new(zone()) LCheckInstanceType(value);
- return AssignEnvironment(result);
-}
-
-
-LInstruction* LChunkBuilder::DoCheckValue(HCheckValue* instr) {
- LOperand* value = UseRegisterAtStart(instr->value());
- return AssignEnvironment(new(zone()) LCheckValue(value));
-}
-
-
-LInstruction* LChunkBuilder::DoCheckMaps(HCheckMaps* instr) {
- if (instr->IsStabilityCheck()) return new(zone()) LCheckMaps;
- LOperand* value = UseRegisterAtStart(instr->value());
- LInstruction* result = AssignEnvironment(new(zone()) LCheckMaps(value));
- if (instr->HasMigrationTarget()) {
- info()->MarkAsDeferredCalling();
- result = AssignPointerMap(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoClampToUint8(HClampToUint8* instr) {
- HValue* value = instr->value();
- Representation input_rep = value->representation();
- LOperand* reg = UseRegister(value);
- if (input_rep.IsDouble()) {
- return DefineAsRegister(new(zone()) LClampDToUint8(reg));
- } else if (input_rep.IsInteger32()) {
- return DefineSameAsFirst(new(zone()) LClampIToUint8(reg));
- } else {
- DCHECK(input_rep.IsSmiOrTagged());
- // Register allocator doesn't (yet) support allocation of double
- // temps. Reserve xmm1 explicitly.
- LClampTToUint8* result = new(zone()) LClampTToUint8(reg,
- FixedTemp(xmm1));
- return AssignEnvironment(DefineSameAsFirst(result));
- }
-}
-
-
-LInstruction* LChunkBuilder::DoDoubleBits(HDoubleBits* instr) {
- HValue* value = instr->value();
- DCHECK(value->representation().IsDouble());
- return DefineAsRegister(new(zone()) LDoubleBits(UseRegister(value)));
-}
-
-
-LInstruction* LChunkBuilder::DoConstructDouble(HConstructDouble* instr) {
- LOperand* lo = UseRegister(instr->lo());
- LOperand* hi = UseRegister(instr->hi());
- return DefineAsRegister(new(zone()) LConstructDouble(hi, lo));
-}
-
-
-LInstruction* LChunkBuilder::DoReturn(HReturn* instr) {
- LOperand* context = info()->IsStub() ? UseFixed(instr->context(), rsi) : NULL;
- LOperand* parameter_count = UseRegisterOrConstant(instr->parameter_count());
- return new(zone()) LReturn(
- UseFixed(instr->value(), rax), context, parameter_count);
-}
-
-
-LInstruction* LChunkBuilder::DoConstant(HConstant* instr) {
- Representation r = instr->representation();
- if (r.IsSmi()) {
- return DefineAsRegister(new(zone()) LConstantS);
- } else if (r.IsInteger32()) {
- return DefineAsRegister(new(zone()) LConstantI);
- } else if (r.IsDouble()) {
- return DefineAsRegister(new (zone()) LConstantD);
- } else if (r.IsExternal()) {
- return DefineAsRegister(new(zone()) LConstantE);
- } else if (r.IsTagged()) {
- return DefineAsRegister(new(zone()) LConstantT);
- } else {
- UNREACHABLE();
- return NULL;
- }
-}
-
-
-LInstruction* LChunkBuilder::DoLoadGlobalGeneric(HLoadGlobalGeneric* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* global_object =
- UseFixed(instr->global_object(), LoadDescriptor::ReceiverRegister());
- LOperand* vector = NULL;
- if (instr->HasVectorAndSlot()) {
- vector = FixedTemp(LoadWithVectorDescriptor::VectorRegister());
- }
-
- LLoadGlobalGeneric* result =
- new(zone()) LLoadGlobalGeneric(context, global_object, vector);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoLoadGlobalViaContext(
- HLoadGlobalViaContext* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- DCHECK(instr->slot_index() > 0);
- LLoadGlobalViaContext* result = new (zone()) LLoadGlobalViaContext(context);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoLoadContextSlot(HLoadContextSlot* instr) {
- LOperand* context = UseRegisterAtStart(instr->value());
- LInstruction* result =
- DefineAsRegister(new(zone()) LLoadContextSlot(context));
- if (instr->RequiresHoleCheck() && instr->DeoptimizesOnHole()) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoStoreContextSlot(HStoreContextSlot* instr) {
- LOperand* context;
- LOperand* value;
- LOperand* temp;
- context = UseRegister(instr->context());
- if (instr->NeedsWriteBarrier()) {
- value = UseTempRegister(instr->value());
- temp = TempRegister();
- } else {
- value = UseRegister(instr->value());
- temp = NULL;
- }
- LInstruction* result = new(zone()) LStoreContextSlot(context, value, temp);
- if (instr->RequiresHoleCheck() && instr->DeoptimizesOnHole()) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoLoadNamedField(HLoadNamedField* instr) {
- // Use the special mov rax, moffs64 encoding for external
- // memory accesses with 64-bit word-sized values.
- if (instr->access().IsExternalMemory() &&
- instr->access().offset() == 0 &&
- (instr->access().representation().IsSmi() ||
- instr->access().representation().IsTagged() ||
- instr->access().representation().IsHeapObject() ||
- instr->access().representation().IsExternal())) {
- LOperand* obj = UseRegisterOrConstantAtStart(instr->object());
- return DefineFixed(new(zone()) LLoadNamedField(obj), rax);
- }
- LOperand* obj = UseRegisterAtStart(instr->object());
- return DefineAsRegister(new(zone()) LLoadNamedField(obj));
-}
-
-
-LInstruction* LChunkBuilder::DoLoadNamedGeneric(HLoadNamedGeneric* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* object =
- UseFixed(instr->object(), LoadDescriptor::ReceiverRegister());
- LOperand* vector = NULL;
- if (instr->HasVectorAndSlot()) {
- vector = FixedTemp(LoadWithVectorDescriptor::VectorRegister());
- }
- LLoadNamedGeneric* result = new(zone()) LLoadNamedGeneric(
- context, object, vector);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoLoadFunctionPrototype(
- HLoadFunctionPrototype* instr) {
- return AssignEnvironment(DefineAsRegister(
- new(zone()) LLoadFunctionPrototype(UseRegister(instr->function()))));
-}
-
-
-LInstruction* LChunkBuilder::DoLoadRoot(HLoadRoot* instr) {
- return DefineAsRegister(new(zone()) LLoadRoot);
-}
-
-
-void LChunkBuilder::FindDehoistedKeyDefinitions(HValue* candidate) {
- // We sign extend the dehoisted key at the definition point when the pointer
- // size is 64-bit. For x32 port, we sign extend the dehoisted key at the use
- // points and should not invoke this function. We can't use STATIC_ASSERT
- // here as the pointer size is 32-bit for x32.
- DCHECK(kPointerSize == kInt64Size);
- BitVector* dehoisted_key_ids = chunk_->GetDehoistedKeyIds();
- if (dehoisted_key_ids->Contains(candidate->id())) return;
- dehoisted_key_ids->Add(candidate->id());
- if (!candidate->IsPhi()) return;
- for (int i = 0; i < candidate->OperandCount(); ++i) {
- FindDehoistedKeyDefinitions(candidate->OperandAt(i));
- }
-}
-
-
-LInstruction* LChunkBuilder::DoLoadKeyed(HLoadKeyed* instr) {
- DCHECK((kPointerSize == kInt64Size &&
- instr->key()->representation().IsInteger32()) ||
- (kPointerSize == kInt32Size &&
- instr->key()->representation().IsSmiOrInteger32()));
- ElementsKind elements_kind = instr->elements_kind();
- LOperand* key = NULL;
- LInstruction* result = NULL;
-
- if (kPointerSize == kInt64Size) {
- key = UseRegisterOrConstantAtStart(instr->key());
- } else {
- bool clobbers_key = ExternalArrayOpRequiresTemp(
- instr->key()->representation(), elements_kind);
- key = clobbers_key
- ? UseTempRegister(instr->key())
- : UseRegisterOrConstantAtStart(instr->key());
- }
-
- if ((kPointerSize == kInt64Size) && instr->IsDehoisted()) {
- FindDehoistedKeyDefinitions(instr->key());
- }
-
- if (!instr->is_fixed_typed_array()) {
- LOperand* obj = UseRegisterAtStart(instr->elements());
- result = DefineAsRegister(new(zone()) LLoadKeyed(obj, key));
- } else {
- DCHECK(
- (instr->representation().IsInteger32() &&
- !(IsDoubleOrFloatElementsKind(elements_kind))) ||
- (instr->representation().IsDouble() &&
- (IsDoubleOrFloatElementsKind(elements_kind))));
- LOperand* backing_store = UseRegister(instr->elements());
- result = DefineAsRegister(new(zone()) LLoadKeyed(backing_store, key));
- }
-
- bool needs_environment;
- if (instr->is_fixed_typed_array()) {
- // see LCodeGen::DoLoadKeyedExternalArray
- needs_environment = elements_kind == UINT32_ELEMENTS &&
- !instr->CheckFlag(HInstruction::kUint32);
- } else {
- // see LCodeGen::DoLoadKeyedFixedDoubleArray and
- // LCodeGen::DoLoadKeyedFixedArray
- needs_environment =
- instr->RequiresHoleCheck() ||
- (instr->hole_mode() == CONVERT_HOLE_TO_UNDEFINED && info()->IsStub());
- }
-
- if (needs_environment) {
- result = AssignEnvironment(result);
- }
- return result;
-}
-
-
-LInstruction* LChunkBuilder::DoLoadKeyedGeneric(HLoadKeyedGeneric* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* object =
- UseFixed(instr->object(), LoadDescriptor::ReceiverRegister());
- LOperand* key = UseFixed(instr->key(), LoadDescriptor::NameRegister());
- LOperand* vector = NULL;
- if (instr->HasVectorAndSlot()) {
- vector = FixedTemp(LoadWithVectorDescriptor::VectorRegister());
- }
-
- LLoadKeyedGeneric* result =
- new(zone()) LLoadKeyedGeneric(context, object, key, vector);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoStoreKeyed(HStoreKeyed* instr) {
- ElementsKind elements_kind = instr->elements_kind();
-
- if ((kPointerSize == kInt64Size) && instr->IsDehoisted()) {
- FindDehoistedKeyDefinitions(instr->key());
- }
-
- if (!instr->is_fixed_typed_array()) {
- DCHECK(instr->elements()->representation().IsTagged());
- bool needs_write_barrier = instr->NeedsWriteBarrier();
- LOperand* object = NULL;
- LOperand* key = NULL;
- LOperand* val = NULL;
-
- Representation value_representation = instr->value()->representation();
- if (value_representation.IsDouble()) {
- object = UseRegisterAtStart(instr->elements());
- val = UseRegisterAtStart(instr->value());
- key = UseRegisterOrConstantAtStart(instr->key());
- } else {
- DCHECK(value_representation.IsSmiOrTagged() ||
- value_representation.IsInteger32());
- if (needs_write_barrier) {
- object = UseTempRegister(instr->elements());
- val = UseTempRegister(instr->value());
- key = UseTempRegister(instr->key());
- } else {
- object = UseRegisterAtStart(instr->elements());
- val = UseRegisterOrConstantAtStart(instr->value());
- key = UseRegisterOrConstantAtStart(instr->key());
- }
- }
-
- return new(zone()) LStoreKeyed(object, key, val);
- }
-
- DCHECK(
- (instr->value()->representation().IsInteger32() &&
- !IsDoubleOrFloatElementsKind(elements_kind)) ||
- (instr->value()->representation().IsDouble() &&
- IsDoubleOrFloatElementsKind(elements_kind)));
- DCHECK(instr->elements()->representation().IsExternal());
- bool val_is_temp_register = elements_kind == UINT8_CLAMPED_ELEMENTS ||
- elements_kind == FLOAT32_ELEMENTS;
- LOperand* val = val_is_temp_register ? UseTempRegister(instr->value())
- : UseRegister(instr->value());
- LOperand* key = NULL;
- if (kPointerSize == kInt64Size) {
- key = UseRegisterOrConstantAtStart(instr->key());
- } else {
- bool clobbers_key = ExternalArrayOpRequiresTemp(
- instr->key()->representation(), elements_kind);
- key = clobbers_key
- ? UseTempRegister(instr->key())
- : UseRegisterOrConstantAtStart(instr->key());
- }
- LOperand* backing_store = UseRegister(instr->elements());
- return new(zone()) LStoreKeyed(backing_store, key, val);
-}
-
-
-LInstruction* LChunkBuilder::DoStoreKeyedGeneric(HStoreKeyedGeneric* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* object =
- UseFixed(instr->object(), StoreDescriptor::ReceiverRegister());
- LOperand* key = UseFixed(instr->key(), StoreDescriptor::NameRegister());
- LOperand* value = UseFixed(instr->value(), StoreDescriptor::ValueRegister());
-
- DCHECK(instr->object()->representation().IsTagged());
- DCHECK(instr->key()->representation().IsTagged());
- DCHECK(instr->value()->representation().IsTagged());
-
- LOperand* slot = NULL;
- LOperand* vector = NULL;
- if (instr->HasVectorAndSlot()) {
- slot = FixedTemp(VectorStoreICDescriptor::SlotRegister());
- vector = FixedTemp(VectorStoreICDescriptor::VectorRegister());
- }
-
- LStoreKeyedGeneric* result = new (zone())
- LStoreKeyedGeneric(context, object, key, value, slot, vector);
- return MarkAsCall(result, instr);
-}
-
-
-LInstruction* LChunkBuilder::DoTransitionElementsKind(
- HTransitionElementsKind* instr) {
- if (IsSimpleMapChangeTransition(instr->from_kind(), instr->to_kind())) {
- LOperand* object = UseRegister(instr->object());
- LOperand* new_map_reg = TempRegister();
- LOperand* temp_reg = TempRegister();
- LTransitionElementsKind* result = new(zone()) LTransitionElementsKind(
- object, NULL, new_map_reg, temp_reg);
- return result;
- } else {
- LOperand* object = UseFixed(instr->object(), rax);
- LOperand* context = UseFixed(instr->context(), rsi);
- LTransitionElementsKind* result =
- new(zone()) LTransitionElementsKind(object, context, NULL, NULL);
- return MarkAsCall(result, instr);
- }
-}
-
-
-LInstruction* LChunkBuilder::DoTrapAllocationMemento(
- HTrapAllocationMemento* instr) {
- LOperand* object = UseRegister(instr->object());
- LOperand* temp = TempRegister();
- LTrapAllocationMemento* result =
- new(zone()) LTrapAllocationMemento(object, temp);
- return AssignEnvironment(result);
-}
-
-
-LInstruction* LChunkBuilder::DoMaybeGrowElements(HMaybeGrowElements* instr) {
- info()->MarkAsDeferredCalling();
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* object = Use(instr->object());
- LOperand* elements = Use(instr->elements());
- LOperand* key = UseRegisterOrConstant(instr->key());
- LOperand* current_capacity = UseRegisterOrConstant(instr->current_capacity());
-
- LMaybeGrowElements* result = new (zone())
- LMaybeGrowElements(context, object, elements, key, current_capacity);
- DefineFixed(result, rax);
- return AssignPointerMap(AssignEnvironment(result));
-}
-
-
-LInstruction* LChunkBuilder::DoStoreNamedField(HStoreNamedField* instr) {
- bool is_in_object = instr->access().IsInobject();
- bool is_external_location = instr->access().IsExternalMemory() &&
- instr->access().offset() == 0;
- bool needs_write_barrier = instr->NeedsWriteBarrier();
- bool needs_write_barrier_for_map = instr->has_transition() &&
- instr->NeedsWriteBarrierForMap();
-
- LOperand* obj;
- if (needs_write_barrier) {
- obj = is_in_object
- ? UseRegister(instr->object())
- : UseTempRegister(instr->object());
- } else if (is_external_location) {
- DCHECK(!is_in_object);
- DCHECK(!needs_write_barrier);
- DCHECK(!needs_write_barrier_for_map);
- obj = UseRegisterOrConstant(instr->object());
- } else {
- obj = needs_write_barrier_for_map
- ? UseRegister(instr->object())
- : UseRegisterAtStart(instr->object());
- }
-
- bool can_be_constant = instr->value()->IsConstant() &&
- HConstant::cast(instr->value())->NotInNewSpace() &&
- !instr->field_representation().IsDouble();
-
- LOperand* val;
- if (needs_write_barrier) {
- val = UseTempRegister(instr->value());
- } else if (is_external_location) {
- val = UseFixed(instr->value(), rax);
- } else if (can_be_constant) {
- val = UseRegisterOrConstant(instr->value());
- } else if (instr->field_representation().IsDouble()) {
- val = UseRegisterAtStart(instr->value());
- } else {
- val = UseRegister(instr->value());
- }
-
- // We only need a scratch register if we have a write barrier or we
- // have a store into the properties array (not in-object-property).
- LOperand* temp = (!is_in_object || needs_write_barrier ||
- needs_write_barrier_for_map) ? TempRegister() : NULL;
-
- return new(zone()) LStoreNamedField(obj, val, temp);
-}
-
-
-LInstruction* LChunkBuilder::DoStoreNamedGeneric(HStoreNamedGeneric* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* object =
- UseFixed(instr->object(), StoreDescriptor::ReceiverRegister());
- LOperand* value = UseFixed(instr->value(), StoreDescriptor::ValueRegister());
- LOperand* slot = NULL;
- LOperand* vector = NULL;
- if (instr->HasVectorAndSlot()) {
- slot = FixedTemp(VectorStoreICDescriptor::SlotRegister());
- vector = FixedTemp(VectorStoreICDescriptor::VectorRegister());
- }
-
- LStoreNamedGeneric* result =
- new (zone()) LStoreNamedGeneric(context, object, value, slot, vector);
- return MarkAsCall(result, instr);
-}
-
-
-LInstruction* LChunkBuilder::DoStoreGlobalViaContext(
- HStoreGlobalViaContext* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* value = UseFixed(instr->value(),
- StoreGlobalViaContextDescriptor::ValueRegister());
- DCHECK(instr->slot_index() > 0);
-
- LStoreGlobalViaContext* result =
- new (zone()) LStoreGlobalViaContext(context, value);
- return MarkAsCall(result, instr);
-}
-
-
-LInstruction* LChunkBuilder::DoStringAdd(HStringAdd* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* left = UseFixed(instr->left(), rdx);
- LOperand* right = UseFixed(instr->right(), rax);
- return MarkAsCall(
- DefineFixed(new(zone()) LStringAdd(context, left, right), rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoStringCharCodeAt(HStringCharCodeAt* instr) {
- LOperand* string = UseTempRegister(instr->string());
- LOperand* index = UseTempRegister(instr->index());
- LOperand* context = UseAny(instr->context());
- LStringCharCodeAt* result =
- new(zone()) LStringCharCodeAt(context, string, index);
- return AssignPointerMap(DefineAsRegister(result));
-}
-
-
-LInstruction* LChunkBuilder::DoStringCharFromCode(HStringCharFromCode* instr) {
- LOperand* char_code = UseRegister(instr->value());
- LOperand* context = UseAny(instr->context());
- LStringCharFromCode* result =
- new(zone()) LStringCharFromCode(context, char_code);
- return AssignPointerMap(DefineAsRegister(result));
-}
-
-
-LInstruction* LChunkBuilder::DoAllocate(HAllocate* instr) {
- info()->MarkAsDeferredCalling();
- LOperand* context = UseAny(instr->context());
- LOperand* size = instr->size()->IsConstant()
- ? UseConstant(instr->size())
- : UseTempRegister(instr->size());
- LOperand* temp = TempRegister();
- LAllocate* result = new(zone()) LAllocate(context, size, temp);
- return AssignPointerMap(DefineAsRegister(result));
-}
-
-
-LInstruction* LChunkBuilder::DoRegExpLiteral(HRegExpLiteral* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LRegExpLiteral* result = new(zone()) LRegExpLiteral(context);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoOsrEntry(HOsrEntry* instr) {
- DCHECK(argument_count_ == 0);
- allocator_->MarkAsOsrEntry();
- current_block_->last_environment()->set_ast_id(instr->ast_id());
- return AssignEnvironment(new(zone()) LOsrEntry);
-}
-
-
-LInstruction* LChunkBuilder::DoParameter(HParameter* instr) {
- LParameter* result = new(zone()) LParameter;
- if (instr->kind() == HParameter::STACK_PARAMETER) {
- int spill_index = chunk()->GetParameterStackSlot(instr->index());
- return DefineAsSpilled(result, spill_index);
- } else {
- DCHECK(info()->IsStub());
- CallInterfaceDescriptor descriptor =
- info()->code_stub()->GetCallInterfaceDescriptor();
- int index = static_cast<int>(instr->index());
- Register reg = descriptor.GetRegisterParameter(index);
- return DefineFixed(result, reg);
- }
-}
-
-
-LInstruction* LChunkBuilder::DoUnknownOSRValue(HUnknownOSRValue* instr) {
- // Use an index that corresponds to the location in the unoptimized frame,
- // which the optimized frame will subsume.
- int env_index = instr->index();
- int spill_index = 0;
- if (instr->environment()->is_parameter_index(env_index)) {
- spill_index = chunk()->GetParameterStackSlot(env_index);
- } else {
- spill_index = env_index - instr->environment()->first_local_index();
- if (spill_index > LUnallocated::kMaxFixedSlotIndex) {
- Retry(kTooManySpillSlotsNeededForOSR);
- spill_index = 0;
- }
- }
- return DefineAsSpilled(new(zone()) LUnknownOSRValue, spill_index);
-}
-
-
-LInstruction* LChunkBuilder::DoCallStub(HCallStub* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LCallStub* result = new(zone()) LCallStub(context);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoArgumentsObject(HArgumentsObject* instr) {
- // There are no real uses of the arguments object.
- // arguments.length and element access are supported directly on
- // stack arguments, and any real arguments object use causes a bailout.
- // So this value is never used.
- return NULL;
-}
-
-
-LInstruction* LChunkBuilder::DoCapturedObject(HCapturedObject* instr) {
- instr->ReplayEnvironment(current_block_->last_environment());
-
- // There are no real uses of a captured object.
- return NULL;
-}
-
-
-LInstruction* LChunkBuilder::DoAccessArgumentsAt(HAccessArgumentsAt* instr) {
- info()->MarkAsRequiresFrame();
- LOperand* args = UseRegister(instr->arguments());
- LOperand* length;
- LOperand* index;
- if (instr->length()->IsConstant() && instr->index()->IsConstant()) {
- length = UseRegisterOrConstant(instr->length());
- index = UseOrConstant(instr->index());
- } else {
- length = UseTempRegister(instr->length());
- index = Use(instr->index());
- }
- return DefineAsRegister(new(zone()) LAccessArgumentsAt(args, length, index));
-}
-
-
-LInstruction* LChunkBuilder::DoToFastProperties(HToFastProperties* instr) {
- LOperand* object = UseFixed(instr->value(), rax);
- LToFastProperties* result = new(zone()) LToFastProperties(object);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoTypeof(HTypeof* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* value = UseFixed(instr->value(), rbx);
- LTypeof* result = new(zone()) LTypeof(context, value);
- return MarkAsCall(DefineFixed(result, rax), instr);
-}
-
-
-LInstruction* LChunkBuilder::DoTypeofIsAndBranch(HTypeofIsAndBranch* instr) {
- return new(zone()) LTypeofIsAndBranch(UseTempRegister(instr->value()));
-}
-
-
-LInstruction* LChunkBuilder::DoIsConstructCallAndBranch(
- HIsConstructCallAndBranch* instr) {
- return new(zone()) LIsConstructCallAndBranch(TempRegister());
-}
-
-
-LInstruction* LChunkBuilder::DoSimulate(HSimulate* instr) {
- instr->ReplayEnvironment(current_block_->last_environment());
- return NULL;
-}
-
-
-LInstruction* LChunkBuilder::DoStackCheck(HStackCheck* instr) {
- info()->MarkAsDeferredCalling();
- if (instr->is_function_entry()) {
- LOperand* context = UseFixed(instr->context(), rsi);
- return MarkAsCall(new(zone()) LStackCheck(context), instr);
- } else {
- DCHECK(instr->is_backwards_branch());
- LOperand* context = UseAny(instr->context());
- return AssignEnvironment(
- AssignPointerMap(new(zone()) LStackCheck(context)));
- }
-}
-
-
-LInstruction* LChunkBuilder::DoEnterInlined(HEnterInlined* instr) {
- HEnvironment* outer = current_block_->last_environment();
- outer->set_ast_id(instr->ReturnId());
- HConstant* undefined = graph()->GetConstantUndefined();
- HEnvironment* inner = outer->CopyForInlining(instr->closure(),
- instr->arguments_count(),
- instr->function(),
- undefined,
- instr->inlining_kind());
- // Only replay binding of arguments object if it wasn't removed from graph.
- if (instr->arguments_var() != NULL && instr->arguments_object()->IsLinked()) {
- inner->Bind(instr->arguments_var(), instr->arguments_object());
- }
- inner->BindContext(instr->closure_context());
- inner->set_entry(instr);
- current_block_->UpdateEnvironment(inner);
- chunk_->AddInlinedFunction(instr->shared());
- return NULL;
-}
-
-
-LInstruction* LChunkBuilder::DoLeaveInlined(HLeaveInlined* instr) {
- LInstruction* pop = NULL;
-
- HEnvironment* env = current_block_->last_environment();
-
- if (env->entry()->arguments_pushed()) {
- int argument_count = env->arguments_environment()->parameter_count();
- pop = new(zone()) LDrop(argument_count);
- DCHECK(instr->argument_delta() == -argument_count);
- }
-
- HEnvironment* outer = current_block_->last_environment()->
- DiscardInlined(false);
- current_block_->UpdateEnvironment(outer);
-
- return pop;
-}
-
-
-LInstruction* LChunkBuilder::DoForInPrepareMap(HForInPrepareMap* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* object = UseFixed(instr->enumerable(), rax);
- LForInPrepareMap* result = new(zone()) LForInPrepareMap(context, object);
- return MarkAsCall(DefineFixed(result, rax), instr, CAN_DEOPTIMIZE_EAGERLY);
-}
-
-
-LInstruction* LChunkBuilder::DoForInCacheArray(HForInCacheArray* instr) {
- LOperand* map = UseRegister(instr->map());
- return AssignEnvironment(DefineAsRegister(
- new(zone()) LForInCacheArray(map)));
-}
-
-
-LInstruction* LChunkBuilder::DoCheckMapValue(HCheckMapValue* instr) {
- LOperand* value = UseRegisterAtStart(instr->value());
- LOperand* map = UseRegisterAtStart(instr->map());
- return AssignEnvironment(new(zone()) LCheckMapValue(value, map));
-}
-
-
-LInstruction* LChunkBuilder::DoLoadFieldByIndex(HLoadFieldByIndex* instr) {
- LOperand* object = UseRegister(instr->object());
- LOperand* index = UseTempRegister(instr->index());
- LLoadFieldByIndex* load = new(zone()) LLoadFieldByIndex(object, index);
- LInstruction* result = DefineSameAsFirst(load);
- return AssignPointerMap(result);
-}
-
-
-LInstruction* LChunkBuilder::DoStoreFrameContext(HStoreFrameContext* instr) {
- LOperand* context = UseRegisterAtStart(instr->context());
- return new(zone()) LStoreFrameContext(context);
-}
-
-
-LInstruction* LChunkBuilder::DoAllocateBlockContext(
- HAllocateBlockContext* instr) {
- LOperand* context = UseFixed(instr->context(), rsi);
- LOperand* function = UseRegisterAtStart(instr->function());
- LAllocateBlockContext* result =
- new(zone()) LAllocateBlockContext(context, function);
- return MarkAsCall(DefineFixed(result, rsi), instr);
-}
-
-
-} // namespace internal
-} // namespace v8
-
-#endif // V8_TARGET_ARCH_X64
diff --git a/deps/v8/src/x64/lithium-x64.h b/deps/v8/src/x64/lithium-x64.h
deleted file mode 100644
index 6129516515..0000000000
--- a/deps/v8/src/x64/lithium-x64.h
+++ /dev/null
@@ -1,2869 +0,0 @@
-// Copyright 2012 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_X64_LITHIUM_X64_H_
-#define V8_X64_LITHIUM_X64_H_
-
-#include "src/hydrogen.h"
-#include "src/lithium.h"
-#include "src/lithium-allocator.h"
-#include "src/safepoint-table.h"
-#include "src/utils.h"
-
-namespace v8 {
-namespace internal {
-
-// Forward declarations.
-class LCodeGen;
-
-#define LITHIUM_CONCRETE_INSTRUCTION_LIST(V) \
- V(AccessArgumentsAt) \
- V(AddI) \
- V(Allocate) \
- V(AllocateBlockContext) \
- V(ApplyArguments) \
- V(ArgumentsElements) \
- V(ArgumentsLength) \
- V(ArithmeticD) \
- V(ArithmeticT) \
- V(BitI) \
- V(BoundsCheck) \
- V(Branch) \
- V(CallJSFunction) \
- V(CallWithDescriptor) \
- V(CallFunction) \
- V(CallNew) \
- V(CallNewArray) \
- V(CallRuntime) \
- V(CallStub) \
- V(CheckArrayBufferNotNeutered) \
- V(CheckInstanceType) \
- V(CheckMaps) \
- V(CheckMapValue) \
- V(CheckNonSmi) \
- V(CheckSmi) \
- V(CheckValue) \
- V(ClampDToUint8) \
- V(ClampIToUint8) \
- V(ClampTToUint8) \
- V(ClassOfTestAndBranch) \
- V(CompareMinusZeroAndBranch) \
- V(CompareNumericAndBranch) \
- V(CmpObjectEqAndBranch) \
- V(CmpHoleAndBranch) \
- V(CmpMapAndBranch) \
- V(CmpT) \
- V(ConstantD) \
- V(ConstantE) \
- V(ConstantI) \
- V(ConstantS) \
- V(ConstantT) \
- V(ConstructDouble) \
- V(Context) \
- V(DateField) \
- V(DebugBreak) \
- V(DeclareGlobals) \
- V(Deoptimize) \
- V(DivByConstI) \
- V(DivByPowerOf2I) \
- V(DivI) \
- V(DoubleBits) \
- V(DoubleToI) \
- V(DoubleToSmi) \
- V(Drop) \
- V(DummyUse) \
- V(Dummy) \
- V(FlooringDivByConstI) \
- V(FlooringDivByPowerOf2I) \
- V(FlooringDivI) \
- V(ForInCacheArray) \
- V(ForInPrepareMap) \
- V(GetCachedArrayIndex) \
- V(Goto) \
- V(HasCachedArrayIndexAndBranch) \
- V(HasInPrototypeChainAndBranch) \
- V(HasInstanceTypeAndBranch) \
- V(InnerAllocatedObject) \
- V(InstanceOf) \
- V(InstructionGap) \
- V(Integer32ToDouble) \
- V(InvokeFunction) \
- V(IsConstructCallAndBranch) \
- V(IsStringAndBranch) \
- V(IsSmiAndBranch) \
- V(IsUndetectableAndBranch) \
- V(Label) \
- V(LazyBailout) \
- V(LoadContextSlot) \
- V(LoadRoot) \
- V(LoadFieldByIndex) \
- V(LoadFunctionPrototype) \
- V(LoadGlobalGeneric) \
- V(LoadGlobalViaContext) \
- V(LoadKeyed) \
- V(LoadKeyedGeneric) \
- V(LoadNamedField) \
- V(LoadNamedGeneric) \
- V(MapEnumLength) \
- V(MathAbs) \
- V(MathClz32) \
- V(MathExp) \
- V(MathFloor) \
- V(MathFround) \
- V(MathLog) \
- V(MathMinMax) \
- V(MathPowHalf) \
- V(MathRound) \
- V(MathSqrt) \
- V(MaybeGrowElements) \
- V(ModByConstI) \
- V(ModByPowerOf2I) \
- V(ModI) \
- V(MulI) \
- V(NumberTagD) \
- V(NumberTagI) \
- V(NumberTagU) \
- V(NumberUntagD) \
- V(OsrEntry) \
- V(Parameter) \
- V(Power) \
- V(Prologue) \
- V(PushArgument) \
- V(RegExpLiteral) \
- V(Return) \
- V(SeqStringGetChar) \
- V(SeqStringSetChar) \
- V(ShiftI) \
- V(SmiTag) \
- V(SmiUntag) \
- V(StackCheck) \
- V(StoreCodeEntry) \
- V(StoreContextSlot) \
- V(StoreFrameContext) \
- V(StoreGlobalViaContext) \
- V(StoreKeyed) \
- V(StoreKeyedGeneric) \
- V(StoreNamedField) \
- V(StoreNamedGeneric) \
- V(StringAdd) \
- V(StringCharCodeAt) \
- V(StringCharFromCode) \
- V(StringCompareAndBranch) \
- V(SubI) \
- V(TaggedToI) \
- V(ThisFunction) \
- V(ToFastProperties) \
- V(TransitionElementsKind) \
- V(TrapAllocationMemento) \
- V(Typeof) \
- V(TypeofIsAndBranch) \
- V(Uint32ToDouble) \
- V(UnknownOSRValue) \
- V(WrapReceiver)
-
-
-#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
- Opcode opcode() const final { return LInstruction::k##type; } \
- void CompileToNative(LCodeGen* generator) final; \
- const char* Mnemonic() const final { return mnemonic; } \
- static L##type* cast(LInstruction* instr) { \
- DCHECK(instr->Is##type()); \
- return reinterpret_cast<L##type*>(instr); \
- }
-
-
-#define DECLARE_HYDROGEN_ACCESSOR(type) \
- H##type* hydrogen() const { \
- return H##type::cast(hydrogen_value()); \
- }
-
-
-class LInstruction : public ZoneObject {
- public:
- LInstruction()
- : environment_(NULL),
- hydrogen_value_(NULL),
- bit_field_(IsCallBits::encode(false)) {
- }
-
- virtual ~LInstruction() {}
-
- virtual void CompileToNative(LCodeGen* generator) = 0;
- virtual const char* Mnemonic() const = 0;
- virtual void PrintTo(StringStream* stream);
- virtual void PrintDataTo(StringStream* stream);
- virtual void PrintOutputOperandTo(StringStream* stream);
-
- enum Opcode {
- // Declare a unique enum value for each instruction.
-#define DECLARE_OPCODE(type) k##type,
- LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_OPCODE)
- kNumberOfInstructions
-#undef DECLARE_OPCODE
- };
-
- virtual Opcode opcode() const = 0;
-
- // Declare non-virtual type testers for all leaf IR classes.
-#define DECLARE_PREDICATE(type) \
- bool Is##type() const { return opcode() == k##type; }
- LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_PREDICATE)
-#undef DECLARE_PREDICATE
-
- // Declare virtual predicates for instructions that don't have
- // an opcode.
- virtual bool IsGap() const { return false; }
-
- virtual bool IsControl() const { return false; }
-
- // Try deleting this instruction if possible.
- virtual bool TryDelete() { return false; }
-
- void set_environment(LEnvironment* env) { environment_ = env; }
- LEnvironment* environment() const { return environment_; }
- bool HasEnvironment() const { return environment_ != NULL; }
-
- void set_pointer_map(LPointerMap* p) { pointer_map_.set(p); }
- LPointerMap* pointer_map() const { return pointer_map_.get(); }
- bool HasPointerMap() const { return pointer_map_.is_set(); }
-
- void set_hydrogen_value(HValue* value) { hydrogen_value_ = value; }
- HValue* hydrogen_value() const { return hydrogen_value_; }
-
- void MarkAsCall() { bit_field_ = IsCallBits::update(bit_field_, true); }
- bool IsCall() const { return IsCallBits::decode(bit_field_); }
-
- // Interface to the register allocator and iterators.
- bool ClobbersTemps() const { return IsCall(); }
- bool ClobbersRegisters() const { return IsCall(); }
- virtual bool ClobbersDoubleRegisters(Isolate* isolate) const {
- return IsCall();
- }
-
- // Interface to the register allocator and iterators.
- bool IsMarkedAsCall() const { return IsCall(); }
-
- virtual bool HasResult() const = 0;
- virtual LOperand* result() const = 0;
-
- LOperand* FirstInput() { return InputAt(0); }
- LOperand* Output() { return HasResult() ? result() : NULL; }
-
- virtual bool HasInterestingComment(LCodeGen* gen) const { return true; }
-
- virtual bool MustSignExtendResult(LPlatformChunk* chunk) const {
- return false;
- }
-
-#ifdef DEBUG
- void VerifyCall();
-#endif
-
- virtual int InputCount() = 0;
- virtual LOperand* InputAt(int i) = 0;
-
- private:
- // Iterator support.
- friend class InputIterator;
-
- friend class TempIterator;
- virtual int TempCount() = 0;
- virtual LOperand* TempAt(int i) = 0;
-
- class IsCallBits: public BitField<bool, 0, 1> {};
-
- LEnvironment* environment_;
- SetOncePointer<LPointerMap> pointer_map_;
- HValue* hydrogen_value_;
- int bit_field_;
-};
-
-
-// R = number of result operands (0 or 1).
-template<int R>
-class LTemplateResultInstruction : public LInstruction {
- public:
- // Allow 0 or 1 output operands.
- STATIC_ASSERT(R == 0 || R == 1);
- bool HasResult() const final { return R != 0 && result() != NULL; }
- void set_result(LOperand* operand) { results_[0] = operand; }
- LOperand* result() const override { return results_[0]; }
-
- bool MustSignExtendResult(LPlatformChunk* chunk) const final;
-
- protected:
- EmbeddedContainer<LOperand*, R> results_;
-};
-
-
-// R = number of result operands (0 or 1).
-// I = number of input operands.
-// T = number of temporary operands.
-template<int R, int I, int T>
-class LTemplateInstruction : public LTemplateResultInstruction<R> {
- protected:
- EmbeddedContainer<LOperand*, I> inputs_;
- EmbeddedContainer<LOperand*, T> temps_;
-
- private:
- // Iterator support.
- int InputCount() final { return I; }
- LOperand* InputAt(int i) final { return inputs_[i]; }
-
- int TempCount() final { return T; }
- LOperand* TempAt(int i) final { return temps_[i]; }
-};
-
-
-class LGap : public LTemplateInstruction<0, 0, 0> {
- public:
- explicit LGap(HBasicBlock* block)
- : block_(block) {
- parallel_moves_[BEFORE] = NULL;
- parallel_moves_[START] = NULL;
- parallel_moves_[END] = NULL;
- parallel_moves_[AFTER] = NULL;
- }
-
- // Can't use the DECLARE-macro here because of sub-classes.
- bool IsGap() const final { return true; }
- void PrintDataTo(StringStream* stream) override;
- static LGap* cast(LInstruction* instr) {
- DCHECK(instr->IsGap());
- return reinterpret_cast<LGap*>(instr);
- }
-
- bool IsRedundant() const;
-
- HBasicBlock* block() const { return block_; }
-
- enum InnerPosition {
- BEFORE,
- START,
- END,
- AFTER,
- FIRST_INNER_POSITION = BEFORE,
- LAST_INNER_POSITION = AFTER
- };
-
- LParallelMove* GetOrCreateParallelMove(InnerPosition pos,
- Zone* zone) {
- if (parallel_moves_[pos] == NULL) {
- parallel_moves_[pos] = new(zone) LParallelMove(zone);
- }
- return parallel_moves_[pos];
- }
-
- LParallelMove* GetParallelMove(InnerPosition pos) {
- return parallel_moves_[pos];
- }
-
- private:
- LParallelMove* parallel_moves_[LAST_INNER_POSITION + 1];
- HBasicBlock* block_;
-};
-
-
-class LInstructionGap final : public LGap {
- public:
- explicit LInstructionGap(HBasicBlock* block) : LGap(block) { }
-
- bool HasInterestingComment(LCodeGen* gen) const override {
- return !IsRedundant();
- }
-
- DECLARE_CONCRETE_INSTRUCTION(InstructionGap, "gap")
-};
-
-
-class LGoto final : public LTemplateInstruction<0, 0, 0> {
- public:
- explicit LGoto(HBasicBlock* block) : block_(block) { }
-
- bool HasInterestingComment(LCodeGen* gen) const override;
- DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")
- void PrintDataTo(StringStream* stream) override;
- bool IsControl() const override { return true; }
-
- int block_id() const { return block_->block_id(); }
-
- private:
- HBasicBlock* block_;
-};
-
-
-class LPrologue final : public LTemplateInstruction<0, 0, 0> {
- public:
- DECLARE_CONCRETE_INSTRUCTION(Prologue, "prologue")
-};
-
-
-class LLazyBailout final : public LTemplateInstruction<0, 0, 0> {
- public:
- LLazyBailout() : gap_instructions_size_(0) { }
-
- DECLARE_CONCRETE_INSTRUCTION(LazyBailout, "lazy-bailout")
-
- void set_gap_instructions_size(int gap_instructions_size) {
- gap_instructions_size_ = gap_instructions_size;
- }
- int gap_instructions_size() { return gap_instructions_size_; }
-
- private:
- int gap_instructions_size_;
-};
-
-
-class LDummy final : public LTemplateInstruction<1, 0, 0> {
- public:
- LDummy() {}
- DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy")
-};
-
-
-class LDummyUse final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LDummyUse(LOperand* value) {
- inputs_[0] = value;
- }
- DECLARE_CONCRETE_INSTRUCTION(DummyUse, "dummy-use")
-};
-
-
-class LDeoptimize final : public LTemplateInstruction<0, 0, 0> {
- public:
- bool IsControl() const override { return true; }
- DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")
- DECLARE_HYDROGEN_ACCESSOR(Deoptimize)
-};
-
-
-class LLabel final : public LGap {
- public:
- explicit LLabel(HBasicBlock* block)
- : LGap(block), replacement_(NULL) { }
-
- bool HasInterestingComment(LCodeGen* gen) const override { return false; }
- DECLARE_CONCRETE_INSTRUCTION(Label, "label")
-
- void PrintDataTo(StringStream* stream) override;
-
- int block_id() const { return block()->block_id(); }
- bool is_loop_header() const { return block()->IsLoopHeader(); }
- bool is_osr_entry() const { return block()->is_osr_entry(); }
- Label* label() { return &label_; }
- LLabel* replacement() const { return replacement_; }
- void set_replacement(LLabel* label) { replacement_ = label; }
- bool HasReplacement() const { return replacement_ != NULL; }
-
- private:
- Label label_;
- LLabel* replacement_;
-};
-
-
-class LParameter final : public LTemplateInstruction<1, 0, 0> {
- public:
- bool HasInterestingComment(LCodeGen* gen) const override { return false; }
- DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")
-};
-
-
-class LCallStub final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LCallStub(LOperand* context) {
- inputs_[0] = context;
- }
-
- LOperand* context() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CallStub, "call-stub")
- DECLARE_HYDROGEN_ACCESSOR(CallStub)
-};
-
-
-class LUnknownOSRValue final : public LTemplateInstruction<1, 0, 0> {
- public:
- bool HasInterestingComment(LCodeGen* gen) const override { return false; }
- DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")
-};
-
-
-template<int I, int T>
-class LControlInstruction : public LTemplateInstruction<0, I, T> {
- public:
- LControlInstruction() : false_label_(NULL), true_label_(NULL) { }
-
- bool IsControl() const final { return true; }
-
- int SuccessorCount() { return hydrogen()->SuccessorCount(); }
- HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); }
-
- int TrueDestination(LChunk* chunk) {
- return chunk->LookupDestination(true_block_id());
- }
- int FalseDestination(LChunk* chunk) {
- return chunk->LookupDestination(false_block_id());
- }
-
- Label* TrueLabel(LChunk* chunk) {
- if (true_label_ == NULL) {
- true_label_ = chunk->GetAssemblyLabel(TrueDestination(chunk));
- }
- return true_label_;
- }
- Label* FalseLabel(LChunk* chunk) {
- if (false_label_ == NULL) {
- false_label_ = chunk->GetAssemblyLabel(FalseDestination(chunk));
- }
- return false_label_;
- }
-
- protected:
- int true_block_id() { return SuccessorAt(0)->block_id(); }
- int false_block_id() { return SuccessorAt(1)->block_id(); }
-
- private:
- HControlInstruction* hydrogen() {
- return HControlInstruction::cast(this->hydrogen_value());
- }
-
- Label* false_label_;
- Label* true_label_;
-};
-
-
-class LWrapReceiver final : public LTemplateInstruction<1, 2, 0> {
- public:
- LWrapReceiver(LOperand* receiver, LOperand* function) {
- inputs_[0] = receiver;
- inputs_[1] = function;
- }
-
- LOperand* receiver() { return inputs_[0]; }
- LOperand* function() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(WrapReceiver, "wrap-receiver")
- DECLARE_HYDROGEN_ACCESSOR(WrapReceiver)
-};
-
-
-class LApplyArguments final : public LTemplateInstruction<1, 4, 0> {
- public:
- LApplyArguments(LOperand* function,
- LOperand* receiver,
- LOperand* length,
- LOperand* elements) {
- inputs_[0] = function;
- inputs_[1] = receiver;
- inputs_[2] = length;
- inputs_[3] = elements;
- }
-
- LOperand* function() { return inputs_[0]; }
- LOperand* receiver() { return inputs_[1]; }
- LOperand* length() { return inputs_[2]; }
- LOperand* elements() { return inputs_[3]; }
-
- DECLARE_CONCRETE_INSTRUCTION(ApplyArguments, "apply-arguments")
-};
-
-
-class LAccessArgumentsAt final : public LTemplateInstruction<1, 3, 0> {
- public:
- LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) {
- inputs_[0] = arguments;
- inputs_[1] = length;
- inputs_[2] = index;
- }
-
- LOperand* arguments() { return inputs_[0]; }
- LOperand* length() { return inputs_[1]; }
- LOperand* index() { return inputs_[2]; }
-
- DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt, "access-arguments-at")
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LArgumentsLength final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LArgumentsLength(LOperand* elements) {
- inputs_[0] = elements;
- }
-
- LOperand* elements() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength, "arguments-length")
-};
-
-
-class LArgumentsElements final : public LTemplateInstruction<1, 0, 0> {
- public:
- DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
- DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements)
-};
-
-
-class LModByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
- public:
- LModByPowerOf2I(LOperand* dividend, int32_t divisor) {
- inputs_[0] = dividend;
- divisor_ = divisor;
- }
-
- LOperand* dividend() { return inputs_[0]; }
- int32_t divisor() const { return divisor_; }
-
- DECLARE_CONCRETE_INSTRUCTION(ModByPowerOf2I, "mod-by-power-of-2-i")
- DECLARE_HYDROGEN_ACCESSOR(Mod)
-
- private:
- int32_t divisor_;
-};
-
-
-class LModByConstI final : public LTemplateInstruction<1, 1, 2> {
- public:
- LModByConstI(LOperand* dividend,
- int32_t divisor,
- LOperand* temp1,
- LOperand* temp2) {
- inputs_[0] = dividend;
- divisor_ = divisor;
- temps_[0] = temp1;
- temps_[1] = temp2;
- }
-
- LOperand* dividend() { return inputs_[0]; }
- int32_t divisor() const { return divisor_; }
- LOperand* temp1() { return temps_[0]; }
- LOperand* temp2() { return temps_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(ModByConstI, "mod-by-const-i")
- DECLARE_HYDROGEN_ACCESSOR(Mod)
-
- private:
- int32_t divisor_;
-};
-
-
-class LModI final : public LTemplateInstruction<1, 2, 1> {
- public:
- LModI(LOperand* left, LOperand* right, LOperand* temp) {
- inputs_[0] = left;
- inputs_[1] = right;
- temps_[0] = temp;
- }
-
- LOperand* left() { return inputs_[0]; }
- LOperand* right() { return inputs_[1]; }
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(ModI, "mod-i")
- DECLARE_HYDROGEN_ACCESSOR(Mod)
-};
-
-
-class LDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
- public:
- LDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
- inputs_[0] = dividend;
- divisor_ = divisor;
- }
-
- LOperand* dividend() { return inputs_[0]; }
- int32_t divisor() const { return divisor_; }
-
- DECLARE_CONCRETE_INSTRUCTION(DivByPowerOf2I, "div-by-power-of-2-i")
- DECLARE_HYDROGEN_ACCESSOR(Div)
-
- private:
- int32_t divisor_;
-};
-
-
-class LDivByConstI final : public LTemplateInstruction<1, 1, 2> {
- public:
- LDivByConstI(LOperand* dividend,
- int32_t divisor,
- LOperand* temp1,
- LOperand* temp2) {
- inputs_[0] = dividend;
- divisor_ = divisor;
- temps_[0] = temp1;
- temps_[1] = temp2;
- }
-
- LOperand* dividend() { return inputs_[0]; }
- int32_t divisor() const { return divisor_; }
- LOperand* temp1() { return temps_[0]; }
- LOperand* temp2() { return temps_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(DivByConstI, "div-by-const-i")
- DECLARE_HYDROGEN_ACCESSOR(Div)
-
- private:
- int32_t divisor_;
-};
-
-
-class LDivI final : public LTemplateInstruction<1, 2, 1> {
- public:
- LDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
- inputs_[0] = dividend;
- inputs_[1] = divisor;
- temps_[0] = temp;
- }
-
- LOperand* dividend() { return inputs_[0]; }
- LOperand* divisor() { return inputs_[1]; }
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(DivI, "div-i")
- DECLARE_HYDROGEN_ACCESSOR(BinaryOperation)
-};
-
-
-class LFlooringDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
- public:
- LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
- inputs_[0] = dividend;
- divisor_ = divisor;
- }
-
- LOperand* dividend() { return inputs_[0]; }
- int32_t divisor() const { return divisor_; }
-
- DECLARE_CONCRETE_INSTRUCTION(FlooringDivByPowerOf2I,
- "flooring-div-by-power-of-2-i")
- DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv)
-
- private:
- int32_t divisor_;
-};
-
-
-class LFlooringDivByConstI final : public LTemplateInstruction<1, 1, 3> {
- public:
- LFlooringDivByConstI(LOperand* dividend,
- int32_t divisor,
- LOperand* temp1,
- LOperand* temp2,
- LOperand* temp3) {
- inputs_[0] = dividend;
- divisor_ = divisor;
- temps_[0] = temp1;
- temps_[1] = temp2;
- temps_[2] = temp3;
- }
-
- LOperand* dividend() { return inputs_[0]; }
- int32_t divisor() const { return divisor_; }
- LOperand* temp1() { return temps_[0]; }
- LOperand* temp2() { return temps_[1]; }
- LOperand* temp3() { return temps_[2]; }
-
- DECLARE_CONCRETE_INSTRUCTION(FlooringDivByConstI, "flooring-div-by-const-i")
- DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv)
-
- private:
- int32_t divisor_;
-};
-
-
-class LFlooringDivI final : public LTemplateInstruction<1, 2, 1> {
- public:
- LFlooringDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
- inputs_[0] = dividend;
- inputs_[1] = divisor;
- temps_[0] = temp;
- }
-
- LOperand* dividend() { return inputs_[0]; }
- LOperand* divisor() { return inputs_[1]; }
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(FlooringDivI, "flooring-div-i")
- DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv)
-};
-
-
-class LMulI final : public LTemplateInstruction<1, 2, 0> {
- public:
- LMulI(LOperand* left, LOperand* right) {
- inputs_[0] = left;
- inputs_[1] = right;
- }
-
- LOperand* left() { return inputs_[0]; }
- LOperand* right() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(MulI, "mul-i")
- DECLARE_HYDROGEN_ACCESSOR(Mul)
-};
-
-
-class LCompareNumericAndBranch final : public LControlInstruction<2, 0> {
- public:
- LCompareNumericAndBranch(LOperand* left, LOperand* right) {
- inputs_[0] = left;
- inputs_[1] = right;
- }
-
- LOperand* left() { return inputs_[0]; }
- LOperand* right() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch,
- "compare-numeric-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(CompareNumericAndBranch)
-
- Token::Value op() const { return hydrogen()->token(); }
- bool is_double() const {
- return hydrogen()->representation().IsDouble();
- }
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LMathFloor final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LMathFloor(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(MathFloor, "math-floor")
- DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)
-};
-
-
-class LMathRound final : public LTemplateInstruction<1, 1, 1> {
- public:
- LMathRound(LOperand* value, LOperand* temp) {
- inputs_[0] = value;
- temps_[0] = temp;
- }
-
- LOperand* value() { return inputs_[0]; }
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(MathRound, "math-round")
- DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)
-};
-
-
-class LMathFround final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LMathFround(LOperand* value) { inputs_[0] = value; }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(MathFround, "math-fround")
-};
-
-
-class LMathAbs final : public LTemplateInstruction<1, 2, 0> {
- public:
- explicit LMathAbs(LOperand* context, LOperand* value) {
- inputs_[1] = context;
- inputs_[0] = value;
- }
-
- LOperand* context() { return inputs_[1]; }
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(MathAbs, "math-abs")
- DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)
-};
-
-
-class LMathLog final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LMathLog(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(MathLog, "math-log")
-};
-
-
-class LMathClz32 final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LMathClz32(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(MathClz32, "math-clz32")
-};
-
-
-class LMathExp final : public LTemplateInstruction<1, 1, 2> {
- public:
- LMathExp(LOperand* value, LOperand* temp1, LOperand* temp2) {
- inputs_[0] = value;
- temps_[0] = temp1;
- temps_[1] = temp2;
- ExternalReference::InitializeMathExpData();
- }
-
- LOperand* value() { return inputs_[0]; }
- LOperand* temp1() { return temps_[0]; }
- LOperand* temp2() { return temps_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(MathExp, "math-exp")
-};
-
-
-class LMathSqrt final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LMathSqrt(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(MathSqrt, "math-sqrt")
-};
-
-
-class LMathPowHalf final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LMathPowHalf(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(MathPowHalf, "math-pow-half")
-};
-
-
-class LCmpObjectEqAndBranch final : public LControlInstruction<2, 0> {
- public:
- LCmpObjectEqAndBranch(LOperand* left, LOperand* right) {
- inputs_[0] = left;
- inputs_[1] = right;
- }
-
- LOperand* left() { return inputs_[0]; }
- LOperand* right() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CmpObjectEqAndBranch, "cmp-object-eq-and-branch")
-};
-
-
-class LCmpHoleAndBranch final : public LControlInstruction<1, 0> {
- public:
- explicit LCmpHoleAndBranch(LOperand* object) {
- inputs_[0] = object;
- }
-
- LOperand* object() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CmpHoleAndBranch, "cmp-hole-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(CompareHoleAndBranch)
-};
-
-
-class LCompareMinusZeroAndBranch final : public LControlInstruction<1, 0> {
- public:
- explicit LCompareMinusZeroAndBranch(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CompareMinusZeroAndBranch,
- "cmp-minus-zero-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(CompareMinusZeroAndBranch)
-};
-
-
-class LIsStringAndBranch final : public LControlInstruction<1, 1> {
- public:
- explicit LIsStringAndBranch(LOperand* value, LOperand* temp) {
- inputs_[0] = value;
- temps_[0] = temp;
- }
-
- LOperand* value() { return inputs_[0]; }
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch)
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LIsSmiAndBranch final : public LControlInstruction<1, 0> {
- public:
- explicit LIsSmiAndBranch(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch)
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LIsUndetectableAndBranch final : public LControlInstruction<1, 1> {
- public:
- explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) {
- inputs_[0] = value;
- temps_[0] = temp;
- }
-
- LOperand* value() { return inputs_[0]; }
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(IsUndetectableAndBranch,
- "is-undetectable-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch)
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LStringCompareAndBranch final : public LControlInstruction<3, 0> {
- public:
- explicit LStringCompareAndBranch(LOperand* context,
- LOperand* left,
- LOperand* right) {
- inputs_[0] = context;
- inputs_[1] = left;
- inputs_[2] = right;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* left() { return inputs_[1]; }
- LOperand* right() { return inputs_[2]; }
-
- DECLARE_CONCRETE_INSTRUCTION(StringCompareAndBranch,
- "string-compare-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(StringCompareAndBranch)
-
- void PrintDataTo(StringStream* stream) override;
-
- Token::Value op() const { return hydrogen()->token(); }
-};
-
-
-class LHasInstanceTypeAndBranch final : public LControlInstruction<1, 0> {
- public:
- explicit LHasInstanceTypeAndBranch(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(HasInstanceTypeAndBranch,
- "has-instance-type-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch)
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LGetCachedArrayIndex final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LGetCachedArrayIndex(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex, "get-cached-array-index")
- DECLARE_HYDROGEN_ACCESSOR(GetCachedArrayIndex)
-};
-
-
-class LHasCachedArrayIndexAndBranch final : public LControlInstruction<1, 0> {
- public:
- explicit LHasCachedArrayIndexAndBranch(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch,
- "has-cached-array-index-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndexAndBranch)
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LClassOfTestAndBranch final : public LControlInstruction<1, 2> {
- public:
- LClassOfTestAndBranch(LOperand* value, LOperand* temp, LOperand* temp2) {
- inputs_[0] = value;
- temps_[0] = temp;
- temps_[1] = temp2;
- }
-
- LOperand* value() { return inputs_[0]; }
- LOperand* temp() { return temps_[0]; }
- LOperand* temp2() { return temps_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch,
- "class-of-test-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch)
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LCmpT final : public LTemplateInstruction<1, 3, 0> {
- public:
- LCmpT(LOperand* context, LOperand* left, LOperand* right) {
- inputs_[0] = context;
- inputs_[1] = left;
- inputs_[2] = right;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* left() { return inputs_[1]; }
- LOperand* right() { return inputs_[2]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CmpT, "cmp-t")
- DECLARE_HYDROGEN_ACCESSOR(CompareGeneric)
-
- Strength strength() { return hydrogen()->strength(); }
-
- Token::Value op() const { return hydrogen()->token(); }
-};
-
-
-class LInstanceOf final : public LTemplateInstruction<1, 3, 0> {
- public:
- LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {
- inputs_[0] = context;
- inputs_[1] = left;
- inputs_[2] = right;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* left() { return inputs_[1]; }
- LOperand* right() { return inputs_[2]; }
-
- DECLARE_CONCRETE_INSTRUCTION(InstanceOf, "instance-of")
-};
-
-
-class LHasInPrototypeChainAndBranch final : public LControlInstruction<2, 0> {
- public:
- LHasInPrototypeChainAndBranch(LOperand* object, LOperand* prototype) {
- inputs_[0] = object;
- inputs_[1] = prototype;
- }
-
- LOperand* object() const { return inputs_[0]; }
- LOperand* prototype() const { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(HasInPrototypeChainAndBranch,
- "has-in-prototype-chain-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(HasInPrototypeChainAndBranch)
-};
-
-
-class LBoundsCheck final : public LTemplateInstruction<0, 2, 0> {
- public:
- LBoundsCheck(LOperand* index, LOperand* length) {
- inputs_[0] = index;
- inputs_[1] = length;
- }
-
- LOperand* index() { return inputs_[0]; }
- LOperand* length() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(BoundsCheck, "bounds-check")
- DECLARE_HYDROGEN_ACCESSOR(BoundsCheck)
-};
-
-
-class LBitI final : public LTemplateInstruction<1, 2, 0> {
- public:
- LBitI(LOperand* left, LOperand* right) {
- inputs_[0] = left;
- inputs_[1] = right;
- }
-
- LOperand* left() { return inputs_[0]; }
- LOperand* right() { return inputs_[1]; }
-
- Token::Value op() const { return hydrogen()->op(); }
- bool IsInteger32() const {
- return hydrogen()->representation().IsInteger32();
- }
-
- DECLARE_CONCRETE_INSTRUCTION(BitI, "bit-i")
- DECLARE_HYDROGEN_ACCESSOR(Bitwise)
-};
-
-
-class LShiftI final : public LTemplateInstruction<1, 2, 0> {
- public:
- LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)
- : op_(op), can_deopt_(can_deopt) {
- inputs_[0] = left;
- inputs_[1] = right;
- }
-
- Token::Value op() const { return op_; }
- LOperand* left() { return inputs_[0]; }
- LOperand* right() { return inputs_[1]; }
- bool can_deopt() const { return can_deopt_; }
-
- DECLARE_CONCRETE_INSTRUCTION(ShiftI, "shift-i")
-
- private:
- Token::Value op_;
- bool can_deopt_;
-};
-
-
-class LSubI final : public LTemplateInstruction<1, 2, 0> {
- public:
- LSubI(LOperand* left, LOperand* right) {
- inputs_[0] = left;
- inputs_[1] = right;
- }
-
- LOperand* left() { return inputs_[0]; }
- LOperand* right() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(SubI, "sub-i")
- DECLARE_HYDROGEN_ACCESSOR(Sub)
-};
-
-
-class LConstantI final : public LTemplateInstruction<1, 0, 0> {
- public:
- DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")
- DECLARE_HYDROGEN_ACCESSOR(Constant)
-
- int32_t value() const { return hydrogen()->Integer32Value(); }
-};
-
-
-class LConstantS final : public LTemplateInstruction<1, 0, 0> {
- public:
- DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")
- DECLARE_HYDROGEN_ACCESSOR(Constant)
-
- Smi* value() const { return Smi::FromInt(hydrogen()->Integer32Value()); }
-};
-
-
-class LConstantD final : public LTemplateInstruction<1, 0, 0> {
- public:
- DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d")
- DECLARE_HYDROGEN_ACCESSOR(Constant)
-
- uint64_t bits() const { return hydrogen()->DoubleValueAsBits(); }
-};
-
-
-class LConstantE final : public LTemplateInstruction<1, 0, 0> {
- public:
- DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")
- DECLARE_HYDROGEN_ACCESSOR(Constant)
-
- ExternalReference value() const {
- return hydrogen()->ExternalReferenceValue();
- }
-};
-
-
-class LConstantT final : public LTemplateInstruction<1, 0, 0> {
- public:
- DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")
- DECLARE_HYDROGEN_ACCESSOR(Constant)
-
- Handle<Object> value(Isolate* isolate) const {
- return hydrogen()->handle(isolate);
- }
-};
-
-
-class LBranch final : public LControlInstruction<1, 0> {
- public:
- explicit LBranch(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")
- DECLARE_HYDROGEN_ACCESSOR(Branch)
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LDebugBreak final : public LTemplateInstruction<0, 0, 0> {
- public:
- DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break")
-};
-
-
-class LCmpMapAndBranch final : public LControlInstruction<1, 0> {
- public:
- explicit LCmpMapAndBranch(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CmpMapAndBranch, "cmp-map-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(CompareMap)
-
- Handle<Map> map() const { return hydrogen()->map().handle(); }
-};
-
-
-class LMapEnumLength final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LMapEnumLength(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(MapEnumLength, "map-enum-length")
-};
-
-
-class LDateField final : public LTemplateInstruction<1, 1, 0> {
- public:
- LDateField(LOperand* date, Smi* index) : index_(index) {
- inputs_[0] = date;
- }
-
- LOperand* date() { return inputs_[0]; }
- Smi* index() const { return index_; }
-
- DECLARE_CONCRETE_INSTRUCTION(DateField, "date-field")
- DECLARE_HYDROGEN_ACCESSOR(DateField)
-
- private:
- Smi* index_;
-};
-
-
-class LSeqStringGetChar final : public LTemplateInstruction<1, 2, 0> {
- public:
- LSeqStringGetChar(LOperand* string, LOperand* index) {
- inputs_[0] = string;
- inputs_[1] = index;
- }
-
- LOperand* string() const { return inputs_[0]; }
- LOperand* index() const { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(SeqStringGetChar, "seq-string-get-char")
- DECLARE_HYDROGEN_ACCESSOR(SeqStringGetChar)
-};
-
-
-class LSeqStringSetChar final : public LTemplateInstruction<1, 4, 0> {
- public:
- LSeqStringSetChar(LOperand* context,
- LOperand* string,
- LOperand* index,
- LOperand* value) {
- inputs_[0] = context;
- inputs_[1] = string;
- inputs_[2] = index;
- inputs_[3] = value;
- }
-
- LOperand* string() { return inputs_[1]; }
- LOperand* index() { return inputs_[2]; }
- LOperand* value() { return inputs_[3]; }
-
- DECLARE_CONCRETE_INSTRUCTION(SeqStringSetChar, "seq-string-set-char")
- DECLARE_HYDROGEN_ACCESSOR(SeqStringSetChar)
-};
-
-
-class LAddI final : public LTemplateInstruction<1, 2, 0> {
- public:
- LAddI(LOperand* left, LOperand* right) {
- inputs_[0] = left;
- inputs_[1] = right;
- }
-
- LOperand* left() { return inputs_[0]; }
- LOperand* right() { return inputs_[1]; }
-
- static bool UseLea(HAdd* add) {
- return !add->CheckFlag(HValue::kCanOverflow) &&
- add->BetterLeftOperand()->UseCount() > 1;
- }
-
- DECLARE_CONCRETE_INSTRUCTION(AddI, "add-i")
- DECLARE_HYDROGEN_ACCESSOR(Add)
-};
-
-
-class LMathMinMax final : public LTemplateInstruction<1, 2, 0> {
- public:
- LMathMinMax(LOperand* left, LOperand* right) {
- inputs_[0] = left;
- inputs_[1] = right;
- }
-
- LOperand* left() { return inputs_[0]; }
- LOperand* right() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(MathMinMax, "math-min-max")
- DECLARE_HYDROGEN_ACCESSOR(MathMinMax)
-};
-
-
-class LPower final : public LTemplateInstruction<1, 2, 0> {
- public:
- LPower(LOperand* left, LOperand* right) {
- inputs_[0] = left;
- inputs_[1] = right;
- }
-
- LOperand* left() { return inputs_[0]; }
- LOperand* right() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(Power, "power")
- DECLARE_HYDROGEN_ACCESSOR(Power)
-};
-
-
-class LArithmeticD final : public LTemplateInstruction<1, 2, 0> {
- public:
- LArithmeticD(Token::Value op, LOperand* left, LOperand* right)
- : op_(op) {
- inputs_[0] = left;
- inputs_[1] = right;
- }
-
- Token::Value op() const { return op_; }
- LOperand* left() { return inputs_[0]; }
- LOperand* right() { return inputs_[1]; }
-
- Opcode opcode() const override { return LInstruction::kArithmeticD; }
- void CompileToNative(LCodeGen* generator) override;
- const char* Mnemonic() const override;
-
- private:
- Token::Value op_;
-};
-
-
-class LArithmeticT final : public LTemplateInstruction<1, 3, 0> {
- public:
- LArithmeticT(Token::Value op,
- LOperand* context,
- LOperand* left,
- LOperand* right)
- : op_(op) {
- inputs_[0] = context;
- inputs_[1] = left;
- inputs_[2] = right;
- }
-
- Token::Value op() const { return op_; }
- LOperand* context() { return inputs_[0]; }
- LOperand* left() { return inputs_[1]; }
- LOperand* right() { return inputs_[2]; }
-
- Opcode opcode() const override { return LInstruction::kArithmeticT; }
- void CompileToNative(LCodeGen* generator) override;
- const char* Mnemonic() const override;
-
- DECLARE_HYDROGEN_ACCESSOR(BinaryOperation)
-
- Strength strength() { return hydrogen()->strength(); }
-
- private:
- Token::Value op_;
-};
-
-
-class LReturn final : public LTemplateInstruction<0, 3, 0> {
- public:
- explicit LReturn(LOperand* value,
- LOperand* context,
- LOperand* parameter_count) {
- inputs_[0] = value;
- inputs_[1] = context;
- inputs_[2] = parameter_count;
- }
-
- LOperand* value() { return inputs_[0]; }
- LOperand* context() { return inputs_[1]; }
-
- bool has_constant_parameter_count() {
- return parameter_count()->IsConstantOperand();
- }
- LConstantOperand* constant_parameter_count() {
- DCHECK(has_constant_parameter_count());
- return LConstantOperand::cast(parameter_count());
- }
- LOperand* parameter_count() { return inputs_[2]; }
-
- DECLARE_CONCRETE_INSTRUCTION(Return, "return")
- DECLARE_HYDROGEN_ACCESSOR(Return)
-};
-
-
-class LLoadNamedField final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LLoadNamedField(LOperand* object) {
- inputs_[0] = object;
- }
-
- LOperand* object() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(LoadNamedField, "load-named-field")
- DECLARE_HYDROGEN_ACCESSOR(LoadNamedField)
-};
-
-
-class LLoadNamedGeneric final : public LTemplateInstruction<1, 2, 1> {
- public:
- explicit LLoadNamedGeneric(LOperand* context, LOperand* object,
- LOperand* vector) {
- inputs_[0] = context;
- inputs_[1] = object;
- temps_[0] = vector;
- }
-
- DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric, "load-named-generic")
- DECLARE_HYDROGEN_ACCESSOR(LoadNamedGeneric)
-
- LOperand* context() { return inputs_[0]; }
- LOperand* object() { return inputs_[1]; }
- LOperand* temp_vector() { return temps_[0]; }
-
- Handle<Object> name() const { return hydrogen()->name(); }
-};
-
-
-class LLoadFunctionPrototype final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LLoadFunctionPrototype(LOperand* function) {
- inputs_[0] = function;
- }
-
- DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype, "load-function-prototype")
- DECLARE_HYDROGEN_ACCESSOR(LoadFunctionPrototype)
-
- LOperand* function() { return inputs_[0]; }
-};
-
-
-class LLoadRoot final : public LTemplateInstruction<1, 0, 0> {
- public:
- DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root")
- DECLARE_HYDROGEN_ACCESSOR(LoadRoot)
-
- Heap::RootListIndex index() const { return hydrogen()->index(); }
-};
-
-
-inline static bool ExternalArrayOpRequiresTemp(
- Representation key_representation,
- ElementsKind elements_kind) {
- // Operations that require the key to be divided by two to be converted into
- // an index cannot fold the scale operation into a load and need an extra
- // temp register to do the work.
- return SmiValuesAre31Bits() && key_representation.IsSmi() &&
- (elements_kind == UINT8_ELEMENTS || elements_kind == INT8_ELEMENTS ||
- elements_kind == UINT8_CLAMPED_ELEMENTS);
-}
-
-
-class LLoadKeyed final : public LTemplateInstruction<1, 2, 0> {
- public:
- LLoadKeyed(LOperand* elements, LOperand* key) {
- inputs_[0] = elements;
- inputs_[1] = key;
- }
-
- DECLARE_CONCRETE_INSTRUCTION(LoadKeyed, "load-keyed")
- DECLARE_HYDROGEN_ACCESSOR(LoadKeyed)
-
- bool is_fixed_typed_array() const {
- return hydrogen()->is_fixed_typed_array();
- }
- LOperand* elements() { return inputs_[0]; }
- LOperand* key() { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) override;
- uint32_t base_offset() const { return hydrogen()->base_offset(); }
- ElementsKind elements_kind() const {
- return hydrogen()->elements_kind();
- }
-};
-
-
-class LLoadKeyedGeneric final : public LTemplateInstruction<1, 3, 1> {
- public:
- LLoadKeyedGeneric(LOperand* context, LOperand* obj, LOperand* key,
- LOperand* vector) {
- inputs_[0] = context;
- inputs_[1] = obj;
- inputs_[2] = key;
- temps_[0] = vector;
- }
-
- DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric, "load-keyed-generic")
- DECLARE_HYDROGEN_ACCESSOR(LoadKeyedGeneric)
-
- LOperand* context() { return inputs_[0]; }
- LOperand* object() { return inputs_[1]; }
- LOperand* key() { return inputs_[2]; }
- LOperand* temp_vector() { return temps_[0]; }
-};
-
-
-class LLoadGlobalGeneric final : public LTemplateInstruction<1, 2, 1> {
- public:
- explicit LLoadGlobalGeneric(LOperand* context, LOperand* global_object,
- LOperand* vector) {
- inputs_[0] = context;
- inputs_[1] = global_object;
- temps_[0] = vector;
- }
-
- DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric, "load-global-generic")
- DECLARE_HYDROGEN_ACCESSOR(LoadGlobalGeneric)
-
- LOperand* context() { return inputs_[0]; }
- LOperand* global_object() { return inputs_[1]; }
- LOperand* temp_vector() { return temps_[0]; }
-
- Handle<Object> name() const { return hydrogen()->name(); }
- TypeofMode typeof_mode() const { return hydrogen()->typeof_mode(); }
-};
-
-
-class LLoadGlobalViaContext final : public LTemplateInstruction<1, 1, 1> {
- public:
- explicit LLoadGlobalViaContext(LOperand* context) { inputs_[0] = context; }
-
- DECLARE_CONCRETE_INSTRUCTION(LoadGlobalViaContext, "load-global-via-context")
- DECLARE_HYDROGEN_ACCESSOR(LoadGlobalViaContext)
-
- void PrintDataTo(StringStream* stream) override;
-
- LOperand* context() { return inputs_[0]; }
-
- int depth() const { return hydrogen()->depth(); }
- int slot_index() const { return hydrogen()->slot_index(); }
-};
-
-
-class LLoadContextSlot final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LLoadContextSlot(LOperand* context) {
- inputs_[0] = context;
- }
-
- LOperand* context() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot, "load-context-slot")
- DECLARE_HYDROGEN_ACCESSOR(LoadContextSlot)
-
- int slot_index() { return hydrogen()->slot_index(); }
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LStoreContextSlot final : public LTemplateInstruction<0, 2, 1> {
- public:
- LStoreContextSlot(LOperand* context, LOperand* value, LOperand* temp) {
- inputs_[0] = context;
- inputs_[1] = value;
- temps_[0] = temp;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* value() { return inputs_[1]; }
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot, "store-context-slot")
- DECLARE_HYDROGEN_ACCESSOR(StoreContextSlot)
-
- int slot_index() { return hydrogen()->slot_index(); }
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LPushArgument final : public LTemplateInstruction<0, 1, 0> {
- public:
- explicit LPushArgument(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(PushArgument, "push-argument")
-};
-
-
-class LDrop final : public LTemplateInstruction<0, 0, 0> {
- public:
- explicit LDrop(int count) : count_(count) { }
-
- int count() const { return count_; }
-
- DECLARE_CONCRETE_INSTRUCTION(Drop, "drop")
-
- private:
- int count_;
-};
-
-
-class LStoreCodeEntry final : public LTemplateInstruction<0, 2, 0> {
- public:
- LStoreCodeEntry(LOperand* function, LOperand* code_object) {
- inputs_[0] = function;
- inputs_[1] = code_object;
- }
-
- LOperand* function() { return inputs_[0]; }
- LOperand* code_object() { return inputs_[1]; }
-
- void PrintDataTo(StringStream* stream) override;
-
- DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry")
- DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry)
-};
-
-
-class LInnerAllocatedObject final : public LTemplateInstruction<1, 2, 0> {
- public:
- LInnerAllocatedObject(LOperand* base_object, LOperand* offset) {
- inputs_[0] = base_object;
- inputs_[1] = offset;
- }
-
- LOperand* base_object() const { return inputs_[0]; }
- LOperand* offset() const { return inputs_[1]; }
-
- void PrintDataTo(StringStream* stream) override;
-
- DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object")
-};
-
-
-class LThisFunction final : public LTemplateInstruction<1, 0, 0> {
- public:
- DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
- DECLARE_HYDROGEN_ACCESSOR(ThisFunction)
-};
-
-
-class LContext final : public LTemplateInstruction<1, 0, 0> {
- public:
- DECLARE_CONCRETE_INSTRUCTION(Context, "context")
- DECLARE_HYDROGEN_ACCESSOR(Context)
-};
-
-
-class LDeclareGlobals final : public LTemplateInstruction<0, 1, 0> {
- public:
- explicit LDeclareGlobals(LOperand* context) {
- inputs_[0] = context;
- }
-
- LOperand* context() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals, "declare-globals")
- DECLARE_HYDROGEN_ACCESSOR(DeclareGlobals)
-};
-
-
-class LCallJSFunction final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LCallJSFunction(LOperand* function) {
- inputs_[0] = function;
- }
-
- LOperand* function() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function")
- DECLARE_HYDROGEN_ACCESSOR(CallJSFunction)
-
- void PrintDataTo(StringStream* stream) override;
-
- int arity() const { return hydrogen()->argument_count() - 1; }
-};
-
-
-class LCallWithDescriptor final : public LTemplateResultInstruction<1> {
- public:
- LCallWithDescriptor(CallInterfaceDescriptor descriptor,
- const ZoneList<LOperand*>& operands, Zone* zone)
- : inputs_(descriptor.GetRegisterParameterCount() +
- kImplicitRegisterParameterCount,
- zone) {
- DCHECK(descriptor.GetRegisterParameterCount() +
- kImplicitRegisterParameterCount ==
- operands.length());
- inputs_.AddAll(operands, zone);
- }
-
- LOperand* target() const { return inputs_[0]; }
-
- DECLARE_HYDROGEN_ACCESSOR(CallWithDescriptor)
-
- // The target and context are passed as implicit parameters that are not
- // explicitly listed in the descriptor.
- static const int kImplicitRegisterParameterCount = 2;
-
- private:
- DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor")
-
- void PrintDataTo(StringStream* stream) override;
-
- int arity() const { return hydrogen()->argument_count() - 1; }
-
- ZoneList<LOperand*> inputs_;
-
- // Iterator support.
- int InputCount() final { return inputs_.length(); }
- LOperand* InputAt(int i) final { return inputs_[i]; }
-
- int TempCount() final { return 0; }
- LOperand* TempAt(int i) final { return NULL; }
-};
-
-
-class LInvokeFunction final : public LTemplateInstruction<1, 2, 0> {
- public:
- LInvokeFunction(LOperand* context, LOperand* function) {
- inputs_[0] = context;
- inputs_[1] = function;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* function() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
- DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
-
- void PrintDataTo(StringStream* stream) override;
-
- int arity() const { return hydrogen()->argument_count() - 1; }
-};
-
-
-class LCallFunction final : public LTemplateInstruction<1, 2, 2> {
- public:
- LCallFunction(LOperand* context, LOperand* function, LOperand* slot,
- LOperand* vector) {
- inputs_[0] = context;
- inputs_[1] = function;
- temps_[0] = slot;
- temps_[1] = vector;
- }
-
- DECLARE_CONCRETE_INSTRUCTION(CallFunction, "call-function")
- DECLARE_HYDROGEN_ACCESSOR(CallFunction)
-
- LOperand* context() { return inputs_[0]; }
- LOperand* function() { return inputs_[1]; }
- LOperand* temp_slot() { return temps_[0]; }
- LOperand* temp_vector() { return temps_[1]; }
- int arity() const { return hydrogen()->argument_count() - 1; }
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LCallNew final : public LTemplateInstruction<1, 2, 0> {
- public:
- LCallNew(LOperand* context, LOperand* constructor) {
- inputs_[0] = context;
- inputs_[1] = constructor;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* constructor() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")
- DECLARE_HYDROGEN_ACCESSOR(CallNew)
-
- void PrintDataTo(StringStream* stream) override;
-
- int arity() const { return hydrogen()->argument_count() - 1; }
-};
-
-
-class LCallNewArray final : public LTemplateInstruction<1, 2, 0> {
- public:
- LCallNewArray(LOperand* context, LOperand* constructor) {
- inputs_[0] = context;
- inputs_[1] = constructor;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* constructor() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array")
- DECLARE_HYDROGEN_ACCESSOR(CallNewArray)
-
- void PrintDataTo(StringStream* stream) override;
-
- int arity() const { return hydrogen()->argument_count() - 1; }
-};
-
-
-class LCallRuntime final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LCallRuntime(LOperand* context) {
- inputs_[0] = context;
- }
-
- LOperand* context() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")
- DECLARE_HYDROGEN_ACCESSOR(CallRuntime)
-
- bool ClobbersDoubleRegisters(Isolate* isolate) const override {
- return save_doubles() == kDontSaveFPRegs;
- }
-
- const Runtime::Function* function() const { return hydrogen()->function(); }
- int arity() const { return hydrogen()->argument_count(); }
- SaveFPRegsMode save_doubles() const { return hydrogen()->save_doubles(); }
-};
-
-
-class LInteger32ToDouble final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LInteger32ToDouble(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(Integer32ToDouble, "int32-to-double")
-};
-
-
-class LUint32ToDouble final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LUint32ToDouble(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(Uint32ToDouble, "uint32-to-double")
-};
-
-
-class LNumberTagI final : public LTemplateInstruction<1, 1, 2> {
- public:
- LNumberTagI(LOperand* value, LOperand* temp1, LOperand* temp2) {
- inputs_[0] = value;
- temps_[0] = temp1;
- temps_[1] = temp2;
- }
-
- LOperand* value() { return inputs_[0]; }
- LOperand* temp1() { return temps_[0]; }
- LOperand* temp2() { return temps_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(NumberTagI, "number-tag-i")
-};
-
-
-class LNumberTagU final : public LTemplateInstruction<1, 1, 2> {
- public:
- LNumberTagU(LOperand* value, LOperand* temp1, LOperand* temp2) {
- inputs_[0] = value;
- temps_[0] = temp1;
- temps_[1] = temp2;
- }
-
- LOperand* value() { return inputs_[0]; }
- LOperand* temp1() { return temps_[0]; }
- LOperand* temp2() { return temps_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(NumberTagU, "number-tag-u")
-};
-
-
-class LNumberTagD final : public LTemplateInstruction<1, 1, 1> {
- public:
- explicit LNumberTagD(LOperand* value, LOperand* temp) {
- inputs_[0] = value;
- temps_[0] = temp;
- }
-
- LOperand* value() { return inputs_[0]; }
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(NumberTagD, "number-tag-d")
- DECLARE_HYDROGEN_ACCESSOR(Change)
-};
-
-
-// Sometimes truncating conversion from a tagged value to an int32.
-class LDoubleToI final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LDoubleToI(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(DoubleToI, "double-to-i")
- DECLARE_HYDROGEN_ACCESSOR(UnaryOperation)
-
- bool truncating() { return hydrogen()->CanTruncateToInt32(); }
-};
-
-
-class LDoubleToSmi final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LDoubleToSmi(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(DoubleToSmi, "double-to-smi")
- DECLARE_HYDROGEN_ACCESSOR(UnaryOperation)
-};
-
-
-// Truncating conversion from a tagged value to an int32.
-class LTaggedToI final : public LTemplateInstruction<1, 1, 1> {
- public:
- LTaggedToI(LOperand* value, LOperand* temp) {
- inputs_[0] = value;
- temps_[0] = temp;
- }
-
- LOperand* value() { return inputs_[0]; }
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(TaggedToI, "tagged-to-i")
- DECLARE_HYDROGEN_ACCESSOR(Change)
-
- bool truncating() { return hydrogen()->CanTruncateToInt32(); }
-};
-
-
-class LSmiTag final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LSmiTag(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(SmiTag, "smi-tag")
- DECLARE_HYDROGEN_ACCESSOR(Change)
-};
-
-
-class LNumberUntagD final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LNumberUntagD(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(NumberUntagD, "double-untag")
- DECLARE_HYDROGEN_ACCESSOR(Change);
-};
-
-
-class LSmiUntag final : public LTemplateInstruction<1, 1, 0> {
- public:
- LSmiUntag(LOperand* value, bool needs_check)
- : needs_check_(needs_check) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
- bool needs_check() const { return needs_check_; }
-
- DECLARE_CONCRETE_INSTRUCTION(SmiUntag, "smi-untag")
-
- private:
- bool needs_check_;
-};
-
-
-class LStoreNamedField final : public LTemplateInstruction<0, 2, 1> {
- public:
- LStoreNamedField(LOperand* object, LOperand* value, LOperand* temp) {
- inputs_[0] = object;
- inputs_[1] = value;
- temps_[0] = temp;
- }
-
- LOperand* object() { return inputs_[0]; }
- LOperand* value() { return inputs_[1]; }
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field")
- DECLARE_HYDROGEN_ACCESSOR(StoreNamedField)
-
- void PrintDataTo(StringStream* stream) override;
-
- Representation representation() const {
- return hydrogen()->field_representation();
- }
-};
-
-
-class LStoreNamedGeneric final : public LTemplateInstruction<0, 3, 2> {
- public:
- LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value,
- LOperand* slot, LOperand* vector) {
- inputs_[0] = context;
- inputs_[1] = object;
- inputs_[2] = value;
- temps_[0] = slot;
- temps_[1] = vector;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* object() { return inputs_[1]; }
- LOperand* value() { return inputs_[2]; }
- LOperand* temp_slot() { return temps_[0]; }
- LOperand* temp_vector() { return temps_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
- DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
-
- void PrintDataTo(StringStream* stream) override;
-
- Handle<Object> name() const { return hydrogen()->name(); }
- LanguageMode language_mode() { return hydrogen()->language_mode(); }
-};
-
-
-class LStoreGlobalViaContext final : public LTemplateInstruction<0, 2, 0> {
- public:
- LStoreGlobalViaContext(LOperand* context, LOperand* value) {
- inputs_[0] = context;
- inputs_[1] = value;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* value() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(StoreGlobalViaContext,
- "store-global-via-context")
- DECLARE_HYDROGEN_ACCESSOR(StoreGlobalViaContext)
-
- void PrintDataTo(StringStream* stream) override;
-
- int depth() { return hydrogen()->depth(); }
- int slot_index() { return hydrogen()->slot_index(); }
- LanguageMode language_mode() { return hydrogen()->language_mode(); }
-};
-
-
-class LStoreKeyed final : public LTemplateInstruction<0, 3, 0> {
- public:
- LStoreKeyed(LOperand* object, LOperand* key, LOperand* value) {
- inputs_[0] = object;
- inputs_[1] = key;
- inputs_[2] = value;
- }
-
- bool is_fixed_typed_array() const {
- return hydrogen()->is_fixed_typed_array();
- }
- LOperand* elements() { return inputs_[0]; }
- LOperand* key() { return inputs_[1]; }
- LOperand* value() { return inputs_[2]; }
- ElementsKind elements_kind() const { return hydrogen()->elements_kind(); }
-
- DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed")
- DECLARE_HYDROGEN_ACCESSOR(StoreKeyed)
-
- void PrintDataTo(StringStream* stream) override;
- bool NeedsCanonicalization() { return hydrogen()->NeedsCanonicalization(); }
- uint32_t base_offset() const { return hydrogen()->base_offset(); }
-};
-
-
-class LStoreKeyedGeneric final : public LTemplateInstruction<0, 4, 2> {
- public:
- LStoreKeyedGeneric(LOperand* context, LOperand* object, LOperand* key,
- LOperand* value, LOperand* slot, LOperand* vector) {
- inputs_[0] = context;
- inputs_[1] = object;
- inputs_[2] = key;
- inputs_[3] = value;
- temps_[0] = slot;
- temps_[1] = vector;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* object() { return inputs_[1]; }
- LOperand* key() { return inputs_[2]; }
- LOperand* value() { return inputs_[3]; }
- LOperand* temp_slot() { return temps_[0]; }
- LOperand* temp_vector() { return temps_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")
- DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric)
-
- void PrintDataTo(StringStream* stream) override;
-
- LanguageMode language_mode() { return hydrogen()->language_mode(); }
-};
-
-
-class LTransitionElementsKind final : public LTemplateInstruction<0, 2, 2> {
- public:
- LTransitionElementsKind(LOperand* object,
- LOperand* context,
- LOperand* new_map_temp,
- LOperand* temp) {
- inputs_[0] = object;
- inputs_[1] = context;
- temps_[0] = new_map_temp;
- temps_[1] = temp;
- }
-
- LOperand* object() { return inputs_[0]; }
- LOperand* context() { return inputs_[1]; }
- LOperand* new_map_temp() { return temps_[0]; }
- LOperand* temp() { return temps_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind,
- "transition-elements-kind")
- DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind)
-
- void PrintDataTo(StringStream* stream) override;
-
- Handle<Map> original_map() { return hydrogen()->original_map().handle(); }
- Handle<Map> transitioned_map() {
- return hydrogen()->transitioned_map().handle();
- }
- ElementsKind from_kind() { return hydrogen()->from_kind(); }
- ElementsKind to_kind() { return hydrogen()->to_kind(); }
-};
-
-
-class LTrapAllocationMemento final : public LTemplateInstruction<0, 1, 1> {
- public:
- LTrapAllocationMemento(LOperand* object,
- LOperand* temp) {
- inputs_[0] = object;
- temps_[0] = temp;
- }
-
- LOperand* object() { return inputs_[0]; }
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(TrapAllocationMemento,
- "trap-allocation-memento")
-};
-
-
-class LMaybeGrowElements final : public LTemplateInstruction<1, 5, 0> {
- public:
- LMaybeGrowElements(LOperand* context, LOperand* object, LOperand* elements,
- LOperand* key, LOperand* current_capacity) {
- inputs_[0] = context;
- inputs_[1] = object;
- inputs_[2] = elements;
- inputs_[3] = key;
- inputs_[4] = current_capacity;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* object() { return inputs_[1]; }
- LOperand* elements() { return inputs_[2]; }
- LOperand* key() { return inputs_[3]; }
- LOperand* current_capacity() { return inputs_[4]; }
-
- DECLARE_HYDROGEN_ACCESSOR(MaybeGrowElements)
- DECLARE_CONCRETE_INSTRUCTION(MaybeGrowElements, "maybe-grow-elements")
-};
-
-
-class LStringAdd final : public LTemplateInstruction<1, 3, 0> {
- public:
- LStringAdd(LOperand* context, LOperand* left, LOperand* right) {
- inputs_[0] = context;
- inputs_[1] = left;
- inputs_[2] = right;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* left() { return inputs_[1]; }
- LOperand* right() { return inputs_[2]; }
-
- DECLARE_CONCRETE_INSTRUCTION(StringAdd, "string-add")
- DECLARE_HYDROGEN_ACCESSOR(StringAdd)
-};
-
-
-class LStringCharCodeAt final : public LTemplateInstruction<1, 3, 0> {
- public:
- LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) {
- inputs_[0] = context;
- inputs_[1] = string;
- inputs_[2] = index;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* string() { return inputs_[1]; }
- LOperand* index() { return inputs_[2]; }
-
- DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt, "string-char-code-at")
- DECLARE_HYDROGEN_ACCESSOR(StringCharCodeAt)
-};
-
-
-class LStringCharFromCode final : public LTemplateInstruction<1, 2, 0> {
- public:
- explicit LStringCharFromCode(LOperand* context, LOperand* char_code) {
- inputs_[0] = context;
- inputs_[1] = char_code;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* char_code() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode, "string-char-from-code")
- DECLARE_HYDROGEN_ACCESSOR(StringCharFromCode)
-};
-
-
-class LCheckValue final : public LTemplateInstruction<0, 1, 0> {
- public:
- explicit LCheckValue(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CheckValue, "check-value")
- DECLARE_HYDROGEN_ACCESSOR(CheckValue)
-};
-
-
-class LCheckArrayBufferNotNeutered final
- : public LTemplateInstruction<0, 1, 0> {
- public:
- explicit LCheckArrayBufferNotNeutered(LOperand* view) { inputs_[0] = view; }
-
- LOperand* view() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CheckArrayBufferNotNeutered,
- "check-array-buffer-not-neutered")
- DECLARE_HYDROGEN_ACCESSOR(CheckArrayBufferNotNeutered)
-};
-
-
-class LCheckInstanceType final : public LTemplateInstruction<0, 1, 0> {
- public:
- explicit LCheckInstanceType(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CheckInstanceType, "check-instance-type")
- DECLARE_HYDROGEN_ACCESSOR(CheckInstanceType)
-};
-
-
-class LCheckMaps final : public LTemplateInstruction<0, 1, 0> {
- public:
- explicit LCheckMaps(LOperand* value = NULL) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CheckMaps, "check-maps")
- DECLARE_HYDROGEN_ACCESSOR(CheckMaps)
-};
-
-
-class LCheckSmi final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LCheckSmi(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CheckSmi, "check-smi")
-};
-
-
-class LClampDToUint8 final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LClampDToUint8(LOperand* unclamped) {
- inputs_[0] = unclamped;
- }
-
- LOperand* unclamped() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(ClampDToUint8, "clamp-d-to-uint8")
-};
-
-
-class LClampIToUint8 final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LClampIToUint8(LOperand* unclamped) {
- inputs_[0] = unclamped;
- }
-
- LOperand* unclamped() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(ClampIToUint8, "clamp-i-to-uint8")
-};
-
-
-class LClampTToUint8 final : public LTemplateInstruction<1, 1, 1> {
- public:
- LClampTToUint8(LOperand* unclamped,
- LOperand* temp_xmm) {
- inputs_[0] = unclamped;
- temps_[0] = temp_xmm;
- }
-
- LOperand* unclamped() { return inputs_[0]; }
- LOperand* temp_xmm() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(ClampTToUint8, "clamp-t-to-uint8")
-};
-
-
-class LCheckNonSmi final : public LTemplateInstruction<0, 1, 0> {
- public:
- explicit LCheckNonSmi(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CheckNonSmi, "check-non-smi")
- DECLARE_HYDROGEN_ACCESSOR(CheckHeapObject)
-};
-
-
-class LDoubleBits final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LDoubleBits(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(DoubleBits, "double-bits")
- DECLARE_HYDROGEN_ACCESSOR(DoubleBits)
-};
-
-
-class LConstructDouble final : public LTemplateInstruction<1, 2, 0> {
- public:
- LConstructDouble(LOperand* hi, LOperand* lo) {
- inputs_[0] = hi;
- inputs_[1] = lo;
- }
-
- LOperand* hi() { return inputs_[0]; }
- LOperand* lo() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(ConstructDouble, "construct-double")
-};
-
-
-class LAllocate final : public LTemplateInstruction<1, 2, 1> {
- public:
- LAllocate(LOperand* context, LOperand* size, LOperand* temp) {
- inputs_[0] = context;
- inputs_[1] = size;
- temps_[0] = temp;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* size() { return inputs_[1]; }
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(Allocate, "allocate")
- DECLARE_HYDROGEN_ACCESSOR(Allocate)
-};
-
-
-class LRegExpLiteral final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LRegExpLiteral(LOperand* context) {
- inputs_[0] = context;
- }
-
- LOperand* context() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(RegExpLiteral, "regexp-literal")
- DECLARE_HYDROGEN_ACCESSOR(RegExpLiteral)
-};
-
-
-class LToFastProperties final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LToFastProperties(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(ToFastProperties, "to-fast-properties")
- DECLARE_HYDROGEN_ACCESSOR(ToFastProperties)
-};
-
-
-class LTypeof final : public LTemplateInstruction<1, 2, 0> {
- public:
- LTypeof(LOperand* context, LOperand* value) {
- inputs_[0] = context;
- inputs_[1] = value;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* value() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof")
-};
-
-
-class LTypeofIsAndBranch final : public LControlInstruction<1, 0> {
- public:
- explicit LTypeofIsAndBranch(LOperand* value) {
- inputs_[0] = value;
- }
-
- LOperand* value() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch, "typeof-is-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(TypeofIsAndBranch)
-
- Handle<String> type_literal() { return hydrogen()->type_literal(); }
-
- void PrintDataTo(StringStream* stream) override;
-};
-
-
-class LIsConstructCallAndBranch final : public LControlInstruction<0, 1> {
- public:
- explicit LIsConstructCallAndBranch(LOperand* temp) {
- temps_[0] = temp;
- }
-
- LOperand* temp() { return temps_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(IsConstructCallAndBranch,
- "is-construct-call-and-branch")
- DECLARE_HYDROGEN_ACCESSOR(IsConstructCallAndBranch)
-};
-
-
-class LOsrEntry final : public LTemplateInstruction<0, 0, 0> {
- public:
- LOsrEntry() {}
-
- bool HasInterestingComment(LCodeGen* gen) const override { return false; }
- DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry")
-};
-
-
-class LStackCheck final : public LTemplateInstruction<0, 1, 0> {
- public:
- explicit LStackCheck(LOperand* context) {
- inputs_[0] = context;
- }
-
- LOperand* context() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(StackCheck, "stack-check")
- DECLARE_HYDROGEN_ACCESSOR(StackCheck)
-
- Label* done_label() { return &done_label_; }
-
- private:
- Label done_label_;
-};
-
-
-class LForInPrepareMap final : public LTemplateInstruction<1, 2, 0> {
- public:
- LForInPrepareMap(LOperand* context, LOperand* object) {
- inputs_[0] = context;
- inputs_[1] = object;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* object() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(ForInPrepareMap, "for-in-prepare-map")
-};
-
-
-class LForInCacheArray final : public LTemplateInstruction<1, 1, 0> {
- public:
- explicit LForInCacheArray(LOperand* map) {
- inputs_[0] = map;
- }
-
- LOperand* map() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(ForInCacheArray, "for-in-cache-array")
-
- int idx() {
- return HForInCacheArray::cast(this->hydrogen_value())->idx();
- }
-};
-
-
-class LCheckMapValue final : public LTemplateInstruction<0, 2, 0> {
- public:
- LCheckMapValue(LOperand* value, LOperand* map) {
- inputs_[0] = value;
- inputs_[1] = map;
- }
-
- LOperand* value() { return inputs_[0]; }
- LOperand* map() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(CheckMapValue, "check-map-value")
-};
-
-
-class LLoadFieldByIndex final : public LTemplateInstruction<1, 2, 0> {
- public:
- LLoadFieldByIndex(LOperand* object, LOperand* index) {
- inputs_[0] = object;
- inputs_[1] = index;
- }
-
- LOperand* object() { return inputs_[0]; }
- LOperand* index() { return inputs_[1]; }
-
- DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex, "load-field-by-index")
-};
-
-
-class LStoreFrameContext: public LTemplateInstruction<0, 1, 0> {
- public:
- explicit LStoreFrameContext(LOperand* context) {
- inputs_[0] = context;
- }
-
- LOperand* context() { return inputs_[0]; }
-
- DECLARE_CONCRETE_INSTRUCTION(StoreFrameContext, "store-frame-context")
-};
-
-
-class LAllocateBlockContext: public LTemplateInstruction<1, 2, 0> {
- public:
- LAllocateBlockContext(LOperand* context, LOperand* function) {
- inputs_[0] = context;
- inputs_[1] = function;
- }
-
- LOperand* context() { return inputs_[0]; }
- LOperand* function() { return inputs_[1]; }
-
- Handle<ScopeInfo> scope_info() { return hydrogen()->scope_info(); }
-
- DECLARE_CONCRETE_INSTRUCTION(AllocateBlockContext, "allocate-block-context")
- DECLARE_HYDROGEN_ACCESSOR(AllocateBlockContext)
-};
-
-
-class LChunkBuilder;
-class LPlatformChunk final : public LChunk {
- public:
- LPlatformChunk(CompilationInfo* info, HGraph* graph)
- : LChunk(info, graph),
- dehoisted_key_ids_(graph->GetMaximumValueID(), graph->zone()) { }
-
- int GetNextSpillIndex(RegisterKind kind);
- LOperand* GetNextSpillSlot(RegisterKind kind);
- BitVector* GetDehoistedKeyIds() { return &dehoisted_key_ids_; }
- bool IsDehoistedKey(HValue* value) {
- return dehoisted_key_ids_.Contains(value->id());
- }
-
- private:
- BitVector dehoisted_key_ids_;
-};
-
-
-class LChunkBuilder final : public LChunkBuilderBase {
- public:
- LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator)
- : LChunkBuilderBase(info, graph),
- current_instruction_(NULL),
- current_block_(NULL),
- next_block_(NULL),
- allocator_(allocator) {}
-
- // Build the sequence for the graph.
- LPlatformChunk* Build();
-
- // Declare methods that deal with the individual node types.
-#define DECLARE_DO(type) LInstruction* Do##type(H##type* node);
- HYDROGEN_CONCRETE_INSTRUCTION_LIST(DECLARE_DO)
-#undef DECLARE_DO
-
- LInstruction* DoMathFloor(HUnaryMathOperation* instr);
- LInstruction* DoMathRound(HUnaryMathOperation* instr);
- LInstruction* DoMathFround(HUnaryMathOperation* instr);
- LInstruction* DoMathAbs(HUnaryMathOperation* instr);
- LInstruction* DoMathLog(HUnaryMathOperation* instr);
- LInstruction* DoMathExp(HUnaryMathOperation* instr);
- LInstruction* DoMathSqrt(HUnaryMathOperation* instr);
- LInstruction* DoMathPowHalf(HUnaryMathOperation* instr);
- LInstruction* DoMathClz32(HUnaryMathOperation* instr);
- LInstruction* DoDivByPowerOf2I(HDiv* instr);
- LInstruction* DoDivByConstI(HDiv* instr);
- LInstruction* DoDivI(HDiv* instr);
- LInstruction* DoModByPowerOf2I(HMod* instr);
- LInstruction* DoModByConstI(HMod* instr);
- LInstruction* DoModI(HMod* instr);
- LInstruction* DoFlooringDivByPowerOf2I(HMathFloorOfDiv* instr);
- LInstruction* DoFlooringDivByConstI(HMathFloorOfDiv* instr);
- LInstruction* DoFlooringDivI(HMathFloorOfDiv* instr);
-
- private:
- // Methods for getting operands for Use / Define / Temp.
- LUnallocated* ToUnallocated(Register reg);
- LUnallocated* ToUnallocated(XMMRegister reg);
-
- // Methods for setting up define-use relationships.
- MUST_USE_RESULT LOperand* Use(HValue* value, LUnallocated* operand);
- MUST_USE_RESULT LOperand* UseFixed(HValue* value, Register fixed_register);
- MUST_USE_RESULT LOperand* UseFixedDouble(HValue* value,
- XMMRegister fixed_register);
-
- // A value that is guaranteed to be allocated to a register.
- // Operand created by UseRegister is guaranteed to be live until the end of
- // instruction. This means that register allocator will not reuse it's
- // register for any other operand inside instruction.
- // Operand created by UseRegisterAtStart is guaranteed to be live only at
- // instruction start. Register allocator is free to assign the same register
- // to some other operand used inside instruction (i.e. temporary or
- // output).
- MUST_USE_RESULT LOperand* UseRegister(HValue* value);
- MUST_USE_RESULT LOperand* UseRegisterAtStart(HValue* value);
-
- // An input operand in a register that may be trashed.
- MUST_USE_RESULT LOperand* UseTempRegister(HValue* value);
-
- // An input operand in a register that may be trashed or a constant operand.
- MUST_USE_RESULT LOperand* UseTempRegisterOrConstant(HValue* value);
-
- // An input operand in a register or stack slot.
- MUST_USE_RESULT LOperand* Use(HValue* value);
- MUST_USE_RESULT LOperand* UseAtStart(HValue* value);
-
- // An input operand in a register, stack slot or a constant operand.
- MUST_USE_RESULT LOperand* UseOrConstant(HValue* value);
- MUST_USE_RESULT LOperand* UseOrConstantAtStart(HValue* value);
-
- // An input operand in a register or a constant operand.
- MUST_USE_RESULT LOperand* UseRegisterOrConstant(HValue* value);
- MUST_USE_RESULT LOperand* UseRegisterOrConstantAtStart(HValue* value);
-
- // An input operand in a constant operand.
- MUST_USE_RESULT LOperand* UseConstant(HValue* value);
-
- // An input operand in register, stack slot or a constant operand.
- // Will not be moved to a register even if one is freely available.
- MUST_USE_RESULT LOperand* UseAny(HValue* value) override;
-
- // Temporary operand that must be in a register.
- MUST_USE_RESULT LUnallocated* TempRegister();
- MUST_USE_RESULT LOperand* FixedTemp(Register reg);
- MUST_USE_RESULT LOperand* FixedTemp(XMMRegister reg);
-
- // Methods for setting up define-use relationships.
- // Return the same instruction that they are passed.
- LInstruction* Define(LTemplateResultInstruction<1>* instr,
- LUnallocated* result);
- LInstruction* DefineAsRegister(LTemplateResultInstruction<1>* instr);
- LInstruction* DefineAsSpilled(LTemplateResultInstruction<1>* instr,
- int index);
- LInstruction* DefineSameAsFirst(LTemplateResultInstruction<1>* instr);
- LInstruction* DefineFixed(LTemplateResultInstruction<1>* instr,
- Register reg);
- LInstruction* DefineFixedDouble(LTemplateResultInstruction<1>* instr,
- XMMRegister reg);
- // Assigns an environment to an instruction. An instruction which can
- // deoptimize must have an environment.
- LInstruction* AssignEnvironment(LInstruction* instr);
- // Assigns a pointer map to an instruction. An instruction which can
- // trigger a GC or a lazy deoptimization must have a pointer map.
- LInstruction* AssignPointerMap(LInstruction* instr);
-
- enum CanDeoptimize { CAN_DEOPTIMIZE_EAGERLY, CANNOT_DEOPTIMIZE_EAGERLY };
-
- // Marks a call for the register allocator. Assigns a pointer map to
- // support GC and lazy deoptimization. Assigns an environment to support
- // eager deoptimization if CAN_DEOPTIMIZE_EAGERLY.
- LInstruction* MarkAsCall(
- LInstruction* instr,
- HInstruction* hinstr,
- CanDeoptimize can_deoptimize = CANNOT_DEOPTIMIZE_EAGERLY);
-
- void VisitInstruction(HInstruction* current);
- void AddInstruction(LInstruction* instr, HInstruction* current);
-
- void DoBasicBlock(HBasicBlock* block, HBasicBlock* next_block);
- LInstruction* DoShift(Token::Value op, HBitwiseBinaryOperation* instr);
- LInstruction* DoArithmeticD(Token::Value op,
- HArithmeticBinaryOperation* instr);
- LInstruction* DoArithmeticT(Token::Value op,
- HBinaryOperation* instr);
- void FindDehoistedKeyDefinitions(HValue* candidate);
-
- HInstruction* current_instruction_;
- HBasicBlock* current_block_;
- HBasicBlock* next_block_;
- LAllocator* allocator_;
-
- DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
-};
-
-#undef DECLARE_HYDROGEN_ACCESSOR
-#undef DECLARE_CONCRETE_INSTRUCTION
-
-} } // namespace v8::int
-
-#endif // V8_X64_LITHIUM_X64_H_
diff --git a/deps/v8/src/x64/macro-assembler-x64.cc b/deps/v8/src/x64/macro-assembler-x64.cc
index ea837dca4b..3c8cab2d83 100644
--- a/deps/v8/src/x64/macro-assembler-x64.cc
+++ b/deps/v8/src/x64/macro-assembler-x64.cc
@@ -10,6 +10,7 @@
#include "src/codegen.h"
#include "src/debug/debug.h"
#include "src/heap/heap.h"
+#include "src/register-configuration.h"
#include "src/x64/assembler-x64.h"
#include "src/x64/macro-assembler-x64.h"
@@ -22,8 +23,8 @@ MacroAssembler::MacroAssembler(Isolate* arg_isolate, void* buffer, int size)
has_frame_(false),
root_array_available_(true) {
if (isolate() != NULL) {
- code_object_ = Handle<Object>(isolate()->heap()->undefined_value(),
- isolate());
+ code_object_ =
+ Handle<Object>::New(isolate()->heap()->undefined_value(), isolate());
}
}
@@ -715,7 +716,7 @@ void MacroAssembler::GetBuiltinFunction(Register target,
int native_context_index) {
// Load the builtins object into target register.
movp(target, Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
- movp(target, FieldOperand(target, GlobalObject::kNativeContextOffset));
+ movp(target, FieldOperand(target, JSGlobalObject::kNativeContextOffset));
movp(target, ContextOperand(target, native_context_index));
}
@@ -729,7 +730,8 @@ void MacroAssembler::GetBuiltinEntry(Register target,
}
-#define REG(Name) { kRegister_ ## Name ## _Code }
+#define REG(Name) \
+ { Register::kCode_##Name }
static const Register saved_regs[] = {
REG(rax), REG(rcx), REG(rdx), REG(rbx), REG(rbp), REG(rsi), REG(rdi), REG(r8),
@@ -759,7 +761,7 @@ void MacroAssembler::PushCallerSaved(SaveFPRegsMode fp_mode,
subp(rsp, Immediate(kDoubleSize * XMMRegister::kMaxNumRegisters));
for (int i = 0; i < XMMRegister::kMaxNumRegisters; i++) {
XMMRegister reg = XMMRegister::from_code(i);
- movsd(Operand(rsp, i * kDoubleSize), reg);
+ Movsd(Operand(rsp, i * kDoubleSize), reg);
}
}
}
@@ -772,7 +774,7 @@ void MacroAssembler::PopCallerSaved(SaveFPRegsMode fp_mode,
if (fp_mode == kSaveFPRegs) {
for (int i = 0; i < XMMRegister::kMaxNumRegisters; i++) {
XMMRegister reg = XMMRegister::from_code(i);
- movsd(reg, Operand(rsp, i * kDoubleSize));
+ Movsd(reg, Operand(rsp, i * kDoubleSize));
}
addp(rsp, Immediate(kDoubleSize * XMMRegister::kMaxNumRegisters));
}
@@ -785,15 +787,165 @@ void MacroAssembler::PopCallerSaved(SaveFPRegsMode fp_mode,
}
+void MacroAssembler::Cvtss2sd(XMMRegister dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vcvtss2sd(dst, src, src);
+ } else {
+ cvtss2sd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Cvtss2sd(XMMRegister dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vcvtss2sd(dst, dst, src);
+ } else {
+ cvtss2sd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Cvtsd2ss(XMMRegister dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vcvtsd2ss(dst, src, src);
+ } else {
+ cvtsd2ss(dst, src);
+ }
+}
+
+
+void MacroAssembler::Cvtsd2ss(XMMRegister dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vcvtsd2ss(dst, dst, src);
+ } else {
+ cvtsd2ss(dst, src);
+ }
+}
+
+
void MacroAssembler::Cvtlsi2sd(XMMRegister dst, Register src) {
- xorps(dst, dst);
- cvtlsi2sd(dst, src);
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vxorpd(dst, dst, dst);
+ vcvtlsi2sd(dst, dst, src);
+ } else {
+ xorpd(dst, dst);
+ cvtlsi2sd(dst, src);
+ }
}
void MacroAssembler::Cvtlsi2sd(XMMRegister dst, const Operand& src) {
- xorps(dst, dst);
- cvtlsi2sd(dst, src);
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vxorpd(dst, dst, dst);
+ vcvtlsi2sd(dst, dst, src);
+ } else {
+ xorpd(dst, dst);
+ cvtlsi2sd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Cvtqsi2ss(XMMRegister dst, Register src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vxorps(dst, dst, dst);
+ vcvtqsi2ss(dst, dst, src);
+ } else {
+ xorps(dst, dst);
+ cvtqsi2ss(dst, src);
+ }
+}
+
+
+void MacroAssembler::Cvtqsi2ss(XMMRegister dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vxorps(dst, dst, dst);
+ vcvtqsi2ss(dst, dst, src);
+ } else {
+ xorps(dst, dst);
+ cvtqsi2ss(dst, src);
+ }
+}
+
+
+void MacroAssembler::Cvtqsi2sd(XMMRegister dst, Register src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vxorpd(dst, dst, dst);
+ vcvtqsi2sd(dst, dst, src);
+ } else {
+ xorpd(dst, dst);
+ cvtqsi2sd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Cvtqsi2sd(XMMRegister dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vxorpd(dst, dst, dst);
+ vcvtqsi2sd(dst, dst, src);
+ } else {
+ xorpd(dst, dst);
+ cvtqsi2sd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Cvtsd2si(Register dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vcvtsd2si(dst, src);
+ } else {
+ cvtsd2si(dst, src);
+ }
+}
+
+
+void MacroAssembler::Cvttsd2si(Register dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vcvttsd2si(dst, src);
+ } else {
+ cvttsd2si(dst, src);
+ }
+}
+
+
+void MacroAssembler::Cvttsd2si(Register dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vcvttsd2si(dst, src);
+ } else {
+ cvttsd2si(dst, src);
+ }
+}
+
+
+void MacroAssembler::Cvttsd2siq(Register dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vcvttsd2siq(dst, src);
+ } else {
+ cvttsd2siq(dst, src);
+ }
+}
+
+
+void MacroAssembler::Cvttsd2siq(Register dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vcvttsd2siq(dst, src);
+ } else {
+ cvttsd2siq(dst, src);
+ }
}
@@ -2391,15 +2543,15 @@ void MacroAssembler::Move(const Operand& dst, Handle<Object> source) {
void MacroAssembler::Move(XMMRegister dst, uint32_t src) {
if (src == 0) {
- xorps(dst, dst);
+ Xorpd(dst, dst);
} else {
unsigned pop = base::bits::CountPopulation32(src);
DCHECK_NE(0u, pop);
if (pop == 32) {
- pcmpeqd(dst, dst);
+ Pcmpeqd(dst, dst);
} else {
movl(kScratchRegister, Immediate(src));
- movq(dst, kScratchRegister);
+ Movq(dst, kScratchRegister);
}
}
}
@@ -2407,20 +2559,20 @@ void MacroAssembler::Move(XMMRegister dst, uint32_t src) {
void MacroAssembler::Move(XMMRegister dst, uint64_t src) {
if (src == 0) {
- xorps(dst, dst);
+ Xorpd(dst, dst);
} else {
unsigned nlz = base::bits::CountLeadingZeros64(src);
unsigned ntz = base::bits::CountTrailingZeros64(src);
unsigned pop = base::bits::CountPopulation64(src);
DCHECK_NE(0u, pop);
if (pop == 64) {
- pcmpeqd(dst, dst);
+ Pcmpeqd(dst, dst);
} else if (pop + ntz == 64) {
- pcmpeqd(dst, dst);
- psllq(dst, ntz);
+ Pcmpeqd(dst, dst);
+ Psllq(dst, ntz);
} else if (pop + nlz == 64) {
- pcmpeqd(dst, dst);
- psrlq(dst, nlz);
+ Pcmpeqd(dst, dst);
+ Psrlq(dst, nlz);
} else {
uint32_t lower = static_cast<uint32_t>(src);
uint32_t upper = static_cast<uint32_t>(src >> 32);
@@ -2428,13 +2580,224 @@ void MacroAssembler::Move(XMMRegister dst, uint64_t src) {
Move(dst, lower);
} else {
movq(kScratchRegister, src);
- movq(dst, kScratchRegister);
+ Movq(dst, kScratchRegister);
}
}
}
}
+void MacroAssembler::Movaps(XMMRegister dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovaps(dst, src);
+ } else {
+ movaps(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movapd(XMMRegister dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovapd(dst, src);
+ } else {
+ movapd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movsd(XMMRegister dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovsd(dst, dst, src);
+ } else {
+ movsd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movsd(XMMRegister dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovsd(dst, src);
+ } else {
+ movsd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movsd(const Operand& dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovsd(dst, src);
+ } else {
+ movsd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movss(XMMRegister dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovss(dst, dst, src);
+ } else {
+ movss(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movss(XMMRegister dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovss(dst, src);
+ } else {
+ movss(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movss(const Operand& dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovss(dst, src);
+ } else {
+ movss(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movd(XMMRegister dst, Register src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovd(dst, src);
+ } else {
+ movd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movd(XMMRegister dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovd(dst, src);
+ } else {
+ movd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movd(Register dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovd(dst, src);
+ } else {
+ movd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movq(XMMRegister dst, Register src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovq(dst, src);
+ } else {
+ movq(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movq(Register dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovq(dst, src);
+ } else {
+ movq(dst, src);
+ }
+}
+
+
+void MacroAssembler::Movmskpd(Register dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vmovmskpd(dst, src);
+ } else {
+ movmskpd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Roundsd(XMMRegister dst, XMMRegister src,
+ RoundingMode mode) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vroundsd(dst, dst, src, mode);
+ } else {
+ roundsd(dst, src, mode);
+ }
+}
+
+
+void MacroAssembler::Sqrtsd(XMMRegister dst, XMMRegister src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vsqrtsd(dst, dst, src);
+ } else {
+ sqrtsd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Sqrtsd(XMMRegister dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vsqrtsd(dst, dst, src);
+ } else {
+ sqrtsd(dst, src);
+ }
+}
+
+
+void MacroAssembler::Ucomiss(XMMRegister src1, XMMRegister src2) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vucomiss(src1, src2);
+ } else {
+ ucomiss(src1, src2);
+ }
+}
+
+
+void MacroAssembler::Ucomiss(XMMRegister src1, const Operand& src2) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vucomiss(src1, src2);
+ } else {
+ ucomiss(src1, src2);
+ }
+}
+
+
+void MacroAssembler::Ucomisd(XMMRegister src1, XMMRegister src2) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vucomisd(src1, src2);
+ } else {
+ ucomisd(src1, src2);
+ }
+}
+
+
+void MacroAssembler::Ucomisd(XMMRegister src1, const Operand& src2) {
+ if (CpuFeatures::IsSupported(AVX)) {
+ CpuFeatureScope scope(this, AVX);
+ vucomisd(src1, src2);
+ } else {
+ ucomisd(src1, src2);
+ }
+}
+
+
void MacroAssembler::Cmp(Register dst, Handle<Object> source) {
AllowDeferredHandleDereference smi_check;
if (source->IsSmi()) {
@@ -2743,7 +3106,7 @@ void MacroAssembler::Call(Handle<Code> code_object,
void MacroAssembler::Pextrd(Register dst, XMMRegister src, int8_t imm8) {
if (imm8 == 0) {
- movd(dst, src);
+ Movd(dst, src);
return;
}
DCHECK_EQ(1, imm8);
@@ -2763,14 +3126,12 @@ void MacroAssembler::Pinsrd(XMMRegister dst, Register src, int8_t imm8) {
pinsrd(dst, src, imm8);
return;
}
- movd(xmm0, src);
+ Movd(xmm0, src);
if (imm8 == 1) {
punpckldq(dst, xmm0);
} else {
DCHECK_EQ(0, imm8);
- psrlq(dst, 32);
- punpckldq(xmm0, dst);
- movaps(dst, xmm0);
+ Movss(dst, xmm0);
}
}
@@ -2782,14 +3143,12 @@ void MacroAssembler::Pinsrd(XMMRegister dst, const Operand& src, int8_t imm8) {
pinsrd(dst, src, imm8);
return;
}
- movd(xmm0, src);
+ Movd(xmm0, src);
if (imm8 == 1) {
punpckldq(dst, xmm0);
} else {
DCHECK_EQ(0, imm8);
- psrlq(dst, 32);
- punpckldq(xmm0, dst);
- movaps(dst, xmm0);
+ Movss(dst, xmm0);
}
}
@@ -2824,6 +3183,134 @@ void MacroAssembler::Lzcntl(Register dst, const Operand& src) {
}
+void MacroAssembler::Lzcntq(Register dst, Register src) {
+ if (CpuFeatures::IsSupported(LZCNT)) {
+ CpuFeatureScope scope(this, LZCNT);
+ lzcntq(dst, src);
+ return;
+ }
+ Label not_zero_src;
+ bsrq(dst, src);
+ j(not_zero, &not_zero_src, Label::kNear);
+ Set(dst, 127); // 127^63 == 64
+ bind(&not_zero_src);
+ xorl(dst, Immediate(63)); // for x in [0..63], 63^x == 63 - x
+}
+
+
+void MacroAssembler::Lzcntq(Register dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(LZCNT)) {
+ CpuFeatureScope scope(this, LZCNT);
+ lzcntq(dst, src);
+ return;
+ }
+ Label not_zero_src;
+ bsrq(dst, src);
+ j(not_zero, &not_zero_src, Label::kNear);
+ Set(dst, 127); // 127^63 == 64
+ bind(&not_zero_src);
+ xorl(dst, Immediate(63)); // for x in [0..63], 63^x == 63 - x
+}
+
+
+void MacroAssembler::Tzcntq(Register dst, Register src) {
+ if (CpuFeatures::IsSupported(BMI1)) {
+ CpuFeatureScope scope(this, BMI1);
+ tzcntq(dst, src);
+ return;
+ }
+ Label not_zero_src;
+ bsfq(dst, src);
+ j(not_zero, &not_zero_src, Label::kNear);
+ // Define the result of tzcnt(0) separately, because bsf(0) is undefined.
+ Set(dst, 64);
+ bind(&not_zero_src);
+}
+
+
+void MacroAssembler::Tzcntq(Register dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(BMI1)) {
+ CpuFeatureScope scope(this, BMI1);
+ tzcntq(dst, src);
+ return;
+ }
+ Label not_zero_src;
+ bsfq(dst, src);
+ j(not_zero, &not_zero_src, Label::kNear);
+ // Define the result of tzcnt(0) separately, because bsf(0) is undefined.
+ Set(dst, 64);
+ bind(&not_zero_src);
+}
+
+
+void MacroAssembler::Tzcntl(Register dst, Register src) {
+ if (CpuFeatures::IsSupported(BMI1)) {
+ CpuFeatureScope scope(this, BMI1);
+ tzcntl(dst, src);
+ return;
+ }
+ Label not_zero_src;
+ bsfl(dst, src);
+ j(not_zero, &not_zero_src, Label::kNear);
+ Set(dst, 32); // The result of tzcnt is 32 if src = 0.
+ bind(&not_zero_src);
+}
+
+
+void MacroAssembler::Tzcntl(Register dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(BMI1)) {
+ CpuFeatureScope scope(this, BMI1);
+ tzcntl(dst, src);
+ return;
+ }
+ Label not_zero_src;
+ bsfl(dst, src);
+ j(not_zero, &not_zero_src, Label::kNear);
+ Set(dst, 32); // The result of tzcnt is 32 if src = 0.
+ bind(&not_zero_src);
+}
+
+
+void MacroAssembler::Popcntl(Register dst, Register src) {
+ if (CpuFeatures::IsSupported(POPCNT)) {
+ CpuFeatureScope scope(this, POPCNT);
+ popcntl(dst, src);
+ return;
+ }
+ UNREACHABLE();
+}
+
+
+void MacroAssembler::Popcntl(Register dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(POPCNT)) {
+ CpuFeatureScope scope(this, POPCNT);
+ popcntl(dst, src);
+ return;
+ }
+ UNREACHABLE();
+}
+
+
+void MacroAssembler::Popcntq(Register dst, Register src) {
+ if (CpuFeatures::IsSupported(POPCNT)) {
+ CpuFeatureScope scope(this, POPCNT);
+ popcntq(dst, src);
+ return;
+ }
+ UNREACHABLE();
+}
+
+
+void MacroAssembler::Popcntq(Register dst, const Operand& src) {
+ if (CpuFeatures::IsSupported(POPCNT)) {
+ CpuFeatureScope scope(this, POPCNT);
+ popcntq(dst, src);
+ return;
+ }
+ UNREACHABLE();
+}
+
+
void MacroAssembler::Pushad() {
Push(rax);
Push(rcx);
@@ -3043,7 +3530,7 @@ void MacroAssembler::StoreNumberToDoubleElements(
SmiToInteger32(kScratchRegister, maybe_number);
Cvtlsi2sd(xmm_scratch, kScratchRegister);
bind(&done);
- movsd(FieldOperand(elements, index, times_8,
+ Movsd(FieldOperand(elements, index, times_8,
FixedDoubleArray::kHeaderSize - elements_offset),
xmm_scratch);
}
@@ -3082,8 +3569,8 @@ void MacroAssembler::ClampDoubleToUint8(XMMRegister input_reg,
Register result_reg) {
Label done;
Label conv_failure;
- xorps(temp_xmm_reg, temp_xmm_reg);
- cvtsd2si(result_reg, input_reg);
+ Xorpd(temp_xmm_reg, temp_xmm_reg);
+ Cvtsd2si(result_reg, input_reg);
testl(result_reg, Immediate(0xFFFFFF00));
j(zero, &done, Label::kNear);
cmpl(result_reg, Immediate(1));
@@ -3095,7 +3582,7 @@ void MacroAssembler::ClampDoubleToUint8(XMMRegister input_reg,
jmp(&done, Label::kNear);
bind(&conv_failure);
Set(result_reg, 0);
- ucomisd(input_reg, temp_xmm_reg);
+ Ucomisd(input_reg, temp_xmm_reg);
j(below, &done, Label::kNear);
Set(result_reg, 255);
bind(&done);
@@ -3108,7 +3595,7 @@ void MacroAssembler::LoadUint32(XMMRegister dst,
cmpq(src, Immediate(0xffffffff));
Assert(below_equal, kInputGPRIsExpectedToHaveUpper32Cleared);
}
- cvtqsi2sd(dst, src);
+ Cvtqsi2sd(dst, src);
}
@@ -3123,15 +3610,15 @@ void MacroAssembler::SlowTruncateToI(Register result_reg,
void MacroAssembler::TruncateHeapNumberToI(Register result_reg,
Register input_reg) {
Label done;
- movsd(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset));
- cvttsd2siq(result_reg, xmm0);
+ Movsd(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset));
+ Cvttsd2siq(result_reg, xmm0);
cmpq(result_reg, Immediate(1));
j(no_overflow, &done, Label::kNear);
// Slow case.
if (input_reg.is(result_reg)) {
subp(rsp, Immediate(kDoubleSize));
- movsd(MemOperand(rsp, 0), xmm0);
+ Movsd(MemOperand(rsp, 0), xmm0);
SlowTruncateToI(result_reg, rsp, 0);
addp(rsp, Immediate(kDoubleSize));
} else {
@@ -3147,12 +3634,12 @@ void MacroAssembler::TruncateHeapNumberToI(Register result_reg,
void MacroAssembler::TruncateDoubleToI(Register result_reg,
XMMRegister input_reg) {
Label done;
- cvttsd2siq(result_reg, input_reg);
+ Cvttsd2siq(result_reg, input_reg);
cmpq(result_reg, Immediate(1));
j(no_overflow, &done, Label::kNear);
subp(rsp, Immediate(kDoubleSize));
- movsd(MemOperand(rsp, 0), input_reg);
+ Movsd(MemOperand(rsp, 0), input_reg);
SlowTruncateToI(result_reg, rsp, 0);
addp(rsp, Immediate(kDoubleSize));
@@ -3167,9 +3654,9 @@ void MacroAssembler::DoubleToI(Register result_reg, XMMRegister input_reg,
MinusZeroMode minus_zero_mode,
Label* lost_precision, Label* is_nan,
Label* minus_zero, Label::Distance dst) {
- cvttsd2si(result_reg, input_reg);
+ Cvttsd2si(result_reg, input_reg);
Cvtlsi2sd(xmm0, result_reg);
- ucomisd(xmm0, input_reg);
+ Ucomisd(xmm0, input_reg);
j(not_equal, lost_precision, dst);
j(parity_even, is_nan, dst); // NaN.
if (minus_zero_mode == FAIL_ON_MINUS_ZERO) {
@@ -3178,7 +3665,7 @@ void MacroAssembler::DoubleToI(Register result_reg, XMMRegister input_reg,
// only have to test if we got -0 as an input.
testl(result_reg, result_reg);
j(not_zero, &done, Label::kNear);
- movmskpd(result_reg, input_reg);
+ Movmskpd(result_reg, input_reg);
// Bit 0 contains the sign of the double in input_reg.
// If input was positive, we are ok and return 0, otherwise
// jump to minus_zero.
@@ -3451,6 +3938,43 @@ void MacroAssembler::DebugBreak() {
}
+void MacroAssembler::InvokeFunction(Register function,
+ const ParameterCount& actual,
+ InvokeFlag flag,
+ const CallWrapper& call_wrapper) {
+ movp(rdx, FieldOperand(function, JSFunction::kSharedFunctionInfoOffset));
+ LoadSharedFunctionInfoSpecialField(
+ rbx, rdx, SharedFunctionInfo::kFormalParameterCountOffset);
+
+ ParameterCount expected(rbx);
+ InvokeFunction(function, expected, actual, flag, call_wrapper);
+}
+
+
+void MacroAssembler::InvokeFunction(Handle<JSFunction> function,
+ const ParameterCount& expected,
+ const ParameterCount& actual,
+ InvokeFlag flag,
+ const CallWrapper& call_wrapper) {
+ Move(rdi, function);
+ InvokeFunction(rdi, expected, actual, flag, call_wrapper);
+}
+
+
+void MacroAssembler::InvokeFunction(Register function,
+ const ParameterCount& expected,
+ const ParameterCount& actual,
+ InvokeFlag flag,
+ const CallWrapper& call_wrapper) {
+ DCHECK(function.is(rdi));
+ movp(rsi, FieldOperand(function, JSFunction::kContextOffset));
+ // Advances rdx to the end of the Code object header, to the start of
+ // the executable code.
+ movp(rdx, FieldOperand(rdi, JSFunction::kCodeEntryOffset));
+ InvokeCode(rdx, expected, actual, flag, call_wrapper);
+}
+
+
void MacroAssembler::InvokeCode(Register code,
const ParameterCount& expected,
const ParameterCount& actual,
@@ -3484,55 +4008,6 @@ void MacroAssembler::InvokeCode(Register code,
}
-void MacroAssembler::InvokeFunction(Register function,
- const ParameterCount& actual,
- InvokeFlag flag,
- const CallWrapper& call_wrapper) {
- // You can't call a function without a valid frame.
- DCHECK(flag == JUMP_FUNCTION || has_frame());
-
- DCHECK(function.is(rdi));
- movp(rdx, FieldOperand(function, JSFunction::kSharedFunctionInfoOffset));
- movp(rsi, FieldOperand(function, JSFunction::kContextOffset));
- LoadSharedFunctionInfoSpecialField(rbx, rdx,
- SharedFunctionInfo::kFormalParameterCountOffset);
- // Advances rdx to the end of the Code object header, to the start of
- // the executable code.
- movp(rdx, FieldOperand(rdi, JSFunction::kCodeEntryOffset));
-
- ParameterCount expected(rbx);
- InvokeCode(rdx, expected, actual, flag, call_wrapper);
-}
-
-
-void MacroAssembler::InvokeFunction(Register function,
- const ParameterCount& expected,
- const ParameterCount& actual,
- InvokeFlag flag,
- const CallWrapper& call_wrapper) {
- // You can't call a function without a valid frame.
- DCHECK(flag == JUMP_FUNCTION || has_frame());
-
- DCHECK(function.is(rdi));
- movp(rsi, FieldOperand(function, JSFunction::kContextOffset));
- // Advances rdx to the end of the Code object header, to the start of
- // the executable code.
- movp(rdx, FieldOperand(rdi, JSFunction::kCodeEntryOffset));
-
- InvokeCode(rdx, expected, actual, flag, call_wrapper);
-}
-
-
-void MacroAssembler::InvokeFunction(Handle<JSFunction> function,
- const ParameterCount& expected,
- const ParameterCount& actual,
- InvokeFlag flag,
- const CallWrapper& call_wrapper) {
- Move(rdi, function);
- InvokeFunction(rdi, expected, actual, flag, call_wrapper);
-}
-
-
void MacroAssembler::InvokePrologue(const ParameterCount& expected,
const ParameterCount& actual,
Handle<Code> code_constant,
@@ -3710,13 +4185,16 @@ void MacroAssembler::EnterExitFrameEpilogue(int arg_stack_space,
#endif
// Optionally save all XMM registers.
if (save_doubles) {
- int space = XMMRegister::kMaxNumAllocatableRegisters * kDoubleSize +
- arg_stack_space * kRegisterSize;
+ int space = XMMRegister::kMaxNumRegisters * kDoubleSize +
+ arg_stack_space * kRegisterSize;
subp(rsp, Immediate(space));
int offset = -2 * kPointerSize;
- for (int i = 0; i < XMMRegister::NumAllocatableRegisters(); i++) {
- XMMRegister reg = XMMRegister::FromAllocationIndex(i);
- movsd(Operand(rbp, offset - ((i + 1) * kDoubleSize)), reg);
+ const RegisterConfiguration* config =
+ RegisterConfiguration::ArchDefault(RegisterConfiguration::CRANKSHAFT);
+ for (int i = 0; i < config->num_allocatable_double_registers(); ++i) {
+ DoubleRegister reg =
+ DoubleRegister::from_code(config->GetAllocatableDoubleCode(i));
+ Movsd(Operand(rbp, offset - ((i + 1) * kDoubleSize)), reg);
}
} else if (arg_stack_space > 0) {
subp(rsp, Immediate(arg_stack_space * kRegisterSize));
@@ -3753,25 +4231,34 @@ void MacroAssembler::EnterApiExitFrame(int arg_stack_space) {
}
-void MacroAssembler::LeaveExitFrame(bool save_doubles) {
+void MacroAssembler::LeaveExitFrame(bool save_doubles, bool pop_arguments) {
// Registers:
// r15 : argv
if (save_doubles) {
int offset = -2 * kPointerSize;
- for (int i = 0; i < XMMRegister::NumAllocatableRegisters(); i++) {
- XMMRegister reg = XMMRegister::FromAllocationIndex(i);
- movsd(reg, Operand(rbp, offset - ((i + 1) * kDoubleSize)));
+ const RegisterConfiguration* config =
+ RegisterConfiguration::ArchDefault(RegisterConfiguration::CRANKSHAFT);
+ for (int i = 0; i < config->num_allocatable_double_registers(); ++i) {
+ DoubleRegister reg =
+ DoubleRegister::from_code(config->GetAllocatableDoubleCode(i));
+ Movsd(reg, Operand(rbp, offset - ((i + 1) * kDoubleSize)));
}
}
- // Get the return address from the stack and restore the frame pointer.
- movp(rcx, Operand(rbp, kFPOnStackSize));
- movp(rbp, Operand(rbp, 0 * kPointerSize));
- // Drop everything up to and including the arguments and the receiver
- // from the caller stack.
- leap(rsp, Operand(r15, 1 * kPointerSize));
+ if (pop_arguments) {
+ // Get the return address from the stack and restore the frame pointer.
+ movp(rcx, Operand(rbp, kFPOnStackSize));
+ movp(rbp, Operand(rbp, 0 * kPointerSize));
+
+ // Drop everything up to and including the arguments and the receiver
+ // from the caller stack.
+ leap(rsp, Operand(r15, 1 * kPointerSize));
- PushReturnAddressFrom(rcx);
+ PushReturnAddressFrom(rcx);
+ } else {
+ // Otherwise just leave the exit frame.
+ leave();
+ }
LeaveExitFrameEpilogue(true);
}
@@ -3823,7 +4310,7 @@ void MacroAssembler::CheckAccessGlobalProxy(Register holder_reg,
int offset =
Context::kHeaderSize + Context::GLOBAL_OBJECT_INDEX * kPointerSize;
movp(scratch, FieldOperand(scratch, offset));
- movp(scratch, FieldOperand(scratch, GlobalObject::kNativeContextOffset));
+ movp(scratch, FieldOperand(scratch, JSGlobalObject::kNativeContextOffset));
// Check the context is a native context.
if (emit_debug_code()) {
@@ -4481,7 +4968,7 @@ void MacroAssembler::LoadContext(Register dst, int context_chain_length) {
void MacroAssembler::LoadGlobalProxy(Register dst) {
movp(dst, GlobalObjectOperand());
- movp(dst, FieldOperand(dst, GlobalObject::kGlobalProxyOffset));
+ movp(dst, FieldOperand(dst, JSGlobalObject::kGlobalProxyOffset));
}
@@ -4494,7 +4981,7 @@ void MacroAssembler::LoadTransitionedArrayMapConditional(
// Load the global or builtins object from the current context.
movp(scratch,
Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
- movp(scratch, FieldOperand(scratch, GlobalObject::kNativeContextOffset));
+ movp(scratch, FieldOperand(scratch, JSGlobalObject::kNativeContextOffset));
// Check that the function's map is the same as the expected cached map.
movp(scratch, Operand(scratch,
@@ -4523,7 +5010,7 @@ void MacroAssembler::LoadGlobalFunction(int index, Register function) {
movp(function,
Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
// Load the native context from the global or builtins object.
- movp(function, FieldOperand(function, GlobalObject::kNativeContextOffset));
+ movp(function, FieldOperand(function, JSGlobalObject::kNativeContextOffset));
// Load the function from the native context.
movp(function, Operand(function, Context::SlotOffset(index)));
}
diff --git a/deps/v8/src/x64/macro-assembler-x64.h b/deps/v8/src/x64/macro-assembler-x64.h
index 1fca0e3594..c7f7f40778 100644
--- a/deps/v8/src/x64/macro-assembler-x64.h
+++ b/deps/v8/src/x64/macro-assembler-x64.h
@@ -16,17 +16,18 @@ namespace v8 {
namespace internal {
// Give alias names to registers for calling conventions.
-const Register kReturnRegister0 = {kRegister_rax_Code};
-const Register kReturnRegister1 = {kRegister_rdx_Code};
-const Register kJSFunctionRegister = {kRegister_rdi_Code};
-const Register kContextRegister = {kRegister_rsi_Code};
-const Register kInterpreterAccumulatorRegister = {kRegister_rax_Code};
-const Register kInterpreterRegisterFileRegister = {kRegister_r11_Code};
-const Register kInterpreterBytecodeOffsetRegister = {kRegister_r12_Code};
-const Register kInterpreterBytecodeArrayRegister = {kRegister_r14_Code};
-const Register kInterpreterDispatchTableRegister = {kRegister_r15_Code};
-const Register kRuntimeCallFunctionRegister = {kRegister_rbx_Code};
-const Register kRuntimeCallArgCountRegister = {kRegister_rax_Code};
+const Register kReturnRegister0 = {Register::kCode_rax};
+const Register kReturnRegister1 = {Register::kCode_rdx};
+const Register kJSFunctionRegister = {Register::kCode_rdi};
+const Register kContextRegister = {Register::kCode_rsi};
+const Register kInterpreterAccumulatorRegister = {Register::kCode_rax};
+const Register kInterpreterRegisterFileRegister = {Register::kCode_r11};
+const Register kInterpreterBytecodeOffsetRegister = {Register::kCode_r12};
+const Register kInterpreterBytecodeArrayRegister = {Register::kCode_r14};
+const Register kInterpreterDispatchTableRegister = {Register::kCode_r15};
+const Register kJavaScriptCallArgCountRegister = {Register::kCode_rax};
+const Register kRuntimeCallFunctionRegister = {Register::kCode_rbx};
+const Register kRuntimeCallArgCountRegister = {Register::kCode_rax};
// Default scratch register used by MacroAssembler (and other code that needs
// a spare register). The register isn't callee save, and not used by the
@@ -342,8 +343,8 @@ class MacroAssembler: public Assembler {
// Leave the current exit frame. Expects/provides the return value in
// register rax:rdx (untouched) and the pointer to the first
- // argument in register rsi.
- void LeaveExitFrame(bool save_doubles = false);
+ // argument in register rsi (if pop_arguments == true).
+ void LeaveExitFrame(bool save_doubles = false, bool pop_arguments = true);
// Leave the current exit frame. Expects/provides the return value in
// register rax (untouched).
@@ -806,12 +807,30 @@ class MacroAssembler: public Assembler {
void Set(Register dst, int64_t x);
void Set(const Operand& dst, intptr_t x);
+ void Cvtss2sd(XMMRegister dst, XMMRegister src);
+ void Cvtss2sd(XMMRegister dst, const Operand& src);
+ void Cvtsd2ss(XMMRegister dst, XMMRegister src);
+ void Cvtsd2ss(XMMRegister dst, const Operand& src);
+
// cvtsi2sd instruction only writes to the low 64-bit of dst register, which
// hinders register renaming and makes dependence chains longer. So we use
- // xorps to clear the dst register before cvtsi2sd to solve this issue.
+ // xorpd to clear the dst register before cvtsi2sd to solve this issue.
void Cvtlsi2sd(XMMRegister dst, Register src);
void Cvtlsi2sd(XMMRegister dst, const Operand& src);
+ void Cvtqsi2ss(XMMRegister dst, Register src);
+ void Cvtqsi2ss(XMMRegister dst, const Operand& src);
+
+ void Cvtqsi2sd(XMMRegister dst, Register src);
+ void Cvtqsi2sd(XMMRegister dst, const Operand& src);
+
+ void Cvtsd2si(Register dst, XMMRegister src);
+
+ void Cvttsd2si(Register dst, XMMRegister src);
+ void Cvttsd2si(Register dst, const Operand& src);
+ void Cvttsd2siq(Register dst, XMMRegister src);
+ void Cvttsd2siq(Register dst, const Operand& src);
+
// Move if the registers are not identical.
void Move(Register target, Register source);
@@ -894,6 +913,65 @@ class MacroAssembler: public Assembler {
void Move(XMMRegister dst, float src) { Move(dst, bit_cast<uint32_t>(src)); }
void Move(XMMRegister dst, double src) { Move(dst, bit_cast<uint64_t>(src)); }
+#define AVX_OP2_WITH_TYPE(macro_name, name, src_type) \
+ void macro_name(XMMRegister dst, src_type src) { \
+ if (CpuFeatures::IsSupported(AVX)) { \
+ CpuFeatureScope scope(this, AVX); \
+ v##name(dst, dst, src); \
+ } else { \
+ name(dst, src); \
+ } \
+ }
+#define AVX_OP2_X(macro_name, name) \
+ AVX_OP2_WITH_TYPE(macro_name, name, XMMRegister)
+#define AVX_OP2_O(macro_name, name) \
+ AVX_OP2_WITH_TYPE(macro_name, name, const Operand&)
+#define AVX_OP2_XO(macro_name, name) \
+ AVX_OP2_X(macro_name, name) \
+ AVX_OP2_O(macro_name, name)
+
+ AVX_OP2_XO(Addsd, addsd)
+ AVX_OP2_XO(Subsd, subsd)
+ AVX_OP2_XO(Mulsd, mulsd)
+ AVX_OP2_XO(Divsd, divsd)
+ AVX_OP2_X(Andpd, andpd)
+ AVX_OP2_X(Orpd, orpd)
+ AVX_OP2_X(Xorpd, xorpd)
+ AVX_OP2_X(Pcmpeqd, pcmpeqd)
+ AVX_OP2_WITH_TYPE(Psllq, psllq, byte)
+ AVX_OP2_WITH_TYPE(Psrlq, psrlq, byte)
+
+#undef AVX_OP2_O
+#undef AVX_OP2_X
+#undef AVX_OP2_XO
+#undef AVX_OP2_WITH_TYPE
+
+ void Movsd(XMMRegister dst, XMMRegister src);
+ void Movsd(XMMRegister dst, const Operand& src);
+ void Movsd(const Operand& dst, XMMRegister src);
+ void Movss(XMMRegister dst, XMMRegister src);
+ void Movss(XMMRegister dst, const Operand& src);
+ void Movss(const Operand& dst, XMMRegister src);
+
+ void Movd(XMMRegister dst, Register src);
+ void Movd(XMMRegister dst, const Operand& src);
+ void Movd(Register dst, XMMRegister src);
+ void Movq(XMMRegister dst, Register src);
+ void Movq(Register dst, XMMRegister src);
+
+ void Movaps(XMMRegister dst, XMMRegister src);
+ void Movapd(XMMRegister dst, XMMRegister src);
+ void Movmskpd(Register dst, XMMRegister src);
+
+ void Roundsd(XMMRegister dst, XMMRegister src, RoundingMode mode);
+ void Sqrtsd(XMMRegister dst, XMMRegister src);
+ void Sqrtsd(XMMRegister dst, const Operand& src);
+
+ void Ucomiss(XMMRegister src1, XMMRegister src2);
+ void Ucomiss(XMMRegister src1, const Operand& src2);
+ void Ucomisd(XMMRegister src1, XMMRegister src2);
+ void Ucomisd(XMMRegister src1, const Operand& src2);
+
// Control Flow
void Jump(Address destination, RelocInfo::Mode rmode);
void Jump(ExternalReference ext);
@@ -936,9 +1014,24 @@ class MacroAssembler: public Assembler {
void Pinsrd(XMMRegister dst, Register src, int8_t imm8);
void Pinsrd(XMMRegister dst, const Operand& src, int8_t imm8);
+ void Lzcntq(Register dst, Register src);
+ void Lzcntq(Register dst, const Operand& src);
+
void Lzcntl(Register dst, Register src);
void Lzcntl(Register dst, const Operand& src);
+ void Tzcntq(Register dst, Register src);
+ void Tzcntq(Register dst, const Operand& src);
+
+ void Tzcntl(Register dst, Register src);
+ void Tzcntl(Register dst, const Operand& src);
+
+ void Popcntl(Register dst, Register src);
+ void Popcntl(Register dst, const Operand& src);
+
+ void Popcntq(Register dst, Register src);
+ void Popcntq(Register dst, const Operand& src);
+
// Non-x64 instructions.
// Push/pop all general purpose registers.
// Does not push rsp/rbp nor any of the assembler's special purpose registers
@@ -1640,6 +1733,7 @@ extern void LogGeneratedCodeCoverage(const char* file_line);
#define ACCESS_MASM(masm) masm->
#endif
-} } // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_X64_MACRO_ASSEMBLER_X64_H_
diff --git a/deps/v8/src/x64/simulator-x64.h b/deps/v8/src/x64/simulator-x64.h
index 35cbdc7888..99649ec018 100644
--- a/deps/v8/src/x64/simulator-x64.h
+++ b/deps/v8/src/x64/simulator-x64.h
@@ -41,6 +41,7 @@ class SimulatorStack : public v8::internal::AllStatic {
static inline void UnregisterCTryCatch() { }
};
-} } // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_X64_SIMULATOR_X64_H_
View Lorry Controller Status