LInstruction* LChunkBuilder::DoArgumentsElements(HArgumentsElements* elems) {
- return DefineAsRegister(new(zone()) LArgumentsElements(
- current_block_->last_environment()->outer() != NULL));
+ return DefineAsRegister(new(zone()) LArgumentsElements);
}
undefined,
instr->call_kind(),
instr->is_construct());
- if (instr->materializes_arguments()) {
- inner->Bind(instr->arguments(), graph()->GetArgumentsObject());
- }
current_block_->UpdateEnvironment(inner);
chunk_->AddInlinedClosure(instr->closure());
return NULL;
LInstruction* LChunkBuilder::DoLeaveInlined(HLeaveInlined* instr) {
- LInstruction* pop = NULL;
-
- HEnvironment* env = current_block_->last_environment();
-
- if (instr->arguments_pushed()) {
- int argument_count = env->arguments_environment()->parameter_count();
- pop = new(zone()) LPop(argument_count);
- argument_count_ -= argument_count;
- }
-
HEnvironment* outer = current_block_->last_environment()->
DiscardInlined(false);
current_block_->UpdateEnvironment(outer);
-
- return pop;
+ return NULL;
}
V(CheckMapValue) \
V(LoadFieldByIndex) \
V(DateField) \
- V(WrapReceiver) \
- V(Pop)
+ V(WrapReceiver)
#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
class LArgumentsElements: public LTemplateInstruction<1, 0, 0> {
public:
- explicit LArgumentsElements(bool from_inlined)
- : from_inlined_(from_inlined) { }
-
- bool from_inlined() const { return from_inlined_; }
+ LArgumentsElements() { }
DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
-
- private:
- bool from_inlined_;
};
};
-class LPop: public LTemplateInstruction<0, 0, 0> {
- public:
- explicit LPop(int count) : count_(count) { }
-
- int count() const { return count_; }
-
- DECLARE_CONCRETE_INSTRUCTION(Pop, "pop")
-
- private:
- int count_;
-};
-
-
class LThisFunction: public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
Register scratch = scratch0();
Register result = ToRegister(instr->result());
- if (instr->from_inlined()) {
- __ add(result, sp, Operand(-2 * kPointerSize));
- } else {
- // Check if the calling frame is an arguments adaptor frame.
- Label done, adapted;
- __ ldr(scratch, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
- __ ldr(result, MemOperand(scratch, StandardFrameConstants::kContextOffset));
- __ cmp(result, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+ // Check if the calling frame is an arguments adaptor frame.
+ Label done, adapted;
+ __ ldr(scratch, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+ __ ldr(result, MemOperand(scratch, StandardFrameConstants::kContextOffset));
+ __ cmp(result, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
- // Result is the frame pointer for the frame if not adapted and for the real
- // frame below the adaptor frame if adapted.
- __ mov(result, fp, LeaveCC, ne);
- __ mov(result, scratch, LeaveCC, eq);
- }
+ // Result is the frame pointer for the frame if not adapted and for the real
+ // frame below the adaptor frame if adapted.
+ __ mov(result, fp, LeaveCC, ne);
+ __ mov(result, scratch, LeaveCC, eq);
}
}
-void LCodeGen::DoPop(LPop* instr) {
- __ Drop(instr->count());
-}
-
-
void LCodeGen::DoThisFunction(LThisFunction* instr) {
Register result = ToRegister(instr->result());
__ LoadHeapObject(result, instr->hydrogen()->closure());
SetBlock(block);
previous->next_ = this;
if (next != NULL) next->previous_ = this;
- if (block->last() == previous) {
- block->set_last(this);
- }
}
int arguments_count,
FunctionLiteral* function,
CallKind call_kind,
- bool is_construct,
- Variable* arguments)
+ bool is_construct)
: closure_(closure),
arguments_count_(arguments_count),
function_(function),
call_kind_(call_kind),
- is_construct_(is_construct),
- arguments_(arguments),
- materializes_arguments_(false) {
+ is_construct_(is_construct) {
}
virtual void PrintDataTo(StringStream* stream);
return Representation::None();
}
- bool materializes_arguments() { return materializes_arguments_; }
- void set_materializes_arguments(bool materializes_arguments) {
- materializes_arguments_ = materializes_arguments;
- }
-
- Variable* arguments() { return arguments_; }
-
DECLARE_CONCRETE_INSTRUCTION(EnterInlined)
private:
FunctionLiteral* function_;
CallKind call_kind_;
bool is_construct_;
- Variable* arguments_;
- bool materializes_arguments_;
};
class HLeaveInlined: public HTemplateInstruction<0> {
public:
- explicit HLeaveInlined(bool arguments_pushed)
- : arguments_pushed_(arguments_pushed) { }
+ HLeaveInlined() {}
virtual Representation RequiredInputRepresentation(int index) {
return Representation::None();
}
- bool arguments_pushed() {
- return arguments_pushed_;
- }
-
DECLARE_CONCRETE_INSTRUCTION(LeaveInlined)
-
- private:
- bool arguments_pushed_;
};
first_ = last_ = entry;
}
instr->InsertAfter(last_);
+ last_ = instr;
}
}
-void HBasicBlock::Goto(HBasicBlock* block, FunctionState* state) {
- bool drop_extra = state != NULL && state->drop_extra();
- bool arguments_pushed = state != NULL && state->arguments_pushed();
-
+void HBasicBlock::Goto(HBasicBlock* block, bool drop_extra) {
if (block->IsInlineReturnTarget()) {
- AddInstruction(new(zone()) HLeaveInlined(arguments_pushed));
+ AddInstruction(new(zone()) HLeaveInlined);
last_environment_ = last_environment()->DiscardInlined(drop_extra);
}
-
AddSimulate(AstNode::kNoNumber);
HGoto* instr = new(zone()) HGoto(block);
Finish(instr);
void HBasicBlock::AddLeaveInlined(HValue* return_value,
HBasicBlock* target,
- FunctionState* state) {
- bool drop_extra = state != NULL && state->drop_extra();
- bool arguments_pushed = state != NULL && state->arguments_pushed();
-
+ bool drop_extra) {
ASSERT(target->IsInlineReturnTarget());
ASSERT(return_value != NULL);
- AddInstruction(new(zone()) HLeaveInlined(arguments_pushed));
+ AddInstruction(new(zone()) HLeaveInlined);
last_environment_ = last_environment()->DiscardInlined(drop_extra);
last_environment()->Push(return_value);
AddSimulate(AstNode::kNoNumber);
return_handling_(return_handling),
function_return_(NULL),
test_context_(NULL),
- entry_(NULL),
- arguments_elements_(NULL),
outer_(owner->function_state()) {
if (outer_ != NULL) {
// State for an inline function.
instr->SetSuccessorAt(0, empty_true);
instr->SetSuccessorAt(1, empty_false);
owner()->current_block()->Finish(instr);
- empty_true->Goto(if_true(), owner()->function_state());
- empty_false->Goto(if_false(), owner()->function_state());
+ empty_true->Goto(if_true(), owner()->function_state()->drop_extra());
+ empty_false->Goto(if_false(), owner()->function_state()->drop_extra());
owner()->set_current_block(NULL);
}
HBranch* test = new(zone()) HBranch(value, empty_true, empty_false, expected);
builder->current_block()->Finish(test);
- empty_true->Goto(if_true(), owner()->function_state());
- empty_false->Goto(if_false(), owner()->function_state());
+ empty_true->Goto(if_true(), owner()->function_state()->drop_extra());
+ empty_false->Goto(if_false(), owner()->function_state()->drop_extra());
builder->set_current_block(NULL);
}
if (context->IsTest()) {
TestContext* test = TestContext::cast(context);
CHECK_ALIVE(VisitForEffect(stmt->expression()));
- current_block()->Goto(test->if_true(), function_state());
+ current_block()->Goto(test->if_true(), function_state()->drop_extra());
} else if (context->IsEffect()) {
CHECK_ALIVE(VisitForEffect(stmt->expression()));
- current_block()->Goto(function_return(), function_state());
+ current_block()->Goto(function_return(), function_state()->drop_extra());
} else {
ASSERT(context->IsValue());
CHECK_ALIVE(VisitForValue(stmt->expression()));
current_block()->Finish(typecheck);
if_spec_object->AddLeaveInlined(return_value,
function_return(),
- function_state());
+ function_state()->drop_extra());
not_spec_object->AddLeaveInlined(receiver,
function_return(),
- function_state());
+ function_state()->drop_extra());
}
} else {
// Return from an inlined function, visit the subexpression in the
test->if_false());
} else if (context->IsEffect()) {
CHECK_ALIVE(VisitForEffect(stmt->expression()));
- current_block()->Goto(function_return(), function_state());
+ current_block()->Goto(function_return(), function_state()->drop_extra());
} else {
ASSERT(context->IsValue());
CHECK_ALIVE(VisitForValue(stmt->expression()));
HValue* return_value = Pop();
current_block()->AddLeaveInlined(return_value,
function_return(),
- function_state());
+ function_state()->drop_extra());
}
}
set_current_block(NULL);
return false;
}
+ // Our implementation of arguments (based on this stack frame or an
+ // adapter below it) does not work for inlined functions.
if (function_state()->outer() != NULL) {
- // Push arguments when entering inlined function.
- if (!function_state()->arguments_pushed()) {
- HEnvironment* arguments_env = environment()->arguments_environment();
-
- HInstruction* insert_after = function_state()->entry();
- ASSERT(insert_after->IsEnterInlined());
- HEnterInlined::cast(insert_after)->set_materializes_arguments(true);
-
- for (int i = 0; i < arguments_env->parameter_count(); i++) {
- HValue* argument = arguments_env->Lookup(i);
- HInstruction* push_argument = new(zone()) HPushArgument(argument);
- push_argument->InsertAfter(insert_after);
- insert_after = push_argument;
- }
-
- HInstruction* arguments_elements = new(zone()) HArgumentsElements();
- arguments_elements->ClearFlag(HValue::kUseGVN);
- arguments_elements->InsertAfter(insert_after);
- function_state()->set_arguments_elements(arguments_elements);
- }
+ Bailout("arguments access in inlined function");
+ return true;
}
HInstruction* result = NULL;
if (expr->key()->IsPropertyName()) {
Handle<String> name = expr->key()->AsLiteral()->AsPropertyName();
if (!name->IsEqualTo(CStrVector("length"))) return false;
-
- if (function_state()->outer() == NULL) {
- HInstruction* elements = AddInstruction(new(zone()) HArgumentsElements);
- result = new(zone()) HArgumentsLength(elements);
- } else {
- // Number of arguments without receiver.
- int argument_count = environment()->
- arguments_environment()->parameter_count() - 1;
- result = new(zone()) HConstant(
- Handle<Object>(Smi::FromInt(argument_count)),
- Representation::Integer32());
- }
+ HInstruction* elements = AddInstruction(new(zone()) HArgumentsElements);
+ result = new(zone()) HArgumentsLength(elements);
} else {
Push(graph()->GetArgumentsObject());
VisitForValue(expr->key());
if (HasStackOverflow() || current_block() == NULL) return true;
HValue* key = Pop();
Drop(1); // Arguments object.
- if (function_state()->outer() == NULL) {
- HInstruction* elements = AddInstruction(new(zone()) HArgumentsElements);
- HInstruction* length = AddInstruction(
- new(zone()) HArgumentsLength(elements));
- HInstruction* checked_key =
- AddInstruction(new(zone()) HBoundsCheck(key, length));
- result = new(zone()) HAccessArgumentsAt(elements, length, checked_key);
- } else {
- // Number of arguments without receiver.
- HInstruction* elements = function_state()->arguments_elements();
- int argument_count = environment()->
- arguments_environment()->parameter_count() - 1;
- HInstruction* length = AddInstruction(new(zone()) HConstant(
- Handle<Object>(Smi::FromInt(argument_count)),
- Representation::Integer32()));
- HInstruction* checked_key =
- AddInstruction(new(zone()) HBoundsCheck(key, length));
- result = new(zone()) HAccessArgumentsAt(elements, length, checked_key);
- }
+ HInstruction* elements = AddInstruction(new(zone()) HArgumentsElements);
+ HInstruction* length = AddInstruction(
+ new(zone()) HArgumentsLength(elements));
+ HInstruction* checked_key =
+ AddInstruction(new(zone()) HBoundsCheck(key, length));
+ result = new(zone()) HAccessArgumentsAt(elements, length, checked_key);
}
ast_context()->ReturnInstruction(result, expr->id());
return true;
AddInstruction(context);
inner_env->BindContext(context);
#endif
+ AddSimulate(return_id);
+ current_block()->UpdateEnvironment(inner_env);
+ AddInstruction(new(zone()) HEnterInlined(target,
+ arguments->length(),
+ function,
+ call_kind,
+ function_state()->is_construct()));
// If the function uses arguments object create and bind one.
if (function->scope()->arguments() != NULL) {
ASSERT(function->scope()->arguments()->IsStackAllocated());
- inner_env->Bind(function->scope()->arguments(),
- graph()->GetArgumentsObject());
+ environment()->Bind(function->scope()->arguments(),
+ graph()->GetArgumentsObject());
}
-
- AddSimulate(return_id);
- current_block()->UpdateEnvironment(inner_env);
-
- HInstruction* enter_inlined =
- AddInstruction(new(zone()) HEnterInlined(target,
- arguments->length(),
- function,
- call_kind,
- function_state()->is_construct(),
- function->scope()->arguments()));
- function_state()->set_entry(enter_inlined);
VisitDeclarations(target_info.scope()->declarations());
VisitStatements(function->body());
if (HasStackOverflow()) {
: undefined;
current_block()->AddLeaveInlined(return_value,
function_return(),
- function_state());
+ function_state()->drop_extra());
} else if (call_context()->IsEffect()) {
ASSERT(function_return() != NULL);
- current_block()->Goto(function_return(), function_state());
+ current_block()->Goto(function_return(), function_state()->drop_extra());
} else {
ASSERT(call_context()->IsTest());
ASSERT(inlined_test_context() != NULL);
HBasicBlock* target = function_state()->is_construct()
? inlined_test_context()->if_true()
: inlined_test_context()->if_false();
- current_block()->Goto(target, function_state());
+ current_block()->Goto(target, function_state()->drop_extra());
}
}
if (if_true->HasPredecessor()) {
if_true->SetJoinId(ast_id);
HBasicBlock* true_target = TestContext::cast(ast_context())->if_true();
- if_true->Goto(true_target, function_state());
+ if_true->Goto(true_target, function_state()->drop_extra());
}
if (if_false->HasPredecessor()) {
if_false->SetJoinId(ast_id);
HBasicBlock* false_target = TestContext::cast(ast_context())->if_false();
- if_false->Goto(false_target, function_state());
+ if_false->Goto(false_target, function_state()->drop_extra());
}
set_current_block(NULL);
return true;
// Forward declarations.
class BitVector;
-class FunctionState;
class HEnvironment;
class HGraph;
class HLoopInformation;
void Finish(HControlInstruction* last);
void FinishExit(HControlInstruction* instruction);
- void Goto(HBasicBlock* block, FunctionState* state = NULL);
+ void Goto(HBasicBlock* block, bool drop_extra = false);
int PredecessorIndexOf(HBasicBlock* predecessor) const;
void AddSimulate(int ast_id) { AddInstruction(CreateSimulate(ast_id)); }
// instruction and updating the bailout environment.
void AddLeaveInlined(HValue* return_value,
HBasicBlock* target,
- FunctionState* state = NULL);
+ bool drop_extra = false);
// If a target block is tagged as an inline function return, all
// predecessors should contain the inlined exit sequence:
FunctionState* outer() { return outer_; }
- HInstruction* entry() { return entry_; }
- void set_entry(HInstruction* entry) { entry_ = entry; }
-
- HInstruction* arguments_elements() { return arguments_elements_; }
- void set_arguments_elements(HInstruction* arguments_elements) {
- arguments_elements_ = arguments_elements;
- }
-
- bool arguments_pushed() { return arguments_elements() != NULL; }
-
private:
HGraphBuilder* owner_;
// return blocks. NULL in all other cases.
TestContext* test_context_;
- // When inlining HEnterInlined instruction corresponding to the function
- // entry.
- HInstruction* entry_;
-
- HInstruction* arguments_elements_;
-
FunctionState* outer_;
};
void LCodeGen::DoArgumentsElements(LArgumentsElements* instr) {
Register result = ToRegister(instr->result());
- if (instr->from_inlined()) {
- __ lea(result, Operand(esp, -2 * kPointerSize));
- } else {
- // Check for arguments adapter frame.
- Label done, adapted;
- __ mov(result, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
- __ mov(result, Operand(result, StandardFrameConstants::kContextOffset));
- __ cmp(Operand(result),
- Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
- __ j(equal, &adapted, Label::kNear);
-
- // No arguments adaptor frame.
- __ mov(result, Operand(ebp));
- __ jmp(&done, Label::kNear);
+ // Check for arguments adapter frame.
+ Label done, adapted;
+ __ mov(result, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
+ __ mov(result, Operand(result, StandardFrameConstants::kContextOffset));
+ __ cmp(Operand(result),
+ Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+ __ j(equal, &adapted, Label::kNear);
- // Arguments adaptor frame present.
- __ bind(&adapted);
- __ mov(result, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
+ // No arguments adaptor frame.
+ __ mov(result, Operand(ebp));
+ __ jmp(&done, Label::kNear);
- // Result is the frame pointer for the frame if not adapted and for the real
- // frame below the adaptor frame if adapted.
- __ bind(&done);
- }
+ // Arguments adaptor frame present.
+ __ bind(&adapted);
+ __ mov(result, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
+
+ // Result is the frame pointer for the frame if not adapted and for the real
+ // frame below the adaptor frame if adapted.
+ __ bind(&done);
}
}
-void LCodeGen::DoPop(LPop* instr) {
- __ Drop(instr->count());
-}
-
-
void LCodeGen::DoThisFunction(LThisFunction* instr) {
Register result = ToRegister(instr->result());
__ LoadHeapObject(result, instr->hydrogen()->closure());
LInstruction* LChunkBuilder::DoArgumentsElements(HArgumentsElements* elems) {
- return DefineAsRegister(new(zone()) LArgumentsElements(
- current_block_->last_environment()->outer() != NULL));
+ return DefineAsRegister(new(zone()) LArgumentsElements);
}
undefined,
instr->call_kind(),
instr->is_construct());
- if (instr->materializes_arguments()) {
- inner->Bind(instr->arguments(), graph()->GetArgumentsObject());
- }
current_block_->UpdateEnvironment(inner);
chunk_->AddInlinedClosure(instr->closure());
return NULL;
LInstruction* LChunkBuilder::DoLeaveInlined(HLeaveInlined* instr) {
- LInstruction* pop = NULL;
-
- HEnvironment* env = current_block_->last_environment();
-
- if (instr->arguments_pushed()) {
- int argument_count = env->arguments_environment()->parameter_count();
- pop = new(zone()) LPop(argument_count);
- argument_count_ -= argument_count;
- }
-
HEnvironment* outer = current_block_->last_environment()->
DiscardInlined(false);
current_block_->UpdateEnvironment(outer);
- return pop;
+ return NULL;
}
V(CheckMapValue) \
V(LoadFieldByIndex) \
V(DateField) \
- V(WrapReceiver) \
- V(Pop)
+ V(WrapReceiver)
#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
class LArgumentsElements: public LTemplateInstruction<1, 0, 0> {
public:
- explicit LArgumentsElements(bool from_inlined)
- : from_inlined_(from_inlined) { }
-
- bool from_inlined() const { return from_inlined_; }
+ LArgumentsElements() { }
DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
-
- private:
- bool from_inlined_;
};
};
-class LPop: public LTemplateInstruction<0, 0, 0> {
- public:
- explicit LPop(int count) : count_(count) { }
-
- int count() const { return count_; }
-
- DECLARE_CONCRETE_INSTRUCTION(Pop, "pop")
-
- private:
- int count_;
-};
-
-
class LThisFunction: public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
Register temp = scratch1();
Register result = ToRegister(instr->result());
- if (instr->from_inlined()) {
- __ Subu(result, sp, 2 * kPointerSize);
- } else {
- // Check if the calling frame is an arguments adaptor frame.
- Label done, adapted;
- __ lw(scratch, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
- __ lw(result, MemOperand(scratch, StandardFrameConstants::kContextOffset));
- __ Xor(temp, result, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
-
- // Result is the frame pointer for the frame if not adapted and for the real
- // frame below the adaptor frame if adapted.
- __ Movn(result, fp, temp); // Move only if temp is not equal to zero (ne).
- __ Movz(result, scratch, temp); // Move only if temp is equal to zero (eq).
- }
+ // Check if the calling frame is an arguments adaptor frame.
+ Label done, adapted;
+ __ lw(scratch, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+ __ lw(result, MemOperand(scratch, StandardFrameConstants::kContextOffset));
+ __ Xor(temp, result, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+
+ // Result is the frame pointer for the frame if not adapted and for the real
+ // frame below the adaptor frame if adapted.
+ __ Movn(result, fp, temp); // Move only if temp is not equal to zero (ne).
+ __ Movz(result, scratch, temp); // Move only if temp is equal to zero (eq).
}
}
-void LCodeGen::DoPop(LPop* instr) {
- __ Drop(instr->count());
-}
-
-
void LCodeGen::DoThisFunction(LThisFunction* instr) {
Register result = ToRegister(instr->result());
__ LoadHeapObject(result, instr->hydrogen()->closure());
LInstruction* LChunkBuilder::DoArgumentsElements(HArgumentsElements* elems) {
- return DefineAsRegister(new(zone()) LArgumentsElements(
- current_block_->last_environment()->outer() != NULL));
+ return DefineAsRegister(new(zone()) LArgumentsElements);
}
undefined,
instr->call_kind(),
instr->is_construct());
- if (instr->materializes_arguments()) {
- inner->Bind(instr->arguments(), graph()->GetArgumentsObject());
- }
current_block_->UpdateEnvironment(inner);
chunk_->AddInlinedClosure(instr->closure());
return NULL;
LInstruction* LChunkBuilder::DoLeaveInlined(HLeaveInlined* instr) {
- LInstruction* pop = NULL;
-
- HEnvironment* env = current_block_->last_environment();
-
- if (instr->arguments_pushed()) {
- int argument_count = env->arguments_environment()->parameter_count();
- pop = new(zone()) LPop(argument_count);
- argument_count_ -= argument_count;
- }
-
HEnvironment* outer = current_block_->last_environment()->
DiscardInlined(false);
current_block_->UpdateEnvironment(outer);
-
- return pop;
+ return NULL;
}
V(CheckMapValue) \
V(LoadFieldByIndex) \
V(DateField) \
- V(WrapReceiver) \
- V(Pop)
+ V(WrapReceiver)
#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
virtual Opcode opcode() const { return LInstruction::k##type; } \
class LArgumentsElements: public LTemplateInstruction<1, 0, 0> {
public:
- explicit LArgumentsElements(bool from_inlined)
- : from_inlined_(from_inlined) { }
-
- bool from_inlined() const { return from_inlined_; }
+ LArgumentsElements() { }
DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
-
- private:
- bool from_inlined_;
};
};
-class LPop: public LTemplateInstruction<0, 0, 0> {
- public:
- explicit LPop(int count) : count_(count) { }
-
- int count() const { return count_; }
-
- DECLARE_CONCRETE_INSTRUCTION(Pop, "pop")
-
- private:
- int count_;
-};
-
-
class LThisFunction: public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
ASSERT(*arguments != isolate->heap()->undefined_value());
}
frame->SetExpression(i, *arguments);
- if (FLAG_trace_deopt) {
- PrintF("Materializing arguments object for frame %p - %p: %p ",
- reinterpret_cast<void*>(frame->sp()),
- reinterpret_cast<void*>(frame->fp()),
- reinterpret_cast<void*>(*arguments));
- arguments->ShortPrint();
- PrintF("\n");
- }
}
}
}
void LCodeGen::DoArgumentsElements(LArgumentsElements* instr) {
Register result = ToRegister(instr->result());
- if (instr->from_inlined()) {
- __ lea(result, Operand(rsp, -2 * kPointerSize));
- } else {
- // Check for arguments adapter frame.
- Label done, adapted;
- __ movq(result, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
- __ Cmp(Operand(result, StandardFrameConstants::kContextOffset),
- Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
- __ j(equal, &adapted, Label::kNear);
-
- // No arguments adaptor frame.
- __ movq(result, rbp);
- __ jmp(&done, Label::kNear);
+ // Check for arguments adapter frame.
+ Label done, adapted;
+ __ movq(result, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
+ __ Cmp(Operand(result, StandardFrameConstants::kContextOffset),
+ Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
+ __ j(equal, &adapted, Label::kNear);
- // Arguments adaptor frame present.
- __ bind(&adapted);
- __ movq(result, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
+ // No arguments adaptor frame.
+ __ movq(result, rbp);
+ __ jmp(&done, Label::kNear);
- // Result is the frame pointer for the frame if not adapted and for the real
- // frame below the adaptor frame if adapted.
- __ bind(&done);
- }
+ // Arguments adaptor frame present.
+ __ bind(&adapted);
+ __ movq(result, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
+
+ // Result is the frame pointer for the frame if not adapted and for the real
+ // frame below the adaptor frame if adapted.
+ __ bind(&done);
}
}
-void LCodeGen::DoPop(LPop* instr) {
- __ Drop(instr->count());
-}
-
-
void LCodeGen::DoThisFunction(LThisFunction* instr) {
Register result = ToRegister(instr->result());
__ LoadHeapObject(result, instr->hydrogen()->closure());
LInstruction* LChunkBuilder::DoArgumentsElements(HArgumentsElements* elems) {
- return DefineAsRegister(new(zone()) LArgumentsElements(
- current_block_->last_environment()->outer() != NULL));
+ return DefineAsRegister(new(zone()) LArgumentsElements);
}
undefined,
instr->call_kind(),
instr->is_construct());
- if (instr->materializes_arguments()) {
- inner->Bind(instr->arguments(), graph()->GetArgumentsObject());
- }
current_block_->UpdateEnvironment(inner);
chunk_->AddInlinedClosure(instr->closure());
return NULL;
LInstruction* LChunkBuilder::DoLeaveInlined(HLeaveInlined* instr) {
- LInstruction* pop = NULL;
-
- HEnvironment* env = current_block_->last_environment();
-
- if (instr->arguments_pushed()) {
- int argument_count = env->arguments_environment()->parameter_count();
- pop = new(zone()) LPop(argument_count);
- argument_count_ -= argument_count;
- }
-
HEnvironment* outer = current_block_->last_environment()->
DiscardInlined(false);
current_block_->UpdateEnvironment(outer);
-
- return pop;
+ return NULL;
}
V(CheckMapValue) \
V(LoadFieldByIndex) \
V(DateField) \
- V(WrapReceiver) \
- V(Pop)
+ V(WrapReceiver)
#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
class LArgumentsElements: public LTemplateInstruction<1, 0, 0> {
public:
- explicit LArgumentsElements(bool from_inlined)
- : from_inlined_(from_inlined) { }
-
- bool from_inlined() const { return from_inlined_; }
+ LArgumentsElements() { }
DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
-
- private:
- bool from_inlined_;
};
};
-class LPop: public LTemplateInstruction<0, 0, 0> {
- public:
- explicit LPop(int count) : count_(count) { }
-
- int count() const { return count_; }
-
- DECLARE_CONCRETE_INSTRUCTION(Pop, "pop")
-
- private:
- int count_;
-};
-
-
class LThisFunction: public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
%OptimizeFunctionOnNextCall(test_adaptation);
test_adaptation();
})();
-
-// Test arguments access from the inlined function.
-function uninlinable(v) {
- assertEquals(0, v);
- try { } catch (e) { }
- return 0;
-}
-
-function toarr_inner() {
- var a = arguments;
- var marker = a[0];
- uninlinable(uninlinable(0, 0), marker.x);
-
- var r = new Array();
- for (var i = a.length - 1; i >= 1; i--) {
- r.push(a[i]);
- }
-
- return r;
-}
-
-function toarr1(marker, a, b, c) {
- return toarr_inner(marker, a / 2, b / 2, c / 2);
-}
-
-function toarr2(marker, a, b, c) {
- var x = 0;
- return uninlinable(uninlinable(0, 0),
- x = toarr_inner(marker, a / 2, b / 2, c / 2)), x;
-}
-
-function test_toarr(toarr) {
- var marker = { x: 0 };
- assertArrayEquals([3, 2, 1], toarr(marker, 2, 4, 6));
- assertArrayEquals([3, 2, 1], toarr(marker, 2, 4, 6));
- %OptimizeFunctionOnNextCall(toarr);
- assertArrayEquals([3, 2, 1], toarr(marker, 2, 4, 6));
- delete marker.x;
- assertArrayEquals([3, 2, 1], toarr(marker, 2, 4, 6));
-}
-
-test_toarr(toarr1);
-test_toarr(toarr2);
projects / platform / upstream / v8.git / commitdiff