mirror of https://github.com/lukechilds/node.git
Ryan
16 years ago
53 changed files with 2256 additions and 231 deletions
@ -0,0 +1,124 @@ |
|||||
|
// 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 "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++) { |
||||
|
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) { |
||||
|
__ mov(ip, Operand(Factory::undefined_value())); |
||||
|
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 ReturnInstr::Compile(MacroAssembler* masm) { |
||||
|
Comment cmnt(masm, "[ ReturnInstr"); |
||||
|
value_->ToRegister(masm, r0); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void Constant::ToRegister(MacroAssembler* masm, Register reg) { |
||||
|
__ mov(reg, Operand(handle_)); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void SlotLocation::ToRegister(MacroAssembler* masm, Register reg) { |
||||
|
switch (type_) { |
||||
|
case Slot::PARAMETER: { |
||||
|
int count = CfgGlobals::current()->fun()->scope()->num_parameters(); |
||||
|
__ ldr(reg, MemOperand(fp, (1 + count - index_) * kPointerSize)); |
||||
|
break; |
||||
|
} |
||||
|
case Slot::LOCAL: { |
||||
|
const int kOffset = JavaScriptFrameConstants::kLocal0Offset; |
||||
|
__ ldr(reg, MemOperand(fp, kOffset - index_ * kPointerSize)); |
||||
|
break; |
||||
|
} |
||||
|
default: |
||||
|
UNREACHABLE(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#undef __ |
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
@ -0,0 +1,485 @@ |
|||||
|
// 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()), |
||||
|
#ifdef DEBUG |
||||
|
node_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()->arguments() != NULL) { |
||||
|
BAILOUT("function uses .arguments"); |
||||
|
} |
||||
|
|
||||
|
ZoneList<Statement*>* body = fun->body(); |
||||
|
if (body->is_empty()) { |
||||
|
BAILOUT("empty function body"); |
||||
|
} |
||||
|
|
||||
|
StatementBuilder builder; |
||||
|
builder.VisitStatements(body); |
||||
|
Cfg* cfg = builder.cfg(); |
||||
|
if (cfg == NULL) { |
||||
|
BAILOUT("unsupported statement type"); |
||||
|
} |
||||
|
if (cfg->has_exit()) { |
||||
|
BAILOUT("control path without explicit return"); |
||||
|
} |
||||
|
cfg->PrependEntryNode(); |
||||
|
return cfg; |
||||
|
} |
||||
|
|
||||
|
#undef BAILOUT |
||||
|
|
||||
|
|
||||
|
void Cfg::PrependEntryNode() { |
||||
|
ASSERT(!is_empty()); |
||||
|
entry_ = new EntryNode(InstructionBlock::cast(entry())); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void Cfg::Append(Instruction* instr) { |
||||
|
ASSERT(has_exit()); |
||||
|
ASSERT(!is_empty()); |
||||
|
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 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; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// The expression builder should not be used for declarations or statements.
|
||||
|
void ExpressionBuilder::VisitDeclaration(Declaration* decl) { UNREACHABLE(); } |
||||
|
|
||||
|
#define DEFINE_VISIT(type) \ |
||||
|
void ExpressionBuilder::Visit##type(type* stmt) { UNREACHABLE(); } |
||||
|
STATEMENT_NODE_LIST(DEFINE_VISIT) |
||||
|
#undef DEFINE_VISIT |
||||
|
|
||||
|
|
||||
|
// Macros (temporarily) handling unsupported expression types.
|
||||
|
#define BAILOUT(reason) \ |
||||
|
do { \ |
||||
|
value_ = NULL; \ |
||||
|
return; \ |
||||
|
} while (false) |
||||
|
|
||||
|
#define CHECK_BAILOUT() \ |
||||
|
if (value_ == NULL) { return; } else {} |
||||
|
|
||||
|
void ExpressionBuilder::VisitFunctionLiteral(FunctionLiteral* expr) { |
||||
|
BAILOUT("FunctionLiteral"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitFunctionBoilerplateLiteral( |
||||
|
FunctionBoilerplateLiteral* expr) { |
||||
|
BAILOUT("FunctionBoilerplateLiteral"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitConditional(Conditional* expr) { |
||||
|
BAILOUT("Conditional"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitSlot(Slot* expr) { |
||||
|
BAILOUT("Slot"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::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)"); |
||||
|
} |
||||
|
value_ = new SlotLocation(slot->type(), slot->index()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitLiteral(Literal* expr) { |
||||
|
value_ = new Constant(expr->handle()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitRegExpLiteral(RegExpLiteral* expr) { |
||||
|
BAILOUT("RegExpLiteral"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitObjectLiteral(ObjectLiteral* expr) { |
||||
|
BAILOUT("ObjectLiteral"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitArrayLiteral(ArrayLiteral* expr) { |
||||
|
BAILOUT("ArrayLiteral"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitCatchExtensionObject(CatchExtensionObject* expr) { |
||||
|
BAILOUT("CatchExtensionObject"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitAssignment(Assignment* expr) { |
||||
|
BAILOUT("Assignment"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitThrow(Throw* expr) { |
||||
|
BAILOUT("Throw"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitProperty(Property* expr) { |
||||
|
BAILOUT("Property"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitCall(Call* expr) { |
||||
|
BAILOUT("Call"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitCallEval(CallEval* expr) { |
||||
|
BAILOUT("CallEval"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitCallNew(CallNew* expr) { |
||||
|
BAILOUT("CallNew"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitCallRuntime(CallRuntime* expr) { |
||||
|
BAILOUT("CallRuntime"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitUnaryOperation(UnaryOperation* expr) { |
||||
|
BAILOUT("UnaryOperation"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitCountOperation(CountOperation* expr) { |
||||
|
BAILOUT("CountOperation"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitBinaryOperation(BinaryOperation* expr) { |
||||
|
BAILOUT("BinaryOperation"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitCompareOperation(CompareOperation* expr) { |
||||
|
BAILOUT("CompareOperation"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExpressionBuilder::VisitThisFunction(ThisFunction* expr) { |
||||
|
BAILOUT("ThisFunction"); |
||||
|
} |
||||
|
|
||||
|
#undef BAILOUT |
||||
|
#undef CHECK_BAILOUT |
||||
|
|
||||
|
|
||||
|
// Macros (temporarily) handling unsupported statement types.
|
||||
|
#define BAILOUT(reason) \ |
||||
|
do { \ |
||||
|
cfg_ = NULL; \ |
||||
|
return; \ |
||||
|
} while (false) |
||||
|
|
||||
|
#define CHECK_BAILOUT() \ |
||||
|
if (cfg_ == NULL) { return; } else {} |
||||
|
|
||||
|
void StatementBuilder::VisitStatements(ZoneList<Statement*>* stmts) { |
||||
|
for (int i = 0, len = stmts->length(); i < len; i++) { |
||||
|
Visit(stmts->at(i)); |
||||
|
CHECK_BAILOUT(); |
||||
|
if (!cfg_->has_exit()) return; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// The statement builder should not be used for declarations or expressions.
|
||||
|
void StatementBuilder::VisitDeclaration(Declaration* decl) { UNREACHABLE(); } |
||||
|
|
||||
|
#define DEFINE_VISIT(type) \ |
||||
|
void StatementBuilder::Visit##type(type* expr) { UNREACHABLE(); } |
||||
|
EXPRESSION_NODE_LIST(DEFINE_VISIT) |
||||
|
#undef DEFINE_VISIT |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitBlock(Block* stmt) { |
||||
|
VisitStatements(stmt->statements()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitExpressionStatement(ExpressionStatement* stmt) { |
||||
|
BAILOUT("ExpressionStatement"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitEmptyStatement(EmptyStatement* stmt) { |
||||
|
// Nothing to do.
|
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitIfStatement(IfStatement* stmt) { |
||||
|
BAILOUT("IfStatement"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitContinueStatement(ContinueStatement* stmt) { |
||||
|
BAILOUT("ContinueStatement"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitBreakStatement(BreakStatement* stmt) { |
||||
|
BAILOUT("BreakStatement"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitReturnStatement(ReturnStatement* stmt) { |
||||
|
ExpressionBuilder builder; |
||||
|
builder.Visit(stmt->expression()); |
||||
|
Value* value = builder.value(); |
||||
|
if (value == NULL) BAILOUT("unsupported expression type"); |
||||
|
cfg_->AppendReturnInstruction(value); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitWithEnterStatement(WithEnterStatement* stmt) { |
||||
|
BAILOUT("WithEnterStatement"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitWithExitStatement(WithExitStatement* stmt) { |
||||
|
BAILOUT("WithExitStatement"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitSwitchStatement(SwitchStatement* stmt) { |
||||
|
BAILOUT("SwitchStatement"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitLoopStatement(LoopStatement* stmt) { |
||||
|
BAILOUT("LoopStatement"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitForInStatement(ForInStatement* stmt) { |
||||
|
BAILOUT("ForInStatement"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitTryCatch(TryCatch* stmt) { |
||||
|
BAILOUT("TryCatch"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::VisitTryFinally(TryFinally* stmt) { |
||||
|
BAILOUT("TryFinally"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void StatementBuilder::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(); |
||||
|
PrintF(")"); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
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 ReturnInstr::Print() { |
||||
|
PrintF("Return "); |
||||
|
value_->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
|
||||
@ -0,0 +1,385 @@ |
|||||
|
// 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; |
||||
|
|
||||
|
// 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_; |
||||
|
} |
||||
|
|
||||
|
FunctionLiteral* fun() { return global_fun_; } |
||||
|
|
||||
|
ExitNode* exit() { return global_exit_; } |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
int next_number() { return node_counter_++; } |
||||
|
#endif |
||||
|
|
||||
|
private: |
||||
|
static CfgGlobals* top_; |
||||
|
|
||||
|
// Function literal currently compiling.
|
||||
|
FunctionLiteral* global_fun_; |
||||
|
|
||||
|
// Shared global exit node for all returns from the same function.
|
||||
|
ExitNode* global_exit_; |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
// Used to number nodes when printing.
|
||||
|
int node_counter_; |
||||
|
#endif |
||||
|
|
||||
|
CfgGlobals* previous_; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// Values appear in instructions. They 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() {} |
||||
|
|
||||
|
virtual void ToRegister(MacroAssembler* masm, Register reg) = 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) {} |
||||
|
|
||||
|
virtual ~Constant() {} |
||||
|
|
||||
|
void ToRegister(MacroAssembler* masm, Register reg); |
||||
|
|
||||
|
#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() {} |
||||
|
|
||||
|
virtual void ToRegister(MacroAssembler* masm, Register reg) = 0; |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
virtual void Print() = 0; |
||||
|
#endif |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// 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) {} |
||||
|
|
||||
|
void ToRegister(MacroAssembler* masm, Register reg); |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
void Print(); |
||||
|
#endif |
||||
|
|
||||
|
private: |
||||
|
Slot::Type type_; |
||||
|
int index_; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// 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: |
||||
|
virtual ~Instruction() {} |
||||
|
|
||||
|
virtual void Compile(MacroAssembler* masm) = 0; |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
virtual void Print() = 0; |
||||
|
#endif |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// Return a value.
|
||||
|
class ReturnInstr : public Instruction { |
||||
|
public: |
||||
|
explicit ReturnInstr(Value* value) : value_(value) {} |
||||
|
|
||||
|
virtual ~ReturnInstr() {} |
||||
|
|
||||
|
void Compile(MacroAssembler* masm); |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
void Print(); |
||||
|
#endif |
||||
|
|
||||
|
private: |
||||
|
Value* value_; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// Nodes make up control-flow graphs. They contain single-entry,
|
||||
|
// single-exit blocks of instructions and administrative nodes making up the
|
||||
|
// graph structure.
|
||||
|
class CfgNode : public ZoneObject { |
||||
|
public: |
||||
|
CfgNode() : is_marked_(false) { |
||||
|
#ifdef DEBUG |
||||
|
number_ = -1; |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
virtual ~CfgNode() {} |
||||
|
|
||||
|
bool is_marked() { return is_marked_; } |
||||
|
|
||||
|
virtual bool is_block() { return false; } |
||||
|
|
||||
|
virtual void Unmark() = 0; |
||||
|
|
||||
|
virtual void Compile(MacroAssembler* masm) = 0; |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
int number() { |
||||
|
if (number_ == -1) number_ = CfgGlobals::current()->next_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() {} |
||||
|
|
||||
|
static InstructionBlock* cast(CfgNode* node) { |
||||
|
ASSERT(node->is_block()); |
||||
|
return reinterpret_cast<InstructionBlock*>(node); |
||||
|
} |
||||
|
|
||||
|
void set_successor(CfgNode* succ) { |
||||
|
ASSERT(successor_ == NULL); |
||||
|
successor_ = succ; |
||||
|
} |
||||
|
|
||||
|
bool is_block() { return true; } |
||||
|
|
||||
|
void Unmark(); |
||||
|
|
||||
|
void Compile(MacroAssembler* masm); |
||||
|
|
||||
|
void Append(Instruction* instr) { instructions_.Add(instr); } |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
void Print(); |
||||
|
#endif |
||||
|
|
||||
|
private: |
||||
|
CfgNode* successor_; |
||||
|
ZoneList<Instruction*> instructions_; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// The CFG for a function has a distinguished entry node. It has no
|
||||
|
// predecessors and a single successor. The successor is the block
|
||||
|
// containing the function's first instruction.
|
||||
|
class EntryNode : public CfgNode { |
||||
|
public: |
||||
|
explicit EntryNode(InstructionBlock* succ) : successor_(succ) {} |
||||
|
|
||||
|
virtual ~EntryNode() {} |
||||
|
|
||||
|
void Unmark(); |
||||
|
|
||||
|
void Compile(MacroAssembler* masm); |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
void Print(); |
||||
|
#endif |
||||
|
|
||||
|
private: |
||||
|
InstructionBlock* successor_; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// The CFG for a function has a distinguished exit node. It has no
|
||||
|
// successor and arbitrarily many predecessors. The predecessors are all
|
||||
|
// the blocks returning from the function.
|
||||
|
class ExitNode : public CfgNode { |
||||
|
public: |
||||
|
ExitNode() {} |
||||
|
|
||||
|
virtual ~ExitNode() {} |
||||
|
|
||||
|
void Unmark(); |
||||
|
|
||||
|
void Compile(MacroAssembler* masm); |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
void Print(); |
||||
|
#endif |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// A CFG consists of a linked structure of nodes. It has a single entry
|
||||
|
// node and optionally an exit node. There is a distinguished global exit
|
||||
|
// node that is used as the successor of all blocks that return from the
|
||||
|
// function.
|
||||
|
//
|
||||
|
// Fragments of control-flow graphs, produced when traversing the statements
|
||||
|
// and expressions in the source AST, are represented by the same class.
|
||||
|
// They have instruction blocks as both their entry and exit (if there is
|
||||
|
// one). Instructions can always be prepended or appended to fragments, and
|
||||
|
// fragments can always be concatenated.
|
||||
|
//
|
||||
|
// A singleton CFG fragment (i.e., with only one node) has the same node as
|
||||
|
// both entry and exit (if the exit is available).
|
||||
|
class Cfg : public ZoneObject { |
||||
|
public: |
||||
|
// Create a singleton CFG fragment.
|
||||
|
explicit Cfg(InstructionBlock* block) : entry_(block), exit_(block) {} |
||||
|
|
||||
|
// Build the CFG for a function.
|
||||
|
static Cfg* Build(); |
||||
|
|
||||
|
// The entry and exit nodes.
|
||||
|
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 entry node to a CFG fragment. It is no longer a fragment
|
||||
|
// (instructions cannot be prepended).
|
||||
|
void PrependEntryNode(); |
||||
|
|
||||
|
// Append an instruction to the end of a CFG fragment. Assumes it has an
|
||||
|
// available exit.
|
||||
|
void Append(Instruction* instr); |
||||
|
|
||||
|
// Appends a return instruction to the end of a CFG fragment. It no
|
||||
|
// longer has an available exit node.
|
||||
|
void AppendReturnInstruction(Value* value); |
||||
|
|
||||
|
Handle<Code> Compile(Handle<Script> script); |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
// Support for printing.
|
||||
|
void Print(); |
||||
|
#endif |
||||
|
|
||||
|
private: |
||||
|
// Entry and exit nodes.
|
||||
|
CfgNode* entry_; |
||||
|
CfgNode* exit_; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// An Expression Builder traverses a trivial expression and returns a value.
|
||||
|
class ExpressionBuilder : public AstVisitor { |
||||
|
public: |
||||
|
ExpressionBuilder() : value_(new Constant(Handle<Object>::null())) {} |
||||
|
|
||||
|
Value* value() { return value_; } |
||||
|
|
||||
|
// AST node visitors.
|
||||
|
#define DECLARE_VISIT(type) void Visit##type(type* node); |
||||
|
AST_NODE_LIST(DECLARE_VISIT) |
||||
|
#undef DECLARE_VISIT |
||||
|
|
||||
|
private: |
||||
|
Value* value_; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// A StatementBuilder traverses a statement and returns a CFG.
|
||||
|
class StatementBuilder : public AstVisitor { |
||||
|
public: |
||||
|
StatementBuilder() : cfg_(new Cfg(new InstructionBlock())) {} |
||||
|
|
||||
|
Cfg* cfg() { return cfg_; } |
||||
|
|
||||
|
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: |
||||
|
Cfg* cfg_; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // V8_CFG_H_
|
||||
@ -0,0 +1,137 @@ |
|||||
|
// 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 "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++) { |
||||
|
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) { |
||||
|
__ 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 ReturnInstr::Compile(MacroAssembler* masm) { |
||||
|
Comment cmnt(masm, "[ ReturnInstr"); |
||||
|
value_->ToRegister(masm, eax); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void Constant::ToRegister(MacroAssembler* masm, Register reg) { |
||||
|
__ mov(reg, Immediate(handle_)); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void SlotLocation::ToRegister(MacroAssembler* masm, Register reg) { |
||||
|
switch (type_) { |
||||
|
case Slot::PARAMETER: { |
||||
|
int count = CfgGlobals::current()->fun()->scope()->num_parameters(); |
||||
|
__ mov(reg, Operand(ebp, (1 + count - index_) * kPointerSize)); |
||||
|
break; |
||||
|
} |
||||
|
case Slot::LOCAL: { |
||||
|
const int kOffset = JavaScriptFrameConstants::kLocal0Offset; |
||||
|
__ mov(reg, Operand(ebp, kOffset - index_ * kPointerSize)); |
||||
|
break; |
||||
|
} |
||||
|
default: |
||||
|
UNREACHABLE(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
#undef __ |
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
@ -0,0 +1,146 @@ |
|||||
|
// 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 "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++) { |
||||
|
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) { |
||||
|
__ movq(kScratchRegister, Factory::undefined_value(), |
||||
|
RelocInfo::EMBEDDED_OBJECT); |
||||
|
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) { |
||||
|
__ 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); |
||||
|
// Add padding that will be overwritten by a debugger breakpoint.
|
||||
|
// "movq rsp, rbp; pop rbp" has length 5. "ret k" has length 2.
|
||||
|
const int kPadding = Debug::kX64JSReturnSequenceLength - 5 - 2; |
||||
|
for (int i = 0; i < kPadding; ++i) { |
||||
|
__ int3(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ReturnInstr::Compile(MacroAssembler* masm) { |
||||
|
Comment cmnt(masm, "[ ReturnInstr"); |
||||
|
value_->ToRegister(masm, rax); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void Constant::ToRegister(MacroAssembler* masm, Register reg) { |
||||
|
__ Move(reg, handle_); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void SlotLocation::ToRegister(MacroAssembler* masm, Register reg) { |
||||
|
switch (type_) { |
||||
|
case Slot::PARAMETER: { |
||||
|
int count = CfgGlobals::current()->fun()->scope()->num_parameters(); |
||||
|
__ movq(reg, Operand(rbp, (1 + count - index_) * kPointerSize)); |
||||
|
break; |
||||
|
} |
||||
|
case Slot::LOCAL: { |
||||
|
const int kOffset = JavaScriptFrameConstants::kLocal0Offset; |
||||
|
__ movq(reg, Operand(rbp, kOffset - index_ * kPointerSize)); |
||||
|
break; |
||||
|
} |
||||
|
default: |
||||
|
UNREACHABLE(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#undef __ |
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
@ -0,0 +1,376 @@ |
|||||
|
// Copyright 2006-2009 the V8 project authors. All rights reserved.
|
||||
|
//
|
||||
|
// Tests of profiler-related functions from log.h
|
||||
|
|
||||
|
#ifdef ENABLE_LOGGING_AND_PROFILING |
||||
|
|
||||
|
#include <stdlib.h> |
||||
|
|
||||
|
#include "v8.h" |
||||
|
|
||||
|
#include "codegen.h" |
||||
|
#include "log.h" |
||||
|
#include "top.h" |
||||
|
#include "cctest.h" |
||||
|
#include "disassembler.h" |
||||
|
#include "register-allocator-inl.h" |
||||
|
|
||||
|
using v8::Function; |
||||
|
using v8::Local; |
||||
|
using v8::Object; |
||||
|
using v8::Script; |
||||
|
using v8::String; |
||||
|
using v8::Value; |
||||
|
|
||||
|
using v8::internal::byte; |
||||
|
using v8::internal::Address; |
||||
|
using v8::internal::Handle; |
||||
|
using v8::internal::JSFunction; |
||||
|
using v8::internal::StackTracer; |
||||
|
using v8::internal::TickSample; |
||||
|
using v8::internal::Top; |
||||
|
|
||||
|
namespace i = v8::internal; |
||||
|
|
||||
|
|
||||
|
static v8::Persistent<v8::Context> env; |
||||
|
|
||||
|
|
||||
|
static struct { |
||||
|
TickSample* sample; |
||||
|
} trace_env = { NULL }; |
||||
|
|
||||
|
|
||||
|
static void InitTraceEnv(TickSample* sample) { |
||||
|
trace_env.sample = sample; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static void DoTrace(Address fp) { |
||||
|
trace_env.sample->fp = reinterpret_cast<uintptr_t>(fp); |
||||
|
// sp is only used to define stack high bound
|
||||
|
trace_env.sample->sp = |
||||
|
reinterpret_cast<uintptr_t>(trace_env.sample) - 10240; |
||||
|
StackTracer::Trace(trace_env.sample); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// Hide c_entry_fp to emulate situation when sampling is done while
|
||||
|
// pure JS code is being executed
|
||||
|
static void DoTraceHideCEntryFPAddress(Address fp) { |
||||
|
v8::internal::Address saved_c_frame_fp = *(Top::c_entry_fp_address()); |
||||
|
CHECK(saved_c_frame_fp); |
||||
|
*(Top::c_entry_fp_address()) = 0; |
||||
|
DoTrace(fp); |
||||
|
*(Top::c_entry_fp_address()) = saved_c_frame_fp; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static void CheckRetAddrIsInFunction(const char* func_name, |
||||
|
Address ret_addr, |
||||
|
Address func_start_addr, |
||||
|
unsigned int func_len) { |
||||
|
printf("CheckRetAddrIsInFunction \"%s\": %p %p %p\n", |
||||
|
func_name, func_start_addr, ret_addr, func_start_addr + func_len); |
||||
|
CHECK_GE(ret_addr, func_start_addr); |
||||
|
CHECK_GE(func_start_addr + func_len, ret_addr); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static void CheckRetAddrIsInJSFunction(const char* func_name, |
||||
|
Address ret_addr, |
||||
|
Handle<JSFunction> func) { |
||||
|
v8::internal::Code* func_code = func->code(); |
||||
|
CheckRetAddrIsInFunction( |
||||
|
func_name, ret_addr, |
||||
|
func_code->instruction_start(), |
||||
|
func_code->ExecutableSize()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// --- T r a c e E x t e n s i o n ---
|
||||
|
|
||||
|
class TraceExtension : public v8::Extension { |
||||
|
public: |
||||
|
TraceExtension() : v8::Extension("v8/trace", kSource) { } |
||||
|
virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction( |
||||
|
v8::Handle<String> name); |
||||
|
static v8::Handle<v8::Value> Trace(const v8::Arguments& args); |
||||
|
static v8::Handle<v8::Value> JSTrace(const v8::Arguments& args); |
||||
|
static v8::Handle<v8::Value> JSEntrySP(const v8::Arguments& args); |
||||
|
static v8::Handle<v8::Value> JSEntrySPLevel2(const v8::Arguments& args); |
||||
|
private: |
||||
|
static Address GetFP(const v8::Arguments& args); |
||||
|
static const char* kSource; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
const char* TraceExtension::kSource = |
||||
|
"native function trace();" |
||||
|
"native function js_trace();" |
||||
|
"native function js_entry_sp();" |
||||
|
"native function js_entry_sp_level2();"; |
||||
|
|
||||
|
v8::Handle<v8::FunctionTemplate> TraceExtension::GetNativeFunction( |
||||
|
v8::Handle<String> name) { |
||||
|
if (name->Equals(String::New("trace"))) { |
||||
|
return v8::FunctionTemplate::New(TraceExtension::Trace); |
||||
|
} else if (name->Equals(String::New("js_trace"))) { |
||||
|
return v8::FunctionTemplate::New(TraceExtension::JSTrace); |
||||
|
} else if (name->Equals(String::New("js_entry_sp"))) { |
||||
|
return v8::FunctionTemplate::New(TraceExtension::JSEntrySP); |
||||
|
} else if (name->Equals(String::New("js_entry_sp_level2"))) { |
||||
|
return v8::FunctionTemplate::New(TraceExtension::JSEntrySPLevel2); |
||||
|
} else { |
||||
|
CHECK(false); |
||||
|
return v8::Handle<v8::FunctionTemplate>(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
Address TraceExtension::GetFP(const v8::Arguments& args) { |
||||
|
CHECK_EQ(1, args.Length()); |
||||
|
// CodeGenerator::GenerateGetFramePointer pushes EBP / RBP value
|
||||
|
// on stack. In 64-bit mode we can't use Smi operations code because
|
||||
|
// they check that value is within Smi bounds.
|
||||
|
Address fp = *reinterpret_cast<Address*>(*args[0]); |
||||
|
printf("Trace: %p\n", fp); |
||||
|
return fp; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
v8::Handle<v8::Value> TraceExtension::Trace(const v8::Arguments& args) { |
||||
|
DoTrace(GetFP(args)); |
||||
|
return v8::Undefined(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
v8::Handle<v8::Value> TraceExtension::JSTrace(const v8::Arguments& args) { |
||||
|
DoTraceHideCEntryFPAddress(GetFP(args)); |
||||
|
return v8::Undefined(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static Address GetJsEntrySp() { |
||||
|
CHECK_NE(NULL, Top::GetCurrentThread()); |
||||
|
return Top::js_entry_sp(Top::GetCurrentThread()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
v8::Handle<v8::Value> TraceExtension::JSEntrySP(const v8::Arguments& args) { |
||||
|
CHECK_NE(0, GetJsEntrySp()); |
||||
|
return v8::Undefined(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static void CompileRun(const char* source) { |
||||
|
Script::Compile(String::New(source))->Run(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
v8::Handle<v8::Value> TraceExtension::JSEntrySPLevel2( |
||||
|
const v8::Arguments& args) { |
||||
|
v8::HandleScope scope; |
||||
|
const Address js_entry_sp = GetJsEntrySp(); |
||||
|
CHECK_NE(0, js_entry_sp); |
||||
|
CompileRun("js_entry_sp();"); |
||||
|
CHECK_EQ(js_entry_sp, GetJsEntrySp()); |
||||
|
return v8::Undefined(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static TraceExtension kTraceExtension; |
||||
|
v8::DeclareExtension kTraceExtensionDeclaration(&kTraceExtension); |
||||
|
|
||||
|
|
||||
|
static void InitializeVM() { |
||||
|
if (env.IsEmpty()) { |
||||
|
v8::HandleScope scope; |
||||
|
const char* extensions[] = { "v8/trace" }; |
||||
|
v8::ExtensionConfiguration config(1, extensions); |
||||
|
env = v8::Context::New(&config); |
||||
|
} |
||||
|
v8::HandleScope scope; |
||||
|
env->Enter(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static Handle<JSFunction> CompileFunction(const char* source) { |
||||
|
return v8::Utils::OpenHandle(*Script::Compile(String::New(source))); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static Local<Value> GetGlobalProperty(const char* name) { |
||||
|
return env->Global()->Get(String::New(name)); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static Handle<JSFunction> GetGlobalJSFunction(const char* name) { |
||||
|
Handle<JSFunction> js_func(JSFunction::cast( |
||||
|
*(v8::Utils::OpenHandle( |
||||
|
*GetGlobalProperty(name))))); |
||||
|
return js_func; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static void CheckRetAddrIsInJSFunction(const char* func_name, |
||||
|
Address ret_addr) { |
||||
|
CheckRetAddrIsInJSFunction(func_name, ret_addr, |
||||
|
GetGlobalJSFunction(func_name)); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static void SetGlobalProperty(const char* name, Local<Value> value) { |
||||
|
env->Global()->Set(String::New(name), value); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static Handle<v8::internal::String> NewString(const char* s) { |
||||
|
return i::Factory::NewStringFromAscii(i::CStrVector(s)); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
class CodeGeneratorPatcher { |
||||
|
public: |
||||
|
CodeGeneratorPatcher() { |
||||
|
CodeGenerator::InlineRuntimeLUT genGetFramePointer = |
||||
|
{&CodeGenerator::GenerateGetFramePointer, "_GetFramePointer"}; |
||||
|
// _FastCharCodeAt is not used in our tests.
|
||||
|
bool result = CodeGenerator::PatchInlineRuntimeEntry( |
||||
|
NewString("_FastCharCodeAt"), |
||||
|
genGetFramePointer, &oldInlineEntry); |
||||
|
CHECK(result); |
||||
|
} |
||||
|
|
||||
|
~CodeGeneratorPatcher() { |
||||
|
CHECK(CodeGenerator::PatchInlineRuntimeEntry( |
||||
|
NewString("_GetFramePointer"), |
||||
|
oldInlineEntry, NULL)); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
CodeGenerator::InlineRuntimeLUT oldInlineEntry; |
||||
|
}; |
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
|
||||
|
// Creates a global function named 'func_name' that calls the tracing
|
||||
|
// function 'trace_func_name' with an actual EBP register value,
|
||||
|
// shifted right to be presented as Smi.
|
||||
|
static void CreateTraceCallerFunction(const char* func_name, |
||||
|
const char* trace_func_name) { |
||||
|
i::EmbeddedVector<char, 256> trace_call_buf; |
||||
|
i::OS::SNPrintF(trace_call_buf, "%s(%%_GetFramePointer());", trace_func_name); |
||||
|
|
||||
|
// Compile the script.
|
||||
|
i::CodeGeneratorPatcher patcher; |
||||
|
bool allow_natives_syntax = i::FLAG_allow_natives_syntax; |
||||
|
i::FLAG_allow_natives_syntax = true; |
||||
|
Handle<JSFunction> func = CompileFunction(trace_call_buf.start()); |
||||
|
CHECK(!func.is_null()); |
||||
|
i::FLAG_allow_natives_syntax = allow_natives_syntax; |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
v8::internal::Code* func_code = func->code(); |
||||
|
CHECK(func_code->IsCode()); |
||||
|
func_code->Print(); |
||||
|
#endif |
||||
|
|
||||
|
SetGlobalProperty(func_name, v8::ToApi<Value>(func)); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(CFromJSStackTrace) { |
||||
|
TickSample sample; |
||||
|
InitTraceEnv(&sample); |
||||
|
|
||||
|
InitializeVM(); |
||||
|
v8::HandleScope scope; |
||||
|
CreateTraceCallerFunction("JSFuncDoTrace", "trace"); |
||||
|
CompileRun( |
||||
|
"function JSTrace() {" |
||||
|
" JSFuncDoTrace();" |
||||
|
"};\n" |
||||
|
"JSTrace();"); |
||||
|
CHECK_GT(sample.frames_count, 1); |
||||
|
// Stack sampling will start from the first JS function, i.e. "JSFuncDoTrace"
|
||||
|
CheckRetAddrIsInJSFunction("JSFuncDoTrace", |
||||
|
sample.stack[0]); |
||||
|
CheckRetAddrIsInJSFunction("JSTrace", |
||||
|
sample.stack[1]); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(PureJSStackTrace) { |
||||
|
TickSample sample; |
||||
|
InitTraceEnv(&sample); |
||||
|
|
||||
|
InitializeVM(); |
||||
|
v8::HandleScope scope; |
||||
|
CreateTraceCallerFunction("JSFuncDoTrace", "js_trace"); |
||||
|
CompileRun( |
||||
|
"function JSTrace() {" |
||||
|
" JSFuncDoTrace();" |
||||
|
"};\n" |
||||
|
"function OuterJSTrace() {" |
||||
|
" JSTrace();" |
||||
|
"};\n" |
||||
|
"OuterJSTrace();"); |
||||
|
CHECK_GT(sample.frames_count, 1); |
||||
|
// Stack sampling will start from the caller of JSFuncDoTrace, i.e. "JSTrace"
|
||||
|
CheckRetAddrIsInJSFunction("JSTrace", |
||||
|
sample.stack[0]); |
||||
|
CheckRetAddrIsInJSFunction("OuterJSTrace", |
||||
|
sample.stack[1]); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static void CFuncDoTrace() { |
||||
|
Address fp; |
||||
|
#ifdef __GNUC__ |
||||
|
fp = reinterpret_cast<Address>(__builtin_frame_address(0)); |
||||
|
#elif defined _MSC_VER && defined V8_TARGET_ARCH_IA32 |
||||
|
__asm mov [fp], ebp // NOLINT
|
||||
|
#elif defined _MSC_VER && defined V8_TARGET_ARCH_X64 |
||||
|
// FIXME: I haven't really tried to compile it.
|
||||
|
__asm movq [fp], rbp // NOLINT
|
||||
|
#endif |
||||
|
DoTrace(fp); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static int CFunc(int depth) { |
||||
|
if (depth <= 0) { |
||||
|
CFuncDoTrace(); |
||||
|
return 0; |
||||
|
} else { |
||||
|
return CFunc(depth - 1) + 1; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(PureCStackTrace) { |
||||
|
TickSample sample; |
||||
|
InitTraceEnv(&sample); |
||||
|
// Check that sampler doesn't crash
|
||||
|
CHECK_EQ(10, CFunc(10)); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(JsEntrySp) { |
||||
|
InitializeVM(); |
||||
|
v8::HandleScope scope; |
||||
|
CHECK_EQ(0, GetJsEntrySp()); |
||||
|
CompileRun("a = 1; b = a + 1;"); |
||||
|
CHECK_EQ(0, GetJsEntrySp()); |
||||
|
CompileRun("js_entry_sp();"); |
||||
|
CHECK_EQ(0, GetJsEntrySp()); |
||||
|
CompileRun("js_entry_sp_level2();"); |
||||
|
CHECK_EQ(0, GetJsEntrySp()); |
||||
|
} |
||||
|
|
||||
|
#endif // ENABLE_LOGGING_AND_PROFILING
|
||||
@ -0,0 +1,38 @@ |
|||||
|
// 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.
|
||||
|
|
||||
|
// Test of invalid Date construction, and TimeClip function.
|
||||
|
|
||||
|
// See http://code.google.com/p/v8/issues/detail?id=416
|
||||
|
|
||||
|
assertTrue(isNaN(new Date(1e81).getTime()), "new Date(1e81)"); |
||||
|
assertTrue(isNaN(new Date(-1e81).getTime()), "new Date(-1e81)"); |
||||
|
assertTrue(isNaN(new Date(1e81, "").getTime()), "new Date(1e81, \"\")"); |
||||
|
assertTrue(isNaN(new Date(-1e81, "").getTime()), "new Date(-1e81, \"\")"); |
||||
|
assertTrue(isNaN(new Date(Number.NaN).getTime()), "new Date(Number.NaN)"); |
||||
|
assertTrue(isNaN(new Date(Number.NaN, "").getTime()), |
||||
|
"new Date(Number.NaN, \"\")"); |
||||
Loading…
Reference in new issue