mirror of https://github.com/lukechilds/node.git
Ryan Dahl
15 years ago
123 changed files with 3495 additions and 4380 deletions
@ -1,301 +0,0 @@ |
|||||
// Copyright 2009 the V8 project authors. All rights reserved.
|
|
||||
// Redistribution and use in source and binary forms, with or without
|
|
||||
// modification, are permitted provided that the following conditions are
|
|
||||
// met:
|
|
||||
//
|
|
||||
// * Redistributions of source code must retain the above copyright
|
|
||||
// notice, this list of conditions and the following disclaimer.
|
|
||||
// * Redistributions in binary form must reproduce the above
|
|
||||
// copyright notice, this list of conditions and the following
|
|
||||
// disclaimer in the documentation and/or other materials provided
|
|
||||
// with the distribution.
|
|
||||
// * Neither the name of Google Inc. nor the names of its
|
|
||||
// contributors may be used to endorse or promote products derived
|
|
||||
// from this software without specific prior written permission.
|
|
||||
//
|
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||
|
|
||||
#include "v8.h" |
|
||||
|
|
||||
#include "cfg.h" |
|
||||
#include "codegen-inl.h" |
|
||||
#include "codegen-arm.h" // Include after codegen-inl.h. |
|
||||
#include "macro-assembler-arm.h" |
|
||||
|
|
||||
namespace v8 { |
|
||||
namespace internal { |
|
||||
|
|
||||
#define __ ACCESS_MASM(masm) |
|
||||
|
|
||||
void InstructionBlock::Compile(MacroAssembler* masm) { |
|
||||
ASSERT(!is_marked()); |
|
||||
is_marked_ = true; |
|
||||
{ |
|
||||
Comment cmt(masm, "[ InstructionBlock"); |
|
||||
for (int i = 0, len = instructions_.length(); i < len; i++) { |
|
||||
// If the location of the current instruction is a temp, then the
|
|
||||
// instruction cannot be in tail position in the block. Allocate the
|
|
||||
// temp based on peeking ahead to the next instruction.
|
|
||||
Instruction* instr = instructions_[i]; |
|
||||
Location* loc = instr->location(); |
|
||||
if (loc->is_temporary()) { |
|
||||
instructions_[i+1]->FastAllocate(TempLocation::cast(loc)); |
|
||||
} |
|
||||
instructions_[i]->Compile(masm); |
|
||||
} |
|
||||
} |
|
||||
successor_->Compile(masm); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void EntryNode::Compile(MacroAssembler* masm) { |
|
||||
ASSERT(!is_marked()); |
|
||||
is_marked_ = true; |
|
||||
{ |
|
||||
Comment cmnt(masm, "[ EntryNode"); |
|
||||
__ stm(db_w, sp, r1.bit() | cp.bit() | fp.bit() | lr.bit()); |
|
||||
__ add(fp, sp, Operand(2 * kPointerSize)); |
|
||||
int count = CfgGlobals::current()->fun()->scope()->num_stack_slots(); |
|
||||
if (count > 0) { |
|
||||
__ LoadRoot(ip, Heap::kUndefinedValueRootIndex); |
|
||||
for (int i = 0; i < count; i++) { |
|
||||
__ push(ip); |
|
||||
} |
|
||||
} |
|
||||
if (FLAG_trace) { |
|
||||
__ CallRuntime(Runtime::kTraceEnter, 0); |
|
||||
} |
|
||||
if (FLAG_check_stack) { |
|
||||
StackCheckStub stub; |
|
||||
__ CallStub(&stub); |
|
||||
} |
|
||||
} |
|
||||
successor_->Compile(masm); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExitNode::Compile(MacroAssembler* masm) { |
|
||||
ASSERT(!is_marked()); |
|
||||
is_marked_ = true; |
|
||||
Comment cmnt(masm, "[ ExitNode"); |
|
||||
if (FLAG_trace) { |
|
||||
__ push(r0); |
|
||||
__ CallRuntime(Runtime::kTraceExit, 1); |
|
||||
} |
|
||||
__ mov(sp, fp); |
|
||||
__ ldm(ia_w, sp, fp.bit() | lr.bit()); |
|
||||
int count = CfgGlobals::current()->fun()->scope()->num_parameters(); |
|
||||
__ add(sp, sp, Operand((count + 1) * kPointerSize)); |
|
||||
__ Jump(lr); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void PropLoadInstr::Compile(MacroAssembler* masm) { |
|
||||
// The key should not be on the stack---if it is a compiler-generated
|
|
||||
// temporary it is in the accumulator.
|
|
||||
ASSERT(!key()->is_on_stack()); |
|
||||
|
|
||||
Comment cmnt(masm, "[ Load from Property"); |
|
||||
// If the key is known at compile-time we may be able to use a load IC.
|
|
||||
bool is_keyed_load = true; |
|
||||
if (key()->is_constant()) { |
|
||||
// Still use the keyed load IC if the key can be parsed as an integer so
|
|
||||
// we will get into the case that handles [] on string objects.
|
|
||||
Handle<Object> key_val = Constant::cast(key())->handle(); |
|
||||
uint32_t ignored; |
|
||||
if (key_val->IsSymbol() && |
|
||||
!String::cast(*key_val)->AsArrayIndex(&ignored)) { |
|
||||
is_keyed_load = false; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if (!object()->is_on_stack()) object()->Push(masm); |
|
||||
|
|
||||
if (is_keyed_load) { |
|
||||
key()->Push(masm); |
|
||||
Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize)); |
|
||||
__ Call(ic, RelocInfo::CODE_TARGET); |
|
||||
// Discard key and receiver.
|
|
||||
__ add(sp, sp, Operand(2 * kPointerSize)); |
|
||||
} else { |
|
||||
key()->Get(masm, r2); |
|
||||
Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize)); |
|
||||
__ Call(ic, RelocInfo::CODE_TARGET); |
|
||||
__ pop(); // Discard receiver.
|
|
||||
} |
|
||||
location()->Set(masm, r0); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void BinaryOpInstr::Compile(MacroAssembler* masm) { |
|
||||
// The right-hand value should not be on the stack---if it is a
|
|
||||
// compiler-generated temporary it is in the accumulator.
|
|
||||
ASSERT(!right()->is_on_stack()); |
|
||||
|
|
||||
Comment cmnt(masm, "[ BinaryOpInstr"); |
|
||||
// We can overwrite one of the operands if it is a temporary.
|
|
||||
OverwriteMode mode = NO_OVERWRITE; |
|
||||
if (left()->is_temporary()) { |
|
||||
mode = OVERWRITE_LEFT; |
|
||||
} else if (right()->is_temporary()) { |
|
||||
mode = OVERWRITE_RIGHT; |
|
||||
} |
|
||||
|
|
||||
// Move left to r1 and right to r0.
|
|
||||
left()->Get(masm, r1); |
|
||||
right()->Get(masm, r0); |
|
||||
GenericBinaryOpStub stub(op(), mode); |
|
||||
__ CallStub(&stub); |
|
||||
location()->Set(masm, r0); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ReturnInstr::Compile(MacroAssembler* masm) { |
|
||||
// The location should be 'Effect'. As a side effect, move the value to
|
|
||||
// the accumulator.
|
|
||||
Comment cmnt(masm, "[ ReturnInstr"); |
|
||||
value()->Get(masm, r0); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Constant::Get(MacroAssembler* masm, Register reg) { |
|
||||
__ mov(reg, Operand(handle_)); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Constant::Push(MacroAssembler* masm) { |
|
||||
__ mov(ip, Operand(handle_)); |
|
||||
__ push(ip); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
static MemOperand ToMemOperand(SlotLocation* loc) { |
|
||||
switch (loc->type()) { |
|
||||
case Slot::PARAMETER: { |
|
||||
int count = CfgGlobals::current()->fun()->scope()->num_parameters(); |
|
||||
return MemOperand(fp, (1 + count - loc->index()) * kPointerSize); |
|
||||
} |
|
||||
case Slot::LOCAL: { |
|
||||
const int kOffset = JavaScriptFrameConstants::kLocal0Offset; |
|
||||
return MemOperand(fp, kOffset - loc->index() * kPointerSize); |
|
||||
} |
|
||||
default: |
|
||||
UNREACHABLE(); |
|
||||
return MemOperand(r0); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Constant::MoveToSlot(MacroAssembler* masm, SlotLocation* loc) { |
|
||||
__ mov(ip, Operand(handle_)); |
|
||||
__ str(ip, ToMemOperand(loc)); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Get(MacroAssembler* masm, Register reg) { |
|
||||
__ ldr(reg, ToMemOperand(this)); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Set(MacroAssembler* masm, Register reg) { |
|
||||
__ str(reg, ToMemOperand(this)); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Push(MacroAssembler* masm) { |
|
||||
__ ldr(ip, ToMemOperand(this)); |
|
||||
__ push(ip); // Push will not destroy ip.
|
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Move(MacroAssembler* masm, Value* value) { |
|
||||
// Double dispatch.
|
|
||||
value->MoveToSlot(masm, this); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::MoveToSlot(MacroAssembler* masm, SlotLocation* loc) { |
|
||||
__ ldr(ip, ToMemOperand(this)); |
|
||||
__ str(ip, ToMemOperand(loc)); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Get(MacroAssembler* masm, Register reg) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
if (!reg.is(r0)) __ mov(reg, r0); |
|
||||
break; |
|
||||
case STACK: |
|
||||
__ pop(reg); |
|
||||
break; |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Set(MacroAssembler* masm, Register reg) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
if (!reg.is(r0)) __ mov(r0, reg); |
|
||||
break; |
|
||||
case STACK: |
|
||||
__ push(reg); |
|
||||
break; |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Push(MacroAssembler* masm) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
__ push(r0); |
|
||||
break; |
|
||||
case STACK: |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Move(MacroAssembler* masm, Value* value) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
value->Get(masm, r0); |
|
||||
case STACK: |
|
||||
value->Push(masm); |
|
||||
break; |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::MoveToSlot(MacroAssembler* masm, SlotLocation* loc) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
__ str(r0, ToMemOperand(loc)); |
|
||||
case STACK: |
|
||||
__ pop(ip); |
|
||||
__ str(ip, ToMemOperand(loc)); |
|
||||
break; |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
#undef __ |
|
||||
|
|
||||
} } // namespace v8::internal
|
|
||||
@ -1,763 +0,0 @@ |
|||||
// Copyright 2009 the V8 project authors. All rights reserved.
|
|
||||
// Redistribution and use in source and binary forms, with or without
|
|
||||
// modification, are permitted provided that the following conditions are
|
|
||||
// met:
|
|
||||
//
|
|
||||
// * Redistributions of source code must retain the above copyright
|
|
||||
// notice, this list of conditions and the following disclaimer.
|
|
||||
// * Redistributions in binary form must reproduce the above
|
|
||||
// copyright notice, this list of conditions and the following
|
|
||||
// disclaimer in the documentation and/or other materials provided
|
|
||||
// with the distribution.
|
|
||||
// * Neither the name of Google Inc. nor the names of its
|
|
||||
// contributors may be used to endorse or promote products derived
|
|
||||
// from this software without specific prior written permission.
|
|
||||
//
|
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||
|
|
||||
#include "v8.h" |
|
||||
|
|
||||
#include "bootstrapper.h" |
|
||||
#include "cfg.h" |
|
||||
#include "scopeinfo.h" |
|
||||
#include "scopes.h" |
|
||||
|
|
||||
namespace v8 { |
|
||||
namespace internal { |
|
||||
|
|
||||
|
|
||||
CfgGlobals* CfgGlobals::top_ = NULL; |
|
||||
|
|
||||
|
|
||||
CfgGlobals::CfgGlobals(FunctionLiteral* fun) |
|
||||
: global_fun_(fun), |
|
||||
global_exit_(new ExitNode()), |
|
||||
nowhere_(new Nowhere()), |
|
||||
#ifdef DEBUG |
|
||||
node_counter_(0), |
|
||||
temp_counter_(0), |
|
||||
#endif |
|
||||
previous_(top_) { |
|
||||
top_ = this; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
#define BAILOUT(reason) \ |
|
||||
do { return NULL; } while (false) |
|
||||
|
|
||||
Cfg* Cfg::Build() { |
|
||||
FunctionLiteral* fun = CfgGlobals::current()->fun(); |
|
||||
if (fun->scope()->num_heap_slots() > 0) { |
|
||||
BAILOUT("function has context slots"); |
|
||||
} |
|
||||
if (fun->scope()->num_stack_slots() > kBitsPerPointer) { |
|
||||
BAILOUT("function has too many locals"); |
|
||||
} |
|
||||
if (fun->scope()->num_parameters() > kBitsPerPointer - 1) { |
|
||||
BAILOUT("function has too many parameters"); |
|
||||
} |
|
||||
if (fun->scope()->arguments() != NULL) { |
|
||||
BAILOUT("function uses .arguments"); |
|
||||
} |
|
||||
|
|
||||
ZoneList<Statement*>* body = fun->body(); |
|
||||
if (body->is_empty()) { |
|
||||
BAILOUT("empty function body"); |
|
||||
} |
|
||||
|
|
||||
StatementCfgBuilder builder; |
|
||||
builder.VisitStatements(body); |
|
||||
Cfg* graph = builder.graph(); |
|
||||
if (graph == NULL) { |
|
||||
BAILOUT("unsupported statement type"); |
|
||||
} |
|
||||
if (graph->is_empty()) { |
|
||||
BAILOUT("function body produces empty cfg"); |
|
||||
} |
|
||||
if (graph->has_exit()) { |
|
||||
BAILOUT("control path without explicit return"); |
|
||||
} |
|
||||
graph->PrependEntryNode(); |
|
||||
return graph; |
|
||||
} |
|
||||
|
|
||||
#undef BAILOUT |
|
||||
|
|
||||
|
|
||||
void Cfg::PrependEntryNode() { |
|
||||
ASSERT(!is_empty()); |
|
||||
entry_ = new EntryNode(InstructionBlock::cast(entry())); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Cfg::Append(Instruction* instr) { |
|
||||
ASSERT(is_empty() || has_exit()); |
|
||||
if (is_empty()) { |
|
||||
entry_ = exit_ = new InstructionBlock(); |
|
||||
} |
|
||||
InstructionBlock::cast(exit_)->Append(instr); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Cfg::AppendReturnInstruction(Value* value) { |
|
||||
Append(new ReturnInstr(value)); |
|
||||
ExitNode* global_exit = CfgGlobals::current()->exit(); |
|
||||
InstructionBlock::cast(exit_)->set_successor(global_exit); |
|
||||
exit_ = NULL; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Cfg::Concatenate(Cfg* other) { |
|
||||
ASSERT(is_empty() || has_exit()); |
|
||||
if (other->is_empty()) return; |
|
||||
|
|
||||
if (is_empty()) { |
|
||||
entry_ = other->entry(); |
|
||||
exit_ = other->exit(); |
|
||||
} else { |
|
||||
// We have a pair of nonempty fragments and this has an available exit.
|
|
||||
// Destructively glue the fragments together.
|
|
||||
InstructionBlock* first = InstructionBlock::cast(exit_); |
|
||||
InstructionBlock* second = InstructionBlock::cast(other->entry()); |
|
||||
first->instructions()->AddAll(*second->instructions()); |
|
||||
if (second->successor() != NULL) { |
|
||||
first->set_successor(second->successor()); |
|
||||
exit_ = other->exit(); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void InstructionBlock::Unmark() { |
|
||||
if (is_marked_) { |
|
||||
is_marked_ = false; |
|
||||
successor_->Unmark(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void EntryNode::Unmark() { |
|
||||
if (is_marked_) { |
|
||||
is_marked_ = false; |
|
||||
successor_->Unmark(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExitNode::Unmark() { |
|
||||
is_marked_ = false; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
Handle<Code> Cfg::Compile(Handle<Script> script) { |
|
||||
const int kInitialBufferSize = 4 * KB; |
|
||||
MacroAssembler* masm = new MacroAssembler(NULL, kInitialBufferSize); |
|
||||
entry()->Compile(masm); |
|
||||
entry()->Unmark(); |
|
||||
CodeDesc desc; |
|
||||
masm->GetCode(&desc); |
|
||||
FunctionLiteral* fun = CfgGlobals::current()->fun(); |
|
||||
ZoneScopeInfo info(fun->scope()); |
|
||||
InLoopFlag in_loop = fun->loop_nesting() ? IN_LOOP : NOT_IN_LOOP; |
|
||||
Code::Flags flags = Code::ComputeFlags(Code::FUNCTION, in_loop); |
|
||||
Handle<Code> code = Factory::NewCode(desc, &info, flags, masm->CodeObject()); |
|
||||
|
|
||||
// Add unresolved entries in the code to the fixup list.
|
|
||||
Bootstrapper::AddFixup(*code, masm); |
|
||||
|
|
||||
#ifdef ENABLE_DISASSEMBLER |
|
||||
if (FLAG_print_code) { |
|
||||
// Print the source code if available.
|
|
||||
if (!script->IsUndefined() && !script->source()->IsUndefined()) { |
|
||||
PrintF("--- Raw source ---\n"); |
|
||||
StringInputBuffer stream(String::cast(script->source())); |
|
||||
stream.Seek(fun->start_position()); |
|
||||
// fun->end_position() points to the last character in the
|
|
||||
// stream. We need to compensate by adding one to calculate the
|
|
||||
// length.
|
|
||||
int source_len = fun->end_position() - fun->start_position() + 1; |
|
||||
for (int i = 0; i < source_len; i++) { |
|
||||
if (stream.has_more()) PrintF("%c", stream.GetNext()); |
|
||||
} |
|
||||
PrintF("\n\n"); |
|
||||
} |
|
||||
PrintF("--- Code ---\n"); |
|
||||
code->Disassemble(*fun->name()->ToCString()); |
|
||||
} |
|
||||
#endif |
|
||||
|
|
||||
return code; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ZeroOperandInstruction::FastAllocate(TempLocation* temp) { |
|
||||
temp->set_where(TempLocation::STACK); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void OneOperandInstruction::FastAllocate(TempLocation* temp) { |
|
||||
temp->set_where((temp == value_) |
|
||||
? TempLocation::ACCUMULATOR |
|
||||
: TempLocation::STACK); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TwoOperandInstruction::FastAllocate(TempLocation* temp) { |
|
||||
temp->set_where((temp == value0_ || temp == value1_) |
|
||||
? TempLocation::ACCUMULATOR |
|
||||
: TempLocation::STACK); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void PositionInstr::Compile(MacroAssembler* masm) { |
|
||||
if (FLAG_debug_info && pos_ != RelocInfo::kNoPosition) { |
|
||||
masm->RecordStatementPosition(pos_); |
|
||||
masm->RecordPosition(pos_); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void MoveInstr::Compile(MacroAssembler* masm) { |
|
||||
location()->Move(masm, value()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
// The expression builder should not be used for declarations or statements.
|
|
||||
void ExpressionCfgBuilder::VisitDeclaration(Declaration* decl) { |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
|
|
||||
#define DEFINE_VISIT(type) \ |
|
||||
void ExpressionCfgBuilder::Visit##type(type* stmt) { UNREACHABLE(); } |
|
||||
STATEMENT_NODE_LIST(DEFINE_VISIT) |
|
||||
#undef DEFINE_VISIT |
|
||||
|
|
||||
|
|
||||
// Macros (temporarily) handling unsupported expression types.
|
|
||||
#define BAILOUT(reason) \ |
|
||||
do { \ |
|
||||
graph_ = NULL; \ |
|
||||
return; \ |
|
||||
} while (false) |
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitFunctionLiteral(FunctionLiteral* expr) { |
|
||||
BAILOUT("FunctionLiteral"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitFunctionBoilerplateLiteral( |
|
||||
FunctionBoilerplateLiteral* expr) { |
|
||||
BAILOUT("FunctionBoilerplateLiteral"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitConditional(Conditional* expr) { |
|
||||
BAILOUT("Conditional"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitSlot(Slot* expr) { |
|
||||
BAILOUT("Slot"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitVariableProxy(VariableProxy* expr) { |
|
||||
Expression* rewrite = expr->var()->rewrite(); |
|
||||
if (rewrite == NULL || rewrite->AsSlot() == NULL) { |
|
||||
BAILOUT("unsupported variable (not a slot)"); |
|
||||
} |
|
||||
Slot* slot = rewrite->AsSlot(); |
|
||||
if (slot->type() != Slot::PARAMETER && slot->type() != Slot::LOCAL) { |
|
||||
BAILOUT("unsupported slot type (not a parameter or local)"); |
|
||||
} |
|
||||
// Ignore the passed destination.
|
|
||||
value_ = new SlotLocation(slot->type(), slot->index()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitLiteral(Literal* expr) { |
|
||||
// Ignore the passed destination.
|
|
||||
value_ = new Constant(expr->handle()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitRegExpLiteral(RegExpLiteral* expr) { |
|
||||
BAILOUT("RegExpLiteral"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitObjectLiteral(ObjectLiteral* expr) { |
|
||||
BAILOUT("ObjectLiteral"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitArrayLiteral(ArrayLiteral* expr) { |
|
||||
BAILOUT("ArrayLiteral"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitCatchExtensionObject( |
|
||||
CatchExtensionObject* expr) { |
|
||||
BAILOUT("CatchExtensionObject"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitAssignment(Assignment* expr) { |
|
||||
if (expr->op() != Token::ASSIGN && expr->op() != Token::INIT_VAR) { |
|
||||
BAILOUT("unsupported compound assignment"); |
|
||||
} |
|
||||
Expression* lhs = expr->target(); |
|
||||
if (lhs->AsProperty() != NULL) { |
|
||||
BAILOUT("unsupported property assignment"); |
|
||||
} |
|
||||
|
|
||||
Variable* var = lhs->AsVariableProxy()->AsVariable(); |
|
||||
if (var == NULL) { |
|
||||
BAILOUT("unsupported invalid left-hand side"); |
|
||||
} |
|
||||
if (var->is_global()) { |
|
||||
BAILOUT("unsupported global variable"); |
|
||||
} |
|
||||
Slot* slot = var->slot(); |
|
||||
ASSERT(slot != NULL); |
|
||||
if (slot->type() != Slot::PARAMETER && slot->type() != Slot::LOCAL) { |
|
||||
BAILOUT("unsupported slot lhs (not a parameter or local)"); |
|
||||
} |
|
||||
|
|
||||
// Parameter and local slot assignments.
|
|
||||
ExpressionCfgBuilder builder; |
|
||||
SlotLocation* loc = new SlotLocation(slot->type(), slot->index()); |
|
||||
builder.Build(expr->value(), loc); |
|
||||
if (builder.graph() == NULL) { |
|
||||
BAILOUT("unsupported expression in assignment"); |
|
||||
} |
|
||||
// If the expression did not come back in the slot location, append
|
|
||||
// a move to the CFG.
|
|
||||
graph_ = builder.graph(); |
|
||||
if (builder.value() != loc) { |
|
||||
graph()->Append(new MoveInstr(loc, builder.value())); |
|
||||
} |
|
||||
// Record the assignment.
|
|
||||
assigned_vars_.AddElement(loc); |
|
||||
// Ignore the destination passed to us.
|
|
||||
value_ = loc; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitThrow(Throw* expr) { |
|
||||
BAILOUT("Throw"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitProperty(Property* expr) { |
|
||||
ExpressionCfgBuilder object, key; |
|
||||
object.Build(expr->obj(), NULL); |
|
||||
if (object.graph() == NULL) { |
|
||||
BAILOUT("unsupported object subexpression in propload"); |
|
||||
} |
|
||||
key.Build(expr->key(), NULL); |
|
||||
if (key.graph() == NULL) { |
|
||||
BAILOUT("unsupported key subexpression in propload"); |
|
||||
} |
|
||||
|
|
||||
if (destination_ == NULL) destination_ = new TempLocation(); |
|
||||
|
|
||||
graph_ = object.graph(); |
|
||||
// Insert a move to a fresh temporary if the object value is in a slot
|
|
||||
// that's assigned in the key.
|
|
||||
Location* temp = NULL; |
|
||||
if (object.value()->is_slot() && |
|
||||
key.assigned_vars()->Contains(SlotLocation::cast(object.value()))) { |
|
||||
temp = new TempLocation(); |
|
||||
graph()->Append(new MoveInstr(temp, object.value())); |
|
||||
} |
|
||||
graph()->Concatenate(key.graph()); |
|
||||
graph()->Append(new PropLoadInstr(destination_, |
|
||||
temp == NULL ? object.value() : temp, |
|
||||
key.value())); |
|
||||
|
|
||||
assigned_vars_ = *object.assigned_vars(); |
|
||||
assigned_vars()->Union(key.assigned_vars()); |
|
||||
|
|
||||
value_ = destination_; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitCall(Call* expr) { |
|
||||
BAILOUT("Call"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitCallEval(CallEval* expr) { |
|
||||
BAILOUT("CallEval"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitCallNew(CallNew* expr) { |
|
||||
BAILOUT("CallNew"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitCallRuntime(CallRuntime* expr) { |
|
||||
BAILOUT("CallRuntime"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitUnaryOperation(UnaryOperation* expr) { |
|
||||
BAILOUT("UnaryOperation"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitCountOperation(CountOperation* expr) { |
|
||||
BAILOUT("CountOperation"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitBinaryOperation(BinaryOperation* expr) { |
|
||||
Token::Value op = expr->op(); |
|
||||
switch (op) { |
|
||||
case Token::COMMA: |
|
||||
case Token::OR: |
|
||||
case Token::AND: |
|
||||
BAILOUT("unsupported binary operation"); |
|
||||
|
|
||||
case Token::BIT_OR: |
|
||||
case Token::BIT_XOR: |
|
||||
case Token::BIT_AND: |
|
||||
case Token::SHL: |
|
||||
case Token::SAR: |
|
||||
case Token::SHR: |
|
||||
case Token::ADD: |
|
||||
case Token::SUB: |
|
||||
case Token::MUL: |
|
||||
case Token::DIV: |
|
||||
case Token::MOD: { |
|
||||
ExpressionCfgBuilder left, right; |
|
||||
left.Build(expr->left(), NULL); |
|
||||
if (left.graph() == NULL) { |
|
||||
BAILOUT("unsupported left subexpression in binop"); |
|
||||
} |
|
||||
right.Build(expr->right(), NULL); |
|
||||
if (right.graph() == NULL) { |
|
||||
BAILOUT("unsupported right subexpression in binop"); |
|
||||
} |
|
||||
|
|
||||
if (destination_ == NULL) destination_ = new TempLocation(); |
|
||||
|
|
||||
graph_ = left.graph(); |
|
||||
// Insert a move to a fresh temporary if the left value is in a
|
|
||||
// slot that's assigned on the right.
|
|
||||
Location* temp = NULL; |
|
||||
if (left.value()->is_slot() && |
|
||||
right.assigned_vars()->Contains(SlotLocation::cast(left.value()))) { |
|
||||
temp = new TempLocation(); |
|
||||
graph()->Append(new MoveInstr(temp, left.value())); |
|
||||
} |
|
||||
graph()->Concatenate(right.graph()); |
|
||||
graph()->Append(new BinaryOpInstr(destination_, op, |
|
||||
temp == NULL ? left.value() : temp, |
|
||||
right.value())); |
|
||||
|
|
||||
assigned_vars_ = *left.assigned_vars(); |
|
||||
assigned_vars()->Union(right.assigned_vars()); |
|
||||
|
|
||||
value_ = destination_; |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
default: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitCompareOperation(CompareOperation* expr) { |
|
||||
BAILOUT("CompareOperation"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExpressionCfgBuilder::VisitThisFunction(ThisFunction* expr) { |
|
||||
BAILOUT("ThisFunction"); |
|
||||
} |
|
||||
|
|
||||
#undef BAILOUT |
|
||||
|
|
||||
|
|
||||
// Macros (temporarily) handling unsupported statement types.
|
|
||||
#define BAILOUT(reason) \ |
|
||||
do { \ |
|
||||
graph_ = NULL; \ |
|
||||
return; \ |
|
||||
} while (false) |
|
||||
|
|
||||
#define CHECK_BAILOUT() \ |
|
||||
if (graph() == NULL) { return; } else {} |
|
||||
|
|
||||
void StatementCfgBuilder::VisitStatements(ZoneList<Statement*>* stmts) { |
|
||||
for (int i = 0, len = stmts->length(); i < len; i++) { |
|
||||
Visit(stmts->at(i)); |
|
||||
CHECK_BAILOUT(); |
|
||||
if (!graph()->has_exit()) return; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
// The statement builder should not be used for declarations or expressions.
|
|
||||
void StatementCfgBuilder::VisitDeclaration(Declaration* decl) { UNREACHABLE(); } |
|
||||
|
|
||||
#define DEFINE_VISIT(type) \ |
|
||||
void StatementCfgBuilder::Visit##type(type* expr) { UNREACHABLE(); } |
|
||||
EXPRESSION_NODE_LIST(DEFINE_VISIT) |
|
||||
#undef DEFINE_VISIT |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitBlock(Block* stmt) { |
|
||||
VisitStatements(stmt->statements()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitExpressionStatement(ExpressionStatement* stmt) { |
|
||||
ExpressionCfgBuilder builder; |
|
||||
builder.Build(stmt->expression(), CfgGlobals::current()->nowhere()); |
|
||||
if (builder.graph() == NULL) { |
|
||||
BAILOUT("unsupported expression in expression statement"); |
|
||||
} |
|
||||
graph()->Append(new PositionInstr(stmt->statement_pos())); |
|
||||
graph()->Concatenate(builder.graph()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitEmptyStatement(EmptyStatement* stmt) { |
|
||||
// Nothing to do.
|
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitIfStatement(IfStatement* stmt) { |
|
||||
BAILOUT("IfStatement"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitContinueStatement(ContinueStatement* stmt) { |
|
||||
BAILOUT("ContinueStatement"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitBreakStatement(BreakStatement* stmt) { |
|
||||
BAILOUT("BreakStatement"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitReturnStatement(ReturnStatement* stmt) { |
|
||||
ExpressionCfgBuilder builder; |
|
||||
builder.Build(stmt->expression(), NULL); |
|
||||
if (builder.graph() == NULL) { |
|
||||
BAILOUT("unsupported expression in return statement"); |
|
||||
} |
|
||||
|
|
||||
graph()->Append(new PositionInstr(stmt->statement_pos())); |
|
||||
graph()->Concatenate(builder.graph()); |
|
||||
graph()->AppendReturnInstruction(builder.value()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitWithEnterStatement(WithEnterStatement* stmt) { |
|
||||
BAILOUT("WithEnterStatement"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitWithExitStatement(WithExitStatement* stmt) { |
|
||||
BAILOUT("WithExitStatement"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitSwitchStatement(SwitchStatement* stmt) { |
|
||||
BAILOUT("SwitchStatement"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitLoopStatement(LoopStatement* stmt) { |
|
||||
BAILOUT("LoopStatement"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitForInStatement(ForInStatement* stmt) { |
|
||||
BAILOUT("ForInStatement"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitTryCatch(TryCatch* stmt) { |
|
||||
BAILOUT("TryCatch"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitTryFinally(TryFinally* stmt) { |
|
||||
BAILOUT("TryFinally"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void StatementCfgBuilder::VisitDebuggerStatement(DebuggerStatement* stmt) { |
|
||||
BAILOUT("DebuggerStatement"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
// CFG printing support (via depth-first, preorder block traversal).
|
|
||||
|
|
||||
void Cfg::Print() { |
|
||||
entry_->Print(); |
|
||||
entry_->Unmark(); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Constant::Print() { |
|
||||
PrintF("Constant "); |
|
||||
handle_->Print(); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Nowhere::Print() { |
|
||||
PrintF("Nowhere"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Print() { |
|
||||
PrintF("Slot "); |
|
||||
switch (type_) { |
|
||||
case Slot::PARAMETER: |
|
||||
PrintF("(PARAMETER, %d)", index_); |
|
||||
break; |
|
||||
case Slot::LOCAL: |
|
||||
PrintF("(LOCAL, %d)", index_); |
|
||||
break; |
|
||||
default: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Print() { |
|
||||
PrintF("Temp %d", number()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void OneOperandInstruction::Print() { |
|
||||
PrintF("("); |
|
||||
location()->Print(); |
|
||||
PrintF(", "); |
|
||||
value_->Print(); |
|
||||
PrintF(")"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TwoOperandInstruction::Print() { |
|
||||
PrintF("("); |
|
||||
location()->Print(); |
|
||||
PrintF(", "); |
|
||||
value0_->Print(); |
|
||||
PrintF(", "); |
|
||||
value1_->Print(); |
|
||||
PrintF(")"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void MoveInstr::Print() { |
|
||||
PrintF("Move "); |
|
||||
OneOperandInstruction::Print(); |
|
||||
PrintF("\n"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void PropLoadInstr::Print() { |
|
||||
PrintF("PropLoad "); |
|
||||
TwoOperandInstruction::Print(); |
|
||||
PrintF("\n"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void BinaryOpInstr::Print() { |
|
||||
switch (op()) { |
|
||||
case Token::OR: |
|
||||
// Two character operand.
|
|
||||
PrintF("BinaryOp[OR] "); |
|
||||
break; |
|
||||
case Token::AND: |
|
||||
case Token::SHL: |
|
||||
case Token::SAR: |
|
||||
case Token::SHR: |
|
||||
case Token::ADD: |
|
||||
case Token::SUB: |
|
||||
case Token::MUL: |
|
||||
case Token::DIV: |
|
||||
case Token::MOD: |
|
||||
// Three character operands.
|
|
||||
PrintF("BinaryOp[%s] ", Token::Name(op())); |
|
||||
break; |
|
||||
case Token::COMMA: |
|
||||
// Five character operand.
|
|
||||
PrintF("BinaryOp[COMMA] "); |
|
||||
break; |
|
||||
case Token::BIT_OR: |
|
||||
// Six character operand.
|
|
||||
PrintF("BinaryOp[BIT_OR] "); |
|
||||
break; |
|
||||
case Token::BIT_XOR: |
|
||||
case Token::BIT_AND: |
|
||||
// Seven character operands.
|
|
||||
PrintF("BinaryOp[%s] ", Token::Name(op())); |
|
||||
break; |
|
||||
default: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
TwoOperandInstruction::Print(); |
|
||||
PrintF("\n"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ReturnInstr::Print() { |
|
||||
PrintF("Return "); |
|
||||
OneOperandInstruction::Print(); |
|
||||
PrintF("\n"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void InstructionBlock::Print() { |
|
||||
if (!is_marked_) { |
|
||||
is_marked_ = true; |
|
||||
PrintF("L%d:\n", number()); |
|
||||
for (int i = 0, len = instructions_.length(); i < len; i++) { |
|
||||
instructions_[i]->Print(); |
|
||||
} |
|
||||
PrintF("Goto L%d\n\n", successor_->number()); |
|
||||
successor_->Print(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void EntryNode::Print() { |
|
||||
if (!is_marked_) { |
|
||||
is_marked_ = true; |
|
||||
successor_->Print(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExitNode::Print() { |
|
||||
if (!is_marked_) { |
|
||||
is_marked_ = true; |
|
||||
PrintF("L%d:\nExit\n\n", number()); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
#endif // DEBUG
|
|
||||
|
|
||||
} } // namespace v8::internal
|
|
||||
@ -1,871 +0,0 @@ |
|||||
// Copyright 2009 the V8 project authors. All rights reserved.
|
|
||||
// Redistribution and use in source and binary forms, with or without
|
|
||||
// modification, are permitted provided that the following conditions are
|
|
||||
// met:
|
|
||||
//
|
|
||||
// * Redistributions of source code must retain the above copyright
|
|
||||
// notice, this list of conditions and the following disclaimer.
|
|
||||
// * Redistributions in binary form must reproduce the above
|
|
||||
// copyright notice, this list of conditions and the following
|
|
||||
// disclaimer in the documentation and/or other materials provided
|
|
||||
// with the distribution.
|
|
||||
// * Neither the name of Google Inc. nor the names of its
|
|
||||
// contributors may be used to endorse or promote products derived
|
|
||||
// from this software without specific prior written permission.
|
|
||||
//
|
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||
|
|
||||
#ifndef V8_CFG_H_ |
|
||||
#define V8_CFG_H_ |
|
||||
|
|
||||
#include "ast.h" |
|
||||
|
|
||||
namespace v8 { |
|
||||
namespace internal { |
|
||||
|
|
||||
class ExitNode; |
|
||||
class Location; |
|
||||
|
|
||||
// Translate a source AST into a control-flow graph (CFG). The CFG contains
|
|
||||
// single-entry, single-exit blocks of straight-line instructions and
|
|
||||
// administrative nodes.
|
|
||||
//
|
|
||||
// Instructions are described by the following grammar.
|
|
||||
//
|
|
||||
// <Instruction> ::=
|
|
||||
// Move <Location> <Value>
|
|
||||
// | PropLoad <Location> <Value> <Value>
|
|
||||
// | BinaryOp <Location> Token::Value <Value> <Value>
|
|
||||
// | Return Nowhere <Value>
|
|
||||
// | Position <Int>
|
|
||||
//
|
|
||||
// Values are trivial expressions:
|
|
||||
//
|
|
||||
// <Value> ::= Constant | <Location>
|
|
||||
//
|
|
||||
// Locations are storable values ('lvalues'). They can be slots,
|
|
||||
// compiler-generated temporaries, or the special location 'Nowhere'
|
|
||||
// indicating that no value is needed.
|
|
||||
//
|
|
||||
// <Location> ::=
|
|
||||
// SlotLocation Slot::Type <Index>
|
|
||||
// | TempLocation
|
|
||||
// | Nowhere
|
|
||||
|
|
||||
|
|
||||
// Administrative nodes: There are several types of 'administrative' nodes
|
|
||||
// that do not contain instructions and do not necessarily have a single
|
|
||||
// predecessor and a single successor.
|
|
||||
//
|
|
||||
// EntryNode: there is a distinguished entry node that has no predecessors
|
|
||||
// and a single successor.
|
|
||||
//
|
|
||||
// ExitNode: there is a distinguished exit node that has arbitrarily many
|
|
||||
// predecessors and no successor.
|
|
||||
//
|
|
||||
// JoinNode: join nodes have multiple predecessors and a single successor.
|
|
||||
//
|
|
||||
// BranchNode: branch nodes have a single predecessor and multiple
|
|
||||
// successors.
|
|
||||
|
|
||||
|
|
||||
// A convenient class to keep 'global' values when building a CFG. Since
|
|
||||
// CFG construction can be invoked recursively, CFG globals are stacked.
|
|
||||
class CfgGlobals BASE_EMBEDDED { |
|
||||
public: |
|
||||
explicit CfgGlobals(FunctionLiteral* fun); |
|
||||
|
|
||||
~CfgGlobals() { top_ = previous_; } |
|
||||
|
|
||||
static CfgGlobals* current() { |
|
||||
ASSERT(top_ != NULL); |
|
||||
return top_; |
|
||||
} |
|
||||
|
|
||||
// The function currently being compiled.
|
|
||||
FunctionLiteral* fun() { return global_fun_; } |
|
||||
|
|
||||
// The shared global exit node for all exits from the function.
|
|
||||
ExitNode* exit() { return global_exit_; } |
|
||||
|
|
||||
// A singleton.
|
|
||||
Location* nowhere() { return nowhere_; } |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
int next_node_number() { return node_counter_++; } |
|
||||
int next_temp_number() { return temp_counter_++; } |
|
||||
#endif |
|
||||
|
|
||||
private: |
|
||||
static CfgGlobals* top_; |
|
||||
FunctionLiteral* global_fun_; |
|
||||
ExitNode* global_exit_; |
|
||||
Location* nowhere_; |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
// Used to number nodes and temporaries when printing.
|
|
||||
int node_counter_; |
|
||||
int temp_counter_; |
|
||||
#endif |
|
||||
|
|
||||
CfgGlobals* previous_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
class SlotLocation; |
|
||||
|
|
||||
// Values represent trivial source expressions: ones with no side effects
|
|
||||
// and that do not require code to be generated.
|
|
||||
class Value : public ZoneObject { |
|
||||
public: |
|
||||
virtual ~Value() {} |
|
||||
|
|
||||
// Predicates:
|
|
||||
|
|
||||
virtual bool is_temporary() { return false; } |
|
||||
virtual bool is_slot() { return false; } |
|
||||
virtual bool is_constant() { return false; } |
|
||||
|
|
||||
// True if the value is a temporary allocated to the stack in
|
|
||||
// fast-compilation mode.
|
|
||||
virtual bool is_on_stack() { return false; } |
|
||||
|
|
||||
// Support for fast-compilation mode:
|
|
||||
|
|
||||
// Move the value into a register.
|
|
||||
virtual void Get(MacroAssembler* masm, Register reg) = 0; |
|
||||
|
|
||||
// Push the value on the stack.
|
|
||||
virtual void Push(MacroAssembler* masm) = 0; |
|
||||
|
|
||||
// Move the value into a slot location.
|
|
||||
virtual void MoveToSlot(MacroAssembler* masm, SlotLocation* loc) = 0; |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
virtual void Print() = 0; |
|
||||
#endif |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// A compile-time constant that appeared as a literal in the source AST.
|
|
||||
class Constant : public Value { |
|
||||
public: |
|
||||
explicit Constant(Handle<Object> handle) : handle_(handle) {} |
|
||||
|
|
||||
// Cast accessor.
|
|
||||
static Constant* cast(Value* value) { |
|
||||
ASSERT(value->is_constant()); |
|
||||
return reinterpret_cast<Constant*>(value); |
|
||||
} |
|
||||
|
|
||||
// Accessors.
|
|
||||
Handle<Object> handle() { return handle_; } |
|
||||
|
|
||||
// Predicates.
|
|
||||
bool is_constant() { return true; } |
|
||||
|
|
||||
// Support for fast-compilation mode.
|
|
||||
void Get(MacroAssembler* masm, Register reg); |
|
||||
void Push(MacroAssembler* masm); |
|
||||
void MoveToSlot(MacroAssembler* masm, SlotLocation* loc); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
void Print(); |
|
||||
#endif |
|
||||
|
|
||||
private: |
|
||||
Handle<Object> handle_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// Locations are values that can be stored into ('lvalues').
|
|
||||
class Location : public Value { |
|
||||
public: |
|
||||
virtual ~Location() {} |
|
||||
|
|
||||
// Static factory function returning the singleton nowhere location.
|
|
||||
static Location* Nowhere() { |
|
||||
return CfgGlobals::current()->nowhere(); |
|
||||
} |
|
||||
|
|
||||
// Support for fast-compilation mode:
|
|
||||
|
|
||||
// Assumes temporaries have been allocated.
|
|
||||
virtual void Get(MacroAssembler* masm, Register reg) = 0; |
|
||||
|
|
||||
// Store the value in a register to the location. Assumes temporaries
|
|
||||
// have been allocated.
|
|
||||
virtual void Set(MacroAssembler* masm, Register reg) = 0; |
|
||||
|
|
||||
// Assumes temporaries have been allocated, and if the value is a
|
|
||||
// temporary it was not allocated to the stack.
|
|
||||
virtual void Push(MacroAssembler* masm) = 0; |
|
||||
|
|
||||
// Emit code to move a value into this location.
|
|
||||
virtual void Move(MacroAssembler* masm, Value* value) = 0; |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
virtual void Print() = 0; |
|
||||
#endif |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// Nowhere is a special (singleton) location that indicates the value of a
|
|
||||
// computation is not needed (though its side effects are).
|
|
||||
class Nowhere : public Location { |
|
||||
public: |
|
||||
// We should not try to emit code to read Nowhere.
|
|
||||
void Get(MacroAssembler* masm, Register reg) { UNREACHABLE(); } |
|
||||
void Push(MacroAssembler* masm) { UNREACHABLE(); } |
|
||||
void MoveToSlot(MacroAssembler* masm, SlotLocation* loc) { UNREACHABLE(); } |
|
||||
|
|
||||
// Setting Nowhere is ignored.
|
|
||||
void Set(MacroAssembler* masm, Register reg) {} |
|
||||
void Move(MacroAssembler* masm, Value* value) {} |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
void Print(); |
|
||||
#endif |
|
||||
|
|
||||
private: |
|
||||
Nowhere() {} |
|
||||
|
|
||||
friend class CfgGlobals; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// SlotLocations represent parameters and stack-allocated (i.e.,
|
|
||||
// non-context) local variables.
|
|
||||
class SlotLocation : public Location { |
|
||||
public: |
|
||||
SlotLocation(Slot::Type type, int index) : type_(type), index_(index) {} |
|
||||
|
|
||||
// Cast accessor.
|
|
||||
static SlotLocation* cast(Value* value) { |
|
||||
ASSERT(value->is_slot()); |
|
||||
return reinterpret_cast<SlotLocation*>(value); |
|
||||
} |
|
||||
|
|
||||
// Accessors.
|
|
||||
Slot::Type type() { return type_; } |
|
||||
int index() { return index_; } |
|
||||
|
|
||||
// Predicates.
|
|
||||
bool is_slot() { return true; } |
|
||||
|
|
||||
// Support for fast-compilation mode.
|
|
||||
void Get(MacroAssembler* masm, Register reg); |
|
||||
void Set(MacroAssembler* masm, Register reg); |
|
||||
void Push(MacroAssembler* masm); |
|
||||
void Move(MacroAssembler* masm, Value* value); |
|
||||
void MoveToSlot(MacroAssembler* masm, SlotLocation* loc); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
void Print(); |
|
||||
#endif |
|
||||
|
|
||||
private: |
|
||||
Slot::Type type_; |
|
||||
int index_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// TempLocations represent compiler generated temporaries. They are
|
|
||||
// allocated to registers or memory either before code generation (in the
|
|
||||
// optimized-for-speed compiler) or on the fly during code generation (in
|
|
||||
// the optimized-for-space compiler).
|
|
||||
class TempLocation : public Location { |
|
||||
public: |
|
||||
// Fast-compilation mode allocation decisions.
|
|
||||
enum Where { |
|
||||
NOT_ALLOCATED, // Not yet allocated.
|
|
||||
ACCUMULATOR, // Allocated to the dedicated accumulator register.
|
|
||||
STACK // " " " " stack.
|
|
||||
}; |
|
||||
|
|
||||
TempLocation() : where_(NOT_ALLOCATED) { |
|
||||
#ifdef DEBUG |
|
||||
number_ = -1; |
|
||||
#endif |
|
||||
} |
|
||||
|
|
||||
// Cast accessor.
|
|
||||
static TempLocation* cast(Value* value) { |
|
||||
ASSERT(value->is_temporary()); |
|
||||
return reinterpret_cast<TempLocation*>(value); |
|
||||
} |
|
||||
|
|
||||
// Accessors.
|
|
||||
Where where() { return where_; } |
|
||||
void set_where(Where where) { |
|
||||
ASSERT(where_ == TempLocation::NOT_ALLOCATED); |
|
||||
where_ = where; |
|
||||
} |
|
||||
|
|
||||
// Predicates.
|
|
||||
bool is_on_stack() { return where_ == STACK; } |
|
||||
bool is_temporary() { return true; } |
|
||||
|
|
||||
// Support for fast-compilation mode. Assume the temp has been allocated.
|
|
||||
void Get(MacroAssembler* masm, Register reg); |
|
||||
void Set(MacroAssembler* masm, Register reg); |
|
||||
void Push(MacroAssembler* masm); |
|
||||
void Move(MacroAssembler* masm, Value* value); |
|
||||
void MoveToSlot(MacroAssembler* masm, SlotLocation* loc); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
int number() { |
|
||||
if (number_ == -1) number_ = CfgGlobals::current()->next_temp_number(); |
|
||||
return number_; |
|
||||
} |
|
||||
|
|
||||
void Print(); |
|
||||
#endif |
|
||||
|
|
||||
private: |
|
||||
Where where_; |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
int number_; |
|
||||
#endif |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// Instructions are computations. The represent non-trivial source
|
|
||||
// expressions: typically ones that have side effects and require code to
|
|
||||
// be generated.
|
|
||||
class Instruction : public ZoneObject { |
|
||||
public: |
|
||||
// Accessors.
|
|
||||
Location* location() { return location_; } |
|
||||
void set_location(Location* location) { location_ = location; } |
|
||||
|
|
||||
// Support for fast-compilation mode:
|
|
||||
|
|
||||
// Emit code to perform the instruction.
|
|
||||
virtual void Compile(MacroAssembler* masm) = 0; |
|
||||
|
|
||||
// Allocate a temporary which is the result of the immediate predecessor
|
|
||||
// instruction. It is allocated to the accumulator register if it is used
|
|
||||
// as an operand to this instruction, otherwise to the stack.
|
|
||||
virtual void FastAllocate(TempLocation* temp) = 0; |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
virtual void Print() = 0; |
|
||||
#endif |
|
||||
|
|
||||
protected: |
|
||||
// Every instruction has a location where its result is stored (which may
|
|
||||
// be Nowhere).
|
|
||||
explicit Instruction(Location* location) : location_(location) {} |
|
||||
|
|
||||
virtual ~Instruction() {} |
|
||||
|
|
||||
Location* location_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// Base class of instructions that have no input operands.
|
|
||||
class ZeroOperandInstruction : public Instruction { |
|
||||
public: |
|
||||
// Support for fast-compilation mode:
|
|
||||
virtual void Compile(MacroAssembler* masm) = 0; |
|
||||
void FastAllocate(TempLocation* temp); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
// Printing support: print the operands (nothing).
|
|
||||
virtual void Print() {} |
|
||||
#endif |
|
||||
|
|
||||
protected: |
|
||||
explicit ZeroOperandInstruction(Location* loc) : Instruction(loc) {} |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// Base class of instructions that have a single input operand.
|
|
||||
class OneOperandInstruction : public Instruction { |
|
||||
public: |
|
||||
// Support for fast-compilation mode:
|
|
||||
virtual void Compile(MacroAssembler* masm) = 0; |
|
||||
void FastAllocate(TempLocation* temp); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
// Printing support: print the operands.
|
|
||||
virtual void Print(); |
|
||||
#endif |
|
||||
|
|
||||
protected: |
|
||||
OneOperandInstruction(Location* loc, Value* value) |
|
||||
: Instruction(loc), value_(value) { |
|
||||
} |
|
||||
|
|
||||
Value* value_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// Base class of instructions that have two input operands.
|
|
||||
class TwoOperandInstruction : public Instruction { |
|
||||
public: |
|
||||
// Support for fast-compilation mode:
|
|
||||
virtual void Compile(MacroAssembler* masm) = 0; |
|
||||
void FastAllocate(TempLocation* temp); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
// Printing support: print the operands.
|
|
||||
virtual void Print(); |
|
||||
#endif |
|
||||
|
|
||||
protected: |
|
||||
TwoOperandInstruction(Location* loc, Value* value0, Value* value1) |
|
||||
: Instruction(loc), value0_(value0), value1_(value1) { |
|
||||
} |
|
||||
|
|
||||
Value* value0_; |
|
||||
Value* value1_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// A phantom instruction that indicates the start of a statement. It
|
|
||||
// causes the statement position to be recorded in the relocation
|
|
||||
// information but generates no code.
|
|
||||
class PositionInstr : public ZeroOperandInstruction { |
|
||||
public: |
|
||||
explicit PositionInstr(int pos) |
|
||||
: ZeroOperandInstruction(CfgGlobals::current()->nowhere()), pos_(pos) { |
|
||||
} |
|
||||
|
|
||||
// Support for fast-compilation mode.
|
|
||||
void Compile(MacroAssembler* masm); |
|
||||
|
|
||||
// This should not be called. The last instruction of the previous
|
|
||||
// statement should not have a temporary as its location.
|
|
||||
void FastAllocate(TempLocation* temp) { UNREACHABLE(); } |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
// Printing support. Print nothing.
|
|
||||
void Print() {} |
|
||||
#endif |
|
||||
|
|
||||
private: |
|
||||
int pos_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// Move a value to a location.
|
|
||||
class MoveInstr : public OneOperandInstruction { |
|
||||
public: |
|
||||
MoveInstr(Location* loc, Value* value) |
|
||||
: OneOperandInstruction(loc, value) { |
|
||||
} |
|
||||
|
|
||||
// Accessors.
|
|
||||
Value* value() { return value_; } |
|
||||
|
|
||||
// Support for fast-compilation mode.
|
|
||||
void Compile(MacroAssembler* masm); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
// Printing support.
|
|
||||
void Print(); |
|
||||
#endif |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// Load a property from a receiver, leaving the result in a location.
|
|
||||
class PropLoadInstr : public TwoOperandInstruction { |
|
||||
public: |
|
||||
PropLoadInstr(Location* loc, Value* object, Value* key) |
|
||||
: TwoOperandInstruction(loc, object, key) { |
|
||||
} |
|
||||
|
|
||||
// Accessors.
|
|
||||
Value* object() { return value0_; } |
|
||||
Value* key() { return value1_; } |
|
||||
|
|
||||
// Support for fast-compilation mode.
|
|
||||
void Compile(MacroAssembler* masm); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
void Print(); |
|
||||
#endif |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// Perform a (non-short-circuited) binary operation on a pair of values,
|
|
||||
// leaving the result in a location.
|
|
||||
class BinaryOpInstr : public TwoOperandInstruction { |
|
||||
public: |
|
||||
BinaryOpInstr(Location* loc, Token::Value op, Value* left, Value* right) |
|
||||
: TwoOperandInstruction(loc, left, right), op_(op) { |
|
||||
} |
|
||||
|
|
||||
// Accessors.
|
|
||||
Value* left() { return value0_; } |
|
||||
Value* right() { return value1_; } |
|
||||
Token::Value op() { return op_; } |
|
||||
|
|
||||
// Support for fast-compilation mode.
|
|
||||
void Compile(MacroAssembler* masm); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
void Print(); |
|
||||
#endif |
|
||||
|
|
||||
private: |
|
||||
Token::Value op_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// Return a value. Has the side effect of moving its value into the return
|
|
||||
// value register. Can only occur as the last instruction in an instruction
|
|
||||
// block, and implies that the block is closed (cannot have instructions
|
|
||||
// appended or graph fragments concatenated to the end) and that the block's
|
|
||||
// successor is the global exit node for the current function.
|
|
||||
class ReturnInstr : public OneOperandInstruction { |
|
||||
public: |
|
||||
explicit ReturnInstr(Value* value) |
|
||||
: OneOperandInstruction(CfgGlobals::current()->nowhere(), value) { |
|
||||
} |
|
||||
|
|
||||
virtual ~ReturnInstr() {} |
|
||||
|
|
||||
// Accessors.
|
|
||||
Value* value() { return value_; } |
|
||||
|
|
||||
// Support for fast-compilation mode.
|
|
||||
void Compile(MacroAssembler* masm); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
void Print(); |
|
||||
#endif |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// Nodes make up control-flow graphs.
|
|
||||
class CfgNode : public ZoneObject { |
|
||||
public: |
|
||||
CfgNode() : is_marked_(false) { |
|
||||
#ifdef DEBUG |
|
||||
number_ = -1; |
|
||||
#endif |
|
||||
} |
|
||||
|
|
||||
virtual ~CfgNode() {} |
|
||||
|
|
||||
// Because CFGs contain cycles, nodes support marking during traversal
|
|
||||
// (e.g., for printing or compilation). The traversal functions will mark
|
|
||||
// unmarked nodes and backtrack if they encounter a marked one. After a
|
|
||||
// traversal, the graph should be explicitly unmarked by calling Unmark on
|
|
||||
// the entry node.
|
|
||||
bool is_marked() { return is_marked_; } |
|
||||
virtual void Unmark() = 0; |
|
||||
|
|
||||
// Predicates:
|
|
||||
|
|
||||
// True if the node is an instruction block.
|
|
||||
virtual bool is_block() { return false; } |
|
||||
|
|
||||
// Support for fast-compilation mode. Emit the instructions or control
|
|
||||
// flow represented by the node.
|
|
||||
virtual void Compile(MacroAssembler* masm) = 0; |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
int number() { |
|
||||
if (number_ == -1) number_ = CfgGlobals::current()->next_node_number(); |
|
||||
return number_; |
|
||||
} |
|
||||
|
|
||||
virtual void Print() = 0; |
|
||||
#endif |
|
||||
|
|
||||
protected: |
|
||||
bool is_marked_; |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
int number_; |
|
||||
#endif |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// A block is a single-entry, single-exit block of instructions.
|
|
||||
class InstructionBlock : public CfgNode { |
|
||||
public: |
|
||||
InstructionBlock() : successor_(NULL), instructions_(4) {} |
|
||||
|
|
||||
virtual ~InstructionBlock() {} |
|
||||
|
|
||||
void Unmark(); |
|
||||
|
|
||||
// Cast accessor.
|
|
||||
static InstructionBlock* cast(CfgNode* node) { |
|
||||
ASSERT(node->is_block()); |
|
||||
return reinterpret_cast<InstructionBlock*>(node); |
|
||||
} |
|
||||
|
|
||||
bool is_block() { return true; } |
|
||||
|
|
||||
// Accessors.
|
|
||||
CfgNode* successor() { return successor_; } |
|
||||
|
|
||||
void set_successor(CfgNode* succ) { |
|
||||
ASSERT(successor_ == NULL); |
|
||||
successor_ = succ; |
|
||||
} |
|
||||
|
|
||||
ZoneList<Instruction*>* instructions() { return &instructions_; } |
|
||||
|
|
||||
// Support for fast-compilation mode.
|
|
||||
void Compile(MacroAssembler* masm); |
|
||||
|
|
||||
// Add an instruction to the end of the block.
|
|
||||
void Append(Instruction* instr) { instructions_.Add(instr); } |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
void Print(); |
|
||||
#endif |
|
||||
|
|
||||
private: |
|
||||
CfgNode* successor_; |
|
||||
ZoneList<Instruction*> instructions_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// An entry node (one per function).
|
|
||||
class EntryNode : public CfgNode { |
|
||||
public: |
|
||||
explicit EntryNode(InstructionBlock* succ) : successor_(succ) {} |
|
||||
|
|
||||
virtual ~EntryNode() {} |
|
||||
|
|
||||
void Unmark(); |
|
||||
|
|
||||
// Support for fast-compilation mode.
|
|
||||
void Compile(MacroAssembler* masm); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
void Print(); |
|
||||
#endif |
|
||||
|
|
||||
private: |
|
||||
InstructionBlock* successor_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// An exit node (one per function).
|
|
||||
class ExitNode : public CfgNode { |
|
||||
public: |
|
||||
ExitNode() {} |
|
||||
|
|
||||
virtual ~ExitNode() {} |
|
||||
|
|
||||
void Unmark(); |
|
||||
|
|
||||
// Support for fast-compilation mode.
|
|
||||
void Compile(MacroAssembler* masm); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
void Print(); |
|
||||
#endif |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// A CFG consists of a linked structure of nodes. Nodes are linked by
|
|
||||
// pointing to their successors, always beginning with a (single) entry node
|
|
||||
// (not necessarily of type EntryNode). If it is still possible to add
|
|
||||
// nodes to the end of the graph (i.e., there is a (single) path that does
|
|
||||
// not end with the global exit node), then the CFG has an exit node as
|
|
||||
// well.
|
|
||||
//
|
|
||||
// The empty CFG is represented by a NULL entry and a NULL exit.
|
|
||||
//
|
|
||||
// We use the term 'open fragment' to mean a CFG whose entry and exits are
|
|
||||
// both instruction blocks. It is always possible to add instructions and
|
|
||||
// nodes to the beginning or end of an open fragment.
|
|
||||
//
|
|
||||
// We use the term 'closed fragment' to mean a CFG whose entry is an
|
|
||||
// instruction block and whose exit is NULL (all paths go to the global
|
|
||||
// exit).
|
|
||||
//
|
|
||||
// We use the term 'fragment' to refer to a CFG that is known to be an open
|
|
||||
// or closed fragment.
|
|
||||
class Cfg : public ZoneObject { |
|
||||
public: |
|
||||
// Create an empty CFG fragment.
|
|
||||
Cfg() : entry_(NULL), exit_(NULL) {} |
|
||||
|
|
||||
// Build the CFG for a function. The returned CFG begins with an
|
|
||||
// EntryNode and all paths end with the ExitNode.
|
|
||||
static Cfg* Build(); |
|
||||
|
|
||||
// The entry and exit nodes of the CFG (not necessarily EntryNode and
|
|
||||
// ExitNode).
|
|
||||
CfgNode* entry() { return entry_; } |
|
||||
CfgNode* exit() { return exit_; } |
|
||||
|
|
||||
// True if the CFG has no nodes.
|
|
||||
bool is_empty() { return entry_ == NULL; } |
|
||||
|
|
||||
// True if the CFG has an available exit node (i.e., it can be appended or
|
|
||||
// concatenated to).
|
|
||||
bool has_exit() { return exit_ != NULL; } |
|
||||
|
|
||||
// Add an EntryNode to a CFG fragment. It is no longer a fragment
|
|
||||
// (instructions can no longer be prepended).
|
|
||||
void PrependEntryNode(); |
|
||||
|
|
||||
// Append an instruction to the end of an open fragment.
|
|
||||
void Append(Instruction* instr); |
|
||||
|
|
||||
// Appends a return instruction to the end of an open fragment and make
|
|
||||
// it a closed fragment (the exit's successor becomes global exit node).
|
|
||||
void AppendReturnInstruction(Value* value); |
|
||||
|
|
||||
// Glue an other CFG fragment to the end of this (open) fragment.
|
|
||||
void Concatenate(Cfg* other); |
|
||||
|
|
||||
// Support for compilation. Compile the entire CFG.
|
|
||||
Handle<Code> Compile(Handle<Script> script); |
|
||||
|
|
||||
#ifdef DEBUG |
|
||||
// Support for printing.
|
|
||||
void Print(); |
|
||||
#endif |
|
||||
|
|
||||
private: |
|
||||
// Entry and exit nodes.
|
|
||||
CfgNode* entry_; |
|
||||
CfgNode* exit_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// An implementation of a set of locations (currently slot locations), most
|
|
||||
// of the operations are destructive.
|
|
||||
class LocationSet BASE_EMBEDDED { |
|
||||
public: |
|
||||
// Construct an empty location set.
|
|
||||
LocationSet() : parameters_(0), locals_(0) {} |
|
||||
|
|
||||
// Raw accessors.
|
|
||||
uintptr_t parameters() { return parameters_; } |
|
||||
uintptr_t locals() { return locals_; } |
|
||||
|
|
||||
// Make this the empty set.
|
|
||||
void Empty() { |
|
||||
parameters_ = locals_ = 0; |
|
||||
} |
|
||||
|
|
||||
// Insert an element.
|
|
||||
void AddElement(SlotLocation* location) { |
|
||||
if (location->type() == Slot::PARAMETER) { |
|
||||
// Parameter indexes begin with -1 ('this').
|
|
||||
ASSERT(location->index() < kBitsPerPointer - 1); |
|
||||
parameters_ |= (1 << (location->index() + 1)); |
|
||||
} else { |
|
||||
ASSERT(location->type() == Slot::LOCAL); |
|
||||
ASSERT(location->index() < kBitsPerPointer); |
|
||||
locals_ |= (1 << location->index()); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// (Destructively) compute the union with another set.
|
|
||||
void Union(LocationSet* other) { |
|
||||
parameters_ |= other->parameters(); |
|
||||
locals_ |= other->locals(); |
|
||||
} |
|
||||
|
|
||||
bool Contains(SlotLocation* location) { |
|
||||
if (location->type() == Slot::PARAMETER) { |
|
||||
ASSERT(location->index() < kBitsPerPointer - 1); |
|
||||
return (parameters_ & (1 << (location->index() + 1))); |
|
||||
} else { |
|
||||
ASSERT(location->type() == Slot::LOCAL); |
|
||||
ASSERT(location->index() < kBitsPerPointer); |
|
||||
return (locals_ & (1 << location->index())); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
private: |
|
||||
uintptr_t parameters_; |
|
||||
uintptr_t locals_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// An ExpressionCfgBuilder traverses an expression and returns an open CFG
|
|
||||
// fragment (currently a possibly empty list of instructions represented by
|
|
||||
// a singleton instruction block) and the expression's value.
|
|
||||
//
|
|
||||
// Failure to build the CFG is indicated by a NULL CFG.
|
|
||||
class ExpressionCfgBuilder : public AstVisitor { |
|
||||
public: |
|
||||
ExpressionCfgBuilder() : destination_(NULL), value_(NULL), graph_(NULL) {} |
|
||||
|
|
||||
// Result accessors.
|
|
||||
Value* value() { return value_; } |
|
||||
Cfg* graph() { return graph_; } |
|
||||
LocationSet* assigned_vars() { return &assigned_vars_; } |
|
||||
|
|
||||
// Build the cfg for an expression and remember its value. The
|
|
||||
// destination is a 'hint' where the value should go which may be ignored.
|
|
||||
// NULL is used to indicate no preference.
|
|
||||
//
|
|
||||
// Concretely, if the expression needs to generate a temporary for its
|
|
||||
// value, it should use the passed destination or generate one if NULL.
|
|
||||
void Build(Expression* expr, Location* destination) { |
|
||||
value_ = NULL; |
|
||||
graph_ = new Cfg(); |
|
||||
assigned_vars_.Empty(); |
|
||||
destination_ = destination; |
|
||||
Visit(expr); |
|
||||
} |
|
||||
|
|
||||
// AST node visitors.
|
|
||||
#define DECLARE_VISIT(type) void Visit##type(type* node); |
|
||||
AST_NODE_LIST(DECLARE_VISIT) |
|
||||
#undef DECLARE_VISIT |
|
||||
|
|
||||
private: |
|
||||
// State for the visitor. Input parameter:
|
|
||||
Location* destination_; |
|
||||
|
|
||||
// Output parameters:
|
|
||||
Value* value_; |
|
||||
Cfg* graph_; |
|
||||
LocationSet assigned_vars_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
// A StatementCfgBuilder maintains a CFG fragment accumulator. When it
|
|
||||
// visits a statement, it concatenates the CFG for the statement to the end
|
|
||||
// of the accumulator.
|
|
||||
class StatementCfgBuilder : public AstVisitor { |
|
||||
public: |
|
||||
StatementCfgBuilder() : graph_(new Cfg()) {} |
|
||||
|
|
||||
Cfg* graph() { return graph_; } |
|
||||
|
|
||||
void VisitStatements(ZoneList<Statement*>* stmts); |
|
||||
|
|
||||
// AST node visitors.
|
|
||||
#define DECLARE_VISIT(type) void Visit##type(type* node); |
|
||||
AST_NODE_LIST(DECLARE_VISIT) |
|
||||
#undef DECLARE_VISIT |
|
||||
|
|
||||
private: |
|
||||
// State for the visitor. Input/output parameter:
|
|
||||
Cfg* graph_; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
} } // namespace v8::internal
|
|
||||
|
|
||||
#endif // V8_CFG_H_
|
|
||||
@ -1,315 +0,0 @@ |
|||||
// Copyright 2009 the V8 project authors. All rights reserved.
|
|
||||
// Redistribution and use in source and binary forms, with or without
|
|
||||
// modification, are permitted provided that the following conditions are
|
|
||||
// met:
|
|
||||
//
|
|
||||
// * Redistributions of source code must retain the above copyright
|
|
||||
// notice, this list of conditions and the following disclaimer.
|
|
||||
// * Redistributions in binary form must reproduce the above
|
|
||||
// copyright notice, this list of conditions and the following
|
|
||||
// disclaimer in the documentation and/or other materials provided
|
|
||||
// with the distribution.
|
|
||||
// * Neither the name of Google Inc. nor the names of its
|
|
||||
// contributors may be used to endorse or promote products derived
|
|
||||
// from this software without specific prior written permission.
|
|
||||
//
|
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||
|
|
||||
#include "v8.h" |
|
||||
|
|
||||
#include "cfg.h" |
|
||||
#include "codegen-inl.h" |
|
||||
#include "codegen-ia32.h" |
|
||||
#include "macro-assembler-ia32.h" |
|
||||
|
|
||||
namespace v8 { |
|
||||
namespace internal { |
|
||||
|
|
||||
#define __ ACCESS_MASM(masm) |
|
||||
|
|
||||
void InstructionBlock::Compile(MacroAssembler* masm) { |
|
||||
ASSERT(!is_marked()); |
|
||||
is_marked_ = true; |
|
||||
{ |
|
||||
Comment cmt(masm, "[ InstructionBlock"); |
|
||||
for (int i = 0, len = instructions_.length(); i < len; i++) { |
|
||||
// If the location of the current instruction is a temp, then the
|
|
||||
// instruction cannot be in tail position in the block. Allocate the
|
|
||||
// temp based on peeking ahead to the next instruction.
|
|
||||
Instruction* instr = instructions_[i]; |
|
||||
Location* loc = instr->location(); |
|
||||
if (loc->is_temporary()) { |
|
||||
instructions_[i+1]->FastAllocate(TempLocation::cast(loc)); |
|
||||
} |
|
||||
instructions_[i]->Compile(masm); |
|
||||
} |
|
||||
} |
|
||||
successor_->Compile(masm); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void EntryNode::Compile(MacroAssembler* masm) { |
|
||||
ASSERT(!is_marked()); |
|
||||
is_marked_ = true; |
|
||||
Label deferred_enter, deferred_exit; |
|
||||
{ |
|
||||
Comment cmnt(masm, "[ EntryNode"); |
|
||||
__ push(ebp); |
|
||||
__ mov(ebp, esp); |
|
||||
__ push(esi); |
|
||||
__ push(edi); |
|
||||
int count = CfgGlobals::current()->fun()->scope()->num_stack_slots(); |
|
||||
if (count > 0) { |
|
||||
__ Set(eax, Immediate(Factory::undefined_value())); |
|
||||
for (int i = 0; i < count; i++) { |
|
||||
__ push(eax); |
|
||||
} |
|
||||
} |
|
||||
if (FLAG_trace) { |
|
||||
__ CallRuntime(Runtime::kTraceEnter, 0); |
|
||||
} |
|
||||
if (FLAG_check_stack) { |
|
||||
ExternalReference stack_limit = |
|
||||
ExternalReference::address_of_stack_guard_limit(); |
|
||||
__ cmp(esp, Operand::StaticVariable(stack_limit)); |
|
||||
__ j(below, &deferred_enter); |
|
||||
__ bind(&deferred_exit); |
|
||||
} |
|
||||
} |
|
||||
successor_->Compile(masm); |
|
||||
if (FLAG_check_stack) { |
|
||||
Comment cmnt(masm, "[ Deferred Stack Check"); |
|
||||
__ bind(&deferred_enter); |
|
||||
StackCheckStub stub; |
|
||||
__ CallStub(&stub); |
|
||||
__ jmp(&deferred_exit); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExitNode::Compile(MacroAssembler* masm) { |
|
||||
ASSERT(!is_marked()); |
|
||||
is_marked_ = true; |
|
||||
Comment cmnt(masm, "[ ExitNode"); |
|
||||
if (FLAG_trace) { |
|
||||
__ push(eax); |
|
||||
__ CallRuntime(Runtime::kTraceExit, 1); |
|
||||
} |
|
||||
__ RecordJSReturn(); |
|
||||
__ mov(esp, ebp); |
|
||||
__ pop(ebp); |
|
||||
int count = CfgGlobals::current()->fun()->scope()->num_parameters(); |
|
||||
__ ret((count + 1) * kPointerSize); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void PropLoadInstr::Compile(MacroAssembler* masm) { |
|
||||
// The key should not be on the stack---if it is a compiler-generated
|
|
||||
// temporary it is in the accumulator.
|
|
||||
ASSERT(!key()->is_on_stack()); |
|
||||
|
|
||||
Comment cmnt(masm, "[ Load from Property"); |
|
||||
// If the key is known at compile-time we may be able to use a load IC.
|
|
||||
bool is_keyed_load = true; |
|
||||
if (key()->is_constant()) { |
|
||||
// Still use the keyed load IC if the key can be parsed as an integer so
|
|
||||
// we will get into the case that handles [] on string objects.
|
|
||||
Handle<Object> key_val = Constant::cast(key())->handle(); |
|
||||
uint32_t ignored; |
|
||||
if (key_val->IsSymbol() && |
|
||||
!String::cast(*key_val)->AsArrayIndex(&ignored)) { |
|
||||
is_keyed_load = false; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if (!object()->is_on_stack()) object()->Push(masm); |
|
||||
// A test eax instruction after the call indicates to the IC code that it
|
|
||||
// was inlined. Ensure there is not one here.
|
|
||||
if (is_keyed_load) { |
|
||||
key()->Push(masm); |
|
||||
Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize)); |
|
||||
__ call(ic, RelocInfo::CODE_TARGET); |
|
||||
__ pop(ebx); // Discard key.
|
|
||||
} else { |
|
||||
key()->Get(masm, ecx); |
|
||||
Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize)); |
|
||||
__ call(ic, RelocInfo::CODE_TARGET); |
|
||||
} |
|
||||
__ pop(ebx); // Discard receiver.
|
|
||||
location()->Set(masm, eax); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void BinaryOpInstr::Compile(MacroAssembler* masm) { |
|
||||
// The right-hand value should not be on the stack---if it is a
|
|
||||
// compiler-generated temporary it is in the accumulator.
|
|
||||
ASSERT(!right()->is_on_stack()); |
|
||||
|
|
||||
Comment cmnt(masm, "[ BinaryOpInstr"); |
|
||||
// We can overwrite one of the operands if it is a temporary.
|
|
||||
OverwriteMode mode = NO_OVERWRITE; |
|
||||
if (left()->is_temporary()) { |
|
||||
mode = OVERWRITE_LEFT; |
|
||||
} else if (right()->is_temporary()) { |
|
||||
mode = OVERWRITE_RIGHT; |
|
||||
} |
|
||||
|
|
||||
// Push both operands and call the specialized stub.
|
|
||||
if (!left()->is_on_stack()) left()->Push(masm); |
|
||||
right()->Push(masm); |
|
||||
GenericBinaryOpStub stub(op(), mode, SMI_CODE_IN_STUB); |
|
||||
__ CallStub(&stub); |
|
||||
location()->Set(masm, eax); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ReturnInstr::Compile(MacroAssembler* masm) { |
|
||||
// The location should be 'Effect'. As a side effect, move the value to
|
|
||||
// the accumulator.
|
|
||||
Comment cmnt(masm, "[ ReturnInstr"); |
|
||||
value_->Get(masm, eax); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Constant::Get(MacroAssembler* masm, Register reg) { |
|
||||
__ mov(reg, Immediate(handle_)); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Constant::Push(MacroAssembler* masm) { |
|
||||
__ push(Immediate(handle_)); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
static Operand ToOperand(SlotLocation* loc) { |
|
||||
switch (loc->type()) { |
|
||||
case Slot::PARAMETER: { |
|
||||
int count = CfgGlobals::current()->fun()->scope()->num_parameters(); |
|
||||
return Operand(ebp, (1 + count - loc->index()) * kPointerSize); |
|
||||
} |
|
||||
case Slot::LOCAL: { |
|
||||
const int kOffset = JavaScriptFrameConstants::kLocal0Offset; |
|
||||
return Operand(ebp, kOffset - loc->index() * kPointerSize); |
|
||||
} |
|
||||
default: |
|
||||
UNREACHABLE(); |
|
||||
return Operand(eax); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Constant::MoveToSlot(MacroAssembler* masm, SlotLocation* loc) { |
|
||||
__ mov(ToOperand(loc), Immediate(handle_)); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Get(MacroAssembler* masm, Register reg) { |
|
||||
__ mov(reg, ToOperand(this)); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Set(MacroAssembler* masm, Register reg) { |
|
||||
__ mov(ToOperand(this), reg); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Push(MacroAssembler* masm) { |
|
||||
__ push(ToOperand(this)); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Move(MacroAssembler* masm, Value* value) { |
|
||||
// We dispatch to the value because in some cases (temp or constant)
|
|
||||
// we can use a single instruction.
|
|
||||
value->MoveToSlot(masm, this); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::MoveToSlot(MacroAssembler* masm, SlotLocation* loc) { |
|
||||
// The accumulator is not live across a MoveInstr.
|
|
||||
__ mov(eax, ToOperand(this)); |
|
||||
__ mov(ToOperand(loc), eax); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Get(MacroAssembler* masm, Register reg) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
if (!reg.is(eax)) __ mov(reg, eax); |
|
||||
break; |
|
||||
case STACK: |
|
||||
__ pop(reg); |
|
||||
break; |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Set(MacroAssembler* masm, Register reg) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
if (!reg.is(eax)) __ mov(eax, reg); |
|
||||
break; |
|
||||
case STACK: |
|
||||
__ push(reg); |
|
||||
break; |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Push(MacroAssembler* masm) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
__ push(eax); |
|
||||
break; |
|
||||
case STACK: |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Move(MacroAssembler* masm, Value* value) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
value->Get(masm, eax); |
|
||||
break; |
|
||||
case STACK: |
|
||||
value->Push(masm); |
|
||||
break; |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::MoveToSlot(MacroAssembler* masm, SlotLocation* loc) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
__ mov(ToOperand(loc), eax); |
|
||||
break; |
|
||||
case STACK: |
|
||||
__ pop(ToOperand(loc)); |
|
||||
break; |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
#undef __ |
|
||||
|
|
||||
} } // namespace v8::internal
|
|
||||
@ -1,324 +0,0 @@ |
|||||
// Copyright 2009 the V8 project authors. All rights reserved.
|
|
||||
// Redistribution and use in source and binary forms, with or without
|
|
||||
// modification, are permitted provided that the following conditions are
|
|
||||
// met:
|
|
||||
//
|
|
||||
// * Redistributions of source code must retain the above copyright
|
|
||||
// notice, this list of conditions and the following disclaimer.
|
|
||||
// * Redistributions in binary form must reproduce the above
|
|
||||
// copyright notice, this list of conditions and the following
|
|
||||
// disclaimer in the documentation and/or other materials provided
|
|
||||
// with the distribution.
|
|
||||
// * Neither the name of Google Inc. nor the names of its
|
|
||||
// contributors may be used to endorse or promote products derived
|
|
||||
// from this software without specific prior written permission.
|
|
||||
//
|
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||
|
|
||||
#include "v8.h" |
|
||||
|
|
||||
#include "cfg.h" |
|
||||
#include "codegen-inl.h" |
|
||||
#include "codegen-x64.h" |
|
||||
#include "debug.h" |
|
||||
#include "macro-assembler-x64.h" |
|
||||
|
|
||||
namespace v8 { |
|
||||
namespace internal { |
|
||||
|
|
||||
#define __ ACCESS_MASM(masm) |
|
||||
|
|
||||
void InstructionBlock::Compile(MacroAssembler* masm) { |
|
||||
ASSERT(!is_marked()); |
|
||||
is_marked_ = true; |
|
||||
{ |
|
||||
Comment cmt(masm, "[ InstructionBlock"); |
|
||||
for (int i = 0, len = instructions_.length(); i < len; i++) { |
|
||||
// If the location of the current instruction is a temp, then the
|
|
||||
// instruction cannot be in tail position in the block. Allocate the
|
|
||||
// temp based on peeking ahead to the next instruction.
|
|
||||
Instruction* instr = instructions_[i]; |
|
||||
Location* loc = instr->location(); |
|
||||
if (loc->is_temporary()) { |
|
||||
instructions_[i+1]->FastAllocate(TempLocation::cast(loc)); |
|
||||
} |
|
||||
instructions_[i]->Compile(masm); |
|
||||
} |
|
||||
} |
|
||||
successor_->Compile(masm); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void EntryNode::Compile(MacroAssembler* masm) { |
|
||||
ASSERT(!is_marked()); |
|
||||
is_marked_ = true; |
|
||||
Label deferred_enter, deferred_exit; |
|
||||
{ |
|
||||
Comment cmnt(masm, "[ EntryNode"); |
|
||||
__ push(rbp); |
|
||||
__ movq(rbp, rsp); |
|
||||
__ push(rsi); |
|
||||
__ push(rdi); |
|
||||
int count = CfgGlobals::current()->fun()->scope()->num_stack_slots(); |
|
||||
if (count > 0) { |
|
||||
__ LoadRoot(kScratchRegister, Heap::kUndefinedValueRootIndex); |
|
||||
for (int i = 0; i < count; i++) { |
|
||||
__ push(kScratchRegister); |
|
||||
} |
|
||||
} |
|
||||
if (FLAG_trace) { |
|
||||
__ CallRuntime(Runtime::kTraceEnter, 0); |
|
||||
} |
|
||||
if (FLAG_check_stack) { |
|
||||
ExternalReference stack_limit = |
|
||||
ExternalReference::address_of_stack_guard_limit(); |
|
||||
__ movq(kScratchRegister, stack_limit); |
|
||||
__ cmpq(rsp, Operand(kScratchRegister, 0)); |
|
||||
__ j(below, &deferred_enter); |
|
||||
__ bind(&deferred_exit); |
|
||||
} |
|
||||
} |
|
||||
successor_->Compile(masm); |
|
||||
if (FLAG_check_stack) { |
|
||||
Comment cmnt(masm, "[ Deferred Stack Check"); |
|
||||
__ bind(&deferred_enter); |
|
||||
StackCheckStub stub; |
|
||||
__ CallStub(&stub); |
|
||||
__ jmp(&deferred_exit); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ExitNode::Compile(MacroAssembler* masm) { |
|
||||
ASSERT(!is_marked()); |
|
||||
is_marked_ = true; |
|
||||
Comment cmnt(masm, "[ ExitNode"); |
|
||||
if (FLAG_trace) { |
|
||||
__ push(rax); |
|
||||
__ CallRuntime(Runtime::kTraceExit, 1); |
|
||||
} |
|
||||
__ RecordJSReturn(); |
|
||||
__ movq(rsp, rbp); |
|
||||
__ pop(rbp); |
|
||||
int count = CfgGlobals::current()->fun()->scope()->num_parameters(); |
|
||||
__ ret((count + 1) * kPointerSize); |
|
||||
#ifdef ENABLE_DEBUGGER_SUPPORT |
|
||||
// Add padding that will be overwritten by a debugger breakpoint.
|
|
||||
// "movq rsp, rbp; pop rbp" has length 4. "ret k" has length 3.
|
|
||||
const int kPadding = Debug::kX64JSReturnSequenceLength - 4 - 3; |
|
||||
for (int i = 0; i < kPadding; ++i) { |
|
||||
__ int3(); |
|
||||
} |
|
||||
#endif |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void PropLoadInstr::Compile(MacroAssembler* masm) { |
|
||||
// The key should not be on the stack---if it is a compiler-generated
|
|
||||
// temporary it is in the accumulator.
|
|
||||
ASSERT(!key()->is_on_stack()); |
|
||||
|
|
||||
Comment cmnt(masm, "[ Load from Property"); |
|
||||
// If the key is known at compile-time we may be able to use a load IC.
|
|
||||
bool is_keyed_load = true; |
|
||||
if (key()->is_constant()) { |
|
||||
// Still use the keyed load IC if the key can be parsed as an integer so
|
|
||||
// we will get into the case that handles [] on string objects.
|
|
||||
Handle<Object> key_val = Constant::cast(key())->handle(); |
|
||||
uint32_t ignored; |
|
||||
if (key_val->IsSymbol() && |
|
||||
!String::cast(*key_val)->AsArrayIndex(&ignored)) { |
|
||||
is_keyed_load = false; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if (!object()->is_on_stack()) object()->Push(masm); |
|
||||
// A test rax instruction after the call indicates to the IC code that it
|
|
||||
// was inlined. Ensure there is not one after the call below.
|
|
||||
if (is_keyed_load) { |
|
||||
key()->Push(masm); |
|
||||
Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize)); |
|
||||
__ Call(ic, RelocInfo::CODE_TARGET); |
|
||||
__ pop(rbx); // Discard key.
|
|
||||
} else { |
|
||||
key()->Get(masm, rcx); |
|
||||
Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize)); |
|
||||
__ Call(ic, RelocInfo::CODE_TARGET); |
|
||||
} |
|
||||
__ pop(rbx); // Discard receiver.
|
|
||||
location()->Set(masm, rax); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void BinaryOpInstr::Compile(MacroAssembler* masm) { |
|
||||
// The right-hand value should not be on the stack---if it is a
|
|
||||
// compiler-generated temporary it is in the accumulator.
|
|
||||
ASSERT(!right()->is_on_stack()); |
|
||||
|
|
||||
Comment cmnt(masm, "[ BinaryOpInstr"); |
|
||||
// We can overwrite one of the operands if it is a temporary.
|
|
||||
OverwriteMode mode = NO_OVERWRITE; |
|
||||
if (left()->is_temporary()) { |
|
||||
mode = OVERWRITE_LEFT; |
|
||||
} else if (right()->is_temporary()) { |
|
||||
mode = OVERWRITE_RIGHT; |
|
||||
} |
|
||||
|
|
||||
// Push both operands and call the specialized stub.
|
|
||||
if (!left()->is_on_stack()) left()->Push(masm); |
|
||||
right()->Push(masm); |
|
||||
GenericBinaryOpStub stub(op(), mode, SMI_CODE_IN_STUB); |
|
||||
__ CallStub(&stub); |
|
||||
location()->Set(masm, rax); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ReturnInstr::Compile(MacroAssembler* masm) { |
|
||||
// The location should be 'Effect'. As a side effect, move the value to
|
|
||||
// the accumulator.
|
|
||||
Comment cmnt(masm, "[ ReturnInstr"); |
|
||||
value()->Get(masm, rax); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Constant::Get(MacroAssembler* masm, Register reg) { |
|
||||
__ Move(reg, handle_); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Constant::Push(MacroAssembler* masm) { |
|
||||
__ Push(handle_); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
static Operand ToOperand(SlotLocation* loc) { |
|
||||
switch (loc->type()) { |
|
||||
case Slot::PARAMETER: { |
|
||||
int count = CfgGlobals::current()->fun()->scope()->num_parameters(); |
|
||||
return Operand(rbp, (1 + count - loc->index()) * kPointerSize); |
|
||||
} |
|
||||
case Slot::LOCAL: { |
|
||||
const int kOffset = JavaScriptFrameConstants::kLocal0Offset; |
|
||||
return Operand(rbp, kOffset - loc->index() * kPointerSize); |
|
||||
} |
|
||||
default: |
|
||||
UNREACHABLE(); |
|
||||
return Operand(rax, 0); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Constant::MoveToSlot(MacroAssembler* masm, SlotLocation* loc) { |
|
||||
__ Move(ToOperand(loc), handle_); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Get(MacroAssembler* masm, Register reg) { |
|
||||
__ movq(reg, ToOperand(this)); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Set(MacroAssembler* masm, Register reg) { |
|
||||
__ movq(ToOperand(this), reg); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Push(MacroAssembler* masm) { |
|
||||
__ push(ToOperand(this)); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::Move(MacroAssembler* masm, Value* value) { |
|
||||
// We dispatch to the value because in some cases (temp or constant) we
|
|
||||
// can use special instruction sequences.
|
|
||||
value->MoveToSlot(masm, this); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void SlotLocation::MoveToSlot(MacroAssembler* masm, SlotLocation* loc) { |
|
||||
__ movq(kScratchRegister, ToOperand(this)); |
|
||||
__ movq(ToOperand(loc), kScratchRegister); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Get(MacroAssembler* masm, Register reg) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
if (!reg.is(rax)) __ movq(reg, rax); |
|
||||
break; |
|
||||
case STACK: |
|
||||
__ pop(reg); |
|
||||
break; |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Set(MacroAssembler* masm, Register reg) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
if (!reg.is(rax)) __ movq(rax, reg); |
|
||||
break; |
|
||||
case STACK: |
|
||||
__ push(reg); |
|
||||
break; |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Push(MacroAssembler* masm) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
__ push(rax); |
|
||||
break; |
|
||||
case STACK: |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::Move(MacroAssembler* masm, Value* value) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
value->Get(masm, rax); |
|
||||
break; |
|
||||
case STACK: |
|
||||
value->Push(masm); |
|
||||
break; |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void TempLocation::MoveToSlot(MacroAssembler* masm, SlotLocation* loc) { |
|
||||
switch (where_) { |
|
||||
case ACCUMULATOR: |
|
||||
__ movq(ToOperand(loc), rax); |
|
||||
break; |
|
||||
case STACK: |
|
||||
__ pop(ToOperand(loc)); |
|
||||
break; |
|
||||
case NOT_ALLOCATED: |
|
||||
UNREACHABLE(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
#undef __ |
|
||||
|
|
||||
} } // namespace v8::internal
|
|
||||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue