UpdateStateValues(&stack_node_, parameters_count() + locals_count(),
stack_height());
- const Operator* op = common()->FrameState(JS_FRAME, ast_id, combine);
+ const Operator* op = common()->FrameState(ast_id, combine);
return graph()->NewNode(op, parameters_node_, locals_node_, stack_node_,
GetContext(),
void AstGraphBuilder::PrepareFrameState(Node* node, BailoutId ast_id,
OutputFrameStateCombine combine) {
if (OperatorProperties::HasFrameStateInput(node->op())) {
- DCHECK(NodeProperties::GetFrameStateInput(node)->opcode() ==
- IrOpcode::kDead);
- NodeProperties::ReplaceFrameStateInput(
- node, environment()->Checkpoint(ast_id, combine));
+ int frame_state_index = NodeProperties::GetFrameStateIndex(node);
+
+ DCHECK(node->InputAt(frame_state_index)->op()->opcode() == IrOpcode::kDead);
+
+ Node* frame_state_node = environment()->Checkpoint(ast_id, combine);
+ node->ReplaceInput(frame_state_index, frame_state_node);
}
}
// (just after the code address).
InstructionOperandConverter converter(this, instr);
// Deoptimization info starts at argument 1
- size_t frame_state_offset = 1;
+ int frame_state_offset = 1;
FrameStateDescriptor* descriptor =
GetFrameStateDescriptor(instr, frame_state_offset);
int pc_offset = masm()->pc_offset();
// Make sure all the values live in stack slots or they are immediates.
// (The values should not live in register because registers are clobbered
// by calls.)
- for (size_t i = 0; i < descriptor->size(); i++) {
+ for (int i = 0; i < descriptor->size(); i++) {
InstructionOperand* op = instr->InputAt(frame_state_offset + 1 + i);
CHECK(op->IsStackSlot() || op->IsImmediate());
}
FrameStateDescriptor* CodeGenerator::GetFrameStateDescriptor(
- Instruction* instr, size_t frame_state_offset) {
+ Instruction* instr, int frame_state_offset) {
InstructionOperandConverter i(this, instr);
- InstructionSequence::StateId state_id = InstructionSequence::StateId::FromInt(
- i.InputInt32(static_cast<int>(frame_state_offset)));
+ InstructionSequence::StateId state_id =
+ InstructionSequence::StateId::FromInt(i.InputInt32(frame_state_offset));
return code()->GetFrameStateDescriptor(state_id);
}
void CodeGenerator::BuildTranslationForFrameStateDescriptor(
FrameStateDescriptor* descriptor, Instruction* instr,
- Translation* translation, size_t frame_state_offset,
+ Translation* translation, int frame_state_offset,
OutputFrameStateCombine state_combine) {
// Outer-most state must be added to translation first.
if (descriptor->outer_state() != NULL) {
- BuildTranslationForFrameStateDescriptor(descriptor->outer_state(), instr,
- translation, frame_state_offset,
- kIgnoreOutput);
+ BuildTranslationForFrameStateDescriptor(
+ descriptor->outer_state(), instr, translation,
+ frame_state_offset + descriptor->size(), kIgnoreOutput);
}
- int id = Translation::kSelfLiteralId;
- if (!descriptor->jsfunction().is_null()) {
- id = DefineDeoptimizationLiteral(
- Handle<Object>::cast(descriptor->jsfunction().ToHandleChecked()));
- }
-
- switch (descriptor->type()) {
- case JS_FRAME:
- translation->BeginJSFrame(
- descriptor->bailout_id(), id,
- static_cast<unsigned int>(descriptor->GetHeight(state_combine)));
+ int height = descriptor->size() - descriptor->parameters_count();
+ switch (state_combine) {
+ case kPushOutput:
+ height++;
break;
- case ARGUMENTS_ADAPTOR:
- translation->BeginArgumentsAdaptorFrame(
- id, static_cast<unsigned int>(descriptor->parameters_count()));
+ case kIgnoreOutput:
break;
}
- frame_state_offset += descriptor->outer_state()->GetTotalSize();
- for (size_t i = 0; i < descriptor->size(); i++) {
- AddTranslationForOperand(
- translation, instr,
- instr->InputAt(static_cast<int>(frame_state_offset + i)));
+ translation->BeginJSFrame(descriptor->bailout_id(),
+ Translation::kSelfLiteralId, height);
+
+ for (int i = 0; i < descriptor->size(); i++) {
+ AddTranslationForOperand(translation, instr,
+ instr->InputAt(i + frame_state_offset));
}
switch (state_combine) {
int CodeGenerator::BuildTranslation(Instruction* instr, int pc_offset,
- size_t frame_state_offset,
+ int frame_state_offset,
OutputFrameStateCombine state_combine) {
FrameStateDescriptor* descriptor =
GetFrameStateDescriptor(instr, frame_state_offset);
frame_state_offset++;
- Translation translation(
- &translations_, static_cast<int>(descriptor->GetFrameCount()),
- static_cast<int>(descriptor->GetJSFrameCount()), zone());
+ int frame_count = descriptor->GetFrameCount();
+ Translation translation(&translations_, frame_count, frame_count, zone());
BuildTranslationForFrameStateDescriptor(descriptor, instr, &translation,
frame_state_offset, state_combine);
void PopulateDeoptimizationData(Handle<Code> code);
int DefineDeoptimizationLiteral(Handle<Object> literal);
FrameStateDescriptor* GetFrameStateDescriptor(Instruction* instr,
- size_t frame_state_offset);
+ int frame_state_offset);
int BuildTranslation(Instruction* instr, int pc_offset,
- size_t frame_state_offset,
+ int frame_state_offset,
OutputFrameStateCombine state_combine);
void BuildTranslationForFrameStateDescriptor(
FrameStateDescriptor* descriptor, Instruction* instr,
- Translation* translation, size_t frame_state_offset,
+ Translation* translation, int frame_state_offset,
OutputFrameStateCombine state_combine);
void AddTranslationForOperand(Translation* translation, Instruction* instr,
InstructionOperand* op);
const Operator* CommonOperatorBuilder::FrameState(
- FrameStateType type, BailoutId bailout_id,
- OutputFrameStateCombine state_combine, MaybeHandle<JSFunction> jsfunction) {
+ BailoutId bailout_id, OutputFrameStateCombine combine) {
return new (zone()) Operator1<FrameStateCallInfo>(
IrOpcode::kFrameState, Operator::kPure, 4, 1, "FrameState",
- FrameStateCallInfo(type, bailout_id, state_combine, jsfunction));
+ FrameStateCallInfo(bailout_id, combine));
}
#define V8_COMPILER_COMMON_OPERATOR_H_
#include "src/compiler/machine-type.h"
-#include "src/unique.h"
namespace v8 {
namespace internal {
// Forward declarations.
class ExternalReference;
class OStream;
+template <typename>
+class Unique;
+class Zone;
namespace compiler {
};
-// The type of stack frame that a FrameState node represents.
-enum FrameStateType {
- JS_FRAME, // Represents an unoptimized JavaScriptFrame.
- ARGUMENTS_ADAPTOR // Represents an ArgumentsAdaptorFrame.
-};
-
-
class FrameStateCallInfo FINAL {
public:
- FrameStateCallInfo(
- FrameStateType type, BailoutId bailout_id,
- OutputFrameStateCombine state_combine,
- MaybeHandle<JSFunction> jsfunction = MaybeHandle<JSFunction>())
- : type_(type),
- bailout_id_(bailout_id),
- frame_state_combine_(state_combine),
- jsfunction_(jsfunction) {}
-
- FrameStateType type() const { return type_; }
+ FrameStateCallInfo(BailoutId bailout_id,
+ OutputFrameStateCombine state_combine)
+ : bailout_id_(bailout_id), frame_state_combine_(state_combine) {}
+
BailoutId bailout_id() const { return bailout_id_; }
OutputFrameStateCombine state_combine() const { return frame_state_combine_; }
- MaybeHandle<JSFunction> jsfunction() const { return jsfunction_; }
private:
- FrameStateType type_;
BailoutId bailout_id_;
OutputFrameStateCombine frame_state_combine_;
- MaybeHandle<JSFunction> jsfunction_;
};
const Operator* ValueEffect(int arguments);
const Operator* Finish(int arguments);
const Operator* StateValues(int arguments);
- const Operator* FrameState(
- FrameStateType type, BailoutId bailout_id,
- OutputFrameStateCombine state_combine,
- MaybeHandle<JSFunction> jsfunction = MaybeHandle<JSFunction>());
+ const Operator* FrameState(BailoutId bailout_id,
+ OutputFrameStateCombine combine);
const Operator* Call(const CallDescriptor* descriptor);
const Operator* Projection(size_t index);
size_t frame_state_value_count() const {
return (frame_state_descriptor == NULL)
? 0
- : (frame_state_descriptor->GetTotalSize() +
+ : (frame_state_descriptor->total_size() +
1); // Include deopt id.
}
};
Node* stack = m.NewNode(m.common()->StateValues(0));
Node* context_dummy = m.Int32Constant(0);
- Node* state_node = m.NewNode(
- m.common()->FrameState(JS_FRAME, bailout_id, kPushOutput), parameters,
- locals, stack, context_dummy, m.UndefinedConstant());
+ Node* state_node =
+ m.NewNode(m.common()->FrameState(bailout_id, kPushOutput), parameters,
+ locals, stack, context_dummy, m.UndefinedConstant());
Node* call = m.CallJS0(function_node, receiver, context, state_node);
m.Return(call);
Node* context_sentinel = m.Int32Constant(0);
Node* frame_state_before = m.NewNode(
- m.common()->FrameState(JS_FRAME, bailout_id_before, kPushOutput),
- parameters, locals, stack, context_sentinel, m.UndefinedConstant());
+ m.common()->FrameState(bailout_id_before, kPushOutput), parameters,
+ locals, stack, context_sentinel, m.UndefinedConstant());
// Build the call.
Node* call = m.CallFunctionStub0(function_node, receiver, context,
s.GetFrameStateDescriptor(deopt_id_before);
EXPECT_EQ(bailout_id_before, desc_before->bailout_id());
EXPECT_EQ(kPushOutput, desc_before->state_combine());
- EXPECT_EQ(1u, desc_before->parameters_count());
- EXPECT_EQ(1u, desc_before->locals_count());
- EXPECT_EQ(1u, desc_before->stack_count());
+ EXPECT_EQ(1, desc_before->parameters_count());
+ EXPECT_EQ(1, desc_before->locals_count());
+ EXPECT_EQ(1, desc_before->stack_count());
EXPECT_EQ(43, s.ToInt32(call_instr->InputAt(2)));
EXPECT_EQ(0, s.ToInt32(call_instr->InputAt(3)));
EXPECT_EQ(44, s.ToInt32(call_instr->InputAt(4)));
Node* parameters = m.NewNode(m.common()->StateValues(1), m.Int32Constant(63));
Node* locals = m.NewNode(m.common()->StateValues(1), m.Int32Constant(64));
Node* stack = m.NewNode(m.common()->StateValues(1), m.Int32Constant(65));
- Node* frame_state_parent = m.NewNode(
- m.common()->FrameState(JS_FRAME, bailout_id_parent, kIgnoreOutput),
- parameters, locals, stack, context, m.UndefinedConstant());
+ Node* frame_state_parent =
+ m.NewNode(m.common()->FrameState(bailout_id_parent, kIgnoreOutput),
+ parameters, locals, stack, context, m.UndefinedConstant());
Node* context2 = m.Int32Constant(46);
Node* parameters2 =
m.NewNode(m.common()->StateValues(1), m.Int32Constant(43));
Node* locals2 = m.NewNode(m.common()->StateValues(1), m.Int32Constant(44));
Node* stack2 = m.NewNode(m.common()->StateValues(1), m.Int32Constant(45));
- Node* frame_state_before = m.NewNode(
- m.common()->FrameState(JS_FRAME, bailout_id_before, kPushOutput),
- parameters2, locals2, stack2, context2, frame_state_parent);
+ Node* frame_state_before =
+ m.NewNode(m.common()->FrameState(bailout_id_before, kPushOutput),
+ parameters2, locals2, stack2, context2, frame_state_parent);
// Build the call.
Node* call = m.CallFunctionStub0(function_node, receiver, context2,
FrameStateDescriptor* desc_before =
s.GetFrameStateDescriptor(deopt_id_before);
EXPECT_EQ(bailout_id_before, desc_before->bailout_id());
- EXPECT_EQ(1u, desc_before->parameters_count());
- EXPECT_EQ(1u, desc_before->locals_count());
- EXPECT_EQ(1u, desc_before->stack_count());
+ EXPECT_EQ(1, desc_before->parameters_count());
+ EXPECT_EQ(1, desc_before->locals_count());
+ EXPECT_EQ(1, desc_before->stack_count());
EXPECT_EQ(63, s.ToInt32(call_instr->InputAt(2)));
// Context:
EXPECT_EQ(66, s.ToInt32(call_instr->InputAt(3)));
DCHECK_EQ(descriptor->stack_count(), stack->InputCount());
OperandGenerator g(this);
- for (int i = 0; i < static_cast<int>(descriptor->parameters_count()); i++) {
+ for (int i = 0; i < descriptor->parameters_count(); i++) {
inputs->push_back(UseOrImmediate(&g, parameters->InputAt(i)));
}
- if (descriptor->HasContext()) {
- inputs->push_back(UseOrImmediate(&g, context));
- }
- for (int i = 0; i < static_cast<int>(descriptor->locals_count()); i++) {
+ inputs->push_back(UseOrImmediate(&g, context));
+ for (int i = 0; i < descriptor->locals_count(); i++) {
inputs->push_back(UseOrImmediate(&g, locals->InputAt(i)));
}
- for (int i = 0; i < static_cast<int>(descriptor->stack_count()); i++) {
+ for (int i = 0; i < descriptor->stack_count(); i++) {
inputs->push_back(UseOrImmediate(&g, stack->InputAt(i)));
}
}
class FrameStateDescriptor : public ZoneObject {
public:
FrameStateDescriptor(const FrameStateCallInfo& state_info,
- size_t parameters_count, size_t locals_count,
- size_t stack_count,
+ int parameters_count, int locals_count, int stack_count,
FrameStateDescriptor* outer_state = NULL)
- : type_(state_info.type()),
- bailout_id_(state_info.bailout_id()),
+ : bailout_id_(state_info.bailout_id()),
frame_state_combine_(state_info.state_combine()),
parameters_count_(parameters_count),
locals_count_(locals_count),
stack_count_(stack_count),
- outer_state_(outer_state),
- jsfunction_(state_info.jsfunction()) {}
+ outer_state_(outer_state) {}
- FrameStateType type() const { return type_; }
BailoutId bailout_id() const { return bailout_id_; }
OutputFrameStateCombine state_combine() const { return frame_state_combine_; }
- size_t parameters_count() const { return parameters_count_; }
- size_t locals_count() const { return locals_count_; }
- size_t stack_count() const { return stack_count_; }
- FrameStateDescriptor* outer_state() const { return outer_state_; }
- MaybeHandle<JSFunction> jsfunction() const { return jsfunction_; }
+ int parameters_count() { return parameters_count_; }
+ int locals_count() { return locals_count_; }
+ int stack_count() { return stack_count_; }
+ FrameStateDescriptor* outer_state() { return outer_state_; }
+ void set_outer_state(FrameStateDescriptor* outer_state) {
+ outer_state_ = outer_state;
+ }
- size_t size() const {
+ int size() {
return parameters_count_ + locals_count_ + stack_count_ +
- (HasContext() ? 1 : 0);
+ 1; // Includes context.
}
- size_t GetTotalSize() const {
- size_t total_size = 0;
- for (const FrameStateDescriptor* iter = this; iter != NULL;
+ int total_size() {
+ int total_size = 0;
+ for (FrameStateDescriptor* iter = this; iter != NULL;
iter = iter->outer_state_) {
total_size += iter->size();
}
return total_size;
}
- size_t GetHeight(OutputFrameStateCombine override) const {
- size_t height = size() - parameters_count();
- switch (override) {
- case kPushOutput:
- ++height;
- break;
- case kIgnoreOutput:
- break;
- }
- return height;
- }
-
- size_t GetFrameCount() const {
- size_t count = 0;
- for (const FrameStateDescriptor* iter = this; iter != NULL;
+ int GetFrameCount() {
+ int count = 0;
+ for (FrameStateDescriptor* iter = this; iter != NULL;
iter = iter->outer_state_) {
++count;
}
return count;
}
- size_t GetJSFrameCount() const {
- size_t count = 0;
- for (const FrameStateDescriptor* iter = this; iter != NULL;
- iter = iter->outer_state_) {
- if (iter->type_ == JS_FRAME) {
- ++count;
- }
- }
- return count;
- }
-
- bool HasContext() const { return type_ == JS_FRAME; }
-
private:
- FrameStateType type_;
BailoutId bailout_id_;
OutputFrameStateCombine frame_state_combine_;
- size_t parameters_count_;
- size_t locals_count_;
- size_t stack_count_;
+ int parameters_count_;
+ int locals_count_;
+ int stack_count_;
FrameStateDescriptor* outer_state_;
- MaybeHandle<JSFunction> jsfunction_;
};
OStream& operator<<(OStream& os, const Constant& constant);
#include "src/compiler/node-properties-inl.h"
#include "src/compiler/simplified-operator.h"
#include "src/compiler/typer.h"
-#include "src/full-codegen.h"
#include "src/parser.h"
#include "src/rewriter.h"
#include "src/scopes.h"
// test cases, where similar code is currently duplicated).
static void Parse(Handle<JSFunction> function, CompilationInfoWithZone* info) {
CHECK(Parser::Parse(info));
+ info->SetOptimizing(BailoutId::None(), Handle<Code>(function->code()));
CHECK(Rewriter::Rewrite(info));
CHECK(Scope::Analyze(info));
CHECK_NE(NULL, info->scope());
DCHECK_EQ(IrOpcode::kReturn, unique_return->opcode());
return unique_return;
}
-
- // Counts JSFunction, Receiver, arguments, context but not effect, control.
- size_t total_parameters() { return start_->op()->OutputCount(); }
-
- // Counts only formal parameters.
- size_t formal_parameters() {
- DCHECK_GE(total_parameters(), 3);
- return total_parameters() - 3;
- }
-
// Inline this graph at {call}, use {jsgraph} and its zone to create
// any new nodes.
void InlineAtCall(JSGraph* jsgraph, Node* call);
private:
void ReplaceSentinels() {
- for (NodeId id = 0; id < source_graph_->NodeCount(); ++id) {
+ for (int id = 0; id < source_graph_->NodeCount(); ++id) {
Node* sentinel = sentinels_[id];
if (sentinel == NULL) continue;
Node* copy = copies_[id];
NodeProperties::GetValueInput(call, 0),
NodeProperties::GetEffectInput(call));
+ // {inlinee_inputs} counts JSFunction, Receiver, arguments, context,
+ // but not effect, control.
+ int inlinee_inputs = start_->op()->OutputCount();
// Context is last argument.
- int inlinee_context_index = static_cast<int>(total_parameters()) - 1;
+ int inlinee_context_index = inlinee_inputs - 1;
// {inliner_inputs} counts JSFunction, Receiver, arguments, but not
// context, effect, control.
int inliner_inputs = OperatorProperties::GetValueInputCount(call->op());
}
-// TODO(turbofan) Provide such accessors for every node, possibly even
-// generate them.
-class JSCallFunctionAccessor {
- public:
- explicit JSCallFunctionAccessor(Node* call) : call_(call) {
- DCHECK_EQ(IrOpcode::kJSCallFunction, call->opcode());
- }
-
- Node* jsfunction() { return call_->InputAt(0); }
-
- Node* receiver() { return call_->InputAt(1); }
-
- Node* formal_argument(size_t index) {
- DCHECK(index < formal_arguments());
- return call_->InputAt(static_cast<int>(2 + index));
- }
-
- size_t formal_arguments() {
- // {value_inputs} includes jsfunction and receiver.
- size_t value_inputs = OperatorProperties::GetValueInputCount(call_->op());
- DCHECK_GE(call_->InputCount(), 2);
- return value_inputs - 2;
- }
-
- Node* frame_state() { return NodeProperties::GetFrameStateInput(call_); }
-
- private:
- Node* call_;
-};
-
-
-void JSInliner::AddClosureToFrameState(Node* frame_state,
- Handle<JSFunction> jsfunction) {
- FrameStateCallInfo call_info = OpParameter<FrameStateCallInfo>(frame_state);
- const Operator* op = jsgraph_->common()->FrameState(
- FrameStateType::JS_FRAME, call_info.bailout_id(),
- call_info.state_combine(), jsfunction);
- frame_state->set_op(op);
-}
-
-
-Node* JSInliner::CreateArgumentsAdaptorFrameState(JSCallFunctionAccessor* call,
- Handle<JSFunction> jsfunction,
- Zone* temp_zone) {
- const Operator* op =
- jsgraph_->common()->FrameState(FrameStateType::ARGUMENTS_ADAPTOR,
- BailoutId(-1), kIgnoreOutput, jsfunction);
- const Operator* op0 = jsgraph_->common()->StateValues(0);
- Node* node0 = jsgraph_->graph()->NewNode(op0);
- NodeVector params(temp_zone);
- params.push_back(call->receiver());
- for (size_t argument = 0; argument != call->formal_arguments(); ++argument) {
- params.push_back(call->formal_argument(argument));
- }
- const Operator* op_param =
- jsgraph_->common()->StateValues(static_cast<int>(params.size()));
- Node* params_node = jsgraph_->graph()->NewNode(
- op_param, static_cast<int>(params.size()), ¶ms.front());
- return jsgraph_->graph()->NewNode(op, params_node, node0, node0,
- jsgraph_->UndefinedConstant(),
- call->frame_state());
-}
-
+void JSInliner::TryInlineCall(Node* call) {
+ DCHECK_EQ(IrOpcode::kJSCallFunction, call->opcode());
-void JSInliner::TryInlineCall(Node* call_node) {
- JSCallFunctionAccessor call(call_node);
-
- HeapObjectMatcher<JSFunction> match(call.jsfunction());
+ HeapObjectMatcher<JSFunction> match(call->InputAt(0));
if (!match.HasValue()) {
return;
}
CompilationInfoWithZone info(function);
Parse(function, &info);
- if (!function->shared()->has_deoptimization_support()) {
- // TODO(turbofan) In the future, unoptimized code with deopt support could
- // be generated lazily once deopt is triggered.
- info.EnableDeoptimizationSupport();
- if (!FullCodeGenerator::MakeCode(&info)) {
- DCHECK(false);
- return;
- }
- function->shared()->EnableDeoptimizationSupport(*info.code());
- function->shared()->set_feedback_vector(*info.feedback_vector());
- }
-
if (info.scope()->arguments() != NULL) {
// For now do not inline functions that use their arguments array.
SmartArrayPointer<char> name = function->shared()->DebugName()->ToCString();
visitor.CopyGraph();
Inlinee inlinee(visitor.GetCopy(graph.start()), visitor.GetCopy(graph.end()));
-
- Node* outer_frame_state = call.frame_state();
- // Insert argument adaptor frame if required.
- if (call.formal_arguments() != inlinee.formal_parameters()) {
- outer_frame_state =
- CreateArgumentsAdaptorFrameState(&call, function, info.zone());
- }
-
- for (NodeVectorConstIter it = visitor.copies().begin();
- it != visitor.copies().end(); ++it) {
- Node* node = *it;
- if (node != NULL && node->opcode() == IrOpcode::kFrameState) {
- AddClosureToFrameState(node, function);
- NodeProperties::ReplaceFrameStateInput(node, outer_frame_state);
- }
- }
-
- inlinee.InlineAtCall(jsgraph_, call_node);
+ inlinee.InlineAtCall(jsgraph_, call);
}
}
}
namespace internal {
namespace compiler {
-class JSCallFunctionAccessor;
-
class JSInliner {
public:
JSInliner(CompilationInfo* info, JSGraph* jsgraph)
CompilationInfo* info_;
JSGraph* jsgraph_;
- Node* CreateArgumentsAdaptorFrameState(JSCallFunctionAccessor* call,
- Handle<JSFunction> jsfunction,
- Zone* temp_zone);
- void AddClosureToFrameState(Node* frame_state, Handle<JSFunction> jsfunction);
static void UnifyReturn(Graph* graph);
};
}
case Runtime::kPrepareStep:
case Runtime::kSetScriptBreakPoint:
case Runtime::kStackGuard:
- case Runtime::kCheckExecutionState:
- case Runtime::kDebugEvaluate:
return true;
default:
return false;
return node->ReplaceInput(FirstEffectIndex(node) + index, effect);
}
-inline void NodeProperties::ReplaceFrameStateInput(Node* node,
- Node* frame_state) {
- DCHECK(OperatorProperties::HasFrameStateInput(node->op()));
- node->ReplaceInput(FirstFrameStateIndex(node), frame_state);
-}
-
inline void NodeProperties::RemoveNonValueInputs(Node* node) {
node->TrimInputCount(OperatorProperties::GetValueInputCount(node->op()));
}
static inline void ReplaceControlInput(Node* node, Node* control);
static inline void ReplaceEffectInput(Node* node, Node* effect,
int index = 0);
- static inline void ReplaceFrameStateInput(Node* node, Node* frame_state);
static inline void RemoveNonValueInputs(Node* node);
static inline void ReplaceWithValue(Node* node, Node* value,
Node* effect = NULL);
typedef ZoneVector<Node*> NodeVector;
typedef NodeVector::iterator NodeVectorIter;
-typedef NodeVector::const_iterator NodeVectorConstIter;
typedef NodeVector::reverse_iterator NodeVectorRIter;
typedef ZoneVector<NodeVector> NodeVectorVector;
DCHECK(frames->length() == 0);
DCHECK(is_optimized());
- // Delegate to JS frame in absence of turbofan deoptimization.
- // TODO(turbofan): Revisit once we support deoptimization across the board.
- if (LookupCode()->is_turbofanned() && !FLAG_turbo_deoptimization) {
+ // Delegate to JS frame in absence of inlining.
+ // TODO(turbofan): Revisit once we support inlining.
+ if (LookupCode()->is_turbofanned()) {
return JavaScriptFrame::Summarize(frames);
}
int OptimizedFrame::GetInlineCount() {
DCHECK(is_optimized());
- // Delegate to JS frame in absence of turbofan deoptimization.
- // TODO(turbofan): Revisit once we support deoptimization across the board.
- if (LookupCode()->is_turbofanned() && !FLAG_turbo_deoptimization) {
+ // Delegate to JS frame in absence of inlining.
+ // TODO(turbofan): Revisit once we support inlining.
+ if (LookupCode()->is_turbofanned()) {
return JavaScriptFrame::GetInlineCount();
}
DCHECK(functions->length() == 0);
DCHECK(is_optimized());
- // Delegate to JS frame in absence of turbofan deoptimization.
- // TODO(turbofan): Revisit once we support deoptimization across the board.
- if (LookupCode()->is_turbofanned() && !FLAG_turbo_deoptimization) {
+ // Delegate to JS frame in absence of inlining.
+ // TODO(turbofan): Revisit once we support inlining.
+ if (LookupCode()->is_turbofanned()) {
return JavaScriptFrame::GetFunctions(functions);
}
##############################################################################
# TurboFan compiler failures.
+ # Scheduler cannot handle free-floating loops yet
+ 'test-run-inlining/InlineLoop': [SKIP],
+
# TODO(dcarney): C calls are broken all over the place.
'test-run-machops/RunCall*': [SKIP],
'test-run-machops/RunLoadImmIndex': [SKIP],
'test-run-machops/RunSpillLotsOfThingsWithCall': [SKIP],
- # TODO(sigurds): The schedule is borked with multiple inlinees,
- # and cannot handle free-floating loops yet
+ # TODO(sigurds): The schedule is borked with multiple inlinees.
'test-run-inlining/InlineTwiceDependentDiamond': [SKIP],
'test-run-inlining/InlineTwiceDependentDiamondDifferent': [SKIP],
- 'test-run-inlining/InlineLoop': [SKIP],
# Some tests are just too slow to run for now.
'test-api/Threading*': [PASS, NO_VARIANTS],
Node* locals = m.NewNode(common.StateValues(0));
Node* stack = m.NewNode(common.StateValues(0));
- Node* state_node = m.NewNode(
- common.FrameState(JS_FRAME, bailout_id, kIgnoreOutput), parameters,
- locals, stack, caller_context_node, m.UndefinedConstant());
+ Node* state_node =
+ m.NewNode(common.FrameState(bailout_id, kIgnoreOutput), parameters,
+ locals, stack, caller_context_node, m.UndefinedConstant());
Handle<Context> context(deopt_function->context(), CcTest::i_isolate());
Unique<Object> context_constant =
Node* locals = m.NewNode(common.StateValues(0));
Node* stack = m.NewNode(common.StateValues(0));
- Node* state_node = m.NewNode(
- common.FrameState(JS_FRAME, bailout_id, kIgnoreOutput), parameters,
- locals, stack, context_node, m.UndefinedConstant());
+ Node* state_node =
+ m.NewNode(common.FrameState(bailout_id, kIgnoreOutput), parameters,
+ locals, stack, context_node, m.UndefinedConstant());
m.CallRuntime1(Runtime::kDeoptimizeFunction, this_fun_node, context_node,
state_node);
Node* stack = graph.NewNode(common.StateValues(0));
Node* state_node =
- graph.NewNode(common.FrameState(JS_FRAME, BailoutId(0), kIgnoreOutput),
+ graph.NewNode(common.FrameState(BailoutId(0), kIgnoreOutput),
parameters, locals, stack, context, UndefinedConstant());
return state_node;
using namespace v8::internal;
using namespace v8::internal::compiler;
-// Helper to determine inline count via JavaScriptFrame::GetInlineCount.
-// Note that a count of 1 indicates that no inlining has occured.
-static void AssertInlineCount(const v8::FunctionCallbackInfo<v8::Value>& args) {
- StackTraceFrameIterator it(CcTest::i_isolate());
- int frames_seen = 0;
- JavaScriptFrame* topmost = it.frame();
- while (!it.done()) {
- JavaScriptFrame* frame = it.frame();
- PrintF("%d %s, inline count: %d\n", frames_seen,
- frame->function()->shared()->DebugName()->ToCString().get(),
- frame->GetInlineCount());
- frames_seen++;
- it.Advance();
- }
- CHECK_EQ(args[0]->ToInt32()->Value(), topmost->GetInlineCount());
+// TODO(sigurds) At the moment we do not write optimization frames when
+// inlining, thus the reported stack depth changes depending on inlining.
+// AssertStackDepth checks the stack depth actually changes as a simple way
+// to ensure that inlining actually occurs.
+// Once inlining creates optimization frames, all these unit tests need to
+// check that the optimization frame is there.
+
+
+static void AssertStackDepth(const v8::FunctionCallbackInfo<v8::Value>& args) {
+ v8::HandleScope scope(args.GetIsolate());
+ v8::Handle<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
+ args.GetIsolate(), 10, v8::StackTrace::kDetailed);
+ CHECK_EQ(args[0]->ToInt32()->Value(), stackTrace->GetFrameCount());
}
-static void InstallAssertInlineCountHelper(v8::Isolate* isolate) {
+static void InstallAssertStackDepthHelper(v8::Isolate* isolate) {
v8::Local<v8::Context> context = isolate->GetCurrentContext();
v8::Local<v8::FunctionTemplate> t =
- v8::FunctionTemplate::New(isolate, AssertInlineCount);
- context->Global()->Set(v8_str("AssertInlineCount"), t->GetFunction());
+ v8::FunctionTemplate::New(isolate, AssertStackDepth);
+ context->Global()->Set(v8_str("AssertStackDepth"), t->GetFunction());
}
TEST(SimpleInlining) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"(function(){"
- "function foo(s) { AssertInlineCount(2); return s; };"
+ "function foo(s) { AssertStackDepth(1); return s; };"
"function bar(s, t) { return foo(s); };"
"return bar;})();",
CompilationInfo::kInliningEnabled |
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
- T.CheckCall(T.Val(1), T.Val(1), T.Val(2));
-}
-
-
-TEST(SimpleInliningDeopt) {
- FLAG_turbo_deoptimization = true;
- FunctionTester T(
- "(function(){"
- "function foo(s) { %DeoptimizeFunction(bar); return "
- "s; };"
- "function bar(s, t) { return foo(s); };"
- "return bar;})();",
- CompilationInfo::kInliningEnabled |
- CompilationInfo::kContextSpecializing |
- CompilationInfo::kTypingEnabled);
-
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckCall(T.Val(1), T.Val(1), T.Val(2));
}
TEST(SimpleInliningContext) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"(function () {"
- "function foo(s) { AssertInlineCount(2); var x = 12; return s + x; };"
+ "function foo(s) { AssertStackDepth(1); var x = 12; return s + x; };"
"function bar(s, t) { return foo(s); };"
"return bar;"
"})();",
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
- T.CheckCall(T.Val(13), T.Val(1), T.Val(2));
-}
-
-
-TEST(SimpleInliningContextDeopt) {
- FLAG_turbo_deoptimization = true;
- FunctionTester T(
- "(function () {"
- "function foo(s) { "
- " AssertInlineCount(2); %DeoptimizeFunction(bar); var x = 12;"
- " return s + x;"
- "};"
- "function bar(s, t) { return foo(s); };"
- "return bar;"
- "})();",
- CompilationInfo::kInliningEnabled |
- CompilationInfo::kContextSpecializing |
- CompilationInfo::kTypingEnabled);
-
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckCall(T.Val(13), T.Val(1), T.Val(2));
}
TEST(CaptureContext) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"var f = (function () {"
"var x = 42;"
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckCall(T.Val(42 + 12), T.Val(12), T.undefined());
}
// TODO(sigurds) For now we do not inline any native functions. If we do at
// some point, change this test.
TEST(DontInlineEval) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"var x = 42;"
"(function () {"
- "function bar(s, t) { return eval(\"AssertInlineCount(1); x\") };"
+ "function bar(s, t) { return eval(\"AssertStackDepth(2); x\") };"
"return bar;"
"})();",
CompilationInfo::kInliningEnabled |
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckCall(T.Val(42), T.Val("x"), T.undefined());
}
TEST(InlineOmitArguments) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"(function () {"
"var x = 42;"
- "function bar(s, t, u, v) { AssertInlineCount(2); return x + s; };"
+ "function bar(s, t, u, v) { AssertStackDepth(1); return x + s; };"
"return (function (s,t) { return bar(s); });"
"})();",
CompilationInfo::kInliningEnabled |
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckCall(T.Val(42 + 12), T.Val(12), T.undefined());
}
-TEST(InlineOmitArgumentsDeopt) {
- FLAG_turbo_deoptimization = true;
- FunctionTester T(
- "(function () {"
- "function foo(s,t,u,v) { AssertInlineCount(2); %DeoptimizeFunction(bar); "
- "return baz(); };"
- "function bar() { return foo(11); };"
- "function baz() { return foo.arguments.length == 1 && "
- " foo.arguments[0] == 11 ; }"
- "return bar;"
- "})();",
- CompilationInfo::kInliningEnabled |
- CompilationInfo::kContextSpecializing |
- CompilationInfo::kTypingEnabled);
-
- InstallAssertInlineCountHelper(CcTest::isolate());
- T.CheckCall(T.true_value(), T.Val(12), T.Val(14));
-}
-
-
TEST(InlineSurplusArguments) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"(function () {"
"var x = 42;"
- "function foo(s) { AssertInlineCount(2); return x + s; };"
+ "function foo(s) { AssertStackDepth(1); return x + s; };"
"function bar(s,t) { return foo(s,t,13); };"
"return bar;"
"})();",
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckCall(T.Val(42 + 12), T.Val(12), T.undefined());
}
-TEST(InlineSurplusArgumentsDeopt) {
- FLAG_turbo_deoptimization = true;
- FunctionTester T(
- "(function () {"
- "function foo(s) { AssertInlineCount(2); %DeoptimizeFunction(bar); "
- "return baz(); };"
- "function bar() { return foo(13, 14, 15); };"
- "function baz() { return foo.arguments.length == 3 && "
- " foo.arguments[0] == 13 && "
- " foo.arguments[1] == 14 && "
- " foo.arguments[2] == 15; }"
- "return bar;"
- "})();",
- CompilationInfo::kInliningEnabled |
- CompilationInfo::kContextSpecializing |
- CompilationInfo::kTypingEnabled);
-
- InstallAssertInlineCountHelper(CcTest::isolate());
- T.CheckCall(T.true_value(), T.Val(12), T.Val(14));
-}
-
-
TEST(InlineTwice) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"(function () {"
"var x = 42;"
- "function bar(s) { AssertInlineCount(2); return x + s; };"
+ "function bar(s) { AssertStackDepth(1); return x + s; };"
"return (function (s,t) { return bar(s) + bar(t); });"
"})();",
CompilationInfo::kInliningEnabled |
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckCall(T.Val(2 * 42 + 12 + 4), T.Val(12), T.Val(4));
}
TEST(InlineTwiceDependent) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"(function () {"
"var x = 42;"
- "function foo(s) { AssertInlineCount(2); return x + s; };"
+ "function foo(s) { AssertStackDepth(1); return x + s; };"
"function bar(s,t) { return foo(foo(s)); };"
"return bar;"
"})();",
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckCall(T.Val(42 + 42 + 12), T.Val(12), T.Val(4));
}
TEST(InlineTwiceDependentDiamond) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"(function () {"
"var x = 41;"
- "function foo(s) { AssertInlineCount(2); if (s % 2 == 0) {"
+ "function foo(s) { AssertStackDepth(1); if (s % 2 == 0) {"
" return x - s } else { return x + s; } };"
"function bar(s,t) { return foo(foo(s)); };"
"return bar;"
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckCall(T.Val(-11), T.Val(11), T.Val(4));
}
TEST(InlineTwiceDependentDiamondDifferent) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"(function () {"
"var x = 41;"
- "function foo(s,t) { AssertInlineCount(2); if (s % 2 == 0) {"
+ "function foo(s,t) { AssertStackDepth(1); if (s % 2 == 0) {"
" return x - s * t } else { return x + s * t; } };"
"function bar(s,t) { return foo(foo(s, 3), 5); };"
"return bar;"
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckCall(T.Val(-329), T.Val(11), T.Val(4));
}
TEST(InlineLoop) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"(function () {"
"var x = 41;"
- "function foo(s) { AssertInlineCount(2); while (s > 0) {"
+ "function foo(s) { AssertStackDepth(1); while (s > 0) {"
" s = s - 1; }; return s; };"
"function bar(s,t) { return foo(foo(s)); };"
"return bar;"
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckCall(T.Val(0.0), T.Val(11), T.Val(4));
}
TEST(InlineStrictIntoNonStrict) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"(function () {"
"var x = Object.create({}, { y: { value:42, writable:false } });"
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckThrows(T.undefined(), T.undefined());
}
TEST(InlineNonStrictIntoStrict) {
- FLAG_turbo_deoptimization = true;
FunctionTester T(
"(function () {"
"var x = Object.create({}, { y: { value:42, writable:false } });"
CompilationInfo::kContextSpecializing |
CompilationInfo::kTypingEnabled);
- InstallAssertInlineCountHelper(CcTest::isolate());
+ InstallAssertStackDepthHelper(CcTest::isolate());
T.CheckCall(T.Val(42), T.undefined(), T.undefined());
}
projects / platform / upstream / v8.git / commitdiff