Merge V8 5.3.332.45. DO NOT MERGE
Test: Manual
FPIIM-449
Change-Id: Id3254828b068abdea3cb10442e0172a8c9a98e03
(cherry picked from commit 13e2dadd00298019ed862f2b2fc5068bba730bcf)
diff --git a/test/cctest/compiler/code-assembler-tester.h b/test/cctest/compiler/code-assembler-tester.h
new file mode 100644
index 0000000..609a137
--- /dev/null
+++ b/test/cctest/compiler/code-assembler-tester.h
@@ -0,0 +1,67 @@
+// Copyright 2016 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/handles.h"
+#include "src/interface-descriptors.h"
+#include "src/isolate.h"
+#include "test/cctest/compiler/function-tester.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class ZoneHolder {
+ public:
+ explicit ZoneHolder(Isolate* isolate) : zone_(isolate->allocator()) {}
+ Zone* zone() { return &zone_; }
+
+ private:
+ Zone zone_;
+};
+
+// Inherit from ZoneHolder in order to create a zone that can be passed to
+// CodeAssembler base class constructor.
+template <typename CodeAssemblerT>
+class CodeAssemblerTesterImpl : private ZoneHolder, public CodeAssemblerT {
+ public:
+ // Test generating code for a stub.
+ CodeAssemblerTesterImpl(Isolate* isolate,
+ const CallInterfaceDescriptor& descriptor)
+ : ZoneHolder(isolate),
+ CodeAssemblerT(isolate, ZoneHolder::zone(), descriptor,
+ Code::ComputeFlags(Code::STUB), "test"),
+ scope_(isolate) {}
+
+ // Test generating code for a JS function (e.g. builtins).
+ CodeAssemblerTesterImpl(Isolate* isolate, int parameter_count)
+ : ZoneHolder(isolate),
+ CodeAssemblerT(isolate, ZoneHolder::zone(), parameter_count,
+ Code::ComputeFlags(Code::FUNCTION), "test"),
+ scope_(isolate) {}
+
+ // This constructor is intended to be used for creating code objects with
+ // specific flags.
+ CodeAssemblerTesterImpl(Isolate* isolate, Code::Flags flags)
+ : ZoneHolder(isolate),
+ CodeAssemblerT(isolate, ZoneHolder::zone(), 0, flags, "test"),
+ scope_(isolate) {}
+
+ Handle<Code> GenerateCodeCloseAndEscape() {
+ return scope_.CloseAndEscape(CodeAssemblerT::GenerateCode());
+ }
+
+ // Expose some internal methods.
+
+ Node* SmiShiftBitsConstant() {
+ return CodeAssemblerT::SmiShiftBitsConstant();
+ }
+
+ private:
+ HandleScope scope_;
+ LocalContext context_;
+};
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
diff --git a/test/cctest/compiler/codegen-tester.h b/test/cctest/compiler/codegen-tester.h
index dbb9a72..3450c3a 100644
--- a/test/cctest/compiler/codegen-tester.h
+++ b/test/cctest/compiler/codegen-tester.h
@@ -256,7 +256,7 @@
// parameters from memory. Thereby it is possible to pass 64 bit parameters
// to the IR graph.
Node* Parameter(size_t index) {
- CHECK(index >= 0 && index < 4);
+ CHECK(index < 4);
return parameter_nodes_[index];
}
diff --git a/test/cctest/compiler/function-tester.h b/test/cctest/compiler/function-tester.h
index 555e049..c7304f1 100644
--- a/test/cctest/compiler/function-tester.h
+++ b/test/cctest/compiler/function-tester.h
@@ -42,16 +42,18 @@
CompileGraph(graph);
}
- FunctionTester(const CallInterfaceDescriptor& descriptor, Handle<Code> code)
+ FunctionTester(Handle<Code> code, int param_count)
: isolate(main_isolate()),
- function(
- (FLAG_allow_natives_syntax = true,
- NewFunction(BuildFunctionFromDescriptor(descriptor).c_str()))),
+ function((FLAG_allow_natives_syntax = true,
+ NewFunction(BuildFunction(param_count).c_str()))),
flags_(0) {
Compile(function);
function->ReplaceCode(*code);
}
+ FunctionTester(const CallInterfaceDescriptor& descriptor, Handle<Code> code)
+ : FunctionTester(code, descriptor.GetParameterCount()) {}
+
Isolate* isolate;
Handle<JSFunction> function;
@@ -59,11 +61,22 @@
return Execution::Call(isolate, function, undefined(), 0, nullptr);
}
+ MaybeHandle<Object> Call(Handle<Object> a) {
+ Handle<Object> args[] = {a};
+ return Execution::Call(isolate, function, undefined(), 1, args);
+ }
+
MaybeHandle<Object> Call(Handle<Object> a, Handle<Object> b) {
Handle<Object> args[] = {a, b};
return Execution::Call(isolate, function, undefined(), 2, args);
}
+ MaybeHandle<Object> Call(Handle<Object> a, Handle<Object> b,
+ Handle<Object> c) {
+ Handle<Object> args[] = {a, b, c};
+ return Execution::Call(isolate, function, undefined(), 3, args);
+ }
+
MaybeHandle<Object> Call(Handle<Object> a, Handle<Object> b, Handle<Object> c,
Handle<Object> d) {
Handle<Object> args[] = {a, b, c, d};
@@ -91,41 +104,56 @@
return try_catch.Message();
}
- void CheckCall(Handle<Object> expected, Handle<Object> a, Handle<Object> b) {
- Handle<Object> result = Call(a, b).ToHandleChecked();
+ void CheckCall(Handle<Object> expected, Handle<Object> a, Handle<Object> b,
+ Handle<Object> c, Handle<Object> d) {
+ Handle<Object> result = Call(a, b, c, d).ToHandleChecked();
CHECK(expected->SameValue(*result));
}
+ void CheckCall(Handle<Object> expected, Handle<Object> a, Handle<Object> b,
+ Handle<Object> c) {
+ return CheckCall(expected, a, b, c, undefined());
+ }
+
+ void CheckCall(Handle<Object> expected, Handle<Object> a, Handle<Object> b) {
+ return CheckCall(expected, a, b, undefined());
+ }
+
void CheckCall(Handle<Object> expected, Handle<Object> a) {
CheckCall(expected, a, undefined());
}
- void CheckCall(Handle<Object> expected) {
- CheckCall(expected, undefined(), undefined());
- }
+ void CheckCall(Handle<Object> expected) { CheckCall(expected, undefined()); }
void CheckCall(double expected, double a, double b) {
CheckCall(Val(expected), Val(a), Val(b));
}
+ void CheckTrue(Handle<Object> a) { CheckCall(true_value(), a); }
+
void CheckTrue(Handle<Object> a, Handle<Object> b) {
CheckCall(true_value(), a, b);
}
- void CheckTrue(Handle<Object> a) { CheckCall(true_value(), a, undefined()); }
+ void CheckTrue(Handle<Object> a, Handle<Object> b, Handle<Object> c) {
+ CheckCall(true_value(), a, b, c);
+ }
+
+ void CheckTrue(Handle<Object> a, Handle<Object> b, Handle<Object> c,
+ Handle<Object> d) {
+ CheckCall(true_value(), a, b, c, d);
+ }
void CheckTrue(double a, double b) {
CheckCall(true_value(), Val(a), Val(b));
}
+ void CheckFalse(Handle<Object> a) { CheckCall(false_value(), a); }
+
void CheckFalse(Handle<Object> a, Handle<Object> b) {
CheckCall(false_value(), a, b);
}
- void CheckFalse(Handle<Object> a) {
- CheckCall(false_value(), a, undefined());
- }
-
void CheckFalse(double a, double b) {
CheckCall(false_value(), Val(a), Val(b));
}
@@ -194,6 +222,7 @@
CHECK(Compiler::Analyze(info.parse_info()));
CHECK(Compiler::EnsureDeoptimizationSupport(&info));
}
+ JSFunction::EnsureLiterals(function);
Handle<Code> code = Pipeline::GenerateCodeForTesting(&info);
CHECK(!code.is_null());
@@ -216,11 +245,6 @@
return function_string;
}
- std::string BuildFunctionFromDescriptor(
- const CallInterfaceDescriptor& descriptor) {
- return BuildFunction(descriptor.GetParameterCount());
- }
-
// Compile the given machine graph instead of the source of the function
// and replace the JSFunction's code with the result.
Handle<JSFunction> CompileGraph(Graph* graph) {
diff --git a/test/cctest/compiler/test-code-stub-assembler.cc b/test/cctest/compiler/test-code-assembler.cc
similarity index 60%
rename from test/cctest/compiler/test-code-stub-assembler.cc
rename to test/cctest/compiler/test-code-assembler.cc
index 37ba9e9..7f27a6f 100644
--- a/test/cctest/compiler/test-code-stub-assembler.cc
+++ b/test/cctest/compiler/test-code-assembler.cc
@@ -2,52 +2,54 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/interface-descriptors.h"
+#include "src/compiler/code-assembler.h"
#include "src/isolate.h"
+#include "test/cctest/compiler/code-assembler-tester.h"
#include "test/cctest/compiler/function-tester.h"
namespace v8 {
namespace internal {
namespace compiler {
+typedef CodeAssemblerTesterImpl<CodeAssembler> CodeAssemblerTester;
-class CodeStubAssemblerTester : public CodeStubAssembler {
- public:
- // Test generating code for a stub.
- CodeStubAssemblerTester(Isolate* isolate,
- const CallInterfaceDescriptor& descriptor)
- : CodeStubAssembler(isolate, isolate->runtime_zone(), descriptor,
- Code::ComputeFlags(Code::STUB), "test"),
- scope_(isolate) {}
+namespace {
- // Test generating code for a JS function (e.g. builtins).
- CodeStubAssemblerTester(Isolate* isolate, int parameter_count)
- : CodeStubAssembler(isolate, isolate->runtime_zone(), parameter_count,
- Code::ComputeFlags(Code::FUNCTION), "test"),
- scope_(isolate) {}
+Node* SmiTag(CodeAssemblerTester& m, Node* value) {
+ int32_t constant_value;
+ if (m.ToInt32Constant(value, constant_value) &&
+ Smi::IsValid(constant_value)) {
+ return m.SmiConstant(Smi::FromInt(constant_value));
+ }
+ return m.WordShl(value, m.SmiShiftBitsConstant());
+}
- private:
- HandleScope scope_;
- LocalContext context_;
-};
+Node* UndefinedConstant(CodeAssemblerTester& m) {
+ return m.LoadRoot(Heap::kUndefinedValueRootIndex);
+}
+Node* LoadObjectField(CodeAssemblerTester& m, Node* object, int offset,
+ MachineType rep = MachineType::AnyTagged()) {
+ return m.Load(rep, object, m.IntPtrConstant(offset - kHeapObjectTag));
+}
+
+} // namespace
TEST(SimpleSmiReturn) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
- m.Return(m.SmiTag(m.Int32Constant(37)));
+ CodeAssemblerTester m(isolate, descriptor);
+ m.Return(SmiTag(m, m.Int32Constant(37)));
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
MaybeHandle<Object> result = ft.Call();
CHECK_EQ(37, Handle<Smi>::cast(result.ToHandleChecked())->value());
}
-
TEST(SimpleIntPtrReturn) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
int test;
m.Return(m.IntPtrConstant(reinterpret_cast<intptr_t>(&test)));
Handle<Code> code = m.GenerateCode();
@@ -57,11 +59,10 @@
reinterpret_cast<intptr_t>(*result.ToHandleChecked()));
}
-
TEST(SimpleDoubleReturn) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
m.Return(m.NumberConstant(0.5));
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
@@ -69,13 +70,12 @@
CHECK_EQ(0.5, Handle<HeapNumber>::cast(result.ToHandleChecked())->value());
}
-
TEST(SimpleCallRuntime1Arg) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
Node* context = m.HeapConstant(Handle<Context>(isolate->native_context()));
- Node* b = m.SmiTag(m.Int32Constant(0));
+ Node* b = SmiTag(m, m.Int32Constant(0));
m.Return(m.CallRuntime(Runtime::kNumberToSmi, context, b));
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
@@ -83,13 +83,12 @@
CHECK_EQ(0, Handle<Smi>::cast(result.ToHandleChecked())->value());
}
-
TEST(SimpleTailCallRuntime1Arg) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
Node* context = m.HeapConstant(Handle<Context>(isolate->native_context()));
- Node* b = m.SmiTag(m.Int32Constant(0));
+ Node* b = SmiTag(m, m.Int32Constant(0));
m.TailCallRuntime(Runtime::kNumberToSmi, context, b);
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
@@ -97,14 +96,13 @@
CHECK_EQ(0, Handle<Smi>::cast(result.ToHandleChecked())->value());
}
-
TEST(SimpleCallRuntime2Arg) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
Node* context = m.HeapConstant(Handle<Context>(isolate->native_context()));
- Node* a = m.SmiTag(m.Int32Constant(2));
- Node* b = m.SmiTag(m.Int32Constant(4));
+ Node* a = SmiTag(m, m.Int32Constant(2));
+ Node* b = SmiTag(m, m.Int32Constant(4));
m.Return(m.CallRuntime(Runtime::kMathPow, context, a, b));
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
@@ -112,14 +110,13 @@
CHECK_EQ(16, Handle<Smi>::cast(result.ToHandleChecked())->value());
}
-
TEST(SimpleTailCallRuntime2Arg) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
Node* context = m.HeapConstant(Handle<Context>(isolate->native_context()));
- Node* a = m.SmiTag(m.Int32Constant(2));
- Node* b = m.SmiTag(m.Int32Constant(4));
+ Node* a = SmiTag(m, m.Int32Constant(2));
+ Node* b = SmiTag(m, m.Int32Constant(4));
m.TailCallRuntime(Runtime::kMathPow, context, a, b);
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
@@ -127,10 +124,95 @@
CHECK_EQ(16, Handle<Smi>::cast(result.ToHandleChecked())->value());
}
+namespace {
+
+Handle<JSFunction> CreateSumAllArgumentsFunction(FunctionTester& ft) {
+ const char* source =
+ "(function() {\n"
+ " var sum = 0 + this;\n"
+ " for (var i = 0; i < arguments.length; i++) {\n"
+ " sum += arguments[i];\n"
+ " }\n"
+ " return sum;\n"
+ "})";
+ return ft.NewFunction(source);
+}
+
+} // namespace
+
+TEST(SimpleCallJSFunction0Arg) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ const int kNumParams = 1;
+ CodeAssemblerTester m(isolate, kNumParams);
+ {
+ Node* function = m.Parameter(0);
+ Node* context = m.Parameter(kNumParams + 2);
+
+ Node* receiver = SmiTag(m, m.Int32Constant(42));
+
+ Callable callable = CodeFactory::Call(isolate);
+ Node* result = m.CallJS(callable, context, function, receiver);
+ m.Return(result);
+ }
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Handle<JSFunction> sum = CreateSumAllArgumentsFunction(ft);
+ MaybeHandle<Object> result = ft.Call(sum);
+ CHECK_EQ(Smi::FromInt(42), *result.ToHandleChecked());
+}
+
+TEST(SimpleCallJSFunction1Arg) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ const int kNumParams = 2;
+ CodeAssemblerTester m(isolate, kNumParams);
+ {
+ Node* function = m.Parameter(0);
+ Node* context = m.Parameter(1);
+
+ Node* receiver = SmiTag(m, m.Int32Constant(42));
+ Node* a = SmiTag(m, m.Int32Constant(13));
+
+ Callable callable = CodeFactory::Call(isolate);
+ Node* result = m.CallJS(callable, context, function, receiver, a);
+ m.Return(result);
+ }
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Handle<JSFunction> sum = CreateSumAllArgumentsFunction(ft);
+ MaybeHandle<Object> result = ft.Call(sum);
+ CHECK_EQ(Smi::FromInt(55), *result.ToHandleChecked());
+}
+
+TEST(SimpleCallJSFunction2Arg) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ const int kNumParams = 2;
+ CodeAssemblerTester m(isolate, kNumParams);
+ {
+ Node* function = m.Parameter(0);
+ Node* context = m.Parameter(1);
+
+ Node* receiver = SmiTag(m, m.Int32Constant(42));
+ Node* a = SmiTag(m, m.Int32Constant(13));
+ Node* b = SmiTag(m, m.Int32Constant(153));
+
+ Callable callable = CodeFactory::Call(isolate);
+ Node* result = m.CallJS(callable, context, function, receiver, a, b);
+ m.Return(result);
+ }
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Handle<JSFunction> sum = CreateSumAllArgumentsFunction(ft);
+ MaybeHandle<Object> result = ft.Call(sum);
+ CHECK_EQ(Smi::FromInt(208), *result.ToHandleChecked());
+}
+
TEST(VariableMerge1) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged);
CodeStubAssembler::Label l1(&m), l2(&m), merge(&m);
Node* temp = m.Int32Constant(0);
@@ -149,7 +231,7 @@
TEST(VariableMerge2) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged);
CodeStubAssembler::Label l1(&m), l2(&m), merge(&m);
Node* temp = m.Int32Constant(0);
@@ -170,7 +252,7 @@
TEST(VariableMerge3) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged);
CodeStubAssembler::Variable var2(&m, MachineRepresentation::kTagged);
CodeStubAssembler::Label l1(&m), l2(&m), merge(&m);
@@ -195,7 +277,7 @@
TEST(VariableMergeBindFirst) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged);
CodeStubAssembler::Label l1(&m), l2(&m), merge(&m, &var1), end(&m);
Node* temp = m.Int32Constant(0);
@@ -221,7 +303,7 @@
TEST(VariableMergeSwitch) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged);
CodeStubAssembler::Label l1(&m), l2(&m), default_label(&m);
CodeStubAssembler::Label* labels[] = {&l1, &l2};
@@ -240,102 +322,10 @@
m.Return(temp);
}
-TEST(FixedArrayAccessSmiIndex) {
- Isolate* isolate(CcTest::InitIsolateOnce());
- VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
- Handle<FixedArray> array = isolate->factory()->NewFixedArray(5);
- array->set(4, Smi::FromInt(733));
- m.Return(m.LoadFixedArrayElement(m.HeapConstant(array),
- m.SmiTag(m.Int32Constant(4)), 0,
- CodeStubAssembler::SMI_PARAMETERS));
- Handle<Code> code = m.GenerateCode();
- FunctionTester ft(descriptor, code);
- MaybeHandle<Object> result = ft.Call();
- CHECK_EQ(733, Handle<Smi>::cast(result.ToHandleChecked())->value());
-}
-
-TEST(LoadHeapNumberValue) {
- Isolate* isolate(CcTest::InitIsolateOnce());
- VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
- Handle<HeapNumber> number = isolate->factory()->NewHeapNumber(1234);
- m.Return(m.SmiTag(
- m.ChangeFloat64ToUint32(m.LoadHeapNumberValue(m.HeapConstant(number)))));
- Handle<Code> code = m.GenerateCode();
- FunctionTester ft(descriptor, code);
- MaybeHandle<Object> result = ft.Call();
- CHECK_EQ(1234, Handle<Smi>::cast(result.ToHandleChecked())->value());
-}
-
-TEST(LoadInstanceType) {
- Isolate* isolate(CcTest::InitIsolateOnce());
- VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
- Handle<HeapObject> undefined = isolate->factory()->undefined_value();
- m.Return(m.SmiTag(m.LoadInstanceType(m.HeapConstant(undefined))));
- Handle<Code> code = m.GenerateCode();
- FunctionTester ft(descriptor, code);
- MaybeHandle<Object> result = ft.Call();
- CHECK_EQ(InstanceType::ODDBALL_TYPE,
- Handle<Smi>::cast(result.ToHandleChecked())->value());
-}
-
-namespace {
-
-class TestBitField : public BitField<unsigned, 3, 3> {};
-
-} // namespace
-
-TEST(BitFieldDecode) {
- Isolate* isolate(CcTest::InitIsolateOnce());
- VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
- m.Return(m.SmiTag(m.BitFieldDecode<TestBitField>(m.Int32Constant(0x2f))));
- Handle<Code> code = m.GenerateCode();
- FunctionTester ft(descriptor, code);
- MaybeHandle<Object> result = ft.Call();
- // value = 00101111
- // mask = 00111000
- // result = 101
- CHECK_EQ(5, Handle<Smi>::cast(result.ToHandleChecked())->value());
-}
-
-namespace {
-
-Handle<JSFunction> CreateFunctionFromCode(int parameter_count_with_receiver,
- Handle<Code> code) {
- Isolate* isolate = code->GetIsolate();
- Handle<String> name = isolate->factory()->InternalizeUtf8String("test");
- Handle<JSFunction> function =
- isolate->factory()->NewFunctionWithoutPrototype(name, code);
- function->shared()->set_internal_formal_parameter_count(
- parameter_count_with_receiver - 1); // Implicit undefined receiver.
- return function;
-}
-
-} // namespace
-
-TEST(JSFunction) {
- const int kNumParams = 3; // Receiver, left, right.
- Isolate* isolate(CcTest::InitIsolateOnce());
- CodeStubAssemblerTester m(isolate, kNumParams);
- m.Return(m.SmiTag(m.Int32Add(m.SmiToWord32(m.Parameter(1)),
- m.SmiToWord32(m.Parameter(2)))));
- Handle<Code> code = m.GenerateCode();
- Handle<JSFunction> function = CreateFunctionFromCode(kNumParams, code);
- Handle<Object> args[] = {Handle<Smi>(Smi::FromInt(23), isolate),
- Handle<Smi>(Smi::FromInt(34), isolate)};
- MaybeHandle<Object> result =
- Execution::Call(isolate, function, isolate->factory()->undefined_value(),
- arraysize(args), args);
- CHECK_EQ(57, Handle<Smi>::cast(result.ToHandleChecked())->value());
-}
-
TEST(SplitEdgeBranchMerge) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Label l1(&m), merge(&m);
m.Branch(m.Int32Constant(1), &l1, &merge);
m.Bind(&l1);
@@ -347,7 +337,7 @@
TEST(SplitEdgeSwitchMerge) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Label l1(&m), l2(&m), l3(&m), default_label(&m);
CodeStubAssembler::Label* labels[] = {&l1, &l2};
int32_t values[] = {1, 2};
@@ -365,7 +355,7 @@
TEST(TestToConstant) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
int32_t value32;
int64_t value64;
Node* a = m.Int32Constant(5);
@@ -380,15 +370,69 @@
CHECK(m.ToInt32Constant(a, value32));
CHECK(m.ToInt64Constant(a, value64));
- a = m.UndefinedConstant();
+ a = UndefinedConstant(m);
CHECK(!m.ToInt32Constant(a, value32));
CHECK(!m.ToInt64Constant(a, value64));
- a = m.UndefinedConstant();
+ a = UndefinedConstant(m);
CHECK(!m.ToInt32Constant(a, value32));
CHECK(!m.ToInt64Constant(a, value64));
}
+TEST(DeferredCodePhiHints) {
+ typedef compiler::Node Node;
+ typedef CodeStubAssembler::Label Label;
+ typedef CodeStubAssembler::Variable Variable;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ VoidDescriptor descriptor(isolate);
+ CodeAssemblerTester m(isolate, descriptor);
+ Label block1(&m, Label::kDeferred);
+ m.Goto(&block1);
+ m.Bind(&block1);
+ {
+ Variable var_object(&m, MachineRepresentation::kTagged);
+ Label loop(&m, &var_object);
+ var_object.Bind(m.IntPtrConstant(0));
+ m.Goto(&loop);
+ m.Bind(&loop);
+ {
+ Node* map = LoadObjectField(m, var_object.value(), JSObject::kMapOffset);
+ var_object.Bind(map);
+ m.Goto(&loop);
+ }
+ }
+ CHECK(!m.GenerateCode().is_null());
+}
+
+TEST(TestOutOfScopeVariable) {
+ typedef CodeStubAssembler::Label Label;
+ typedef CodeStubAssembler::Variable Variable;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ VoidDescriptor descriptor(isolate);
+ CodeAssemblerTester m(isolate, descriptor);
+ Label block1(&m);
+ Label block2(&m);
+ Label block3(&m);
+ Label block4(&m);
+ m.Branch(m.WordEqual(m.Parameter(0), m.IntPtrConstant(0)), &block1, &block4);
+ m.Bind(&block4);
+ {
+ Variable var_object(&m, MachineRepresentation::kTagged);
+ m.Branch(m.WordEqual(m.Parameter(0), m.IntPtrConstant(0)), &block2,
+ &block3);
+
+ m.Bind(&block2);
+ var_object.Bind(m.IntPtrConstant(55));
+ m.Goto(&block1);
+
+ m.Bind(&block3);
+ var_object.Bind(m.IntPtrConstant(66));
+ m.Goto(&block1);
+ }
+ m.Bind(&block1);
+ CHECK(!m.GenerateCode().is_null());
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
diff --git a/test/cctest/compiler/test-gap-resolver.cc b/test/cctest/compiler/test-gap-resolver.cc
index 9781aeb..8d0ca8b 100644
--- a/test/cctest/compiler/test-gap-resolver.cc
+++ b/test/cctest/compiler/test-gap-resolver.cc
@@ -116,9 +116,7 @@
InstructionOperand source = FromKey(it->first);
InstructionOperand destination = FromKey(it->second);
MoveOperands mo(source, destination);
- PrintableMoveOperands pmo = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN),
- &mo};
+ PrintableMoveOperands pmo = {RegisterConfiguration::Turbofan(), &mo};
os << pmo;
}
return os;
@@ -167,8 +165,10 @@
ParallelMove* Create(int size) {
ParallelMove* parallel_move = new (main_zone()) ParallelMove(main_zone());
std::set<InstructionOperand, CompareOperandModuloType> seen;
+ MachineRepresentation rep = RandomRepresentation();
for (int i = 0; i < size; ++i) {
- MoveOperands mo(CreateRandomOperand(true), CreateRandomOperand(false));
+ MoveOperands mo(CreateRandomOperand(true, rep),
+ CreateRandomOperand(false, rep));
if (!mo.IsRedundant() && seen.find(mo.destination()) == seen.end()) {
parallel_move->AddMove(mo.source(), mo.destination());
seen.insert(mo.destination());
@@ -179,52 +179,54 @@
private:
MachineRepresentation RandomRepresentation() {
- int index = rng_->NextInt(3);
+ int index = rng_->NextInt(5);
switch (index) {
case 0:
return MachineRepresentation::kWord32;
case 1:
return MachineRepresentation::kWord64;
case 2:
+ return MachineRepresentation::kFloat32;
+ case 3:
+ return MachineRepresentation::kFloat64;
+ case 4:
return MachineRepresentation::kTagged;
}
UNREACHABLE();
return MachineRepresentation::kNone;
}
- MachineRepresentation RandomDoubleRepresentation() {
- int index = rng_->NextInt(2);
- if (index == 0) return MachineRepresentation::kFloat64;
- return MachineRepresentation::kFloat32;
- }
+ InstructionOperand CreateRandomOperand(bool is_source,
+ MachineRepresentation rep) {
+ auto conf = RegisterConfiguration::Turbofan();
+ auto GetRegisterCode = [&conf](MachineRepresentation rep, int index) {
+ switch (rep) {
+ case MachineRepresentation::kFloat32:
+ case MachineRepresentation::kFloat64:
+ return conf->RegisterConfiguration::GetAllocatableDoubleCode(index);
+ break;
- InstructionOperand CreateRandomOperand(bool is_source) {
+ default:
+ return conf->RegisterConfiguration::GetAllocatableGeneralCode(index);
+ break;
+ }
+ UNREACHABLE();
+ return static_cast<int>(Register::kCode_no_reg);
+ };
int index = rng_->NextInt(7);
// destination can't be Constant.
- switch (rng_->NextInt(is_source ? 7 : 6)) {
+ switch (rng_->NextInt(is_source ? 5 : 4)) {
case 0:
- return AllocatedOperand(LocationOperand::STACK_SLOT,
- RandomRepresentation(), index);
+ return AllocatedOperand(LocationOperand::STACK_SLOT, rep, index);
case 1:
- return AllocatedOperand(LocationOperand::STACK_SLOT,
- RandomDoubleRepresentation(), index);
+ return AllocatedOperand(LocationOperand::REGISTER, rep, index);
case 2:
- return AllocatedOperand(LocationOperand::REGISTER,
- RandomRepresentation(), index);
+ return ExplicitOperand(LocationOperand::REGISTER, rep,
+ GetRegisterCode(rep, 1));
case 3:
- return AllocatedOperand(LocationOperand::REGISTER,
- RandomDoubleRepresentation(), index);
+ return ExplicitOperand(LocationOperand::STACK_SLOT, rep,
+ GetRegisterCode(rep, index));
case 4:
- return ExplicitOperand(
- LocationOperand::REGISTER, RandomRepresentation(),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(1));
- case 5:
- return ExplicitOperand(
- LocationOperand::STACK_SLOT, RandomRepresentation(),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(index));
- case 6:
return ConstantOperand(index);
}
UNREACHABLE();
diff --git a/test/cctest/compiler/test-js-context-specialization.cc b/test/cctest/compiler/test-js-context-specialization.cc
index c7cd47a..e9bf064 100644
--- a/test/cctest/compiler/test-js-context-specialization.cc
+++ b/test/cctest/compiler/test-js-context-specialization.cc
@@ -186,81 +186,6 @@
}
-// TODO(titzer): factor out common code with effects checking in typed lowering.
-static void CheckEffectInput(Node* effect, Node* use) {
- CHECK_EQ(effect, NodeProperties::GetEffectInput(use));
-}
-
-
-TEST(SpecializeToContext) {
- ContextSpecializationTester t;
-
- Node* start = t.graph()->NewNode(t.common()->Start(0));
- t.graph()->SetStart(start);
-
- // Make a context and initialize it a bit for this test.
- Handle<Context> native = t.factory()->NewNativeContext();
- Handle<Object> expected = t.factory()->InternalizeUtf8String("gboy!");
- const int slot = Context::NATIVE_CONTEXT_INDEX;
- native->set(slot, *expected);
-
- Node* const_context = t.jsgraph()->Constant(native);
- Node* param_context = t.graph()->NewNode(t.common()->Parameter(0), start);
-
- {
- // Check that specialization replaces values and forwards effects
- // correctly, and folds values from constant and non-constant contexts
- Node* effect_in = start;
- Node* load = t.graph()->NewNode(t.javascript()->LoadContext(0, slot, true),
- const_context, const_context, effect_in);
-
-
- Node* value_use =
- t.graph()->NewNode(t.simplified()->ChangeTaggedToInt32(), load);
- Node* other_load =
- t.graph()->NewNode(t.javascript()->LoadContext(0, slot, true),
- param_context, param_context, load);
- Node* effect_use = other_load;
- Node* other_use =
- t.graph()->NewNode(t.simplified()->ChangeTaggedToInt32(), other_load);
-
- Node* add = t.graph()->NewNode(
- t.javascript()->Add(BinaryOperationHints::Any()), value_use, other_use,
- param_context, t.jsgraph()->EmptyFrameState(),
- t.jsgraph()->EmptyFrameState(), other_load, start);
-
- Node* ret =
- t.graph()->NewNode(t.common()->Return(), add, effect_use, start);
- Node* end = t.graph()->NewNode(t.common()->End(1), ret);
- USE(end);
- t.graph()->SetEnd(end);
-
- // Double check the above graph is what we expect, or the test is broken.
- CheckEffectInput(effect_in, load);
- CheckEffectInput(load, effect_use);
-
- // Perform the reduction on the entire graph.
- GraphReducer graph_reducer(t.main_zone(), t.graph());
- JSContextSpecialization spec(&graph_reducer, t.jsgraph(),
- MaybeHandle<Context>());
- graph_reducer.AddReducer(&spec);
- graph_reducer.ReduceGraph();
-
- // Effects should have been forwarded (not replaced with a value).
- CheckEffectInput(effect_in, effect_use);
-
- // Use of {other_load} should not have been replaced.
- CHECK_EQ(other_load, other_use->InputAt(0));
-
- Node* replacement = value_use->InputAt(0);
- HeapObjectMatcher match(replacement);
- CHECK(match.HasValue());
- CHECK_EQ(*expected, *match.Value());
- }
- // TODO(titzer): clean up above test and test more complicated effects.
-}
-
-
TEST(SpecializeJSFunction_ToConstant1) {
FunctionTester T(
"(function() { var x = 1; function inc(a)"
@@ -300,10 +225,14 @@
FunctionTester T(
"(function() { if (false) { var x = 1; } function inc(a)"
" { return x; } return inc; })()"); // x is undefined!
-
- CHECK(T.Call(T.Val(0.0), T.Val(0.0)).ToHandleChecked()->IsUndefined());
- CHECK(T.Call(T.Val(2.0), T.Val(0.0)).ToHandleChecked()->IsUndefined());
- CHECK(T.Call(T.Val(-2.1), T.Val(0.0)).ToHandleChecked()->IsUndefined());
+ i::Isolate* isolate = CcTest::i_isolate();
+ CHECK(
+ T.Call(T.Val(0.0), T.Val(0.0)).ToHandleChecked()->IsUndefined(isolate));
+ CHECK(
+ T.Call(T.Val(2.0), T.Val(0.0)).ToHandleChecked()->IsUndefined(isolate));
+ CHECK(T.Call(T.Val(-2.1), T.Val(0.0))
+ .ToHandleChecked()
+ ->IsUndefined(isolate));
}
{
diff --git a/test/cctest/compiler/test-js-typed-lowering.cc b/test/cctest/compiler/test-js-typed-lowering.cc
index 0075de5..0dac0da 100644
--- a/test/cctest/compiler/test-js-typed-lowering.cc
+++ b/test/cctest/compiler/test-js-typed-lowering.cc
@@ -47,7 +47,8 @@
Graph graph;
Typer typer;
Node* context_node;
- BinaryOperationHints const hints = BinaryOperationHints::Any();
+ BinaryOperationHints const binop_hints = BinaryOperationHints::Any();
+ CompareOperationHints const compare_hints = CompareOperationHints::Any();
Node* Parameter(Type* t, int32_t index = 0) {
Node* n = graph.NewNode(common.Parameter(index), graph.start());
@@ -255,11 +256,11 @@
TEST(NumberBinops) {
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.Add(R.hints), R.simplified.NumberAdd(),
- R.javascript.Subtract(R.hints), R.simplified.NumberSubtract(),
- R.javascript.Multiply(R.hints), R.simplified.NumberMultiply(),
- R.javascript.Divide(R.hints), R.simplified.NumberDivide(),
- R.javascript.Modulus(R.hints), R.simplified.NumberModulus(),
+ R.javascript.Add(R.binop_hints), R.simplified.NumberAdd(),
+ R.javascript.Subtract(R.binop_hints), R.simplified.NumberSubtract(),
+ R.javascript.Multiply(R.binop_hints), R.simplified.NumberMultiply(),
+ R.javascript.Divide(R.binop_hints), R.simplified.NumberDivide(),
+ R.javascript.Modulus(R.binop_hints), R.simplified.NumberModulus(),
};
for (size_t i = 0; i < arraysize(kNumberTypes); ++i) {
@@ -301,11 +302,11 @@
public:
JSBitwiseShiftTypedLoweringTester() : JSTypedLoweringTester() {
int i = 0;
- set(i++, javascript.ShiftLeft(hints), true);
+ set(i++, javascript.ShiftLeft(binop_hints), true);
set(i++, simplified.NumberShiftLeft(), false);
- set(i++, javascript.ShiftRight(hints), true);
+ set(i++, javascript.ShiftRight(binop_hints), true);
set(i++, simplified.NumberShiftRight(), false);
- set(i++, javascript.ShiftRightLogical(hints), false);
+ set(i++, javascript.ShiftRightLogical(binop_hints), false);
set(i++, simplified.NumberShiftRightLogical(), false);
}
static const int kNumberOps = 6;
@@ -357,11 +358,11 @@
public:
JSBitwiseTypedLoweringTester() : JSTypedLoweringTester() {
int i = 0;
- set(i++, javascript.BitwiseOr(hints), true);
+ set(i++, javascript.BitwiseOr(binop_hints), true);
set(i++, simplified.NumberBitwiseOr(), true);
- set(i++, javascript.BitwiseXor(hints), true);
+ set(i++, javascript.BitwiseXor(binop_hints), true);
set(i++, simplified.NumberBitwiseXor(), true);
- set(i++, javascript.BitwiseAnd(hints), true);
+ set(i++, javascript.BitwiseAnd(binop_hints), true);
set(i++, simplified.NumberBitwiseAnd(), true);
}
static const int kNumberOps = 6;
@@ -492,7 +493,7 @@
for (size_t i = 0; i < arraysize(others); i++) {
Type* t = Type::Union(Type::Number(), others[i], R.main_zone());
Node* r = R.ReduceUnop(R.javascript.ToNumber(), t);
- CHECK_EQ(IrOpcode::kJSToNumber, r->opcode());
+ CHECK_EQ(IrOpcode::kPlainPrimitiveToNumber, r->opcode());
}
}
@@ -571,10 +572,14 @@
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.LessThan(), R.simplified.StringLessThan(),
- R.javascript.LessThanOrEqual(), R.simplified.StringLessThanOrEqual(),
- R.javascript.GreaterThan(), R.simplified.StringLessThan(),
- R.javascript.GreaterThanOrEqual(), R.simplified.StringLessThanOrEqual()};
+ R.javascript.LessThan(CompareOperationHints::Any()),
+ R.simplified.StringLessThan(),
+ R.javascript.LessThanOrEqual(CompareOperationHints::Any()),
+ R.simplified.StringLessThanOrEqual(),
+ R.javascript.GreaterThan(CompareOperationHints::Any()),
+ R.simplified.StringLessThan(),
+ R.javascript.GreaterThanOrEqual(CompareOperationHints::Any()),
+ R.simplified.StringLessThanOrEqual()};
for (size_t i = 0; i < arraysize(kStringTypes); i++) {
Node* p0 = R.Parameter(kStringTypes[i], 0);
@@ -618,10 +623,14 @@
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.LessThan(), R.simplified.NumberLessThan(),
- R.javascript.LessThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
- R.javascript.GreaterThan(), R.simplified.NumberLessThan(),
- R.javascript.GreaterThanOrEqual(), R.simplified.NumberLessThanOrEqual()};
+ R.javascript.LessThan(CompareOperationHints::Any()),
+ R.simplified.NumberLessThan(),
+ R.javascript.LessThanOrEqual(CompareOperationHints::Any()),
+ R.simplified.NumberLessThanOrEqual(),
+ R.javascript.GreaterThan(CompareOperationHints::Any()),
+ R.simplified.NumberLessThan(),
+ R.javascript.GreaterThanOrEqual(CompareOperationHints::Any()),
+ R.simplified.NumberLessThanOrEqual()};
Node* const p0 = R.Parameter(Type::Number(), 0);
Node* const p1 = R.Parameter(Type::Number(), 1);
@@ -655,7 +664,8 @@
for (size_t j = 0; j < arraysize(types); j++) {
Node* p1 = R.Parameter(types[j], 1);
{
- const Operator* less_than = R.javascript.LessThan();
+ const Operator* less_than =
+ R.javascript.LessThan(CompareOperationHints::Any());
Node* cmp = R.Binop(less_than, p0, p1);
Node* r = R.reduce(cmp);
if (types[i]->Is(Type::String()) && types[j]->Is(Type::String())) {
@@ -700,14 +710,14 @@
case 2:
effect_use = R.graph.NewNode(R.common.EffectPhi(1), ton, R.start());
case 3:
- effect_use =
- R.graph.NewNode(R.javascript.Add(R.hints), ton, ton, R.context(),
- frame_state, frame_state, ton, R.start());
+ effect_use = R.graph.NewNode(R.javascript.Add(R.binop_hints), ton, ton,
+ R.context(), frame_state, frame_state, ton,
+ R.start());
break;
case 4:
- effect_use =
- R.graph.NewNode(R.javascript.Add(R.hints), p0, p0, R.context(),
- frame_state, frame_state, ton, R.start());
+ effect_use = R.graph.NewNode(R.javascript.Add(R.binop_hints), p0, p0,
+ R.context(), frame_state, frame_state, ton,
+ R.start());
break;
case 5:
effect_use = R.graph.NewNode(R.common.Return(), p0, ton, R.start());
@@ -801,7 +811,8 @@
{
const Operator* op =
- strict ? R->javascript.StrictEqual() : R->javascript.Equal();
+ strict ? R->javascript.StrictEqual(CompareOperationHints::Any())
+ : R->javascript.Equal(CompareOperationHints::Any());
Node* eq = R->Binop(op, p0, p1);
Node* r = R->reduce(eq);
R->CheckBinop(expected, r);
@@ -809,7 +820,8 @@
{
const Operator* op =
- strict ? R->javascript.StrictNotEqual() : R->javascript.NotEqual();
+ strict ? R->javascript.StrictNotEqual(CompareOperationHints::Any())
+ : R->javascript.NotEqual(CompareOperationHints::Any());
Node* ne = R->Binop(op, p0, p1);
Node* n = R->reduce(ne);
CHECK_EQ(IrOpcode::kBooleanNot, n->opcode());
@@ -876,14 +888,22 @@
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.Equal(), R.simplified.NumberEqual(),
- R.javascript.Add(R.hints), R.simplified.NumberAdd(),
- R.javascript.Subtract(R.hints), R.simplified.NumberSubtract(),
- R.javascript.Multiply(R.hints), R.simplified.NumberMultiply(),
- R.javascript.Divide(R.hints), R.simplified.NumberDivide(),
- R.javascript.Modulus(R.hints), R.simplified.NumberModulus(),
- R.javascript.LessThan(), R.simplified.NumberLessThan(),
- R.javascript.LessThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
+ R.javascript.Equal(R.compare_hints),
+ R.simplified.NumberEqual(),
+ R.javascript.Add(R.binop_hints),
+ R.simplified.NumberAdd(),
+ R.javascript.Subtract(R.binop_hints),
+ R.simplified.NumberSubtract(),
+ R.javascript.Multiply(R.binop_hints),
+ R.simplified.NumberMultiply(),
+ R.javascript.Divide(R.binop_hints),
+ R.simplified.NumberDivide(),
+ R.javascript.Modulus(R.binop_hints),
+ R.simplified.NumberModulus(),
+ R.javascript.LessThan(R.compare_hints),
+ R.simplified.NumberLessThan(),
+ R.javascript.LessThanOrEqual(R.compare_hints),
+ R.simplified.NumberLessThanOrEqual(),
};
for (size_t j = 0; j < arraysize(ops); j += 2) {
@@ -904,9 +924,9 @@
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.Subtract(R.hints), R.simplified.NumberSubtract(),
- R.javascript.Multiply(R.hints), R.simplified.NumberMultiply(),
- R.javascript.Divide(R.hints), R.simplified.NumberDivide(),
+ R.javascript.Subtract(R.binop_hints), R.simplified.NumberSubtract(),
+ R.javascript.Multiply(R.binop_hints), R.simplified.NumberMultiply(),
+ R.javascript.Divide(R.binop_hints), R.simplified.NumberDivide(),
};
for (size_t j = 0; j < arraysize(ops); j += 2) {
@@ -929,10 +949,10 @@
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.Add(R.hints), R.simplified.NumberAdd(),
- R.javascript.Subtract(R.hints), R.simplified.NumberSubtract(),
- R.javascript.Multiply(R.hints), R.simplified.NumberMultiply(),
- R.javascript.Divide(R.hints), R.simplified.NumberDivide(),
+ R.javascript.Add(R.binop_hints), R.simplified.NumberAdd(),
+ R.javascript.Subtract(R.binop_hints), R.simplified.NumberSubtract(),
+ R.javascript.Multiply(R.binop_hints), R.simplified.NumberMultiply(),
+ R.javascript.Divide(R.binop_hints), R.simplified.NumberDivide(),
};
for (size_t j = 0; j < arraysize(ops); j += 2) {
@@ -967,8 +987,9 @@
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.GreaterThan(), R.simplified.NumberLessThan(),
- R.javascript.GreaterThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
+ R.javascript.GreaterThan(R.compare_hints), R.simplified.NumberLessThan(),
+ R.javascript.GreaterThanOrEqual(R.compare_hints),
+ R.simplified.NumberLessThanOrEqual(),
};
for (size_t j = 0; j < arraysize(ops); j += 2) {
@@ -1178,16 +1199,16 @@
};
Entry ops[] = {
- {R.javascript.LessThan(), R.machine.Uint32LessThan(),
+ {R.javascript.LessThan(R.compare_hints), R.machine.Uint32LessThan(),
R.machine.Int32LessThan(), R.simplified.NumberLessThan(), false},
- {R.javascript.LessThanOrEqual(), R.machine.Uint32LessThanOrEqual(),
- R.machine.Int32LessThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
- false},
- {R.javascript.GreaterThan(), R.machine.Uint32LessThan(),
+ {R.javascript.LessThanOrEqual(R.compare_hints),
+ R.machine.Uint32LessThanOrEqual(), R.machine.Int32LessThanOrEqual(),
+ R.simplified.NumberLessThanOrEqual(), false},
+ {R.javascript.GreaterThan(R.compare_hints), R.machine.Uint32LessThan(),
R.machine.Int32LessThan(), R.simplified.NumberLessThan(), true},
- {R.javascript.GreaterThanOrEqual(), R.machine.Uint32LessThanOrEqual(),
- R.machine.Int32LessThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
- true}};
+ {R.javascript.GreaterThanOrEqual(R.compare_hints),
+ R.machine.Uint32LessThanOrEqual(), R.machine.Int32LessThanOrEqual(),
+ R.simplified.NumberLessThanOrEqual(), true}};
for (size_t o = 0; o < arraysize(ops); o++) {
for (size_t i = 0; i < arraysize(kNumberTypes); i++) {
diff --git a/test/cctest/compiler/test-linkage.cc b/test/cctest/compiler/test-linkage.cc
index dc83f4d..436b0f3 100644
--- a/test/cctest/compiler/test-linkage.cc
+++ b/test/cctest/compiler/test-linkage.cc
@@ -7,6 +7,7 @@
#include "src/parsing/parser.h"
#include "src/zone.h"
+#include "src/code-factory.h"
#include "src/compiler/common-operator.h"
#include "src/compiler/graph.h"
#include "src/compiler/linkage.h"
@@ -97,14 +98,12 @@
TEST(TestLinkageStubCall) {
Isolate* isolate = CcTest::InitIsolateOnce();
Zone zone(isolate->allocator());
- ToNumberStub stub(isolate);
+ Callable callable = CodeFactory::ToNumber(isolate);
CompilationInfo info(ArrayVector("test"), isolate, &zone,
Code::ComputeFlags(Code::STUB));
- CallInterfaceDescriptor interface_descriptor =
- stub.GetCallInterfaceDescriptor();
CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(
- isolate, &zone, interface_descriptor, stub.GetStackParameterCount(),
- CallDescriptor::kNoFlags, Operator::kNoProperties);
+ isolate, &zone, callable.descriptor(), 0, CallDescriptor::kNoFlags,
+ Operator::kNoProperties);
CHECK(descriptor);
CHECK_EQ(0, static_cast<int>(descriptor->StackParameterCount()));
CHECK_EQ(1, static_cast<int>(descriptor->ReturnCount()));
diff --git a/test/cctest/compiler/test-machine-operator-reducer.cc b/test/cctest/compiler/test-machine-operator-reducer.cc
index 86888e9..799a804 100644
--- a/test/cctest/compiler/test-machine-operator-reducer.cc
+++ b/test/cctest/compiler/test-machine-operator-reducer.cc
@@ -616,13 +616,8 @@
R.CheckDontPutConstantOnRight(-440197);
Node* x = R.Parameter(0);
- Node* y = R.Parameter(1);
- Node* zero = R.Constant<int32_t>(0);
- Node* sub = R.graph.NewNode(R.machine.Int32Sub(), x, y);
R.CheckFoldBinop<int32_t>(0, x, x); // x < x => 0
- R.CheckFoldBinop(x, y, sub, zero); // x - y < 0 => x < y
- R.CheckFoldBinop(y, x, zero, sub); // 0 < x - y => y < x
}
@@ -640,13 +635,8 @@
FOR_INT32_INPUTS(i) { R.CheckDontPutConstantOnRight<int32_t>(*i); }
Node* x = R.Parameter(0);
- Node* y = R.Parameter(1);
- Node* zero = R.Constant<int32_t>(0);
- Node* sub = R.graph.NewNode(R.machine.Int32Sub(), x, y);
R.CheckFoldBinop<int32_t>(1, x, x); // x <= x => 1
- R.CheckFoldBinop(x, y, sub, zero); // x - y <= 0 => x <= y
- R.CheckFoldBinop(y, x, zero, sub); // 0 <= x - y => y <= x
}
diff --git a/test/cctest/compiler/test-multiple-return.cc b/test/cctest/compiler/test-multiple-return.cc
index 53bae5e..aa7ec02 100644
--- a/test/cctest/compiler/test-multiple-return.cc
+++ b/test/cctest/compiler/test-multiple-return.cc
@@ -27,8 +27,7 @@
int param_count) {
MachineSignature::Builder msig(zone, return_count, param_count);
LocationSignature::Builder locations(zone, return_count, param_count);
- const RegisterConfiguration* config =
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN);
+ const RegisterConfiguration* config = RegisterConfiguration::Turbofan();
// Add return location(s).
CHECK(return_count <= config->num_allocatable_general_registers());
diff --git a/test/cctest/compiler/test-representation-change.cc b/test/cctest/compiler/test-representation-change.cc
index 76aa390..0d6b5b2 100644
--- a/test/cctest/compiler/test-representation-change.cc
+++ b/test/cctest/compiler/test-representation-change.cc
@@ -83,12 +83,20 @@
return n;
}
+ Node* Return(Node* input) {
+ Node* n = graph()->NewNode(common()->Return(), input, graph()->start(),
+ graph()->start());
+ return n;
+ }
+
void CheckTypeError(MachineRepresentation from, Type* from_type,
MachineRepresentation to) {
changer()->testing_type_errors_ = true;
changer()->type_error_ = false;
Node* n = Parameter(0);
- Node* c = changer()->GetRepresentationFor(n, from, from_type, to);
+ Node* use = Return(n);
+ Node* c = changer()->GetRepresentationFor(n, from, from_type, use,
+ UseInfo(to, Truncation::None()));
CHECK(changer()->type_error_);
CHECK_EQ(n, c);
}
@@ -96,7 +104,9 @@
void CheckNop(MachineRepresentation from, Type* from_type,
MachineRepresentation to) {
Node* n = Parameter(0);
- Node* c = changer()->GetRepresentationFor(n, from, from_type, to);
+ Node* use = Return(n);
+ Node* c = changer()->GetRepresentationFor(n, from, from_type, use,
+ UseInfo(to, Truncation::None()));
CHECK_EQ(n, c);
}
};
@@ -113,15 +123,17 @@
RepresentationChangerTester r;
Node* true_node = r.jsgraph()->TrueConstant();
+ Node* true_use = r.Return(true_node);
Node* true_bit = r.changer()->GetRepresentationFor(
- true_node, MachineRepresentation::kTagged, Type::None(),
- MachineRepresentation::kBit);
+ true_node, MachineRepresentation::kTagged, Type::None(), true_use,
+ UseInfo(MachineRepresentation::kBit, Truncation::None()));
r.CheckInt32Constant(true_bit, 1);
Node* false_node = r.jsgraph()->FalseConstant();
+ Node* false_use = r.Return(false_node);
Node* false_bit = r.changer()->GetRepresentationFor(
- false_node, MachineRepresentation::kTagged, Type::None(),
- MachineRepresentation::kBit);
+ false_node, MachineRepresentation::kTagged, Type::None(), false_use,
+ UseInfo(MachineRepresentation::kBit, Truncation::None()));
r.CheckInt32Constant(false_bit, 0);
}
@@ -131,9 +143,10 @@
for (int i = -5; i < 5; i++) {
Node* node = r.jsgraph()->Int32Constant(i);
+ Node* use = r.Return(node);
Node* val = r.changer()->GetRepresentationFor(
- node, MachineRepresentation::kBit, Type::Boolean(),
- MachineRepresentation::kTagged);
+ node, MachineRepresentation::kBit, Type::Boolean(), use,
+ UseInfo(MachineRepresentation::kTagged, Truncation::None()));
r.CheckHeapConstant(val, i == 0 ? r.isolate()->heap()->false_value()
: r.isolate()->heap()->true_value());
}
@@ -146,49 +159,54 @@
{
FOR_FLOAT64_INPUTS(i) {
Node* n = r.jsgraph()->Float64Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat64, Type::None(),
- MachineRepresentation::kTagged);
- r.CheckNumberConstant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat64, Type::None(), use,
+ UseInfo(MachineRepresentation::kTagged, Truncation::None()));
+ r.CheckNumberConstant(c, *i);
}
}
{
FOR_FLOAT64_INPUTS(i) {
Node* n = r.jsgraph()->Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat64, Type::None(),
- MachineRepresentation::kTagged);
- r.CheckNumberConstant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat64, Type::None(), use,
+ UseInfo(MachineRepresentation::kTagged, Truncation::None()));
+ r.CheckNumberConstant(c, *i);
}
}
{
FOR_FLOAT32_INPUTS(i) {
Node* n = r.jsgraph()->Float32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat32, Type::None(),
- MachineRepresentation::kTagged);
- r.CheckNumberConstant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat32, Type::None(), use,
+ UseInfo(MachineRepresentation::kTagged, Truncation::None()));
+ r.CheckNumberConstant(c, *i);
}
}
{
FOR_INT32_INPUTS(i) {
Node* n = r.jsgraph()->Int32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Signed32(),
- MachineRepresentation::kTagged);
- r.CheckNumberConstant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kWord32, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kTagged, Truncation::None()));
+ r.CheckNumberConstant(c, *i);
}
}
{
FOR_UINT32_INPUTS(i) {
Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Unsigned32(),
- MachineRepresentation::kTagged);
+ n, MachineRepresentation::kWord32, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kTagged, Truncation::None()));
r.CheckNumberConstant(c, *i);
}
}
@@ -201,49 +219,54 @@
{
FOR_FLOAT64_INPUTS(i) {
Node* n = r.jsgraph()->Float64Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat64, Type::None(),
- MachineRepresentation::kFloat64);
- CHECK_EQ(n, c);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat64, Type::None(), use,
+ UseInfo(MachineRepresentation::kFloat64, Truncation::None()));
+ CHECK_EQ(n, c);
}
}
{
FOR_FLOAT64_INPUTS(i) {
Node* n = r.jsgraph()->Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kTagged, Type::None(),
- MachineRepresentation::kFloat64);
- r.CheckFloat64Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kTagged, Type::None(), use,
+ UseInfo(MachineRepresentation::kFloat64, Truncation::None()));
+ r.CheckFloat64Constant(c, *i);
}
}
{
FOR_FLOAT32_INPUTS(i) {
Node* n = r.jsgraph()->Float32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat32, Type::None(),
- MachineRepresentation::kFloat64);
- r.CheckFloat64Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat32, Type::None(), use,
+ UseInfo(MachineRepresentation::kFloat64, Truncation::None()));
+ r.CheckFloat64Constant(c, *i);
}
}
{
FOR_INT32_INPUTS(i) {
Node* n = r.jsgraph()->Int32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Signed32(),
- MachineRepresentation::kFloat64);
- r.CheckFloat64Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kWord32, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kFloat64, Truncation::None()));
+ r.CheckFloat64Constant(c, *i);
}
}
{
FOR_UINT32_INPUTS(i) {
Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Unsigned32(),
- MachineRepresentation::kFloat64);
+ n, MachineRepresentation::kWord32, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kFloat64, Truncation::None()));
r.CheckFloat64Constant(c, *i);
}
}
@@ -264,30 +287,33 @@
{
FOR_FLOAT32_INPUTS(i) {
Node* n = r.jsgraph()->Float32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat32, Type::None(),
- MachineRepresentation::kFloat32);
- CHECK_EQ(n, c);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat32, Type::None(), use,
+ UseInfo(MachineRepresentation::kFloat32, Truncation::None()));
+ CHECK_EQ(n, c);
}
}
{
FOR_FLOAT32_INPUTS(i) {
Node* n = r.jsgraph()->Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kTagged, Type::None(),
- MachineRepresentation::kFloat32);
- r.CheckFloat32Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kTagged, Type::None(), use,
+ UseInfo(MachineRepresentation::kFloat32, Truncation::None()));
+ r.CheckFloat32Constant(c, *i);
}
}
{
FOR_FLOAT32_INPUTS(i) {
Node* n = r.jsgraph()->Float64Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat64, Type::None(),
- MachineRepresentation::kFloat32);
- r.CheckFloat32Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat64, Type::None(), use,
+ UseInfo(MachineRepresentation::kFloat32, Truncation::None()));
+ r.CheckFloat32Constant(c, *i);
}
}
@@ -295,9 +321,10 @@
FOR_INT32_INPUTS(i) {
if (!IsFloat32Int32(*i)) continue;
Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Signed32(),
- MachineRepresentation::kFloat32);
+ n, MachineRepresentation::kWord32, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kFloat32, Truncation::None()));
r.CheckFloat32Constant(c, static_cast<float>(*i));
}
}
@@ -306,9 +333,10 @@
FOR_UINT32_INPUTS(i) {
if (!IsFloat32Uint32(*i)) continue;
Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Unsigned32(),
- MachineRepresentation::kFloat32);
+ n, MachineRepresentation::kWord32, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kFloat32, Truncation::None()));
r.CheckFloat32Constant(c, static_cast<float>(*i));
}
}
@@ -321,10 +349,11 @@
{
FOR_INT32_INPUTS(i) {
Node* n = r.jsgraph()->Int32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Signed32(),
- MachineRepresentation::kWord32);
- r.CheckInt32Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kWord32, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
+ r.CheckInt32Constant(c, *i);
}
}
@@ -332,9 +361,10 @@
FOR_INT32_INPUTS(i) {
if (!IsFloat32Int32(*i)) continue;
Node* n = r.jsgraph()->Float32Constant(static_cast<float>(*i));
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat32, Type::Signed32(),
- MachineRepresentation::kWord32);
+ n, MachineRepresentation::kFloat32, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
r.CheckInt32Constant(c, *i);
}
}
@@ -342,19 +372,21 @@
{
FOR_INT32_INPUTS(i) {
Node* n = r.jsgraph()->Float64Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat64, Type::Signed32(),
- MachineRepresentation::kWord32);
- r.CheckInt32Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat64, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
+ r.CheckInt32Constant(c, *i);
}
}
{
FOR_INT32_INPUTS(i) {
Node* n = r.jsgraph()->Constant(*i);
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kTagged, Type::Signed32(),
- MachineRepresentation::kWord32);
+ n, MachineRepresentation::kTagged, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
r.CheckInt32Constant(c, *i);
}
}
@@ -367,10 +399,11 @@
{
FOR_UINT32_INPUTS(i) {
Node* n = r.jsgraph()->Int32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Unsigned32(),
- MachineRepresentation::kWord32);
- r.CheckUint32Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kWord32, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
+ r.CheckUint32Constant(c, *i);
}
}
@@ -378,9 +411,10 @@
FOR_UINT32_INPUTS(i) {
if (!IsFloat32Uint32(*i)) continue;
Node* n = r.jsgraph()->Float32Constant(static_cast<float>(*i));
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat32, Type::Unsigned32(),
- MachineRepresentation::kWord32);
+ n, MachineRepresentation::kFloat32, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
r.CheckUint32Constant(c, *i);
}
}
@@ -388,19 +422,21 @@
{
FOR_UINT32_INPUTS(i) {
Node* n = r.jsgraph()->Float64Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat64, Type::Unsigned32(),
- MachineRepresentation::kWord32);
- r.CheckUint32Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat64, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
+ r.CheckUint32Constant(c, *i);
}
}
{
FOR_UINT32_INPUTS(i) {
Node* n = r.jsgraph()->Constant(static_cast<double>(*i));
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kTagged, Type::Unsigned32(),
- MachineRepresentation::kWord32);
+ n, MachineRepresentation::kTagged, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
r.CheckUint32Constant(c, *i);
}
}
@@ -412,7 +448,9 @@
RepresentationChangerTester r;
Node* n = r.Parameter();
- Node* c = r.changer()->GetRepresentationFor(n, from, from_type, to);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(n, from, from_type, use,
+ UseInfo(to, Truncation::None()));
CHECK_NE(c, n);
CHECK_EQ(expected, c->opcode());
@@ -427,7 +465,9 @@
RepresentationChangerTester r;
Node* n = r.Parameter();
- Node* c1 = r.changer()->GetRepresentationFor(n, from, from_type, to);
+ Node* use = r.Return(n);
+ Node* c1 = r.changer()->GetRepresentationFor(n, from, from_type, use,
+ UseInfo(to, Truncation::None()));
CHECK_NE(c1, n);
CHECK_EQ(expected1, c1->opcode());
@@ -473,7 +513,10 @@
CheckChange(IrOpcode::kChangeTaggedToFloat64, MachineRepresentation::kTagged,
Type::Number(), MachineRepresentation::kFloat64);
CheckChange(IrOpcode::kChangeTaggedToFloat64, MachineRepresentation::kTagged,
- Type::NumberOrUndefined(), MachineRepresentation::kFloat64);
+ Type::Number(), MachineRepresentation::kFloat64);
+ CheckChange(IrOpcode::kTruncateTaggedToFloat64,
+ MachineRepresentation::kTagged, Type::NumberOrUndefined(),
+ MachineRepresentation::kFloat64);
CheckTwoChanges(IrOpcode::kChangeTaggedSignedToInt32,
IrOpcode::kChangeInt32ToFloat64,
MachineRepresentation::kTagged, Type::TaggedSigned(),
diff --git a/test/cctest/compiler/test-run-intrinsics.cc b/test/cctest/compiler/test-run-intrinsics.cc
index 6aa5f39..0ea611b 100644
--- a/test/cctest/compiler/test-run-intrinsics.cc
+++ b/test/cctest/compiler/test-run-intrinsics.cc
@@ -111,37 +111,6 @@
}
-TEST(OneByteSeqStringGetChar) {
- FunctionTester T("(function(a,b) { return %_OneByteSeqStringGetChar(a,b); })",
- flags);
-
- Handle<SeqOneByteString> string =
- T.main_isolate()->factory()->NewRawOneByteString(3).ToHandleChecked();
- string->SeqOneByteStringSet(0, 'b');
- string->SeqOneByteStringSet(1, 'a');
- string->SeqOneByteStringSet(2, 'r');
- T.CheckCall(T.Val('b'), string, T.Val(0.0));
- T.CheckCall(T.Val('a'), string, T.Val(1));
- T.CheckCall(T.Val('r'), string, T.Val(2));
-}
-
-
-TEST(OneByteSeqStringSetChar) {
- FunctionTester T("(function(a,b) { %_OneByteSeqStringSetChar(a,88,b); })",
- flags);
-
- Handle<SeqOneByteString> string =
- T.main_isolate()->factory()->NewRawOneByteString(3).ToHandleChecked();
- string->SeqOneByteStringSet(0, 'b');
- string->SeqOneByteStringSet(1, 'a');
- string->SeqOneByteStringSet(2, 'r');
- T.Call(T.Val(1), string);
- CHECK_EQ('b', string->SeqOneByteStringGet(0));
- CHECK_EQ('X', string->SeqOneByteStringGet(1));
- CHECK_EQ('r', string->SeqOneByteStringGet(2));
-}
-
-
TEST(StringAdd) {
FunctionTester T("(function(a,b) { return %_StringAdd(a,b); })", flags);
@@ -151,15 +120,6 @@
}
-TEST(StringCharAt) {
- FunctionTester T("(function(a,b) { return %_StringCharAt(a,b); })", flags);
-
- T.CheckCall(T.Val("e"), T.Val("huge fan!"), T.Val(3));
- T.CheckCall(T.Val("f"), T.Val("\xE2\x9D\x8A fan!"), T.Val(2));
- T.CheckCall(T.Val(""), T.Val("not a fan!"), T.Val(23));
-}
-
-
TEST(StringCharCodeAt) {
FunctionTester T("(function(a,b) { return %_StringCharCodeAt(a,b); })",
flags);
@@ -197,37 +157,6 @@
}
-TEST(TwoByteSeqStringGetChar) {
- FunctionTester T("(function(a,b) { return %_TwoByteSeqStringGetChar(a,b); })",
- flags);
-
- Handle<SeqTwoByteString> string =
- T.main_isolate()->factory()->NewRawTwoByteString(3).ToHandleChecked();
- string->SeqTwoByteStringSet(0, 'b');
- string->SeqTwoByteStringSet(1, 'a');
- string->SeqTwoByteStringSet(2, 'r');
- T.CheckCall(T.Val('b'), string, T.Val(0.0));
- T.CheckCall(T.Val('a'), string, T.Val(1));
- T.CheckCall(T.Val('r'), string, T.Val(2));
-}
-
-
-TEST(TwoByteSeqStringSetChar) {
- FunctionTester T("(function(a,b) { %_TwoByteSeqStringSetChar(a,88,b); })",
- flags);
-
- Handle<SeqTwoByteString> string =
- T.main_isolate()->factory()->NewRawTwoByteString(3).ToHandleChecked();
- string->SeqTwoByteStringSet(0, 'b');
- string->SeqTwoByteStringSet(1, 'a');
- string->SeqTwoByteStringSet(2, 'r');
- T.Call(T.Val(1), string);
- CHECK_EQ('b', string->SeqTwoByteStringGet(0));
- CHECK_EQ('X', string->SeqTwoByteStringGet(1));
- CHECK_EQ('r', string->SeqTwoByteStringGet(2));
-}
-
-
TEST(ValueOf) {
FunctionTester T("(function(a) { return %_ValueOf(a); })", flags);
diff --git a/test/cctest/compiler/test-run-jscalls.cc b/test/cctest/compiler/test-run-jscalls.cc
index 12566c2..06cfcd2 100644
--- a/test/cctest/compiler/test-run-jscalls.cc
+++ b/test/cctest/compiler/test-run-jscalls.cc
@@ -218,6 +218,7 @@
i::Handle<i::JSFunction> jsfun = Handle<JSFunction>::cast(ofun);
jsfun->set_code(T.function->code());
jsfun->set_shared(T.function->shared());
+ jsfun->set_literals(T.function->literals());
CHECK(context->Global()
->Set(context, v8_str("foo"), v8::Utils::CallableToLocal(jsfun))
.FromJust());
@@ -242,6 +243,7 @@
i::Handle<i::JSFunction> jsfun = Handle<JSFunction>::cast(ofun);
jsfun->set_code(T.function->code());
jsfun->set_shared(T.function->shared());
+ jsfun->set_literals(T.function->literals());
CHECK(context->Global()
->Set(context, v8_str("foo"), v8::Utils::CallableToLocal(jsfun))
.FromJust());
diff --git a/test/cctest/compiler/test-run-machops.cc b/test/cctest/compiler/test-run-machops.cc
index 6d681bc..685918a 100644
--- a/test/cctest/compiler/test-run-machops.cc
+++ b/test/cctest/compiler/test-run-machops.cc
@@ -7,6 +7,7 @@
#include <limits>
#include "src/base/bits.h"
+#include "src/base/ieee754.h"
#include "src/base/utils/random-number-generator.h"
#include "src/codegen.h"
#include "test/cctest/cctest.h"
@@ -3568,6 +3569,12 @@
}
}
+TEST(RunFloat32Neg) {
+ BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
+ if (!m.machine()->Float32Neg().IsSupported()) return;
+ m.Return(m.AddNode(m.machine()->Float32Neg().op(), m.Parameter(0)));
+ FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(-0.0f - *i, m.Call(*i)); }
+}
TEST(RunFloat32Mul) {
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
@@ -3612,6 +3619,12 @@
}
}
+TEST(RunFloat64Neg) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ if (!m.machine()->Float64Neg().IsSupported()) return;
+ m.Return(m.AddNode(m.machine()->Float64Neg().op(), m.Parameter(0)));
+ FOR_FLOAT64_INPUTS(i) { CHECK_FLOAT_EQ(-0.0 - *i, m.Call(*i)); }
+}
TEST(RunFloat64Mul) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
@@ -5483,6 +5496,156 @@
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(std::abs(*i), m.Call(*i)); }
}
+TEST(RunFloat64Atan) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Atan(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK_DOUBLE_EQ(-0.0, m.Call(-0.0));
+ CHECK_DOUBLE_EQ(0.0, m.Call(0.0));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::atan(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Atan2) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
+ MachineType::Float64());
+ m.Return(m.Float64Atan2(m.Parameter(0), m.Parameter(1)));
+ FOR_FLOAT64_INPUTS(i) {
+ FOR_FLOAT64_INPUTS(j) {
+ CHECK_DOUBLE_EQ(ieee754::atan2(*i, *j), m.Call(*i, *j));
+ }
+ }
+}
+
+TEST(RunFloat64Atanh) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Atanh(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(), m.Call(1.0));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-1.0));
+ CHECK_DOUBLE_EQ(-0.0, m.Call(-0.0));
+ CHECK_DOUBLE_EQ(0.0, m.Call(0.0));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::atanh(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Cos) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Cos(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::cos(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Exp) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Exp(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK_EQ(0.0, m.Call(-std::numeric_limits<double>::infinity()));
+ CHECK_DOUBLE_EQ(1.0, m.Call(-0.0));
+ CHECK_DOUBLE_EQ(1.0, m.Call(0.0));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::exp(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Expm1) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Expm1(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK_EQ(-1.0, m.Call(-std::numeric_limits<double>::infinity()));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::expm1(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Log) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Log(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
+ CHECK(std::isnan(m.Call(-1.0)));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0));
+ CHECK_DOUBLE_EQ(0.0, m.Call(1.0));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Log1p) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Log1p(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-1.0));
+ CHECK_DOUBLE_EQ(0.0, m.Call(0.0));
+ CHECK_DOUBLE_EQ(-0.0, m.Call(-0.0));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log1p(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Log2) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Log2(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
+ CHECK(std::isnan(m.Call(-1.0)));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0));
+ CHECK_DOUBLE_EQ(0.0, m.Call(1.0));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log2(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Log10) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Log10(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
+ CHECK(std::isnan(m.Call(-1.0)));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log10(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Cbrt) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Cbrt(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(),
+ m.Call(-std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::cbrt(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Sin) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Sin(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::sin(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Tan) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Tan(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::tan(*i), m.Call(*i)); }
+}
static double two_30 = 1 << 30; // 2^30 is a smi boundary.
static double two_52 = two_30 * (1 << 22); // 2^52 is a precision boundary.
diff --git a/test/cctest/compiler/test-run-native-calls.cc b/test/cctest/compiler/test-run-native-calls.cc
index a63cc8a..9c67fd5 100644
--- a/test/cctest/compiler/test-run-native-calls.cc
+++ b/test/cctest/compiler/test-run-native-calls.cc
@@ -18,6 +18,8 @@
namespace internal {
namespace compiler {
+const auto GetRegConfig = RegisterConfiguration::Turbofan;
+
namespace {
typedef float float32;
typedef double float64;
@@ -76,12 +78,8 @@
class RegisterPairs : public Pairs {
public:
RegisterPairs()
- : Pairs(
- 100,
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_general_registers(),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->allocatable_general_codes()) {}
+ : Pairs(100, GetRegConfig()->num_allocatable_general_registers(),
+ GetRegConfig()->allocatable_general_codes()) {}
};
@@ -91,10 +89,14 @@
Float32RegisterPairs()
: Pairs(
100,
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_aliased_double_registers(),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->allocatable_double_codes()) {}
+#if V8_TARGET_ARCH_ARM
+ // TODO(bbudge) Modify wasm linkage to allow use of all float regs.
+ GetRegConfig()->num_allocatable_double_registers() / 2 - 2,
+#else
+ GetRegConfig()->num_allocatable_double_registers(),
+#endif
+ GetRegConfig()->allocatable_double_codes()) {
+ }
};
@@ -102,12 +104,8 @@
class Float64RegisterPairs : public Pairs {
public:
Float64RegisterPairs()
- : Pairs(
- 100,
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_aliased_double_registers(),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->allocatable_double_codes()) {}
+ : Pairs(100, GetRegConfig()->num_allocatable_double_registers(),
+ GetRegConfig()->allocatable_double_codes()) {}
};
@@ -136,7 +134,12 @@
if (IsFloatingPoint(type.representation())) {
// Allocate a floating point register/stack location.
if (fp_offset < fp_count) {
- return LinkageLocation::ForRegister(fp_regs[fp_offset++]);
+ int code = fp_regs[fp_offset++];
+#if V8_TARGET_ARCH_ARM
+ // TODO(bbudge) Modify wasm linkage to allow use of all float regs.
+ if (type.representation() == MachineRepresentation::kFloat32) code *= 2;
+#endif
+ return LinkageLocation::ForRegister(code);
} else {
int offset = -1 - stack_offset;
stack_offset += StackWords(type);
@@ -154,10 +157,7 @@
}
}
int StackWords(MachineType type) {
- // TODO(titzer): hack. float32 occupies 8 bytes on stack.
- int size = IsFloatingPoint(type.representation())
- ? kDoubleSize
- : (1 << ElementSizeLog2Of(type.representation()));
+ int size = 1 << ElementSizeLog2Of(type.representation());
return size <= kPointerSize ? 1 : size / kPointerSize;
}
void Reset() {
@@ -636,15 +636,14 @@
// Separate tests for parallelization.
-#define TEST_INT32_SUB_WITH_RET(x) \
- TEST(Run_Int32Sub_all_allocatable_pairs_##x) { \
- if (x < Register::kNumRegisters && \
- Register::from_code(x).IsAllocatable()) { \
- Test_RunInt32SubWithRet(x); \
- } \
+#define TEST_INT32_SUB_WITH_RET(x) \
+ TEST(Run_Int32Sub_all_allocatable_pairs_##x) { \
+ if (x < Register::kNumRegisters && \
+ GetRegConfig()->IsAllocatableGeneralCode(x)) { \
+ Test_RunInt32SubWithRet(x); \
+ } \
}
-
TEST_INT32_SUB_WITH_RET(0)
TEST_INT32_SUB_WITH_RET(1)
TEST_INT32_SUB_WITH_RET(2)
@@ -692,9 +691,7 @@
base::AccountingAllocator allocator;
Zone zone(&allocator);
int parray[2];
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
pairs.Next(&parray[0], &parray[1], false);
Allocator params(parray, 2, nullptr, 0);
Allocator rets(rarray, 1, nullptr, 0);
@@ -741,14 +738,12 @@
static void Test_Int32_WeightedSum_of_size(int count) {
Int32Signature sig(count);
for (int p0 = 0; p0 < Register::kNumRegisters; p0++) {
- if (Register::from_code(p0).IsAllocatable()) {
+ if (GetRegConfig()->IsAllocatableGeneralCode(p0)) {
base::AccountingAllocator allocator;
Zone zone(&allocator);
int parray[] = {p0};
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
Allocator params(parray, 1, nullptr, 0);
Allocator rets(rarray, 1, nullptr, 0);
RegisterConfig config(params, rets);
@@ -801,12 +796,8 @@
template <int which>
void Test_Int32_Select() {
- int parray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
+ int parray[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
Allocator params(parray, 1, nullptr, 0);
Allocator rets(rarray, 1, nullptr, 0);
RegisterConfig config(params, rets);
@@ -843,14 +834,10 @@
TEST(Int64Select_registers) {
- if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_general_registers() < 2)
- return;
+ if (GetRegConfig()->num_allocatable_general_registers() < 2) return;
if (kPointerSize < 8) return; // TODO(titzer): int64 on 32-bit platforms
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
ArgsBuffer<int64_t>::Sig sig(2);
RegisterPairs pairs;
@@ -871,14 +858,11 @@
TEST(Float32Select_registers) {
- if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_double_registers() < 2) {
+ if (GetRegConfig()->num_allocatable_double_registers() < 2) {
return;
}
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
ArgsBuffer<float32>::Sig sig(2);
Float32RegisterPairs pairs;
@@ -899,15 +883,9 @@
TEST(Float64Select_registers) {
- if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_double_registers() < 2)
- return;
- if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_general_registers() < 2)
- return;
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ if (GetRegConfig()->num_allocatable_double_registers() < 2) return;
+ if (GetRegConfig()->num_allocatable_general_registers() < 2) return;
+ int rarray[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
ArgsBuffer<float64>::Sig sig(2);
Float64RegisterPairs pairs;
@@ -928,9 +906,7 @@
TEST(Float32Select_stack_params_return_reg) {
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
Allocator params(nullptr, 0, nullptr, 0);
Allocator rets(nullptr, 0, rarray, 1);
RegisterConfig config(params, rets);
@@ -951,9 +927,7 @@
TEST(Float64Select_stack_params_return_reg) {
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
Allocator params(nullptr, 0, nullptr, 0);
Allocator rets(nullptr, 0, rarray, 1);
RegisterConfig config(params, rets);
@@ -1006,9 +980,7 @@
TEST(Float64StackParamsToStackParams) {
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
Allocator params(nullptr, 0, nullptr, 0);
Allocator rets(nullptr, 0, rarray, 1);
@@ -1027,9 +999,7 @@
void MixedParamTest(int start) {
- if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_double_registers() < 2)
- return;
+ if (GetRegConfig()->num_double_registers() < 2) return;
// TODO(titzer): mix in 64-bit types on all platforms when supported.
#if V8_TARGET_ARCH_32_BIT
@@ -1058,22 +1028,12 @@
const int num_params = static_cast<int>(arraysize(types) - start);
// Build call descriptor
- int parray_gp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(1)};
- int rarray_gp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
- int parray_fp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(1)};
- int rarray_fp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ int parray_gp[] = {GetRegConfig()->GetAllocatableGeneralCode(0),
+ GetRegConfig()->GetAllocatableGeneralCode(1)};
+ int rarray_gp[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
+ int parray_fp[] = {GetRegConfig()->GetAllocatableDoubleCode(0),
+ GetRegConfig()->GetAllocatableDoubleCode(1)};
+ int rarray_fp[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
Allocator palloc(parray_gp, 2, parray_fp, 2);
Allocator ralloc(rarray_gp, 1, rarray_fp, 1);
RegisterConfig config(palloc, ralloc);
@@ -1174,29 +1134,17 @@
// Test: Generate with a function f which reserves a stack slot, call an inner
// function g from f which writes into the stack slot of f.
- if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_double_registers() < 2)
- return;
+ if (GetRegConfig()->num_allocatable_double_registers() < 2) return;
Isolate* isolate = CcTest::InitIsolateOnce();
// Lots of code to generate the build descriptor for the inner function.
- int parray_gp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(1)};
- int rarray_gp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
- int parray_fp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(1)};
- int rarray_fp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ int parray_gp[] = {GetRegConfig()->GetAllocatableGeneralCode(0),
+ GetRegConfig()->GetAllocatableGeneralCode(1)};
+ int rarray_gp[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
+ int parray_fp[] = {GetRegConfig()->GetAllocatableDoubleCode(0),
+ GetRegConfig()->GetAllocatableDoubleCode(1)};
+ int rarray_fp[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
Allocator palloc(parray_gp, 2, parray_fp, 2);
Allocator ralloc(rarray_gp, 1, rarray_fp, 1);
RegisterConfig config(palloc, ralloc);
diff --git a/test/cctest/compiler/test-simplified-lowering.cc b/test/cctest/compiler/test-simplified-lowering.cc
index 4efb149..b56721e 100644
--- a/test/cctest/compiler/test-simplified-lowering.cc
+++ b/test/cctest/compiler/test-simplified-lowering.cc
@@ -1167,7 +1167,7 @@
Type::Unsigned32());
CheckChangeInsertion(IrOpcode::kChangeFloat64ToTagged, MachineType::Float64(),
- MachineType::AnyTagged());
+ MachineType::AnyTagged(), Type::Number());
CheckChangeInsertion(IrOpcode::kChangeTaggedToFloat64,
MachineType::AnyTagged(), MachineType::Float64(),
Type::Number());
@@ -1258,7 +1258,7 @@
for (size_t i = 0; i < arraysize(ops); i++) {
CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToFloat64,
- IrOpcode::kChangeFloat64ToTagged);
+ IrOpcode::kChangeFloat64ToTagged, Type::Number());
}
}
@@ -1488,8 +1488,9 @@
TEST(InsertChangeForLoadElement) {
// TODO(titzer): test all load/store representation change insertions.
TestingGraph t(Type::Any(), Type::Signed32(), Type::Any());
- ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
- MachineType::Float64(), kNoWriteBarrier};
+ ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
+ Type::Number(), MachineType::Float64(),
+ kNoWriteBarrier};
Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
t.p1, t.start, t.start);
@@ -1505,8 +1506,8 @@
// TODO(titzer): test all load/store representation change insertions.
TestingGraph t(Type::Any(), Type::Signed32());
FieldAccess access = {
- kTaggedBase, FixedArrayBase::kHeaderSize, Handle<Name>::null(),
- Type::Any(), MachineType::Float64(), kNoWriteBarrier};
+ kTaggedBase, FixedArrayBase::kHeaderSize, Handle<Name>::null(),
+ Type::Number(), MachineType::Float64(), kNoWriteBarrier};
Node* load = t.graph()->NewNode(t.simplified()->LoadField(access), t.p0,
t.start, t.start);
diff --git a/test/cctest/compiler/value-helper.h b/test/cctest/compiler/value-helper.h
index 7d26dba..75d22b4 100644
--- a/test/cctest/compiler/value-helper.h
+++ b/test/cctest/compiler/value-helper.h
@@ -110,7 +110,9 @@
-3.63759e-10f,
-4.30175e-14f,
-5.27385e-15f,
+ -1.5707963267948966f,
-1.48084e-15f,
+ -2.220446049250313e-16f,
-1.05755e-19f,
-3.2995e-21f,
-1.67354e-23f,
@@ -129,6 +131,7 @@
6.25073e-22f,
4.1723e-13f,
1.44343e-09f,
+ 1.5707963267948966f,
5.27004e-08f,
9.48298e-08f,
5.57888e-07f,
@@ -177,6 +180,7 @@
static std::vector<double> float64_vector() {
static const double nan = std::numeric_limits<double>::quiet_NaN();
static const double values[] = {-2e66,
+ -2.220446049250313e-16,
-9223373136366403584.0,
-9223372036854775808.0, // INT64_MIN
-2147483649.5,
@@ -188,6 +192,7 @@
-999.75,
-2e66,
-1.75,
+ -1.5707963267948966,
-1.0,
-0.5,
-0.0,
@@ -198,7 +203,11 @@
0.375,
0.5,
1.0,
+ 1.17549e-38,
+ 1.56657e-37,
+ 1.0000001,
1.25,
+ 1.5707963267948966,
2,
3.1e7,
5.125,