Update V8 to version 4.1.0.21
This is a cherry-pick of all commits up to and including the
4.1.0.21 cherry-pick in Chromium.
Original commit message:
Version 4.1.0.21 (cherry-pick)
Merged 206e9136bde0f2b5ae8cb77afbb1e7833e5bd412
Unlink pages from the space page list after evacuation.
BUG=430201
LOG=N
R=jkummerow@chromium.org
Review URL: https://codereview.chromium.org/953813002
Cr-Commit-Position: refs/branch-heads/4.1@{#22}
Cr-Branched-From: 2e08d2a7aa9d65d269d8c57aba82eb38a8cb0a18-refs/heads/candidates@{#25353}
---
FPIIM-449
Change-Id: I8c23c7bbb70772b4858fe8a47b64fa97ee0d1f8c
diff --git a/src/compiler/common-operator.cc b/src/compiler/common-operator.cc
index 19792bd..a6cca45 100644
--- a/src/compiler/common-operator.cc
+++ b/src/compiler/common-operator.cc
@@ -7,6 +7,8 @@
#include "src/assembler.h"
#include "src/base/lazy-instance.h"
#include "src/compiler/linkage.h"
+#include "src/compiler/opcodes.h"
+#include "src/compiler/operator.h"
#include "src/unique.h"
#include "src/zone.h"
@@ -14,209 +16,430 @@
namespace internal {
namespace compiler {
-namespace {
-
-// TODO(turbofan): Use size_t instead of int here.
-class ControlOperator : public Operator1<int> {
- public:
- ControlOperator(IrOpcode::Value opcode, Properties properties, int inputs,
- int outputs, int controls, const char* mnemonic)
- : Operator1<int>(opcode, properties, inputs, outputs, mnemonic,
- controls) {}
-
- virtual OStream& PrintParameter(OStream& os) const FINAL { return os; }
-};
-
-} // namespace
-
-
-// Specialization for static parameters of type {ExternalReference}.
-template <>
-struct StaticParameterTraits<ExternalReference> {
- static OStream& PrintTo(OStream& os, ExternalReference reference) {
- os << reference.address();
- // TODO(bmeurer): Move to operator<<(os, ExternalReference)
- const Runtime::Function* function =
- Runtime::FunctionForEntry(reference.address());
- if (function) {
- os << " <" << function->name << ".entry>";
- }
- return os;
+std::ostream& operator<<(std::ostream& os, BranchHint hint) {
+ switch (hint) {
+ case BranchHint::kNone:
+ return os << "None";
+ case BranchHint::kTrue:
+ return os << "True";
+ case BranchHint::kFalse:
+ return os << "False";
}
- static int HashCode(ExternalReference reference) {
- return bit_cast<int>(static_cast<uint32_t>(
- reinterpret_cast<uintptr_t>(reference.address())));
+ UNREACHABLE();
+ return os;
+}
+
+
+BranchHint BranchHintOf(const Operator* const op) {
+ DCHECK_EQ(IrOpcode::kBranch, op->opcode());
+ return OpParameter<BranchHint>(op);
+}
+
+
+bool operator==(SelectParameters const& lhs, SelectParameters const& rhs) {
+ return lhs.type() == rhs.type() && lhs.hint() == rhs.hint();
+}
+
+
+bool operator!=(SelectParameters const& lhs, SelectParameters const& rhs) {
+ return !(lhs == rhs);
+}
+
+
+size_t hash_value(SelectParameters const& p) {
+ return base::hash_combine(p.type(), p.hint());
+}
+
+
+std::ostream& operator<<(std::ostream& os, SelectParameters const& p) {
+ return os << p.type() << "|" << p.hint();
+}
+
+
+SelectParameters const& SelectParametersOf(const Operator* const op) {
+ DCHECK_EQ(IrOpcode::kSelect, op->opcode());
+ return OpParameter<SelectParameters>(op);
+}
+
+
+size_t hash_value(OutputFrameStateCombine const& sc) {
+ return base::hash_combine(sc.kind_, sc.parameter_);
+}
+
+
+std::ostream& operator<<(std::ostream& os, OutputFrameStateCombine const& sc) {
+ switch (sc.kind_) {
+ case OutputFrameStateCombine::kPushOutput:
+ if (sc.parameter_ == 0) return os << "Ignore";
+ return os << "Push(" << sc.parameter_ << ")";
+ case OutputFrameStateCombine::kPokeAt:
+ return os << "PokeAt(" << sc.parameter_ << ")";
}
- static bool Equals(ExternalReference lhs, ExternalReference rhs) {
- return lhs == rhs;
- }
-};
+ UNREACHABLE();
+ return os;
+}
-#define SHARED_OP_LIST(V) \
- V(Dead, Operator::kFoldable, 0, 0) \
- V(End, Operator::kFoldable, 0, 1) \
- V(Branch, Operator::kFoldable, 1, 1) \
- V(IfTrue, Operator::kFoldable, 0, 1) \
- V(IfFalse, Operator::kFoldable, 0, 1) \
- V(Throw, Operator::kFoldable, 1, 1) \
- V(Return, Operator::kNoProperties, 1, 1)
+bool operator==(FrameStateCallInfo const& lhs, FrameStateCallInfo const& rhs) {
+ return lhs.type() == rhs.type() && lhs.bailout_id() == rhs.bailout_id() &&
+ lhs.state_combine() == rhs.state_combine();
+}
-struct CommonOperatorBuilderImpl FINAL {
-#define SHARED(Name, properties, value_input_count, control_input_count) \
- struct Name##Operator FINAL : public ControlOperator { \
- Name##Operator() \
- : ControlOperator(IrOpcode::k##Name, properties, value_input_count, 0, \
- control_input_count, #Name) {} \
- }; \
+bool operator!=(FrameStateCallInfo const& lhs, FrameStateCallInfo const& rhs) {
+ return !(lhs == rhs);
+}
+
+
+size_t hash_value(FrameStateCallInfo const& info) {
+ return base::hash_combine(info.type(), info.bailout_id(),
+ info.state_combine());
+}
+
+
+std::ostream& operator<<(std::ostream& os, FrameStateCallInfo const& info) {
+ return os << info.type() << ", " << info.bailout_id() << ", "
+ << info.state_combine();
+}
+
+
+#define CACHED_OP_LIST(V) \
+ V(Dead, Operator::kFoldable, 0, 0, 0, 1) \
+ V(End, Operator::kFoldable, 0, 0, 1, 0) \
+ V(IfTrue, Operator::kFoldable, 0, 0, 1, 1) \
+ V(IfFalse, Operator::kFoldable, 0, 0, 1, 1) \
+ V(Throw, Operator::kFoldable, 1, 1, 1, 1) \
+ V(Return, Operator::kNoProperties, 1, 1, 1, 1)
+
+
+#define CACHED_LOOP_LIST(V) \
+ V(1) \
+ V(2)
+
+
+#define CACHED_MERGE_LIST(V) \
+ V(1) \
+ V(2) \
+ V(3) \
+ V(4) \
+ V(5) \
+ V(6) \
+ V(7) \
+ V(8)
+
+
+#define CACHED_PARAMETER_LIST(V) \
+ V(0) \
+ V(1) \
+ V(2) \
+ V(3) \
+ V(4) \
+ V(5) \
+ V(6)
+
+
+struct CommonOperatorGlobalCache FINAL {
+#define CACHED(Name, properties, value_input_count, effect_input_count, \
+ control_input_count, control_output_count) \
+ struct Name##Operator FINAL : public Operator { \
+ Name##Operator() \
+ : Operator(IrOpcode::k##Name, properties, #Name, value_input_count, \
+ effect_input_count, control_input_count, 0, 0, \
+ control_output_count) {} \
+ }; \
Name##Operator k##Name##Operator;
- SHARED_OP_LIST(SHARED)
-#undef SHARED
+ CACHED_OP_LIST(CACHED)
+#undef CACHED
- struct ControlEffectOperator FINAL : public SimpleOperator {
- ControlEffectOperator()
- : SimpleOperator(IrOpcode::kControlEffect, Operator::kPure, 0, 0,
- "ControlEffect") {}
+ template <BranchHint kBranchHint>
+ struct BranchOperator FINAL : public Operator1<BranchHint> {
+ BranchOperator()
+ : Operator1<BranchHint>( // --
+ IrOpcode::kBranch, Operator::kFoldable, // opcode
+ "Branch", // name
+ 1, 0, 1, 0, 0, 2, // counts
+ kBranchHint) {} // parameter
};
- ControlEffectOperator kControlEffectOperator;
+ BranchOperator<BranchHint::kNone> kBranchNoneOperator;
+ BranchOperator<BranchHint::kTrue> kBranchTrueOperator;
+ BranchOperator<BranchHint::kFalse> kBranchFalseOperator;
+
+ template <size_t kInputCount>
+ struct LoopOperator FINAL : public Operator {
+ LoopOperator()
+ : Operator( // --
+ IrOpcode::kLoop, Operator::kFoldable, // opcode
+ "Loop", // name
+ 0, 0, kInputCount, 0, 0, 1) {} // counts
+ };
+#define CACHED_LOOP(input_count) \
+ LoopOperator<input_count> kLoop##input_count##Operator;
+ CACHED_LOOP_LIST(CACHED_LOOP)
+#undef CACHED_LOOP
+
+ template <size_t kInputCount>
+ struct MergeOperator FINAL : public Operator {
+ MergeOperator()
+ : Operator( // --
+ IrOpcode::kMerge, Operator::kFoldable, // opcode
+ "Merge", // name
+ 0, 0, kInputCount, 0, 0, 1) {} // counts
+ };
+#define CACHED_MERGE(input_count) \
+ MergeOperator<input_count> kMerge##input_count##Operator;
+ CACHED_MERGE_LIST(CACHED_MERGE)
+#undef CACHED_MERGE
+
+ template <int kIndex>
+ struct ParameterOperator FINAL : public Operator1<int> {
+ ParameterOperator()
+ : Operator1<int>( // --
+ IrOpcode::kParameter, Operator::kPure, // opcode
+ "Parameter", // name
+ 1, 0, 0, 1, 0, 0, // counts,
+ kIndex) {} // parameter
+ };
+#define CACHED_PARAMETER(index) \
+ ParameterOperator<index> kParameter##index##Operator;
+ CACHED_PARAMETER_LIST(CACHED_PARAMETER)
+#undef CACHED_PARAMETER
};
-static base::LazyInstance<CommonOperatorBuilderImpl>::type kImpl =
+static base::LazyInstance<CommonOperatorGlobalCache>::type kCache =
LAZY_INSTANCE_INITIALIZER;
CommonOperatorBuilder::CommonOperatorBuilder(Zone* zone)
- : impl_(kImpl.Get()), zone_(zone) {}
+ : cache_(kCache.Get()), zone_(zone) {}
-#define SHARED(Name, properties, value_input_count, control_input_count) \
- const Operator* CommonOperatorBuilder::Name() { \
- return &impl_.k##Name##Operator; \
+#define CACHED(Name, properties, value_input_count, effect_input_count, \
+ control_input_count, control_output_count) \
+ const Operator* CommonOperatorBuilder::Name() { \
+ return &cache_.k##Name##Operator; \
}
-SHARED_OP_LIST(SHARED)
-#undef SHARED
+CACHED_OP_LIST(CACHED)
+#undef CACHED
+
+
+const Operator* CommonOperatorBuilder::Branch(BranchHint hint) {
+ switch (hint) {
+ case BranchHint::kNone:
+ return &cache_.kBranchNoneOperator;
+ case BranchHint::kTrue:
+ return &cache_.kBranchTrueOperator;
+ case BranchHint::kFalse:
+ return &cache_.kBranchFalseOperator;
+ }
+ UNREACHABLE();
+ return nullptr;
+}
const Operator* CommonOperatorBuilder::Start(int num_formal_parameters) {
// Outputs are formal parameters, plus context, receiver, and JSFunction.
const int value_output_count = num_formal_parameters + 3;
- return new (zone()) ControlOperator(IrOpcode::kStart, Operator::kFoldable, 0,
- value_output_count, 0, "Start");
+ return new (zone()) Operator( // --
+ IrOpcode::kStart, Operator::kFoldable, // opcode
+ "Start", // name
+ 0, 0, 0, value_output_count, 1, 1); // counts
}
-const Operator* CommonOperatorBuilder::Merge(int controls) {
- return new (zone()) ControlOperator(IrOpcode::kMerge, Operator::kFoldable, 0,
- 0, controls, "Merge");
+const Operator* CommonOperatorBuilder::Loop(int control_input_count) {
+ switch (control_input_count) {
+#define CACHED_LOOP(input_count) \
+ case input_count: \
+ return &cache_.kLoop##input_count##Operator;
+ CACHED_LOOP_LIST(CACHED_LOOP)
+#undef CACHED_LOOP
+ default:
+ break;
+ }
+ // Uncached.
+ return new (zone()) Operator( // --
+ IrOpcode::kLoop, Operator::kFoldable, // opcode
+ "Loop", // name
+ 0, 0, control_input_count, 0, 0, 1); // counts
}
-const Operator* CommonOperatorBuilder::Loop(int controls) {
- return new (zone()) ControlOperator(IrOpcode::kLoop, Operator::kFoldable, 0,
- 0, controls, "Loop");
+const Operator* CommonOperatorBuilder::Merge(int control_input_count) {
+ switch (control_input_count) {
+#define CACHED_MERGE(input_count) \
+ case input_count: \
+ return &cache_.kMerge##input_count##Operator;
+ CACHED_MERGE_LIST(CACHED_MERGE)
+#undef CACHED_MERGE
+ default:
+ break;
+ }
+ // Uncached.
+ return new (zone()) Operator( // --
+ IrOpcode::kMerge, Operator::kFoldable, // opcode
+ "Merge", // name
+ 0, 0, control_input_count, 0, 0, 1); // counts
+}
+
+
+const Operator* CommonOperatorBuilder::Terminate(int effects) {
+ return new (zone()) Operator( // --
+ IrOpcode::kTerminate, Operator::kPure, // opcode
+ "Terminate", // name
+ 0, effects, 1, 0, 0, 1); // counts
}
const Operator* CommonOperatorBuilder::Parameter(int index) {
- return new (zone()) Operator1<int>(IrOpcode::kParameter, Operator::kPure, 1,
- 1, "Parameter", index);
+ switch (index) {
+#define CACHED_PARAMETER(index) \
+ case index: \
+ return &cache_.kParameter##index##Operator;
+ CACHED_PARAMETER_LIST(CACHED_PARAMETER)
+#undef CACHED_PARAMETER
+ default:
+ break;
+ }
+ // Uncached.
+ return new (zone()) Operator1<int>( // --
+ IrOpcode::kParameter, Operator::kPure, // opcode
+ "Parameter", // name
+ 1, 0, 0, 1, 0, 0, // counts
+ index); // parameter
}
const Operator* CommonOperatorBuilder::Int32Constant(int32_t value) {
- return new (zone()) Operator1<int32_t>(
- IrOpcode::kInt32Constant, Operator::kPure, 0, 1, "Int32Constant", value);
+ return new (zone()) Operator1<int32_t>( // --
+ IrOpcode::kInt32Constant, Operator::kPure, // opcode
+ "Int32Constant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
const Operator* CommonOperatorBuilder::Int64Constant(int64_t value) {
- return new (zone()) Operator1<int64_t>(
- IrOpcode::kInt64Constant, Operator::kPure, 0, 1, "Int64Constant", value);
+ return new (zone()) Operator1<int64_t>( // --
+ IrOpcode::kInt64Constant, Operator::kPure, // opcode
+ "Int64Constant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
const Operator* CommonOperatorBuilder::Float32Constant(volatile float value) {
return new (zone())
- Operator1<float>(IrOpcode::kFloat32Constant, Operator::kPure, 0, 1,
- "Float32Constant", value);
+ Operator1<float, base::bit_equal_to<float>, base::bit_hash<float>>( // --
+ IrOpcode::kFloat32Constant, Operator::kPure, // opcode
+ "Float32Constant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
const Operator* CommonOperatorBuilder::Float64Constant(volatile double value) {
- return new (zone())
- Operator1<double>(IrOpcode::kFloat64Constant, Operator::kPure, 0, 1,
- "Float64Constant", value);
+ return new (zone()) Operator1<double, base::bit_equal_to<double>,
+ base::bit_hash<double>>( // --
+ IrOpcode::kFloat64Constant, Operator::kPure, // opcode
+ "Float64Constant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
const Operator* CommonOperatorBuilder::ExternalConstant(
const ExternalReference& value) {
- return new (zone())
- Operator1<ExternalReference>(IrOpcode::kExternalConstant, Operator::kPure,
- 0, 1, "ExternalConstant", value);
+ return new (zone()) Operator1<ExternalReference>( // --
+ IrOpcode::kExternalConstant, Operator::kPure, // opcode
+ "ExternalConstant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
const Operator* CommonOperatorBuilder::NumberConstant(volatile double value) {
- return new (zone())
- Operator1<double>(IrOpcode::kNumberConstant, Operator::kPure, 0, 1,
- "NumberConstant", value);
+ return new (zone()) Operator1<double, base::bit_equal_to<double>,
+ base::bit_hash<double>>( // --
+ IrOpcode::kNumberConstant, Operator::kPure, // opcode
+ "NumberConstant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
const Operator* CommonOperatorBuilder::HeapConstant(
- const Unique<Object>& value) {
- return new (zone()) Operator1<Unique<Object> >(
- IrOpcode::kHeapConstant, Operator::kPure, 0, 1, "HeapConstant", value);
+ const Unique<HeapObject>& value) {
+ return new (zone()) Operator1<Unique<HeapObject>>( // --
+ IrOpcode::kHeapConstant, Operator::kPure, // opcode
+ "HeapConstant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
+}
+
+
+const Operator* CommonOperatorBuilder::Select(MachineType type,
+ BranchHint hint) {
+ return new (zone()) Operator1<SelectParameters>( // --
+ IrOpcode::kSelect, Operator::kPure, // opcode
+ "Select", // name
+ 3, 0, 0, 1, 0, 0, // counts
+ SelectParameters(type, hint)); // parameter
}
const Operator* CommonOperatorBuilder::Phi(MachineType type, int arguments) {
- DCHECK(arguments > 0); // Disallow empty phis.
- return new (zone()) Operator1<MachineType>(IrOpcode::kPhi, Operator::kPure,
- arguments, 1, "Phi", type);
+ DCHECK(arguments > 0); // Disallow empty phis.
+ return new (zone()) Operator1<MachineType>( // --
+ IrOpcode::kPhi, Operator::kPure, // opcode
+ "Phi", // name
+ arguments, 0, 1, 1, 0, 0, // counts
+ type); // parameter
}
const Operator* CommonOperatorBuilder::EffectPhi(int arguments) {
- DCHECK(arguments > 0); // Disallow empty phis.
- return new (zone()) Operator1<int>(IrOpcode::kEffectPhi, Operator::kPure, 0,
- 0, "EffectPhi", arguments);
-}
-
-
-const Operator* CommonOperatorBuilder::ControlEffect() {
- return &impl_.kControlEffectOperator;
+ DCHECK(arguments > 0); // Disallow empty phis.
+ return new (zone()) Operator( // --
+ IrOpcode::kEffectPhi, Operator::kPure, // opcode
+ "EffectPhi", // name
+ 0, arguments, 1, 0, 1, 0); // counts
}
const Operator* CommonOperatorBuilder::ValueEffect(int arguments) {
- DCHECK(arguments > 0); // Disallow empty value effects.
- return new (zone()) SimpleOperator(IrOpcode::kValueEffect, Operator::kPure,
- arguments, 0, "ValueEffect");
+ DCHECK(arguments > 0); // Disallow empty value effects.
+ return new (zone()) Operator( // --
+ IrOpcode::kValueEffect, Operator::kPure, // opcode
+ "ValueEffect", // name
+ arguments, 0, 0, 0, 1, 0); // counts
}
const Operator* CommonOperatorBuilder::Finish(int arguments) {
- DCHECK(arguments > 0); // Disallow empty finishes.
- return new (zone()) Operator1<int>(IrOpcode::kFinish, Operator::kPure, 1, 1,
- "Finish", arguments);
+ DCHECK(arguments > 0); // Disallow empty finishes.
+ return new (zone()) Operator( // --
+ IrOpcode::kFinish, Operator::kPure, // opcode
+ "Finish", // name
+ 1, arguments, 0, 1, 0, 0); // counts
}
const Operator* CommonOperatorBuilder::StateValues(int arguments) {
- return new (zone()) Operator1<int>(IrOpcode::kStateValues, Operator::kPure,
- arguments, 1, "StateValues", arguments);
+ return new (zone()) Operator( // --
+ IrOpcode::kStateValues, Operator::kPure, // opcode
+ "StateValues", // name
+ arguments, 0, 0, 1, 0, 0); // counts
}
const Operator* CommonOperatorBuilder::FrameState(
FrameStateType type, BailoutId bailout_id,
OutputFrameStateCombine state_combine, MaybeHandle<JSFunction> jsfunction) {
- return new (zone()) Operator1<FrameStateCallInfo>(
- IrOpcode::kFrameState, Operator::kPure, 4, 1, "FrameState",
+ return new (zone()) Operator1<FrameStateCallInfo>( // --
+ IrOpcode::kFrameState, Operator::kPure, // opcode
+ "FrameState", // name
+ 4, 0, 0, 1, 0, 0, // counts
FrameStateCallInfo(type, bailout_id, state_combine, jsfunction));
}
@@ -224,18 +447,17 @@
const Operator* CommonOperatorBuilder::Call(const CallDescriptor* descriptor) {
class CallOperator FINAL : public Operator1<const CallDescriptor*> {
public:
- // TODO(titzer): Operator still uses int, whereas CallDescriptor uses
- // size_t.
CallOperator(const CallDescriptor* descriptor, const char* mnemonic)
: Operator1<const CallDescriptor*>(
- IrOpcode::kCall, descriptor->properties(),
- static_cast<int>(descriptor->InputCount() +
- descriptor->FrameStateCount()),
- static_cast<int>(descriptor->ReturnCount()), mnemonic,
- descriptor) {}
+ IrOpcode::kCall, descriptor->properties(), mnemonic,
+ descriptor->InputCount() + descriptor->FrameStateCount(),
+ Operator::ZeroIfPure(descriptor->properties()),
+ Operator::ZeroIfPure(descriptor->properties()),
+ descriptor->ReturnCount(),
+ Operator::ZeroIfPure(descriptor->properties()), 0, descriptor) {}
- virtual OStream& PrintParameter(OStream& os) const OVERRIDE {
- return os << "[" << *parameter() << "]";
+ void PrintParameter(std::ostream& os) const OVERRIDE {
+ os << "[" << *parameter() << "]";
}
};
return new (zone()) CallOperator(descriptor, "Call");
@@ -243,8 +465,11 @@
const Operator* CommonOperatorBuilder::Projection(size_t index) {
- return new (zone()) Operator1<size_t>(IrOpcode::kProjection, Operator::kPure,
- 1, 1, "Projection", index);
+ return new (zone()) Operator1<size_t>( // --
+ IrOpcode::kProjection, Operator::kPure, // opcode
+ "Projection", // name
+ 1, 0, 0, 1, 0, 0, // counts
+ index); // parameter
}
} // namespace compiler