mirror of https://github.com/lukechilds/node.git
Ryan
16 years ago
251 changed files with 15652 additions and 2807 deletions
@ -0,0 +1,633 @@ |
|||
// Copyright 2006-2008 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_IA32_CODEGEN_IA32_H_ |
|||
#define V8_IA32_CODEGEN_IA32_H_ |
|||
|
|||
namespace v8 { namespace internal { |
|||
|
|||
// Forward declarations
|
|||
class DeferredCode; |
|||
class RegisterAllocator; |
|||
class RegisterFile; |
|||
|
|||
enum InitState { CONST_INIT, NOT_CONST_INIT }; |
|||
enum TypeofState { INSIDE_TYPEOF, NOT_INSIDE_TYPEOF }; |
|||
|
|||
|
|||
// -------------------------------------------------------------------------
|
|||
// Reference support
|
|||
|
|||
// A reference is a C++ stack-allocated object that keeps an ECMA
|
|||
// reference on the execution stack while in scope. For variables
|
|||
// the reference is empty, indicating that it isn't necessary to
|
|||
// store state on the stack for keeping track of references to those.
|
|||
// For properties, we keep either one (named) or two (indexed) values
|
|||
// on the execution stack to represent the reference.
|
|||
|
|||
class Reference BASE_EMBEDDED { |
|||
public: |
|||
// The values of the types is important, see size().
|
|||
enum Type { ILLEGAL = -1, SLOT = 0, NAMED = 1, KEYED = 2 }; |
|||
Reference(CodeGenerator* cgen, Expression* expression); |
|||
~Reference(); |
|||
|
|||
Expression* expression() const { return expression_; } |
|||
Type type() const { return type_; } |
|||
void set_type(Type value) { |
|||
ASSERT(type_ == ILLEGAL); |
|||
type_ = value; |
|||
} |
|||
|
|||
// The size the reference takes up on the stack.
|
|||
int size() const { return (type_ == ILLEGAL) ? 0 : type_; } |
|||
|
|||
bool is_illegal() const { return type_ == ILLEGAL; } |
|||
bool is_slot() const { return type_ == SLOT; } |
|||
bool is_property() const { return type_ == NAMED || type_ == KEYED; } |
|||
|
|||
// Return the name. Only valid for named property references.
|
|||
Handle<String> GetName(); |
|||
|
|||
// Generate code to push the value of the reference on top of the
|
|||
// expression stack. The reference is expected to be already on top of
|
|||
// the expression stack, and it is left in place with its value above it.
|
|||
void GetValue(TypeofState typeof_state); |
|||
|
|||
// Like GetValue except that the slot is expected to be written to before
|
|||
// being read from again. Thae value of the reference may be invalidated,
|
|||
// causing subsequent attempts to read it to fail.
|
|||
void TakeValue(TypeofState typeof_state); |
|||
|
|||
// Generate code to store the value on top of the expression stack in the
|
|||
// reference. The reference is expected to be immediately below the value
|
|||
// on the expression stack. The stored value is left in place (with the
|
|||
// reference intact below it) to support chained assignments.
|
|||
void SetValue(InitState init_state); |
|||
|
|||
private: |
|||
CodeGenerator* cgen_; |
|||
Expression* expression_; |
|||
Type type_; |
|||
}; |
|||
|
|||
|
|||
// -------------------------------------------------------------------------
|
|||
// Control destinations.
|
|||
|
|||
// A control destination encapsulates a pair of jump targets and a
|
|||
// flag indicating which one is the preferred fall-through. The
|
|||
// preferred fall-through must be unbound, the other may be already
|
|||
// bound (ie, a backward target).
|
|||
//
|
|||
// The true and false targets may be jumped to unconditionally or
|
|||
// control may split conditionally. Unconditional jumping and
|
|||
// splitting should be emitted in tail position (as the last thing
|
|||
// when compiling an expression) because they can cause either label
|
|||
// to be bound or the non-fall through to be jumped to leaving an
|
|||
// invalid virtual frame.
|
|||
//
|
|||
// The labels in the control destination can be extracted and
|
|||
// manipulated normally without affecting the state of the
|
|||
// destination.
|
|||
|
|||
class ControlDestination BASE_EMBEDDED { |
|||
public: |
|||
ControlDestination(JumpTarget* true_target, |
|||
JumpTarget* false_target, |
|||
bool true_is_fall_through) |
|||
: true_target_(true_target), |
|||
false_target_(false_target), |
|||
true_is_fall_through_(true_is_fall_through), |
|||
is_used_(false) { |
|||
ASSERT(true_is_fall_through ? !true_target->is_bound() |
|||
: !false_target->is_bound()); |
|||
} |
|||
|
|||
// Accessors for the jump targets. Directly jumping or branching to
|
|||
// or binding the targets will not update the destination's state.
|
|||
JumpTarget* true_target() const { return true_target_; } |
|||
JumpTarget* false_target() const { return false_target_; } |
|||
|
|||
// True if the the destination has been jumped to unconditionally or
|
|||
// control has been split to both targets. This predicate does not
|
|||
// test whether the targets have been extracted and manipulated as
|
|||
// raw jump targets.
|
|||
bool is_used() const { return is_used_; } |
|||
|
|||
// True if the destination is used and the true target (respectively
|
|||
// false target) was the fall through. If the target is backward,
|
|||
// "fall through" included jumping unconditionally to it.
|
|||
bool true_was_fall_through() const { |
|||
return is_used_ && true_is_fall_through_; |
|||
} |
|||
|
|||
bool false_was_fall_through() const { |
|||
return is_used_ && !true_is_fall_through_; |
|||
} |
|||
|
|||
// Emit a branch to one of the true or false targets, and bind the
|
|||
// other target. Because this binds the fall-through target, it
|
|||
// should be emitted in tail position (as the last thing when
|
|||
// compiling an expression).
|
|||
void Split(Condition cc) { |
|||
ASSERT(!is_used_); |
|||
if (true_is_fall_through_) { |
|||
false_target_->Branch(NegateCondition(cc)); |
|||
true_target_->Bind(); |
|||
} else { |
|||
true_target_->Branch(cc); |
|||
false_target_->Bind(); |
|||
} |
|||
is_used_ = true; |
|||
} |
|||
|
|||
// Emit an unconditional jump in tail position, to the true target
|
|||
// (if the argument is true) or the false target. The "jump" will
|
|||
// actually bind the jump target if it is forward, jump to it if it
|
|||
// is backward.
|
|||
void Goto(bool where) { |
|||
ASSERT(!is_used_); |
|||
JumpTarget* target = where ? true_target_ : false_target_; |
|||
if (target->is_bound()) { |
|||
target->Jump(); |
|||
} else { |
|||
target->Bind(); |
|||
} |
|||
is_used_ = true; |
|||
true_is_fall_through_ = where; |
|||
} |
|||
|
|||
// Mark this jump target as used as if Goto had been called, but
|
|||
// without generating a jump or binding a label (the control effect
|
|||
// should have already happened). This is used when the left
|
|||
// subexpression of the short-circuit boolean operators are
|
|||
// compiled.
|
|||
void Use(bool where) { |
|||
ASSERT(!is_used_); |
|||
ASSERT((where ? true_target_ : false_target_)->is_bound()); |
|||
is_used_ = true; |
|||
true_is_fall_through_ = where; |
|||
} |
|||
|
|||
// Swap the true and false targets but keep the same actual label as
|
|||
// the fall through. This is used when compiling negated
|
|||
// expressions, where we want to swap the targets but preserve the
|
|||
// state.
|
|||
void Invert() { |
|||
JumpTarget* temp_target = true_target_; |
|||
true_target_ = false_target_; |
|||
false_target_ = temp_target; |
|||
|
|||
true_is_fall_through_ = !true_is_fall_through_; |
|||
} |
|||
|
|||
private: |
|||
// True and false jump targets.
|
|||
JumpTarget* true_target_; |
|||
JumpTarget* false_target_; |
|||
|
|||
// Before using the destination: true if the true target is the
|
|||
// preferred fall through, false if the false target is. After
|
|||
// using the destination: true if the true target was actually used
|
|||
// as the fall through, false if the false target was.
|
|||
bool true_is_fall_through_; |
|||
|
|||
// True if the Split or Goto functions have been called.
|
|||
bool is_used_; |
|||
}; |
|||
|
|||
|
|||
// -------------------------------------------------------------------------
|
|||
// Code generation state
|
|||
|
|||
// The state is passed down the AST by the code generator (and back up, in
|
|||
// the form of the state of the jump target pair). It is threaded through
|
|||
// the call stack. Constructing a state implicitly pushes it on the owning
|
|||
// code generator's stack of states, and destroying one implicitly pops it.
|
|||
//
|
|||
// The code generator state is only used for expressions, so statements have
|
|||
// the initial state.
|
|||
|
|||
class CodeGenState BASE_EMBEDDED { |
|||
public: |
|||
// Create an initial code generator state. Destroying the initial state
|
|||
// leaves the code generator with a NULL state.
|
|||
explicit CodeGenState(CodeGenerator* owner); |
|||
|
|||
// Create a code generator state based on a code generator's current
|
|||
// state. The new state may or may not be inside a typeof, and has its
|
|||
// own control destination.
|
|||
CodeGenState(CodeGenerator* owner, |
|||
TypeofState typeof_state, |
|||
ControlDestination* destination); |
|||
|
|||
// Destroy a code generator state and restore the owning code generator's
|
|||
// previous state.
|
|||
~CodeGenState(); |
|||
|
|||
// Accessors for the state.
|
|||
TypeofState typeof_state() const { return typeof_state_; } |
|||
ControlDestination* destination() const { return destination_; } |
|||
|
|||
private: |
|||
// The owning code generator.
|
|||
CodeGenerator* owner_; |
|||
|
|||
// A flag indicating whether we are compiling the immediate subexpression
|
|||
// of a typeof expression.
|
|||
TypeofState typeof_state_; |
|||
|
|||
// A control destination in case the expression has a control-flow
|
|||
// effect.
|
|||
ControlDestination* destination_; |
|||
|
|||
// The previous state of the owning code generator, restored when
|
|||
// this state is destroyed.
|
|||
CodeGenState* previous_; |
|||
}; |
|||
|
|||
|
|||
|
|||
|
|||
// -------------------------------------------------------------------------
|
|||
// CodeGenerator
|
|||
|
|||
class CodeGenerator: public AstVisitor { |
|||
public: |
|||
// Takes a function literal, generates code for it. This function should only
|
|||
// be called by compiler.cc.
|
|||
static Handle<Code> MakeCode(FunctionLiteral* fun, |
|||
Handle<Script> script, |
|||
bool is_eval); |
|||
|
|||
#ifdef ENABLE_LOGGING_AND_PROFILING |
|||
static bool ShouldGenerateLog(Expression* type); |
|||
#endif |
|||
|
|||
static void SetFunctionInfo(Handle<JSFunction> fun, |
|||
int length, |
|||
int function_token_position, |
|||
int start_position, |
|||
int end_position, |
|||
bool is_expression, |
|||
bool is_toplevel, |
|||
Handle<Script> script, |
|||
Handle<String> inferred_name); |
|||
|
|||
// Accessors
|
|||
MacroAssembler* masm() { return masm_; } |
|||
|
|||
VirtualFrame* frame() const { return frame_; } |
|||
|
|||
bool has_valid_frame() const { return frame_ != NULL; } |
|||
|
|||
// Set the virtual frame to be new_frame, with non-frame register
|
|||
// reference counts given by non_frame_registers. The non-frame
|
|||
// register reference counts of the old frame are returned in
|
|||
// non_frame_registers.
|
|||
void SetFrame(VirtualFrame* new_frame, RegisterFile* non_frame_registers); |
|||
|
|||
void DeleteFrame(); |
|||
|
|||
RegisterAllocator* allocator() const { return allocator_; } |
|||
|
|||
CodeGenState* state() { return state_; } |
|||
void set_state(CodeGenState* state) { state_ = state; } |
|||
|
|||
void AddDeferred(DeferredCode* code) { deferred_.Add(code); } |
|||
|
|||
bool in_spilled_code() const { return in_spilled_code_; } |
|||
void set_in_spilled_code(bool flag) { in_spilled_code_ = flag; } |
|||
|
|||
private: |
|||
// Construction/Destruction
|
|||
CodeGenerator(int buffer_size, Handle<Script> script, bool is_eval); |
|||
virtual ~CodeGenerator() { delete masm_; } |
|||
|
|||
// Accessors
|
|||
Scope* scope() const { return scope_; } |
|||
|
|||
// Clearing and generating deferred code.
|
|||
void ClearDeferred(); |
|||
void ProcessDeferred(); |
|||
|
|||
bool is_eval() { return is_eval_; } |
|||
|
|||
// State
|
|||
TypeofState typeof_state() const { return state_->typeof_state(); } |
|||
ControlDestination* destination() const { return state_->destination(); } |
|||
|
|||
// Track loop nesting level.
|
|||
int loop_nesting() const { return loop_nesting_; } |
|||
void IncrementLoopNesting() { loop_nesting_++; } |
|||
void DecrementLoopNesting() { loop_nesting_--; } |
|||
|
|||
|
|||
// Node visitors.
|
|||
void VisitStatements(ZoneList<Statement*>* statements); |
|||
|
|||
#define DEF_VISIT(type) \ |
|||
void Visit##type(type* node); |
|||
NODE_LIST(DEF_VISIT) |
|||
#undef DEF_VISIT |
|||
|
|||
// Visit a statement and then spill the virtual frame if control flow can
|
|||
// reach the end of the statement (ie, it does not exit via break,
|
|||
// continue, return, or throw). This function is used temporarily while
|
|||
// the code generator is being transformed.
|
|||
void VisitAndSpill(Statement* statement); |
|||
|
|||
// Visit a list of statements and then spill the virtual frame if control
|
|||
// flow can reach the end of the list.
|
|||
void VisitStatementsAndSpill(ZoneList<Statement*>* statements); |
|||
|
|||
// Main code generation function
|
|||
void GenCode(FunctionLiteral* fun); |
|||
|
|||
// Generate the return sequence code. Should be called no more than
|
|||
// once per compiled function, immediately after binding the return
|
|||
// target (which can not be done more than once).
|
|||
void GenerateReturnSequence(Result* return_value); |
|||
|
|||
// The following are used by class Reference.
|
|||
void LoadReference(Reference* ref); |
|||
void UnloadReference(Reference* ref); |
|||
|
|||
Operand ContextOperand(Register context, int index) const { |
|||
return Operand(context, Context::SlotOffset(index)); |
|||
} |
|||
|
|||
Operand SlotOperand(Slot* slot, Register tmp); |
|||
|
|||
Operand ContextSlotOperandCheckExtensions(Slot* slot, |
|||
Result tmp, |
|||
JumpTarget* slow); |
|||
|
|||
// Expressions
|
|||
Operand GlobalObject() const { |
|||
return ContextOperand(esi, Context::GLOBAL_INDEX); |
|||
} |
|||
|
|||
void LoadCondition(Expression* x, |
|||
TypeofState typeof_state, |
|||
ControlDestination* destination, |
|||
bool force_control); |
|||
void Load(Expression* x, TypeofState typeof_state = NOT_INSIDE_TYPEOF); |
|||
void LoadGlobal(); |
|||
void LoadGlobalReceiver(); |
|||
|
|||
// Generate code to push the value of an expression on top of the frame
|
|||
// and then spill the frame fully to memory. This function is used
|
|||
// temporarily while the code generator is being transformed.
|
|||
void LoadAndSpill(Expression* expression, |
|||
TypeofState typeof_state = NOT_INSIDE_TYPEOF); |
|||
|
|||
// Read a value from a slot and leave it on top of the expression stack.
|
|||
void LoadFromSlot(Slot* slot, TypeofState typeof_state); |
|||
Result LoadFromGlobalSlotCheckExtensions(Slot* slot, |
|||
TypeofState typeof_state, |
|||
JumpTarget* slow); |
|||
|
|||
// Store the value on top of the expression stack into a slot, leaving the
|
|||
// value in place.
|
|||
void StoreToSlot(Slot* slot, InitState init_state); |
|||
|
|||
// Special code for typeof expressions: Unfortunately, we must
|
|||
// be careful when loading the expression in 'typeof'
|
|||
// expressions. We are not allowed to throw reference errors for
|
|||
// non-existing properties of the global object, so we must make it
|
|||
// look like an explicit property access, instead of an access
|
|||
// through the context chain.
|
|||
void LoadTypeofExpression(Expression* x); |
|||
|
|||
// Translate the value on top of the frame into control flow to the
|
|||
// control destination.
|
|||
void ToBoolean(ControlDestination* destination); |
|||
|
|||
void GenericBinaryOperation( |
|||
Token::Value op, |
|||
SmiAnalysis* type, |
|||
OverwriteMode overwrite_mode); |
|||
|
|||
// If possible, combine two constant smi values using op to produce
|
|||
// a smi result, and push it on the virtual frame, all at compile time.
|
|||
// Returns true if it succeeds. Otherwise it has no effect.
|
|||
bool FoldConstantSmis(Token::Value op, int left, int right); |
|||
|
|||
// Emit code to perform a binary operation on a constant
|
|||
// smi and a likely smi. Consumes the Result *operand.
|
|||
void ConstantSmiBinaryOperation(Token::Value op, |
|||
Result* operand, |
|||
Handle<Object> constant_operand, |
|||
SmiAnalysis* type, |
|||
bool reversed, |
|||
OverwriteMode overwrite_mode); |
|||
|
|||
// Emit code to perform a binary operation on two likely smis.
|
|||
// The code to handle smi arguments is produced inline.
|
|||
// Consumes the Results *left and *right.
|
|||
void LikelySmiBinaryOperation(Token::Value op, |
|||
Result* left, |
|||
Result* right, |
|||
OverwriteMode overwrite_mode); |
|||
|
|||
void Comparison(Condition cc, |
|||
bool strict, |
|||
ControlDestination* destination); |
|||
|
|||
// To prevent long attacker-controlled byte sequences, integer constants
|
|||
// from the JavaScript source are loaded in two parts if they are larger
|
|||
// than 16 bits.
|
|||
static const int kMaxSmiInlinedBits = 16; |
|||
bool IsUnsafeSmi(Handle<Object> value); |
|||
// Load an integer constant x into a register target using
|
|||
// at most 16 bits of user-controlled data per assembly operation.
|
|||
void LoadUnsafeSmi(Register target, Handle<Object> value); |
|||
|
|||
void CallWithArguments(ZoneList<Expression*>* arguments, int position); |
|||
|
|||
void CheckStack(); |
|||
|
|||
struct InlineRuntimeLUT { |
|||
void (CodeGenerator::*method)(ZoneList<Expression*>*); |
|||
const char* name; |
|||
}; |
|||
|
|||
static InlineRuntimeLUT* FindInlineRuntimeLUT(Handle<String> name); |
|||
bool CheckForInlineRuntimeCall(CallRuntime* node); |
|||
static bool PatchInlineRuntimeEntry(Handle<String> name, |
|||
const InlineRuntimeLUT& new_entry, |
|||
InlineRuntimeLUT* old_entry); |
|||
|
|||
Handle<JSFunction> BuildBoilerplate(FunctionLiteral* node); |
|||
void ProcessDeclarations(ZoneList<Declaration*>* declarations); |
|||
|
|||
Handle<Code> ComputeCallInitialize(int argc); |
|||
Handle<Code> ComputeCallInitializeInLoop(int argc); |
|||
|
|||
// Declare global variables and functions in the given array of
|
|||
// name/value pairs.
|
|||
void DeclareGlobals(Handle<FixedArray> pairs); |
|||
|
|||
// Instantiate the function boilerplate.
|
|||
void InstantiateBoilerplate(Handle<JSFunction> boilerplate); |
|||
|
|||
// Support for type checks.
|
|||
void GenerateIsSmi(ZoneList<Expression*>* args); |
|||
void GenerateIsNonNegativeSmi(ZoneList<Expression*>* args); |
|||
void GenerateIsArray(ZoneList<Expression*>* args); |
|||
|
|||
// Support for arguments.length and arguments[?].
|
|||
void GenerateArgumentsLength(ZoneList<Expression*>* args); |
|||
void GenerateArgumentsAccess(ZoneList<Expression*>* args); |
|||
|
|||
// Support for accessing the value field of an object (used by Date).
|
|||
void GenerateValueOf(ZoneList<Expression*>* args); |
|||
void GenerateSetValueOf(ZoneList<Expression*>* args); |
|||
|
|||
// Fast support for charCodeAt(n).
|
|||
void GenerateFastCharCodeAt(ZoneList<Expression*>* args); |
|||
|
|||
// Fast support for object equality testing.
|
|||
void GenerateObjectEquals(ZoneList<Expression*>* args); |
|||
|
|||
void GenerateLog(ZoneList<Expression*>* args); |
|||
|
|||
void GenerateGetFramePointer(ZoneList<Expression*>* args); |
|||
|
|||
// Methods and constants for fast case switch statement support.
|
|||
//
|
|||
// Only allow fast-case switch if the range of labels is at most
|
|||
// this factor times the number of case labels.
|
|||
// Value is derived from comparing the size of code generated by the normal
|
|||
// switch code for Smi-labels to the size of a single pointer. If code
|
|||
// quality increases this number should be decreased to match.
|
|||
static const int kFastSwitchMaxOverheadFactor = 5; |
|||
|
|||
// Minimal number of switch cases required before we allow jump-table
|
|||
// optimization.
|
|||
static const int kFastSwitchMinCaseCount = 5; |
|||
|
|||
// The limit of the range of a fast-case switch, as a factor of the number
|
|||
// of cases of the switch. Each platform should return a value that
|
|||
// is optimal compared to the default code generated for a switch statement
|
|||
// on that platform.
|
|||
int FastCaseSwitchMaxOverheadFactor(); |
|||
|
|||
// The minimal number of cases in a switch before the fast-case switch
|
|||
// optimization is enabled. Each platform should return a value that
|
|||
// is optimal compared to the default code generated for a switch statement
|
|||
// on that platform.
|
|||
int FastCaseSwitchMinCaseCount(); |
|||
|
|||
// Allocate a jump table and create code to jump through it.
|
|||
// Should call GenerateFastCaseSwitchCases to generate the code for
|
|||
// all the cases at the appropriate point.
|
|||
void GenerateFastCaseSwitchJumpTable(SwitchStatement* node, |
|||
int min_index, |
|||
int range, |
|||
Label* fail_label, |
|||
Vector<Label*> case_targets, |
|||
Vector<Label> case_labels); |
|||
|
|||
// Generate the code for cases for the fast case switch.
|
|||
// Called by GenerateFastCaseSwitchJumpTable.
|
|||
void GenerateFastCaseSwitchCases(SwitchStatement* node, |
|||
Vector<Label> case_labels, |
|||
VirtualFrame* start_frame); |
|||
|
|||
// Fast support for constant-Smi switches.
|
|||
void GenerateFastCaseSwitchStatement(SwitchStatement* node, |
|||
int min_index, |
|||
int range, |
|||
int default_index); |
|||
|
|||
// Fast support for constant-Smi switches. Tests whether switch statement
|
|||
// permits optimization and calls GenerateFastCaseSwitch if it does.
|
|||
// Returns true if the fast-case switch was generated, and false if not.
|
|||
bool TryGenerateFastCaseSwitchStatement(SwitchStatement* node); |
|||
|
|||
// Methods used to indicate which source code is generated for. Source
|
|||
// positions are collected by the assembler and emitted with the relocation
|
|||
// information.
|
|||
void CodeForFunctionPosition(FunctionLiteral* fun); |
|||
void CodeForReturnPosition(FunctionLiteral* fun); |
|||
void CodeForStatementPosition(Node* node); |
|||
void CodeForSourcePosition(int pos); |
|||
|
|||
#ifdef DEBUG |
|||
// True if the registers are valid for entry to a block. There should be
|
|||
// no frame-external references to eax, ebx, ecx, edx, or edi.
|
|||
bool HasValidEntryRegisters(); |
|||
#endif |
|||
|
|||
bool is_eval_; // Tells whether code is generated for eval.
|
|||
Handle<Script> script_; |
|||
List<DeferredCode*> deferred_; |
|||
|
|||
// Assembler
|
|||
MacroAssembler* masm_; // to generate code
|
|||
|
|||
// Code generation state
|
|||
Scope* scope_; |
|||
VirtualFrame* frame_; |
|||
RegisterAllocator* allocator_; |
|||
CodeGenState* state_; |
|||
int loop_nesting_; |
|||
|
|||
// Jump targets.
|
|||
// The target of the return from the function.
|
|||
BreakTarget function_return_; |
|||
|
|||
// True if the function return is shadowed (ie, jumping to the target
|
|||
// function_return_ does not jump to the true function return, but rather
|
|||
// to some unlinking code).
|
|||
bool function_return_is_shadowed_; |
|||
|
|||
// True when we are in code that expects the virtual frame to be fully
|
|||
// spilled. Some virtual frame function are disabled in DEBUG builds when
|
|||
// called from spilled code, because they do not leave the virtual frame
|
|||
// in a spilled state.
|
|||
bool in_spilled_code_; |
|||
|
|||
static InlineRuntimeLUT kInlineRuntimeLUT[]; |
|||
|
|||
friend class VirtualFrame; |
|||
friend class JumpTarget; |
|||
friend class Reference; |
|||
friend class Result; |
|||
|
|||
friend class CodeGeneratorPatcher; // Used in test-log-ia32.cc
|
|||
|
|||
DISALLOW_COPY_AND_ASSIGN(CodeGenerator); |
|||
}; |
|||
|
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_IA32_CODEGEN_IA32_H_
|
|||
@ -0,0 +1,371 @@ |
|||
// Copyright 2006-2008 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_IA32_MACRO_ASSEMBLER_IA32_H_ |
|||
#define V8_IA32_MACRO_ASSEMBLER_IA32_H_ |
|||
|
|||
#include "assembler.h" |
|||
|
|||
namespace v8 { namespace internal { |
|||
|
|||
// Forward declaration.
|
|||
class JumpTarget; |
|||
|
|||
|
|||
// Helper types to make flags easier to read at call sites.
|
|||
enum InvokeFlag { |
|||
CALL_FUNCTION, |
|||
JUMP_FUNCTION |
|||
}; |
|||
|
|||
enum CodeLocation { |
|||
IN_JAVASCRIPT, |
|||
IN_JS_ENTRY, |
|||
IN_C_ENTRY |
|||
}; |
|||
|
|||
enum HandlerType { |
|||
TRY_CATCH_HANDLER, |
|||
TRY_FINALLY_HANDLER, |
|||
JS_ENTRY_HANDLER |
|||
}; |
|||
|
|||
|
|||
// MacroAssembler implements a collection of frequently used macros.
|
|||
class MacroAssembler: public Assembler { |
|||
public: |
|||
MacroAssembler(void* buffer, int size); |
|||
|
|||
// ---------------------------------------------------------------------------
|
|||
// GC Support
|
|||
|
|||
// Set the remembered set bit for [object+offset].
|
|||
// object is the object being stored into, value is the object being stored.
|
|||
// If offset is zero, then the scratch register contains the array index into
|
|||
// the elements array represented as a Smi.
|
|||
// All registers are clobbered by the operation.
|
|||
void RecordWrite(Register object, |
|||
int offset, |
|||
Register value, |
|||
Register scratch); |
|||
|
|||
#ifdef ENABLE_DEBUGGER_SUPPORT |
|||
// ---------------------------------------------------------------------------
|
|||
// Debugger Support
|
|||
|
|||
void SaveRegistersToMemory(RegList regs); |
|||
void RestoreRegistersFromMemory(RegList regs); |
|||
void PushRegistersFromMemory(RegList regs); |
|||
void PopRegistersToMemory(RegList regs); |
|||
void CopyRegistersFromStackToMemory(Register base, |
|||
Register scratch, |
|||
RegList regs); |
|||
#endif |
|||
|
|||
// ---------------------------------------------------------------------------
|
|||
// Activation frames
|
|||
|
|||
void EnterInternalFrame() { EnterFrame(StackFrame::INTERNAL); } |
|||
void LeaveInternalFrame() { LeaveFrame(StackFrame::INTERNAL); } |
|||
|
|||
void EnterConstructFrame() { EnterFrame(StackFrame::CONSTRUCT); } |
|||
void LeaveConstructFrame() { LeaveFrame(StackFrame::CONSTRUCT); } |
|||
|
|||
// Enter specific kind of exit frame; either EXIT or
|
|||
// EXIT_DEBUG. Expects the number of arguments in register eax and
|
|||
// sets up the number of arguments in register edi and the pointer
|
|||
// to the first argument in register esi.
|
|||
void EnterExitFrame(StackFrame::Type type); |
|||
|
|||
// Leave the current exit frame. Expects the return value in
|
|||
// register eax:edx (untouched) and the pointer to the first
|
|||
// argument in register esi.
|
|||
void LeaveExitFrame(StackFrame::Type type); |
|||
|
|||
|
|||
// ---------------------------------------------------------------------------
|
|||
// JavaScript invokes
|
|||
|
|||
// Invoke the JavaScript function code by either calling or jumping.
|
|||
void InvokeCode(const Operand& code, |
|||
const ParameterCount& expected, |
|||
const ParameterCount& actual, |
|||
InvokeFlag flag); |
|||
|
|||
void InvokeCode(Handle<Code> code, |
|||
const ParameterCount& expected, |
|||
const ParameterCount& actual, |
|||
RelocInfo::Mode rmode, |
|||
InvokeFlag flag); |
|||
|
|||
// Invoke the JavaScript function in the given register. Changes the
|
|||
// current context to the context in the function before invoking.
|
|||
void InvokeFunction(Register function, |
|||
const ParameterCount& actual, |
|||
InvokeFlag flag); |
|||
|
|||
// Invoke specified builtin JavaScript function. Adds an entry to
|
|||
// the unresolved list if the name does not resolve.
|
|||
void InvokeBuiltin(Builtins::JavaScript id, InvokeFlag flag); |
|||
|
|||
// Store the code object for the given builtin in the target register.
|
|||
void GetBuiltinEntry(Register target, Builtins::JavaScript id); |
|||
|
|||
// Expression support
|
|||
void Set(Register dst, const Immediate& x); |
|||
void Set(const Operand& dst, const Immediate& x); |
|||
|
|||
// Compare object type for heap object.
|
|||
// Incoming register is heap_object and outgoing register is map.
|
|||
void CmpObjectType(Register heap_object, InstanceType type, Register map); |
|||
|
|||
// Compare instance type for map.
|
|||
void CmpInstanceType(Register map, InstanceType type); |
|||
|
|||
// FCmp is similar to integer cmp, but requires unsigned
|
|||
// jcc instructions (je, ja, jae, jb, jbe, je, and jz).
|
|||
void FCmp(); |
|||
|
|||
// ---------------------------------------------------------------------------
|
|||
// Exception handling
|
|||
|
|||
// Push a new try handler and link into try handler chain.
|
|||
// The return address must be pushed before calling this helper.
|
|||
// On exit, eax contains TOS (next_sp).
|
|||
void PushTryHandler(CodeLocation try_location, HandlerType type); |
|||
|
|||
|
|||
// ---------------------------------------------------------------------------
|
|||
// Inline caching support
|
|||
|
|||
// Generates code that verifies that the maps of objects in the
|
|||
// prototype chain of object hasn't changed since the code was
|
|||
// generated and branches to the miss label if any map has. If
|
|||
// necessary the function also generates code for security check
|
|||
// in case of global object holders. The scratch and holder
|
|||
// registers are always clobbered, but the object register is only
|
|||
// clobbered if it the same as the holder register. The function
|
|||
// returns a register containing the holder - either object_reg or
|
|||
// holder_reg.
|
|||
Register CheckMaps(JSObject* object, Register object_reg, |
|||
JSObject* holder, Register holder_reg, |
|||
Register scratch, Label* miss); |
|||
|
|||
// Generate code for checking access rights - used for security checks
|
|||
// on access to global objects across environments. The holder register
|
|||
// is left untouched, but the scratch register is clobbered.
|
|||
void CheckAccessGlobalProxy(Register holder_reg, |
|||
Register scratch, |
|||
Label* miss); |
|||
|
|||
|
|||
// ---------------------------------------------------------------------------
|
|||
// Support functions.
|
|||
|
|||
// Check if result is zero and op is negative.
|
|||
void NegativeZeroTest(Register result, Register op, Label* then_label); |
|||
|
|||
// Check if result is zero and op is negative in code using jump targets.
|
|||
void NegativeZeroTest(CodeGenerator* cgen, |
|||
Register result, |
|||
Register op, |
|||
JumpTarget* then_target); |
|||
|
|||
// Check if result is zero and any of op1 and op2 are negative.
|
|||
// Register scratch is destroyed, and it must be different from op2.
|
|||
void NegativeZeroTest(Register result, Register op1, Register op2, |
|||
Register scratch, Label* then_label); |
|||
|
|||
// Try to get function prototype of a function and puts the value in
|
|||
// the result register. Checks that the function really is a
|
|||
// function and jumps to the miss label if the fast checks fail. The
|
|||
// function register will be untouched; the other registers may be
|
|||
// clobbered.
|
|||
void TryGetFunctionPrototype(Register function, |
|||
Register result, |
|||
Register scratch, |
|||
Label* miss); |
|||
|
|||
// Generates code for reporting that an illegal operation has
|
|||
// occurred.
|
|||
void IllegalOperation(int num_arguments); |
|||
|
|||
// ---------------------------------------------------------------------------
|
|||
// Runtime calls
|
|||
|
|||
// Call a code stub.
|
|||
void CallStub(CodeStub* stub); |
|||
|
|||
// Return from a code stub after popping its arguments.
|
|||
void StubReturn(int argc); |
|||
|
|||
// Call a runtime routine.
|
|||
// Eventually this should be used for all C calls.
|
|||
void CallRuntime(Runtime::Function* f, int num_arguments); |
|||
|
|||
// Convenience function: Same as above, but takes the fid instead.
|
|||
void CallRuntime(Runtime::FunctionId id, int num_arguments); |
|||
|
|||
// Tail call of a runtime routine (jump).
|
|||
// Like JumpToBuiltin, but also takes care of passing the number
|
|||
// of arguments.
|
|||
void TailCallRuntime(const ExternalReference& ext, int num_arguments); |
|||
|
|||
// Jump to the builtin routine.
|
|||
void JumpToBuiltin(const ExternalReference& ext); |
|||
|
|||
|
|||
// ---------------------------------------------------------------------------
|
|||
// Utilities
|
|||
|
|||
void Ret(); |
|||
|
|||
struct Unresolved { |
|||
int pc; |
|||
uint32_t flags; // see Bootstrapper::FixupFlags decoders/encoders.
|
|||
const char* name; |
|||
}; |
|||
List<Unresolved>* unresolved() { return &unresolved_; } |
|||
|
|||
Handle<Object> CodeObject() { return code_object_; } |
|||
|
|||
|
|||
// ---------------------------------------------------------------------------
|
|||
// StatsCounter support
|
|||
|
|||
void SetCounter(StatsCounter* counter, int value); |
|||
void IncrementCounter(StatsCounter* counter, int value); |
|||
void DecrementCounter(StatsCounter* counter, int value); |
|||
|
|||
|
|||
// ---------------------------------------------------------------------------
|
|||
// Debugging
|
|||
|
|||
// Calls Abort(msg) if the condition cc is not satisfied.
|
|||
// Use --debug_code to enable.
|
|||
void Assert(Condition cc, const char* msg); |
|||
|
|||
// Like Assert(), but always enabled.
|
|||
void Check(Condition cc, const char* msg); |
|||
|
|||
// Print a message to stdout and abort execution.
|
|||
void Abort(const char* msg); |
|||
|
|||
// Verify restrictions about code generated in stubs.
|
|||
void set_generating_stub(bool value) { generating_stub_ = value; } |
|||
bool generating_stub() { return generating_stub_; } |
|||
void set_allow_stub_calls(bool value) { allow_stub_calls_ = value; } |
|||
bool allow_stub_calls() { return allow_stub_calls_; } |
|||
|
|||
private: |
|||
List<Unresolved> unresolved_; |
|||
bool generating_stub_; |
|||
bool allow_stub_calls_; |
|||
Handle<Object> code_object_; // This handle will be patched with the code
|
|||
// code object on installation.
|
|||
|
|||
// Helper functions for generating invokes.
|
|||
void InvokePrologue(const ParameterCount& expected, |
|||
const ParameterCount& actual, |
|||
Handle<Code> code_constant, |
|||
const Operand& code_operand, |
|||
Label* done, |
|||
InvokeFlag flag); |
|||
|
|||
// Get the code for the given builtin. Returns if able to resolve
|
|||
// the function in the 'resolved' flag.
|
|||
Handle<Code> ResolveBuiltin(Builtins::JavaScript id, bool* resolved); |
|||
|
|||
// Activation support.
|
|||
void EnterFrame(StackFrame::Type type); |
|||
void LeaveFrame(StackFrame::Type type); |
|||
}; |
|||
|
|||
|
|||
// The code patcher is used to patch (typically) small parts of code e.g. for
|
|||
// debugging and other types of instrumentation. When using the code patcher
|
|||
// the exact number of bytes specified must be emitted. Is not legal to emit
|
|||
// relocation information. If any of these constraints are violated it causes
|
|||
// an assertion.
|
|||
class CodePatcher { |
|||
public: |
|||
CodePatcher(byte* address, int size); |
|||
virtual ~CodePatcher(); |
|||
|
|||
// Macro assembler to emit code.
|
|||
MacroAssembler* masm() { return &masm_; } |
|||
|
|||
private: |
|||
byte* address_; // The address of the code being patched.
|
|||
int size_; // Number of bytes of the expected patch size.
|
|||
MacroAssembler masm_; // Macro assembler used to generate the code.
|
|||
}; |
|||
|
|||
|
|||
// -----------------------------------------------------------------------------
|
|||
// Static helper functions.
|
|||
|
|||
// Generate an Operand for loading a field from an object.
|
|||
static inline Operand FieldOperand(Register object, int offset) { |
|||
return Operand(object, offset - kHeapObjectTag); |
|||
} |
|||
|
|||
|
|||
// Generate an Operand for loading an indexed field from an object.
|
|||
static inline Operand FieldOperand(Register object, |
|||
Register index, |
|||
ScaleFactor scale, |
|||
int offset) { |
|||
return Operand(object, index, scale, offset - kHeapObjectTag); |
|||
} |
|||
|
|||
|
|||
#ifdef GENERATED_CODE_COVERAGE |
|||
extern void LogGeneratedCodeCoverage(const char* file_line); |
|||
#define CODE_COVERAGE_STRINGIFY(x) #x |
|||
#define CODE_COVERAGE_TOSTRING(x) CODE_COVERAGE_STRINGIFY(x) |
|||
#define __FILE_LINE__ __FILE__ ":" CODE_COVERAGE_TOSTRING(__LINE__) |
|||
#define ACCESS_MASM(masm) { \ |
|||
byte* ia32_coverage_function = \ |
|||
reinterpret_cast<byte*>(FUNCTION_ADDR(LogGeneratedCodeCoverage)); \ |
|||
masm->pushfd(); \ |
|||
masm->pushad(); \ |
|||
masm->push(Immediate(reinterpret_cast<int>(&__FILE_LINE__))); \ |
|||
masm->call(ia32_coverage_function, RelocInfo::RUNTIME_ENTRY); \ |
|||
masm->pop(eax); \ |
|||
masm->popad(); \ |
|||
masm->popfd(); \ |
|||
} \ |
|||
masm-> |
|||
#else |
|||
#define ACCESS_MASM(masm) masm-> |
|||
#endif |
|||
|
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_IA32_MACRO_ASSEMBLER_IA32_H_
|
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue