mirror of https://github.com/lukechilds/node.git
Ryan Dahl
15 years ago
176 changed files with 8628 additions and 6128 deletions
@ -1,263 +0,0 @@ |
|||
// Copyright (c) 1994-2006 Sun Microsystems Inc.
|
|||
// 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.
|
|||
//
|
|||
// - Redistribution 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 Sun Microsystems or the names of 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.
|
|||
|
|||
// The original source code covered by the above license above has been modified
|
|||
// significantly by Google Inc.
|
|||
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
|||
|
|||
#ifndef V8_ARM_ASSEMBLER_THUMB2_INL_H_ |
|||
#define V8_ARM_ASSEMBLER_THUMB2_INL_H_ |
|||
|
|||
#include "arm/assembler-thumb2.h" |
|||
#include "cpu.h" |
|||
|
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
Condition NegateCondition(Condition cc) { |
|||
ASSERT(cc != al); |
|||
return static_cast<Condition>(cc ^ ne); |
|||
} |
|||
|
|||
|
|||
void RelocInfo::apply(intptr_t delta) { |
|||
if (RelocInfo::IsInternalReference(rmode_)) { |
|||
// absolute code pointer inside code object moves with the code object.
|
|||
int32_t* p = reinterpret_cast<int32_t*>(pc_); |
|||
*p += delta; // relocate entry
|
|||
} |
|||
// We do not use pc relative addressing on ARM, so there is
|
|||
// nothing else to do.
|
|||
} |
|||
|
|||
|
|||
Address RelocInfo::target_address() { |
|||
ASSERT(IsCodeTarget(rmode_) || rmode_ == RUNTIME_ENTRY); |
|||
return Assembler::target_address_at(pc_); |
|||
} |
|||
|
|||
|
|||
Address RelocInfo::target_address_address() { |
|||
ASSERT(IsCodeTarget(rmode_) || rmode_ == RUNTIME_ENTRY); |
|||
return reinterpret_cast<Address>(Assembler::target_address_address_at(pc_)); |
|||
} |
|||
|
|||
|
|||
void RelocInfo::set_target_address(Address target) { |
|||
ASSERT(IsCodeTarget(rmode_) || rmode_ == RUNTIME_ENTRY); |
|||
Assembler::set_target_address_at(pc_, target); |
|||
} |
|||
|
|||
|
|||
Object* RelocInfo::target_object() { |
|||
ASSERT(IsCodeTarget(rmode_) || rmode_ == EMBEDDED_OBJECT); |
|||
return Memory::Object_at(Assembler::target_address_address_at(pc_)); |
|||
} |
|||
|
|||
|
|||
Handle<Object> RelocInfo::target_object_handle(Assembler* origin) { |
|||
ASSERT(IsCodeTarget(rmode_) || rmode_ == EMBEDDED_OBJECT); |
|||
return Memory::Object_Handle_at(Assembler::target_address_address_at(pc_)); |
|||
} |
|||
|
|||
|
|||
Object** RelocInfo::target_object_address() { |
|||
ASSERT(IsCodeTarget(rmode_) || rmode_ == EMBEDDED_OBJECT); |
|||
return reinterpret_cast<Object**>(Assembler::target_address_address_at(pc_)); |
|||
} |
|||
|
|||
|
|||
void RelocInfo::set_target_object(Object* target) { |
|||
ASSERT(IsCodeTarget(rmode_) || rmode_ == EMBEDDED_OBJECT); |
|||
Assembler::set_target_address_at(pc_, reinterpret_cast<Address>(target)); |
|||
} |
|||
|
|||
|
|||
Address* RelocInfo::target_reference_address() { |
|||
ASSERT(rmode_ == EXTERNAL_REFERENCE); |
|||
return reinterpret_cast<Address*>(Assembler::target_address_address_at(pc_)); |
|||
} |
|||
|
|||
|
|||
Address RelocInfo::call_address() { |
|||
ASSERT(IsPatchedReturnSequence()); |
|||
// The 2 instructions offset assumes patched return sequence.
|
|||
ASSERT(IsJSReturn(rmode())); |
|||
return Memory::Address_at(pc_ + 2 * Assembler::kInstrSize); |
|||
} |
|||
|
|||
|
|||
void RelocInfo::set_call_address(Address target) { |
|||
ASSERT(IsPatchedReturnSequence()); |
|||
// The 2 instructions offset assumes patched return sequence.
|
|||
ASSERT(IsJSReturn(rmode())); |
|||
Memory::Address_at(pc_ + 2 * Assembler::kInstrSize) = target; |
|||
} |
|||
|
|||
|
|||
Object* RelocInfo::call_object() { |
|||
return *call_object_address(); |
|||
} |
|||
|
|||
|
|||
Object** RelocInfo::call_object_address() { |
|||
ASSERT(IsPatchedReturnSequence()); |
|||
// The 2 instructions offset assumes patched return sequence.
|
|||
ASSERT(IsJSReturn(rmode())); |
|||
return reinterpret_cast<Object**>(pc_ + 2 * Assembler::kInstrSize); |
|||
} |
|||
|
|||
|
|||
void RelocInfo::set_call_object(Object* target) { |
|||
*call_object_address() = target; |
|||
} |
|||
|
|||
|
|||
bool RelocInfo::IsPatchedReturnSequence() { |
|||
// On ARM a "call instruction" is actually two instructions.
|
|||
// mov lr, pc
|
|||
// ldr pc, [pc, #XXX]
|
|||
return (Assembler::instr_at(pc_) == kMovLrPc) |
|||
&& ((Assembler::instr_at(pc_ + Assembler::kInstrSize) & kLdrPCPattern) |
|||
== kLdrPCPattern); |
|||
} |
|||
|
|||
|
|||
Operand::Operand(int32_t immediate, RelocInfo::Mode rmode) { |
|||
rm_ = no_reg; |
|||
imm32_ = immediate; |
|||
rmode_ = rmode; |
|||
} |
|||
|
|||
|
|||
Operand::Operand(const char* s) { |
|||
rm_ = no_reg; |
|||
imm32_ = reinterpret_cast<int32_t>(s); |
|||
rmode_ = RelocInfo::EMBEDDED_STRING; |
|||
} |
|||
|
|||
|
|||
Operand::Operand(const ExternalReference& f) { |
|||
rm_ = no_reg; |
|||
imm32_ = reinterpret_cast<int32_t>(f.address()); |
|||
rmode_ = RelocInfo::EXTERNAL_REFERENCE; |
|||
} |
|||
|
|||
|
|||
Operand::Operand(Smi* value) { |
|||
rm_ = no_reg; |
|||
imm32_ = reinterpret_cast<intptr_t>(value); |
|||
rmode_ = RelocInfo::NONE; |
|||
} |
|||
|
|||
|
|||
Operand::Operand(Register rm) { |
|||
rm_ = rm; |
|||
rs_ = no_reg; |
|||
shift_op_ = LSL; |
|||
shift_imm_ = 0; |
|||
} |
|||
|
|||
|
|||
bool Operand::is_reg() const { |
|||
return rm_.is_valid() && |
|||
rs_.is(no_reg) && |
|||
shift_op_ == LSL && |
|||
shift_imm_ == 0; |
|||
} |
|||
|
|||
|
|||
void Assembler::CheckBuffer() { |
|||
if (buffer_space() <= kGap) { |
|||
GrowBuffer(); |
|||
} |
|||
if (pc_offset() >= next_buffer_check_) { |
|||
CheckConstPool(false, true); |
|||
} |
|||
} |
|||
|
|||
|
|||
void Assembler::emit(Instr x) { |
|||
CheckBuffer(); |
|||
*reinterpret_cast<Instr*>(pc_) = x; |
|||
pc_ += kInstrSize; |
|||
} |
|||
|
|||
|
|||
Address Assembler::target_address_address_at(Address pc) { |
|||
Address target_pc = pc; |
|||
Instr instr = Memory::int32_at(target_pc); |
|||
// If we have a bx instruction, the instruction before the bx is
|
|||
// what we need to patch.
|
|||
static const int32_t kBxInstMask = 0x0ffffff0; |
|||
static const int32_t kBxInstPattern = 0x012fff10; |
|||
if ((instr & kBxInstMask) == kBxInstPattern) { |
|||
target_pc -= kInstrSize; |
|||
instr = Memory::int32_at(target_pc); |
|||
} |
|||
// Verify that the instruction to patch is a
|
|||
// ldr<cond> <Rd>, [pc +/- offset_12].
|
|||
ASSERT((instr & 0x0f7f0000) == 0x051f0000); |
|||
int offset = instr & 0xfff; // offset_12 is unsigned
|
|||
if ((instr & (1 << 23)) == 0) offset = -offset; // U bit defines offset sign
|
|||
// Verify that the constant pool comes after the instruction referencing it.
|
|||
ASSERT(offset >= -4); |
|||
return target_pc + offset + 8; |
|||
} |
|||
|
|||
|
|||
Address Assembler::target_address_at(Address pc) { |
|||
return Memory::Address_at(target_address_address_at(pc)); |
|||
} |
|||
|
|||
|
|||
void Assembler::set_target_at(Address constant_pool_entry, |
|||
Address target) { |
|||
Memory::Address_at(constant_pool_entry) = target; |
|||
} |
|||
|
|||
|
|||
void Assembler::set_target_address_at(Address pc, Address target) { |
|||
Memory::Address_at(target_address_address_at(pc)) = target; |
|||
// Intuitively, we would think it is necessary to flush the instruction cache
|
|||
// after patching a target address in the code as follows:
|
|||
// CPU::FlushICache(pc, sizeof(target));
|
|||
// However, on ARM, no instruction was actually patched by the assignment
|
|||
// above; the target address is not part of an instruction, it is patched in
|
|||
// the constant pool and is read via a data access; the instruction accessing
|
|||
// this address in the constant pool remains unchanged.
|
|||
} |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_ARM_ASSEMBLER_THUMB2_INL_H_
|
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,53 @@ |
|||
// Copyright 2010 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_VIRTUAL_FRAME_ARM_INL_H_ |
|||
#define V8_VIRTUAL_FRAME_ARM_INL_H_ |
|||
|
|||
#include "assembler-arm.h" |
|||
#include "virtual-frame-arm.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
// These VirtualFrame methods should actually be in a virtual-frame-arm-inl.h
|
|||
// file if such a thing existed.
|
|||
MemOperand VirtualFrame::ParameterAt(int index) { |
|||
// Index -1 corresponds to the receiver.
|
|||
ASSERT(-1 <= index); // -1 is the receiver.
|
|||
ASSERT(index <= parameter_count()); |
|||
return MemOperand(fp, (1 + parameter_count() - index) * kPointerSize); |
|||
} |
|||
|
|||
// The receiver frame slot.
|
|||
MemOperand VirtualFrame::Receiver() { |
|||
return ParameterAt(-1); |
|||
} |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_VIRTUAL_FRAME_ARM_INL_H_
|
|||
@ -0,0 +1,79 @@ |
|||
// Copyright 2010 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 "ast.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
BreakableStatement::BreakableStatement(ZoneStringList* labels, Type type) |
|||
: labels_(labels), type_(type) { |
|||
ASSERT(labels == NULL || labels->length() > 0); |
|||
} |
|||
|
|||
|
|||
SwitchStatement::SwitchStatement(ZoneStringList* labels) |
|||
: BreakableStatement(labels, TARGET_FOR_ANONYMOUS), |
|||
tag_(NULL), cases_(NULL) { |
|||
} |
|||
|
|||
|
|||
IterationStatement::IterationStatement(ZoneStringList* labels) |
|||
: BreakableStatement(labels, TARGET_FOR_ANONYMOUS), body_(NULL) { |
|||
} |
|||
|
|||
|
|||
Block::Block(ZoneStringList* labels, int capacity, bool is_initializer_block) |
|||
: BreakableStatement(labels, TARGET_FOR_NAMED_ONLY), |
|||
statements_(capacity), |
|||
is_initializer_block_(is_initializer_block) { |
|||
} |
|||
|
|||
|
|||
ForStatement::ForStatement(ZoneStringList* labels) |
|||
: IterationStatement(labels), |
|||
init_(NULL), |
|||
cond_(NULL), |
|||
next_(NULL), |
|||
may_have_function_literal_(true), |
|||
loop_variable_(NULL), |
|||
peel_this_loop_(false) { |
|||
} |
|||
|
|||
|
|||
ForInStatement::ForInStatement(ZoneStringList* labels) |
|||
: IterationStatement(labels), each_(NULL), enumerable_(NULL) { |
|||
} |
|||
|
|||
|
|||
DoWhileStatement::DoWhileStatement(ZoneStringList* labels) |
|||
: IterationStatement(labels), cond_(NULL), condition_position_(-1) { |
|||
} |
|||
|
|||
} } // namespace v8::internal
|
|||
File diff suppressed because it is too large
@ -0,0 +1,242 @@ |
|||
// Copyright 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_JUMP_TARGET_HEAVY_H_ |
|||
#define V8_JUMP_TARGET_HEAVY_H_ |
|||
|
|||
#include "macro-assembler.h" |
|||
#include "zone-inl.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
// Forward declarations.
|
|||
class FrameElement; |
|||
class Result; |
|||
class VirtualFrame; |
|||
|
|||
// -------------------------------------------------------------------------
|
|||
// Jump targets
|
|||
//
|
|||
// A jump target is an abstraction of a basic-block entry in generated
|
|||
// code. It collects all the virtual frames reaching the block by
|
|||
// forward jumps and pairs them with labels for the merge code along
|
|||
// all forward-reaching paths. When bound, an expected frame for the
|
|||
// block is determined and code is generated to merge to the expected
|
|||
// frame. For backward jumps, the merge code is generated at the edge
|
|||
// leaving the predecessor block.
|
|||
//
|
|||
// A jump target must have been reached via control flow (either by
|
|||
// jumping, branching, or falling through) at the time it is bound.
|
|||
// In particular, this means that at least one of the control-flow
|
|||
// graph edges reaching the target must be a forward edge.
|
|||
|
|||
class JumpTarget : public ZoneObject { // Shadows are dynamically allocated.
|
|||
public: |
|||
// Forward-only jump targets can only be reached by forward CFG edges.
|
|||
enum Directionality { FORWARD_ONLY, BIDIRECTIONAL }; |
|||
|
|||
// Construct a jump target used to generate code and to provide
|
|||
// access to a current frame.
|
|||
explicit JumpTarget(Directionality direction) |
|||
: direction_(direction), |
|||
reaching_frames_(0), |
|||
merge_labels_(0), |
|||
entry_frame_(NULL) { |
|||
} |
|||
|
|||
// Construct a jump target.
|
|||
JumpTarget() |
|||
: direction_(FORWARD_ONLY), |
|||
reaching_frames_(0), |
|||
merge_labels_(0), |
|||
entry_frame_(NULL) { |
|||
} |
|||
|
|||
virtual ~JumpTarget() {} |
|||
|
|||
// Set the direction of the jump target.
|
|||
virtual void set_direction(Directionality direction) { |
|||
direction_ = direction; |
|||
} |
|||
|
|||
// Treat the jump target as a fresh one. The state is reset.
|
|||
void Unuse(); |
|||
|
|||
inline CodeGenerator* cgen(); |
|||
|
|||
Label* entry_label() { return &entry_label_; } |
|||
|
|||
VirtualFrame* entry_frame() const { return entry_frame_; } |
|||
void set_entry_frame(VirtualFrame* frame) { |
|||
entry_frame_ = frame; |
|||
} |
|||
|
|||
// Predicates testing the state of the encapsulated label.
|
|||
bool is_bound() const { return entry_label_.is_bound(); } |
|||
bool is_linked() const { |
|||
return !is_bound() && !reaching_frames_.is_empty(); |
|||
} |
|||
bool is_unused() const { |
|||
// This is !is_bound() && !is_linked().
|
|||
return !is_bound() && reaching_frames_.is_empty(); |
|||
} |
|||
|
|||
// Emit a jump to the target. There must be a current frame at the
|
|||
// jump and there will be no current frame after the jump.
|
|||
virtual void Jump(); |
|||
virtual void Jump(Result* arg); |
|||
|
|||
// Emit a conditional branch to the target. There must be a current
|
|||
// frame at the branch. The current frame will fall through to the
|
|||
// code after the branch. The arg is a result that is live both at
|
|||
// the target and the fall-through.
|
|||
virtual void Branch(Condition cc, Hint hint = no_hint); |
|||
virtual void Branch(Condition cc, Result* arg, Hint hint = no_hint); |
|||
virtual void Branch(Condition cc, |
|||
Result* arg0, |
|||
Result* arg1, |
|||
Hint hint = no_hint); |
|||
|
|||
// Bind a jump target. If there is no current frame at the binding
|
|||
// site, there must be at least one frame reaching via a forward
|
|||
// jump.
|
|||
virtual void Bind(); |
|||
virtual void Bind(Result* arg); |
|||
virtual void Bind(Result* arg0, Result* arg1); |
|||
|
|||
// Emit a call to a jump target. There must be a current frame at
|
|||
// the call. The frame at the target is the same as the current
|
|||
// frame except for an extra return address on top of it. The frame
|
|||
// after the call is the same as the frame before the call.
|
|||
void Call(); |
|||
|
|||
static void set_compiling_deferred_code(bool flag) { |
|||
compiling_deferred_code_ = flag; |
|||
} |
|||
|
|||
protected: |
|||
// Directionality flag set at initialization time.
|
|||
Directionality direction_; |
|||
|
|||
// A list of frames reaching this block via forward jumps.
|
|||
ZoneList<VirtualFrame*> reaching_frames_; |
|||
|
|||
// A parallel list of labels for merge code.
|
|||
ZoneList<Label> merge_labels_; |
|||
|
|||
// The frame used on entry to the block and expected at backward
|
|||
// jumps to the block. Set when the jump target is bound, but may
|
|||
// or may not be set for forward-only blocks.
|
|||
VirtualFrame* entry_frame_; |
|||
|
|||
// The actual entry label of the block.
|
|||
Label entry_label_; |
|||
|
|||
// Implementations of Jump, Branch, and Bind with all arguments and
|
|||
// return values using the virtual frame.
|
|||
void DoJump(); |
|||
void DoBranch(Condition cc, Hint hint); |
|||
void DoBind(); |
|||
|
|||
private: |
|||
static bool compiling_deferred_code_; |
|||
|
|||
// Add a virtual frame reaching this labeled block via a forward jump,
|
|||
// and a corresponding merge code label.
|
|||
void AddReachingFrame(VirtualFrame* frame); |
|||
|
|||
// Perform initialization required during entry frame computation
|
|||
// after setting the virtual frame element at index in frame to be
|
|||
// target.
|
|||
inline void InitializeEntryElement(int index, FrameElement* target); |
|||
|
|||
// Compute a frame to use for entry to this block.
|
|||
void ComputeEntryFrame(); |
|||
|
|||
DISALLOW_COPY_AND_ASSIGN(JumpTarget); |
|||
}; |
|||
|
|||
|
|||
// -------------------------------------------------------------------------
|
|||
// Break targets
|
|||
//
|
|||
// A break target is a jump target that can be used to break out of a
|
|||
// statement that keeps extra state on the stack (eg, for/in or
|
|||
// try/finally). They know the expected stack height at the target
|
|||
// and will drop state from nested statements as part of merging.
|
|||
//
|
|||
// Break targets are used for return, break, and continue targets.
|
|||
|
|||
class BreakTarget : public JumpTarget { |
|||
public: |
|||
// Construct a break target.
|
|||
BreakTarget() {} |
|||
|
|||
virtual ~BreakTarget() {} |
|||
|
|||
// Set the direction of the break target.
|
|||
virtual void set_direction(Directionality direction); |
|||
|
|||
// Copy the state of this break target to the destination. The
|
|||
// lists of forward-reaching frames and merge-point labels are
|
|||
// copied. All virtual frame pointers are copied, not the
|
|||
// pointed-to frames. The previous state of the destination is
|
|||
// overwritten, without deallocating pointed-to virtual frames.
|
|||
void CopyTo(BreakTarget* destination); |
|||
|
|||
// Emit a jump to the target. There must be a current frame at the
|
|||
// jump and there will be no current frame after the jump.
|
|||
virtual void Jump(); |
|||
virtual void Jump(Result* arg); |
|||
|
|||
// Emit a conditional branch to the target. There must be a current
|
|||
// frame at the branch. The current frame will fall through to the
|
|||
// code after the branch.
|
|||
virtual void Branch(Condition cc, Hint hint = no_hint); |
|||
virtual void Branch(Condition cc, Result* arg, Hint hint = no_hint); |
|||
|
|||
// Bind a break target. If there is no current frame at the binding
|
|||
// site, there must be at least one frame reaching via a forward
|
|||
// jump.
|
|||
virtual void Bind(); |
|||
virtual void Bind(Result* arg); |
|||
|
|||
// Setter for expected height.
|
|||
void set_expected_height(int expected) { expected_height_ = expected; } |
|||
|
|||
private: |
|||
// The expected height of the expression stack where the target will
|
|||
// be bound, statically known at initialization time.
|
|||
int expected_height_; |
|||
|
|||
DISALLOW_COPY_AND_ASSIGN(BreakTarget); |
|||
}; |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_JUMP_TARGET_HEAVY_H_
|
|||
@ -0,0 +1,187 @@ |
|||
// Copyright 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_JUMP_TARGET_LIGHT_H_ |
|||
#define V8_JUMP_TARGET_LIGHT_H_ |
|||
|
|||
#include "macro-assembler.h" |
|||
#include "zone-inl.h" |
|||
#include "virtual-frame.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
// Forward declarations.
|
|||
class FrameElement; |
|||
class Result; |
|||
|
|||
// -------------------------------------------------------------------------
|
|||
// Jump targets
|
|||
//
|
|||
// A jump target is an abstraction of a basic-block entry in generated
|
|||
// code. It collects all the virtual frames reaching the block by
|
|||
// forward jumps and pairs them with labels for the merge code along
|
|||
// all forward-reaching paths. When bound, an expected frame for the
|
|||
// block is determined and code is generated to merge to the expected
|
|||
// frame. For backward jumps, the merge code is generated at the edge
|
|||
// leaving the predecessor block.
|
|||
//
|
|||
// A jump target must have been reached via control flow (either by
|
|||
// jumping, branching, or falling through) at the time it is bound.
|
|||
// In particular, this means that at least one of the control-flow
|
|||
// graph edges reaching the target must be a forward edge.
|
|||
|
|||
class JumpTarget : public ZoneObject { // Shadows are dynamically allocated.
|
|||
public: |
|||
// Forward-only jump targets can only be reached by forward CFG edges.
|
|||
enum Directionality { FORWARD_ONLY, BIDIRECTIONAL }; |
|||
|
|||
// Construct a jump target.
|
|||
explicit inline JumpTarget(Directionality direction); |
|||
|
|||
inline JumpTarget(); |
|||
|
|||
virtual ~JumpTarget() {} |
|||
|
|||
void Unuse() { |
|||
entry_frame_set_ = false; |
|||
entry_label_.Unuse(); |
|||
} |
|||
|
|||
inline CodeGenerator* cgen(); |
|||
|
|||
const VirtualFrame* entry_frame() const { |
|||
return entry_frame_set_ ? &entry_frame_ : NULL; |
|||
} |
|||
|
|||
void set_entry_frame(VirtualFrame* frame) { |
|||
entry_frame_ = *frame; |
|||
entry_frame_set_ = true; |
|||
} |
|||
|
|||
// Predicates testing the state of the encapsulated label.
|
|||
bool is_bound() const { return entry_label_.is_bound(); } |
|||
bool is_linked() const { return entry_label_.is_linked(); } |
|||
bool is_unused() const { return entry_label_.is_unused(); } |
|||
|
|||
// Copy the state of this jump target to the destination.
|
|||
inline void CopyTo(JumpTarget* destination) { |
|||
*destination = *this; |
|||
} |
|||
|
|||
// Emit a jump to the target. There must be a current frame at the
|
|||
// jump and there will be no current frame after the jump.
|
|||
virtual void Jump(); |
|||
|
|||
// Emit a conditional branch to the target. There must be a current
|
|||
// frame at the branch. The current frame will fall through to the
|
|||
// code after the branch. The arg is a result that is live both at
|
|||
// the target and the fall-through.
|
|||
virtual void Branch(Condition cc, Hint hint = no_hint); |
|||
|
|||
// Bind a jump target. If there is no current frame at the binding
|
|||
// site, there must be at least one frame reaching via a forward
|
|||
// jump.
|
|||
virtual void Bind(); |
|||
|
|||
// Emit a call to a jump target. There must be a current frame at
|
|||
// the call. The frame at the target is the same as the current
|
|||
// frame except for an extra return address on top of it. The frame
|
|||
// after the call is the same as the frame before the call.
|
|||
void Call(); |
|||
|
|||
protected: |
|||
// Has an entry frame been found?
|
|||
bool entry_frame_set_; |
|||
|
|||
// The frame used on entry to the block and expected at backward
|
|||
// jumps to the block. Set the first time something branches to this
|
|||
// jump target.
|
|||
VirtualFrame entry_frame_; |
|||
|
|||
// The actual entry label of the block.
|
|||
Label entry_label_; |
|||
|
|||
// Implementations of Jump, Branch, and Bind with all arguments and
|
|||
// return values using the virtual frame.
|
|||
void DoJump(); |
|||
void DoBranch(Condition cc, Hint hint); |
|||
void DoBind(); |
|||
}; |
|||
|
|||
|
|||
// -------------------------------------------------------------------------
|
|||
// Break targets
|
|||
//
|
|||
// A break target is a jump target that can be used to break out of a
|
|||
// statement that keeps extra state on the stack (eg, for/in or
|
|||
// try/finally). They know the expected stack height at the target
|
|||
// and will drop state from nested statements as part of merging.
|
|||
//
|
|||
// Break targets are used for return, break, and continue targets.
|
|||
|
|||
class BreakTarget : public JumpTarget { |
|||
public: |
|||
// Construct a break target.
|
|||
inline BreakTarget(); |
|||
|
|||
virtual ~BreakTarget() {} |
|||
|
|||
// Copy the state of this jump target to the destination.
|
|||
inline void CopyTo(BreakTarget* destination) { |
|||
*destination = *this; |
|||
} |
|||
|
|||
// Emit a jump to the target. There must be a current frame at the
|
|||
// jump and there will be no current frame after the jump.
|
|||
virtual void Jump(); |
|||
|
|||
// Emit a conditional branch to the target. There must be a current
|
|||
// frame at the branch. The current frame will fall through to the
|
|||
// code after the branch.
|
|||
virtual void Branch(Condition cc, Hint hint = no_hint); |
|||
|
|||
// Bind a break target. If there is no current frame at the binding
|
|||
// site, there must be at least one frame reaching via a forward
|
|||
// jump.
|
|||
virtual void Bind(); |
|||
|
|||
// Setter for expected height.
|
|||
void set_expected_height(int expected) { expected_height_ = expected; } |
|||
|
|||
// Uses the current frame to set the expected height.
|
|||
void SetExpectedHeight(); |
|||
|
|||
private: |
|||
// The expected height of the expression stack where the target will
|
|||
// be bound, statically known at initialization time.
|
|||
int expected_height_; |
|||
}; |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_JUMP_TARGET_LIGHT_H_
|
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue