Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/test/cctest/compiler/codegen-tester.h b/test/cctest/compiler/codegen-tester.h
index 283d533..56e90c6 100644
--- a/test/cctest/compiler/codegen-tester.h
+++ b/test/cctest/compiler/codegen-tester.h
@@ -5,8 +5,6 @@
#ifndef V8_CCTEST_COMPILER_CODEGEN_TESTER_H_
#define V8_CCTEST_COMPILER_CODEGEN_TESTER_H_
-#include "src/v8.h"
-
#include "src/compiler/instruction-selector.h"
#include "src/compiler/pipeline.h"
#include "src/compiler/raw-machine-assembler.h"
@@ -17,38 +15,29 @@
namespace internal {
namespace compiler {
-template <typename MachineAssembler>
-class MachineAssemblerTester : public HandleAndZoneScope,
- public CallHelper,
- public MachineAssembler {
+template <typename ReturnType>
+class RawMachineAssemblerTester : public HandleAndZoneScope,
+ public CallHelper<ReturnType>,
+ public RawMachineAssembler {
public:
- MachineAssemblerTester(MachineType return_type, MachineType p0,
- MachineType p1, MachineType p2, MachineType p3,
- MachineType p4,
- MachineOperatorBuilder::Flags flags =
- MachineOperatorBuilder::Flag::kNoFlags)
+ RawMachineAssemblerTester(MachineType p0 = MachineType::None(),
+ MachineType p1 = MachineType::None(),
+ MachineType p2 = MachineType::None(),
+ MachineType p3 = MachineType::None(),
+ MachineType p4 = MachineType::None())
: HandleAndZoneScope(),
- CallHelper(
+ CallHelper<ReturnType>(
main_isolate(),
- MakeMachineSignature(main_zone(), return_type, p0, p1, p2, p3, p4)),
- MachineAssembler(
- new (main_zone()) Graph(main_zone()),
- MakeMachineSignature(main_zone(), return_type, p0, p1, p2, p3, p4),
- kMachPtr, flags) {}
-
- Node* LoadFromPointer(void* address, MachineType rep, int32_t offset = 0) {
- return this->Load(rep, this->PointerConstant(address),
- this->Int32Constant(offset));
- }
-
- void StoreToPointer(void* address, MachineType rep, Node* node) {
- this->Store(rep, this->PointerConstant(address), node);
- }
-
- Node* StringConstant(const char* string) {
- return this->HeapConstant(
- this->isolate()->factory()->InternalizeUtf8String(string));
- }
+ CSignature::New(main_zone(), MachineTypeForC<ReturnType>(), p0, p1,
+ p2, p3, p4)),
+ RawMachineAssembler(
+ main_isolate(), new (main_zone()) Graph(main_zone()),
+ Linkage::GetSimplifiedCDescriptor(
+ main_zone(),
+ CSignature::New(main_zone(), MachineTypeForC<ReturnType>(), p0,
+ p1, p2, p3, p4)),
+ MachineType::PointerRepresentation(),
+ InstructionSelector::SupportedMachineOperatorFlags()) {}
void CheckNumber(double expected, Object* number) {
CHECK(this->isolate()->factory()->NewNumber(expected)->SameValue(number));
@@ -62,14 +51,20 @@
void GenerateCode() { Generate(); }
+ Handle<Code> GetCode() {
+ Generate();
+ return code_.ToHandleChecked();
+ }
+
protected:
virtual byte* Generate() {
if (code_.is_null()) {
Schedule* schedule = this->Export();
CallDescriptor* call_descriptor = this->call_descriptor();
Graph* graph = this->graph();
- code_ =
- Pipeline::GenerateCodeForTesting(call_descriptor, graph, schedule);
+ CompilationInfo info("testing", main_isolate(), main_zone());
+ code_ = Pipeline::GenerateCodeForTesting(&info, call_descriptor, graph,
+ schedule);
}
return this->code_.ToHandleChecked()->entry();
}
@@ -80,40 +75,226 @@
template <typename ReturnType>
-class RawMachineAssemblerTester
- : public MachineAssemblerTester<RawMachineAssembler>,
- public CallHelper2<ReturnType, RawMachineAssemblerTester<ReturnType> > {
+class BufferedRawMachineAssemblerTester
+ : public RawMachineAssemblerTester<int32_t> {
public:
- RawMachineAssemblerTester(MachineType p0 = kMachNone,
- MachineType p1 = kMachNone,
- MachineType p2 = kMachNone,
- MachineType p3 = kMachNone,
- MachineType p4 = kMachNone)
- : MachineAssemblerTester<RawMachineAssembler>(
- ReturnValueTraits<ReturnType>::Representation(), p0, p1, p2, p3, p4,
- InstructionSelector::SupportedMachineOperatorFlags()) {}
+ BufferedRawMachineAssemblerTester(MachineType p0 = MachineType::None(),
+ MachineType p1 = MachineType::None(),
+ MachineType p2 = MachineType::None(),
+ MachineType p3 = MachineType::None())
+ : BufferedRawMachineAssemblerTester(ComputeParameterCount(p0, p1, p2, p3),
+ p0, p1, p2, p3) {}
- template <typename Ci, typename Fn>
- void Run(const Ci& ci, const Fn& fn) {
- typename Ci::const_iterator i;
- for (i = ci.begin(); i != ci.end(); ++i) {
- CHECK_EQ(fn(*i), this->Call(*i));
- }
+
+ // The BufferedRawMachineAssemblerTester does not pass parameters directly
+ // to the constructed IR graph. Instead it passes a pointer to the parameter
+ // to the IR graph, and adds Load nodes to the IR graph to load the
+ // 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);
+ return parameter_nodes_[index];
}
- template <typename Ci, typename Cj, typename Fn>
- void Run(const Ci& ci, const Cj& cj, const Fn& fn) {
- typename Ci::const_iterator i;
- typename Cj::const_iterator j;
- for (i = ci.begin(); i != ci.end(); ++i) {
- for (j = cj.begin(); j != cj.end(); ++j) {
- CHECK_EQ(fn(*i, *j), this->Call(*i, *j));
- }
- }
+
+ // The BufferedRawMachineAssemblerTester adds a Store node to the IR graph
+ // to store the graph's return value in memory. The memory address for the
+ // Store node is provided as a parameter. By storing the return value in
+ // memory it is possible to return 64 bit values.
+ void Return(Node* input) {
+ Store(MachineTypeForC<ReturnType>().representation(),
+ RawMachineAssembler::Parameter(return_parameter_index_), input,
+ kNoWriteBarrier);
+ RawMachineAssembler::Return(Int32Constant(1234));
}
+
+ ReturnType Call() {
+ ReturnType return_value;
+ test_graph_signature_->VerifyParams();
+ CallHelper<int32_t>::Call(reinterpret_cast<void*>(&return_value));
+ return return_value;
+ }
+
+ template <typename P0>
+ ReturnType Call(P0 p0) {
+ ReturnType return_value;
+ test_graph_signature_->VerifyParams<P0>();
+ CallHelper<int32_t>::Call(reinterpret_cast<void*>(&p0),
+ reinterpret_cast<void*>(&return_value));
+ return return_value;
+ }
+
+ template <typename P0, typename P1>
+ ReturnType Call(P0 p0, P1 p1) {
+ ReturnType return_value;
+ test_graph_signature_->VerifyParams<P0, P1>();
+ CallHelper<int32_t>::Call(reinterpret_cast<void*>(&p0),
+ reinterpret_cast<void*>(&p1),
+ reinterpret_cast<void*>(&return_value));
+ return return_value;
+ }
+
+ template <typename P0, typename P1, typename P2>
+ ReturnType Call(P0 p0, P1 p1, P2 p2) {
+ ReturnType return_value;
+ test_graph_signature_->VerifyParams<P0, P1, P2>();
+ CallHelper<int32_t>::Call(
+ reinterpret_cast<void*>(&p0), reinterpret_cast<void*>(&p1),
+ reinterpret_cast<void*>(&p2), reinterpret_cast<void*>(&return_value));
+ return return_value;
+ }
+
+ template <typename P0, typename P1, typename P2, typename P3>
+ ReturnType Call(P0 p0, P1 p1, P2 p2, P3 p3) {
+ ReturnType return_value;
+ test_graph_signature_->VerifyParams<P0, P1, P2, P3>();
+ CallHelper<int32_t>::Call(
+ reinterpret_cast<void*>(&p0), reinterpret_cast<void*>(&p1),
+ reinterpret_cast<void*>(&p2), reinterpret_cast<void*>(&p3),
+ reinterpret_cast<void*>(&return_value));
+ return return_value;
+ }
+
+ private:
+ BufferedRawMachineAssemblerTester(uint32_t return_parameter_index,
+ MachineType p0, MachineType p1,
+ MachineType p2, MachineType p3)
+ : RawMachineAssemblerTester<int32_t>(
+ MachineType::Pointer(),
+ p0 == MachineType::None() ? MachineType::None()
+ : MachineType::Pointer(),
+ p1 == MachineType::None() ? MachineType::None()
+ : MachineType::Pointer(),
+ p2 == MachineType::None() ? MachineType::None()
+ : MachineType::Pointer(),
+ p3 == MachineType::None() ? MachineType::None()
+ : MachineType::Pointer()),
+ test_graph_signature_(
+ CSignature::New(main_zone(), MachineType::Int32(), p0, p1, p2, p3)),
+ return_parameter_index_(return_parameter_index) {
+ parameter_nodes_[0] = p0 == MachineType::None()
+ ? nullptr
+ : Load(p0, RawMachineAssembler::Parameter(0));
+ parameter_nodes_[1] = p1 == MachineType::None()
+ ? nullptr
+ : Load(p1, RawMachineAssembler::Parameter(1));
+ parameter_nodes_[2] = p2 == MachineType::None()
+ ? nullptr
+ : Load(p2, RawMachineAssembler::Parameter(2));
+ parameter_nodes_[3] = p3 == MachineType::None()
+ ? nullptr
+ : Load(p3, RawMachineAssembler::Parameter(3));
+ }
+
+
+ static uint32_t ComputeParameterCount(MachineType p0, MachineType p1,
+ MachineType p2, MachineType p3) {
+ if (p0 == MachineType::None()) {
+ return 0;
+ }
+ if (p1 == MachineType::None()) {
+ return 1;
+ }
+ if (p2 == MachineType::None()) {
+ return 2;
+ }
+ if (p3 == MachineType::None()) {
+ return 3;
+ }
+ return 4;
+ }
+
+
+ CSignature* test_graph_signature_;
+ Node* parameter_nodes_[4];
+ uint32_t return_parameter_index_;
};
+template <>
+class BufferedRawMachineAssemblerTester<void>
+ : public RawMachineAssemblerTester<void> {
+ public:
+ BufferedRawMachineAssemblerTester(MachineType p0 = MachineType::None(),
+ MachineType p1 = MachineType::None(),
+ MachineType p2 = MachineType::None(),
+ MachineType p3 = MachineType::None())
+ : RawMachineAssemblerTester<void>(
+ p0 == MachineType::None() ? MachineType::None()
+ : MachineType::Pointer(),
+ p1 == MachineType::None() ? MachineType::None()
+ : MachineType::Pointer(),
+ p2 == MachineType::None() ? MachineType::None()
+ : MachineType::Pointer(),
+ p3 == MachineType::None() ? MachineType::None()
+ : MachineType::Pointer()),
+ test_graph_signature_(
+ CSignature::New(RawMachineAssemblerTester<void>::main_zone(),
+ MachineType::None(), p0, p1, p2, p3)) {
+ parameter_nodes_[0] = p0 == MachineType::None()
+ ? nullptr
+ : Load(p0, RawMachineAssembler::Parameter(0));
+ parameter_nodes_[1] = p1 == MachineType::None()
+ ? nullptr
+ : Load(p1, RawMachineAssembler::Parameter(1));
+ parameter_nodes_[2] = p2 == MachineType::None()
+ ? nullptr
+ : Load(p2, RawMachineAssembler::Parameter(2));
+ parameter_nodes_[3] = p3 == MachineType::None()
+ ? nullptr
+ : Load(p3, RawMachineAssembler::Parameter(3));
+ }
+
+
+ // The BufferedRawMachineAssemblerTester does not pass parameters directly
+ // to the constructed IR graph. Instead it passes a pointer to the parameter
+ // to the IR graph, and adds Load nodes to the IR graph to load the
+ // 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);
+ return parameter_nodes_[index];
+ }
+
+
+ void Call() {
+ test_graph_signature_->VerifyParams();
+ CallHelper<void>::Call();
+ }
+
+ template <typename P0>
+ void Call(P0 p0) {
+ test_graph_signature_->VerifyParams<P0>();
+ CallHelper<void>::Call(reinterpret_cast<void*>(&p0));
+ }
+
+ template <typename P0, typename P1>
+ void Call(P0 p0, P1 p1) {
+ test_graph_signature_->VerifyParams<P0, P1>();
+ CallHelper<void>::Call(reinterpret_cast<void*>(&p0),
+ reinterpret_cast<void*>(&p1));
+ }
+
+ template <typename P0, typename P1, typename P2>
+ void Call(P0 p0, P1 p1, P2 p2) {
+ test_graph_signature_->VerifyParams<P0, P1, P2>();
+ CallHelper<void>::Call(reinterpret_cast<void*>(&p0),
+ reinterpret_cast<void*>(&p1),
+ reinterpret_cast<void*>(&p2));
+ }
+
+ template <typename P0, typename P1, typename P2, typename P3>
+ void Call(P0 p0, P1 p1, P2 p2, P3 p3) {
+ test_graph_signature_->VerifyParams<P0, P1, P2, P3>();
+ CallHelper<void>::Call(
+ reinterpret_cast<void*>(&p0), reinterpret_cast<void*>(&p1),
+ reinterpret_cast<void*>(&p2), reinterpret_cast<void*>(&p3));
+ }
+
+ private:
+ CSignature* test_graph_signature_;
+ Node* parameter_nodes_[4];
+};
static const bool USE_RESULT_BUFFER = true;
static const bool USE_RETURN_REGISTER = false;
static const int32_t CHECK_VALUE = 0x99BEEDCE;
@@ -121,13 +302,15 @@
// TODO(titzer): use the C-style calling convention, or any register-based
// calling convention for binop tests.
-template <typename CType, MachineType rep, bool use_result_buffer>
+template <typename CType, bool use_result_buffer>
class BinopTester {
public:
- explicit BinopTester(RawMachineAssemblerTester<int32_t>* tester)
+ explicit BinopTester(RawMachineAssemblerTester<int32_t>* tester,
+ MachineType rep)
: T(tester),
param0(T->LoadFromPointer(&p0, rep)),
param1(T->LoadFromPointer(&p1, rep)),
+ rep(rep),
p0(static_cast<CType>(0)),
p1(static_cast<CType>(0)),
result(static_cast<CType>(0)) {}
@@ -143,13 +326,14 @@
CHECK_EQ(CHECK_VALUE, T->Call());
return result;
} else {
- return T->Call();
+ return static_cast<CType>(T->Call());
}
}
void AddReturn(Node* val) {
if (use_result_buffer) {
- T->Store(rep, T->PointerConstant(&result), T->Int32Constant(0), val);
+ T->Store(rep.representation(), T->PointerConstant(&result),
+ T->Int32Constant(0), val, kNoWriteBarrier);
T->Return(T->Int32Constant(CHECK_VALUE));
} else {
T->Return(val);
@@ -168,6 +352,7 @@
}
protected:
+ MachineType rep;
CType p0;
CType p1;
CType result;
@@ -176,21 +361,31 @@
// A helper class for testing code sequences that take two int parameters and
// return an int value.
-class Int32BinopTester
- : public BinopTester<int32_t, kMachInt32, USE_RETURN_REGISTER> {
+class Int32BinopTester : public BinopTester<int32_t, USE_RETURN_REGISTER> {
public:
explicit Int32BinopTester(RawMachineAssemblerTester<int32_t>* tester)
- : BinopTester<int32_t, kMachInt32, USE_RETURN_REGISTER>(tester) {}
+ : BinopTester<int32_t, USE_RETURN_REGISTER>(tester,
+ MachineType::Int32()) {}
+};
+
+
+// A helper class for testing code sequences that take two int parameters and
+// return an int value.
+class Int64BinopTester : public BinopTester<int64_t, USE_RETURN_REGISTER> {
+ public:
+ explicit Int64BinopTester(RawMachineAssemblerTester<int32_t>* tester)
+ : BinopTester<int64_t, USE_RETURN_REGISTER>(tester,
+ MachineType::Int64()) {}
};
// A helper class for testing code sequences that take two uint parameters and
// return an uint value.
-class Uint32BinopTester
- : public BinopTester<uint32_t, kMachUint32, USE_RETURN_REGISTER> {
+class Uint32BinopTester : public BinopTester<uint32_t, USE_RETURN_REGISTER> {
public:
explicit Uint32BinopTester(RawMachineAssemblerTester<int32_t>* tester)
- : BinopTester<uint32_t, kMachUint32, USE_RETURN_REGISTER>(tester) {}
+ : BinopTester<uint32_t, USE_RETURN_REGISTER>(tester,
+ MachineType::Uint32()) {}
uint32_t call(uint32_t a0, uint32_t a1) {
p0 = a0;
@@ -200,14 +395,24 @@
};
+// A helper class for testing code sequences that take two float parameters and
+// return a float value.
+// TODO(titzer): figure out how to return floats correctly on ia32.
+class Float32BinopTester : public BinopTester<float, USE_RESULT_BUFFER> {
+ public:
+ explicit Float32BinopTester(RawMachineAssemblerTester<int32_t>* tester)
+ : BinopTester<float, USE_RESULT_BUFFER>(tester, MachineType::Float32()) {}
+};
+
+
// A helper class for testing code sequences that take two double parameters and
// return a double value.
// TODO(titzer): figure out how to return doubles correctly on ia32.
-class Float64BinopTester
- : public BinopTester<double, kMachFloat64, USE_RESULT_BUFFER> {
+class Float64BinopTester : public BinopTester<double, USE_RESULT_BUFFER> {
public:
explicit Float64BinopTester(RawMachineAssemblerTester<int32_t>* tester)
- : BinopTester<double, kMachFloat64, USE_RESULT_BUFFER>(tester) {}
+ : BinopTester<double, USE_RESULT_BUFFER>(tester, MachineType::Float64()) {
+ }
};
@@ -215,22 +420,22 @@
// and return a pointer value.
// TODO(titzer): pick word size of pointers based on V8_TARGET.
template <typename Type>
-class PointerBinopTester
- : public BinopTester<Type*, kMachPtr, USE_RETURN_REGISTER> {
+class PointerBinopTester : public BinopTester<Type*, USE_RETURN_REGISTER> {
public:
explicit PointerBinopTester(RawMachineAssemblerTester<int32_t>* tester)
- : BinopTester<Type*, kMachPtr, USE_RETURN_REGISTER>(tester) {}
+ : BinopTester<Type*, USE_RETURN_REGISTER>(tester,
+ MachineType::Pointer()) {}
};
// A helper class for testing code sequences that take two tagged parameters and
// return a tagged value.
template <typename Type>
-class TaggedBinopTester
- : public BinopTester<Type*, kMachAnyTagged, USE_RETURN_REGISTER> {
+class TaggedBinopTester : public BinopTester<Type*, USE_RETURN_REGISTER> {
public:
explicit TaggedBinopTester(RawMachineAssemblerTester<int32_t>* tester)
- : BinopTester<Type*, kMachAnyTagged, USE_RETURN_REGISTER>(tester) {}
+ : BinopTester<Type*, USE_RETURN_REGISTER>(tester,
+ MachineType::AnyTagged()) {}
};
// A helper class for testing compares. Wraps a machine opcode and provides
@@ -240,7 +445,7 @@
explicit CompareWrapper(IrOpcode::Value op) : opcode(op) {}
Node* MakeNode(RawMachineAssemblerTester<int32_t>* m, Node* a, Node* b) {
- return m->NewNode(op(m->machine()), a, b);
+ return m->AddNode(op(m->machine()), a, b);
}
const Operator* op(MachineOperatorBuilder* machine) {
@@ -332,6 +537,24 @@
void RunLeft(RawMachineAssemblerTester<int32_t>* m);
void RunRight(RawMachineAssemblerTester<int32_t>* m);
};
+
+// TODO(bmeurer): Drop this crap once we switch to GTest/Gmock.
+static inline void CheckFloatEq(volatile float x, volatile float y) {
+ if (std::isnan(x)) {
+ CHECK(std::isnan(y));
+ } else {
+ CHECK_EQ(x, y);
+ }
+}
+
+static inline void CheckDoubleEq(volatile double x, volatile double y) {
+ if (std::isnan(x)) {
+ CHECK(std::isnan(y));
+ } else {
+ CHECK_EQ(x, y);
+ }
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8