mirror of https://github.com/lukechilds/node.git
Ryan Dahl
15 years ago
213 changed files with 23731 additions and 4858 deletions
File diff suppressed because it is too large
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,87 @@ |
|||
// 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 "liveedit.h" |
|||
#include "compiler.h" |
|||
#include "oprofile-agent.h" |
|||
#include "scopes.h" |
|||
#include "global-handles.h" |
|||
#include "debug.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
|
|||
class FunctionInfoListener { |
|||
public: |
|||
void FunctionStarted(FunctionLiteral* fun) { |
|||
// Implementation follows.
|
|||
} |
|||
|
|||
void FunctionDone() { |
|||
// Implementation follows.
|
|||
} |
|||
|
|||
void FunctionScope(Scope* scope) { |
|||
// Implementation follows.
|
|||
} |
|||
|
|||
void FunctionCode(Handle<Code> function_code) { |
|||
// Implementation follows.
|
|||
} |
|||
}; |
|||
|
|||
static FunctionInfoListener* active_function_info_listener = NULL; |
|||
|
|||
LiveEditFunctionTracker::LiveEditFunctionTracker(FunctionLiteral* fun) { |
|||
if (active_function_info_listener != NULL) { |
|||
active_function_info_listener->FunctionStarted(fun); |
|||
} |
|||
} |
|||
LiveEditFunctionTracker::~LiveEditFunctionTracker() { |
|||
if (active_function_info_listener != NULL) { |
|||
active_function_info_listener->FunctionDone(); |
|||
} |
|||
} |
|||
void LiveEditFunctionTracker::RecordFunctionCode(Handle<Code> code) { |
|||
if (active_function_info_listener != NULL) { |
|||
active_function_info_listener->FunctionCode(code); |
|||
} |
|||
} |
|||
void LiveEditFunctionTracker::RecordFunctionScope(Scope* scope) { |
|||
if (active_function_info_listener != NULL) { |
|||
active_function_info_listener->FunctionScope(scope); |
|||
} |
|||
} |
|||
bool LiveEditFunctionTracker::IsActive() { |
|||
return active_function_info_listener != NULL; |
|||
} |
|||
|
|||
} } // namespace v8::internal
|
|||
@ -0,0 +1,78 @@ |
|||
// 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_LIVEEDIT_H_ |
|||
#define V8_LIVEEDIT_H_ |
|||
|
|||
|
|||
|
|||
// Live Edit feature implementation.
|
|||
// User should be able to change script on already running VM. This feature
|
|||
// matches hot swap features in other frameworks.
|
|||
//
|
|||
// The basic use-case is when user spots some mistake in function body
|
|||
// from debugger and wishes to change the algorithm without restart.
|
|||
//
|
|||
// A single change always has a form of a simple replacement (in pseudo-code):
|
|||
// script.source[positions, positions+length] = new_string;
|
|||
// Implementation first determines, which function's body includes this
|
|||
// change area. Then both old and new versions of script are fully compiled
|
|||
// in order to analyze, whether the function changed its outer scope
|
|||
// expectations (or number of parameters). If it didn't, function's code is
|
|||
// patched with a newly compiled code. If it did change, enclosing function
|
|||
// gets patched. All inner functions are left untouched, whatever happened
|
|||
// to them in a new script version. However, new version of code will
|
|||
// instantiate newly compiled functions.
|
|||
|
|||
|
|||
#include "compiler.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
// This class collects some specific information on structure of functions
|
|||
// in a particular script. It gets called from compiler all the time, but
|
|||
// actually records any data only when liveedit operation is in process;
|
|||
// in any other time this class is very cheap.
|
|||
//
|
|||
// The primary interest of the Tracker is to record function scope structures
|
|||
// in order to analyze whether function code maybe safely patched (with new
|
|||
// code successfully reading existing data from function scopes). The Tracker
|
|||
// also collects compiled function codes.
|
|||
class LiveEditFunctionTracker { |
|||
public: |
|||
explicit LiveEditFunctionTracker(FunctionLiteral* fun); |
|||
~LiveEditFunctionTracker(); |
|||
void RecordFunctionCode(Handle<Code> code); |
|||
void RecordFunctionScope(Scope* scope); |
|||
|
|||
static bool IsActive(); |
|||
}; |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif /* V*_LIVEEDIT_H_ */ |
|||
@ -0,0 +1,215 @@ |
|||
// 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 2010 the V8 project authors. All rights reserved.
|
|||
|
|||
|
|||
#ifndef V8_MIPS_ASSEMBLER_MIPS_INL_H_ |
|||
#define V8_MIPS_ASSEMBLER_MIPS_INL_H_ |
|||
|
|||
#include "mips/assembler-mips.h" |
|||
#include "cpu.h" |
|||
|
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
// -----------------------------------------------------------------------------
|
|||
// Condition
|
|||
|
|||
Condition NegateCondition(Condition cc) { |
|||
ASSERT(cc != cc_always); |
|||
return static_cast<Condition>(cc ^ 1); |
|||
} |
|||
|
|||
|
|||
// -----------------------------------------------------------------------------
|
|||
// Operand and MemOperand
|
|||
|
|||
Operand::Operand(int32_t immediate, RelocInfo::Mode rmode) { |
|||
rm_ = no_reg; |
|||
imm32_ = immediate; |
|||
rmode_ = rmode; |
|||
} |
|||
|
|||
Operand::Operand(const ExternalReference& f) { |
|||
rm_ = no_reg; |
|||
imm32_ = reinterpret_cast<int32_t>(f.address()); |
|||
rmode_ = RelocInfo::EXTERNAL_REFERENCE; |
|||
} |
|||
|
|||
Operand::Operand(const char* s) { |
|||
rm_ = no_reg; |
|||
imm32_ = reinterpret_cast<int32_t>(s); |
|||
rmode_ = RelocInfo::EMBEDDED_STRING; |
|||
} |
|||
|
|||
Operand::Operand(Smi* value) { |
|||
rm_ = no_reg; |
|||
imm32_ = reinterpret_cast<intptr_t>(value); |
|||
rmode_ = RelocInfo::NONE; |
|||
} |
|||
|
|||
Operand::Operand(Register rm) { |
|||
rm_ = rm; |
|||
} |
|||
|
|||
bool Operand::is_reg() const { |
|||
return rm_.is_valid(); |
|||
} |
|||
|
|||
|
|||
|
|||
// -----------------------------------------------------------------------------
|
|||
// RelocInfo
|
|||
|
|||
void RelocInfo::apply(intptr_t delta) { |
|||
// On MIPS we do not use pc relative addressing, so we don't need to patch the
|
|||
// code here.
|
|||
} |
|||
|
|||
|
|||
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>(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 reinterpret_cast<Object*>(Assembler::target_address_at(pc_)); |
|||
} |
|||
|
|||
|
|||
Handle<Object> RelocInfo::target_object_handle(Assembler *origin) { |
|||
ASSERT(IsCodeTarget(rmode_) || rmode_ == EMBEDDED_OBJECT); |
|||
return Handle<Object>(reinterpret_cast<Object**>( |
|||
Assembler::target_address_at(pc_))); |
|||
} |
|||
|
|||
|
|||
Object** RelocInfo::target_object_address() { |
|||
ASSERT(IsCodeTarget(rmode_) || rmode_ == EMBEDDED_OBJECT); |
|||
return reinterpret_cast<Object**>(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*>(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() { |
|||
#ifdef DEBUG |
|||
PrintF("%s - %d - %s : Checking for jal(r)", |
|||
__FILE__, __LINE__, __func__); |
|||
#endif |
|||
return ((Assembler::instr_at(pc_) & kOpcodeMask) == SPECIAL) && |
|||
(((Assembler::instr_at(pc_) & kFunctionFieldMask) == JAL) || |
|||
((Assembler::instr_at(pc_) & kFunctionFieldMask) == JALR)); |
|||
} |
|||
|
|||
|
|||
// -----------------------------------------------------------------------------
|
|||
// Assembler
|
|||
|
|||
|
|||
void Assembler::CheckBuffer() { |
|||
if (buffer_space() <= kGap) { |
|||
GrowBuffer(); |
|||
} |
|||
} |
|||
|
|||
|
|||
void Assembler::emit(Instr x) { |
|||
CheckBuffer(); |
|||
*reinterpret_cast<Instr*>(pc_) = x; |
|||
pc_ += kInstrSize; |
|||
} |
|||
|
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_MIPS_ASSEMBLER_MIPS_INL_H_
|
|||
File diff suppressed because it is too large
@ -0,0 +1,663 @@ |
|||
// 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 2010 the V8 project authors. All rights reserved.
|
|||
|
|||
|
|||
#ifndef V8_MIPS_ASSEMBLER_MIPS_H_ |
|||
#define V8_MIPS_ASSEMBLER_MIPS_H_ |
|||
|
|||
#include <stdio.h> |
|||
#include "assembler.h" |
|||
#include "constants-mips.h" |
|||
#include "serialize.h" |
|||
|
|||
using namespace assembler::mips; |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
// CPU Registers.
|
|||
//
|
|||
// 1) We would prefer to use an enum, but enum values are assignment-
|
|||
// compatible with int, which has caused code-generation bugs.
|
|||
//
|
|||
// 2) We would prefer to use a class instead of a struct but we don't like
|
|||
// the register initialization to depend on the particular initialization
|
|||
// order (which appears to be different on OS X, Linux, and Windows for the
|
|||
// installed versions of C++ we tried). Using a struct permits C-style
|
|||
// "initialization". Also, the Register objects cannot be const as this
|
|||
// forces initialization stubs in MSVC, making us dependent on initialization
|
|||
// order.
|
|||
//
|
|||
// 3) By not using an enum, we are possibly preventing the compiler from
|
|||
// doing certain constant folds, which may significantly reduce the
|
|||
// code generated for some assembly instructions (because they boil down
|
|||
// to a few constants). If this is a problem, we could change the code
|
|||
// such that we use an enum in optimized mode, and the struct in debug
|
|||
// mode. This way we get the compile-time error checking in debug mode
|
|||
// and best performance in optimized code.
|
|||
|
|||
|
|||
// -----------------------------------------------------------------------------
|
|||
// Implementation of Register and FPURegister
|
|||
|
|||
// Core register.
|
|||
struct Register { |
|||
bool is_valid() const { return 0 <= code_ && code_ < kNumRegisters; } |
|||
bool is(Register reg) const { return code_ == reg.code_; } |
|||
int code() const { |
|||
ASSERT(is_valid()); |
|||
return code_; |
|||
} |
|||
int bit() const { |
|||
ASSERT(is_valid()); |
|||
return 1 << code_; |
|||
} |
|||
|
|||
// Unfortunately we can't make this private in a struct.
|
|||
int code_; |
|||
}; |
|||
|
|||
extern const Register no_reg; |
|||
|
|||
extern const Register zero_reg; |
|||
extern const Register at; |
|||
extern const Register v0; |
|||
extern const Register v1; |
|||
extern const Register a0; |
|||
extern const Register a1; |
|||
extern const Register a2; |
|||
extern const Register a3; |
|||
extern const Register t0; |
|||
extern const Register t1; |
|||
extern const Register t2; |
|||
extern const Register t3; |
|||
extern const Register t4; |
|||
extern const Register t5; |
|||
extern const Register t6; |
|||
extern const Register t7; |
|||
extern const Register s0; |
|||
extern const Register s1; |
|||
extern const Register s2; |
|||
extern const Register s3; |
|||
extern const Register s4; |
|||
extern const Register s5; |
|||
extern const Register s6; |
|||
extern const Register s7; |
|||
extern const Register t8; |
|||
extern const Register t9; |
|||
extern const Register k0; |
|||
extern const Register k1; |
|||
extern const Register gp; |
|||
extern const Register sp; |
|||
extern const Register s8_fp; |
|||
extern const Register ra; |
|||
|
|||
int ToNumber(Register reg); |
|||
|
|||
Register ToRegister(int num); |
|||
|
|||
// Coprocessor register.
|
|||
struct FPURegister { |
|||
bool is_valid() const { return 0 <= code_ && code_ < kNumFPURegister ; } |
|||
bool is(FPURegister creg) const { return code_ == creg.code_; } |
|||
int code() const { |
|||
ASSERT(is_valid()); |
|||
return code_; |
|||
} |
|||
int bit() const { |
|||
ASSERT(is_valid()); |
|||
return 1 << code_; |
|||
} |
|||
|
|||
// Unfortunately we can't make this private in a struct.
|
|||
int code_; |
|||
}; |
|||
|
|||
extern const FPURegister no_creg; |
|||
|
|||
extern const FPURegister f0; |
|||
extern const FPURegister f1; |
|||
extern const FPURegister f2; |
|||
extern const FPURegister f3; |
|||
extern const FPURegister f4; |
|||
extern const FPURegister f5; |
|||
extern const FPURegister f6; |
|||
extern const FPURegister f7; |
|||
extern const FPURegister f8; |
|||
extern const FPURegister f9; |
|||
extern const FPURegister f10; |
|||
extern const FPURegister f11; |
|||
extern const FPURegister f12; // arg
|
|||
extern const FPURegister f13; |
|||
extern const FPURegister f14; // arg
|
|||
extern const FPURegister f15; |
|||
extern const FPURegister f16; |
|||
extern const FPURegister f17; |
|||
extern const FPURegister f18; |
|||
extern const FPURegister f19; |
|||
extern const FPURegister f20; |
|||
extern const FPURegister f21; |
|||
extern const FPURegister f22; |
|||
extern const FPURegister f23; |
|||
extern const FPURegister f24; |
|||
extern const FPURegister f25; |
|||
extern const FPURegister f26; |
|||
extern const FPURegister f27; |
|||
extern const FPURegister f28; |
|||
extern const FPURegister f29; |
|||
extern const FPURegister f30; |
|||
extern const FPURegister f31; |
|||
|
|||
|
|||
// Returns the equivalent of !cc.
|
|||
// Negation of the default no_condition (-1) results in a non-default
|
|||
// no_condition value (-2). As long as tests for no_condition check
|
|||
// for condition < 0, this will work as expected.
|
|||
inline Condition NegateCondition(Condition cc); |
|||
|
|||
inline Condition ReverseCondition(Condition cc) { |
|||
switch (cc) { |
|||
case Uless: |
|||
return Ugreater; |
|||
case Ugreater: |
|||
return Uless; |
|||
case Ugreater_equal: |
|||
return Uless_equal; |
|||
case Uless_equal: |
|||
return Ugreater_equal; |
|||
case less: |
|||
return greater; |
|||
case greater: |
|||
return less; |
|||
case greater_equal: |
|||
return less_equal; |
|||
case less_equal: |
|||
return greater_equal; |
|||
default: |
|||
return cc; |
|||
}; |
|||
} |
|||
|
|||
|
|||
enum Hint { |
|||
no_hint = 0 |
|||
}; |
|||
|
|||
inline Hint NegateHint(Hint hint) { |
|||
return no_hint; |
|||
} |
|||
|
|||
|
|||
// -----------------------------------------------------------------------------
|
|||
// Machine instruction Operands.
|
|||
|
|||
// Class Operand represents a shifter operand in data processing instructions.
|
|||
class Operand BASE_EMBEDDED { |
|||
public: |
|||
// Immediate.
|
|||
INLINE(explicit Operand(int32_t immediate, |
|||
RelocInfo::Mode rmode = RelocInfo::NONE)); |
|||
INLINE(explicit Operand(const ExternalReference& f)); |
|||
INLINE(explicit Operand(const char* s)); |
|||
INLINE(explicit Operand(Object** opp)); |
|||
INLINE(explicit Operand(Context** cpp)); |
|||
explicit Operand(Handle<Object> handle); |
|||
INLINE(explicit Operand(Smi* value)); |
|||
|
|||
// Register.
|
|||
INLINE(explicit Operand(Register rm)); |
|||
|
|||
// Return true if this is a register operand.
|
|||
INLINE(bool is_reg() const); |
|||
|
|||
Register rm() const { return rm_; } |
|||
|
|||
private: |
|||
Register rm_; |
|||
int32_t imm32_; // Valid if rm_ == no_reg
|
|||
RelocInfo::Mode rmode_; |
|||
|
|||
friend class Assembler; |
|||
friend class MacroAssembler; |
|||
}; |
|||
|
|||
|
|||
// On MIPS we have only one adressing mode with base_reg + offset.
|
|||
// Class MemOperand represents a memory operand in load and store instructions.
|
|||
class MemOperand : public Operand { |
|||
public: |
|||
|
|||
explicit MemOperand(Register rn, int16_t offset = 0); |
|||
|
|||
private: |
|||
int16_t offset_; |
|||
|
|||
friend class Assembler; |
|||
}; |
|||
|
|||
|
|||
class Assembler : public Malloced { |
|||
public: |
|||
// Create an assembler. Instructions and relocation information are emitted
|
|||
// into a buffer, with the instructions starting from the beginning and the
|
|||
// relocation information starting from the end of the buffer. See CodeDesc
|
|||
// for a detailed comment on the layout (globals.h).
|
|||
//
|
|||
// If the provided buffer is NULL, the assembler allocates and grows its own
|
|||
// buffer, and buffer_size determines the initial buffer size. The buffer is
|
|||
// owned by the assembler and deallocated upon destruction of the assembler.
|
|||
//
|
|||
// If the provided buffer is not NULL, the assembler uses the provided buffer
|
|||
// for code generation and assumes its size to be buffer_size. If the buffer
|
|||
// is too small, a fatal error occurs. No deallocation of the buffer is done
|
|||
// upon destruction of the assembler.
|
|||
Assembler(void* buffer, int buffer_size); |
|||
~Assembler(); |
|||
|
|||
// GetCode emits any pending (non-emitted) code and fills the descriptor
|
|||
// desc. GetCode() is idempotent; it returns the same result if no other
|
|||
// Assembler functions are invoked in between GetCode() calls.
|
|||
void GetCode(CodeDesc* desc); |
|||
|
|||
// Label operations & relative jumps (PPUM Appendix D).
|
|||
//
|
|||
// Takes a branch opcode (cc) and a label (L) and generates
|
|||
// either a backward branch or a forward branch and links it
|
|||
// to the label fixup chain. Usage:
|
|||
//
|
|||
// Label L; // unbound label
|
|||
// j(cc, &L); // forward branch to unbound label
|
|||
// bind(&L); // bind label to the current pc
|
|||
// j(cc, &L); // backward branch to bound label
|
|||
// bind(&L); // illegal: a label may be bound only once
|
|||
//
|
|||
// Note: The same Label can be used for forward and backward branches
|
|||
// but it may be bound only once.
|
|||
void bind(Label* L); // binds an unbound label L to the current code position
|
|||
|
|||
// Returns the branch offset to the given label from the current code position
|
|||
// Links the label to the current position if it is still unbound
|
|||
// Manages the jump elimination optimization if the second parameter is true.
|
|||
int32_t branch_offset(Label* L, bool jump_elimination_allowed); |
|||
int32_t shifted_branch_offset(Label* L, bool jump_elimination_allowed) { |
|||
int32_t o = branch_offset(L, jump_elimination_allowed); |
|||
ASSERT((o & 3) == 0); // Assert the offset is aligned.
|
|||
return o >> 2; |
|||
} |
|||
|
|||
// Puts a labels target address at the given position.
|
|||
// The high 8 bits are set to zero.
|
|||
void label_at_put(Label* L, int at_offset); |
|||
|
|||
// Size of an instruction.
|
|||
static const int kInstrSize = sizeof(Instr); |
|||
|
|||
// Difference between address of current opcode and target address offset.
|
|||
static const int kBranchPCOffset = 4; |
|||
|
|||
// Read/Modify the code target address in the branch/call instruction at pc.
|
|||
static Address target_address_at(Address pc); |
|||
static void set_target_address_at(Address pc, Address target); |
|||
|
|||
// This sets the branch destination (which gets loaded at the call address).
|
|||
// This is for calls and branches within generated code.
|
|||
inline static void set_target_at(Address instruction_payload, |
|||
Address target) { |
|||
set_target_address_at(instruction_payload, target); |
|||
} |
|||
|
|||
// This sets the branch destination.
|
|||
// This is for calls and branches to runtime code.
|
|||
inline static void set_external_target_at(Address instruction_payload, |
|||
Address target) { |
|||
set_target_address_at(instruction_payload, target); |
|||
} |
|||
|
|||
static const int kCallTargetSize = 3 * kPointerSize; |
|||
static const int kExternalTargetSize = 3 * kPointerSize; |
|||
|
|||
// Distance between the instruction referring to the address of the call
|
|||
// target and the return address.
|
|||
static const int kCallTargetAddressOffset = 4 * kInstrSize; |
|||
|
|||
// Distance between start of patched return sequence and the emitted address
|
|||
// to jump to.
|
|||
static const int kPatchReturnSequenceAddressOffset = kInstrSize; |
|||
|
|||
|
|||
// ---------------------------------------------------------------------------
|
|||
// Code generation.
|
|||
|
|||
void nop() { sll(zero_reg, zero_reg, 0); } |
|||
|
|||
|
|||
//------- Branch and jump instructions --------
|
|||
// We don't use likely variant of instructions.
|
|||
void b(int16_t offset); |
|||
void b(Label* L) { b(branch_offset(L, false)>>2); } |
|||
void bal(int16_t offset); |
|||
void bal(Label* L) { bal(branch_offset(L, false)>>2); } |
|||
|
|||
void beq(Register rs, Register rt, int16_t offset); |
|||
void beq(Register rs, Register rt, Label* L) { |
|||
beq(rs, rt, branch_offset(L, false) >> 2); |
|||
} |
|||
void bgez(Register rs, int16_t offset); |
|||
void bgezal(Register rs, int16_t offset); |
|||
void bgtz(Register rs, int16_t offset); |
|||
void blez(Register rs, int16_t offset); |
|||
void bltz(Register rs, int16_t offset); |
|||
void bltzal(Register rs, int16_t offset); |
|||
void bne(Register rs, Register rt, int16_t offset); |
|||
void bne(Register rs, Register rt, Label* L) { |
|||
bne(rs, rt, branch_offset(L, false)>>2); |
|||
} |
|||
|
|||
// Never use the int16_t b(l)cond version with a branch offset
|
|||
// instead of using the Label* version. See Twiki for infos.
|
|||
|
|||
// Jump targets must be in the current 256 MB-aligned region. ie 28 bits.
|
|||
void j(int32_t target); |
|||
void jal(int32_t target); |
|||
void jalr(Register rs, Register rd = ra); |
|||
void jr(Register target); |
|||
|
|||
|
|||
//-------Data-processing-instructions---------
|
|||
|
|||
// Arithmetic.
|
|||
void add(Register rd, Register rs, Register rt); |
|||
void addu(Register rd, Register rs, Register rt); |
|||
void sub(Register rd, Register rs, Register rt); |
|||
void subu(Register rd, Register rs, Register rt); |
|||
void mult(Register rs, Register rt); |
|||
void multu(Register rs, Register rt); |
|||
void div(Register rs, Register rt); |
|||
void divu(Register rs, Register rt); |
|||
void mul(Register rd, Register rs, Register rt); |
|||
|
|||
void addi(Register rd, Register rs, int32_t j); |
|||
void addiu(Register rd, Register rs, int32_t j); |
|||
|
|||
// Logical.
|
|||
void and_(Register rd, Register rs, Register rt); |
|||
void or_(Register rd, Register rs, Register rt); |
|||
void xor_(Register rd, Register rs, Register rt); |
|||
void nor(Register rd, Register rs, Register rt); |
|||
|
|||
void andi(Register rd, Register rs, int32_t j); |
|||
void ori(Register rd, Register rs, int32_t j); |
|||
void xori(Register rd, Register rs, int32_t j); |
|||
void lui(Register rd, int32_t j); |
|||
|
|||
// Shifts.
|
|||
void sll(Register rd, Register rt, uint16_t sa); |
|||
void sllv(Register rd, Register rt, Register rs); |
|||
void srl(Register rd, Register rt, uint16_t sa); |
|||
void srlv(Register rd, Register rt, Register rs); |
|||
void sra(Register rt, Register rd, uint16_t sa); |
|||
void srav(Register rt, Register rd, Register rs); |
|||
|
|||
|
|||
//------------Memory-instructions-------------
|
|||
|
|||
void lb(Register rd, const MemOperand& rs); |
|||
void lbu(Register rd, const MemOperand& rs); |
|||
void lw(Register rd, const MemOperand& rs); |
|||
void sb(Register rd, const MemOperand& rs); |
|||
void sw(Register rd, const MemOperand& rs); |
|||
|
|||
|
|||
//-------------Misc-instructions--------------
|
|||
|
|||
// Break / Trap instructions.
|
|||
void break_(uint32_t code); |
|||
void tge(Register rs, Register rt, uint16_t code); |
|||
void tgeu(Register rs, Register rt, uint16_t code); |
|||
void tlt(Register rs, Register rt, uint16_t code); |
|||
void tltu(Register rs, Register rt, uint16_t code); |
|||
void teq(Register rs, Register rt, uint16_t code); |
|||
void tne(Register rs, Register rt, uint16_t code); |
|||
|
|||
// Move from HI/LO register.
|
|||
void mfhi(Register rd); |
|||
void mflo(Register rd); |
|||
|
|||
// Set on less than.
|
|||
void slt(Register rd, Register rs, Register rt); |
|||
void sltu(Register rd, Register rs, Register rt); |
|||
void slti(Register rd, Register rs, int32_t j); |
|||
void sltiu(Register rd, Register rs, int32_t j); |
|||
|
|||
|
|||
//--------Coprocessor-instructions----------------
|
|||
|
|||
// Load, store, and move.
|
|||
void lwc1(FPURegister fd, const MemOperand& src); |
|||
void ldc1(FPURegister fd, const MemOperand& src); |
|||
|
|||
void swc1(FPURegister fs, const MemOperand& dst); |
|||
void sdc1(FPURegister fs, const MemOperand& dst); |
|||
|
|||
// When paired with MTC1 to write a value to a 64-bit FPR, the MTC1 must be
|
|||
// executed first, followed by the MTHC1.
|
|||
void mtc1(FPURegister fs, Register rt); |
|||
void mthc1(FPURegister fs, Register rt); |
|||
void mfc1(FPURegister fs, Register rt); |
|||
void mfhc1(FPURegister fs, Register rt); |
|||
|
|||
// Conversion.
|
|||
void cvt_w_s(FPURegister fd, FPURegister fs); |
|||
void cvt_w_d(FPURegister fd, FPURegister fs); |
|||
|
|||
void cvt_l_s(FPURegister fd, FPURegister fs); |
|||
void cvt_l_d(FPURegister fd, FPURegister fs); |
|||
|
|||
void cvt_s_w(FPURegister fd, FPURegister fs); |
|||
void cvt_s_l(FPURegister fd, FPURegister fs); |
|||
void cvt_s_d(FPURegister fd, FPURegister fs); |
|||
|
|||
void cvt_d_w(FPURegister fd, FPURegister fs); |
|||
void cvt_d_l(FPURegister fd, FPURegister fs); |
|||
void cvt_d_s(FPURegister fd, FPURegister fs); |
|||
|
|||
// Conditions and branches.
|
|||
void c(FPUCondition cond, SecondaryField fmt, |
|||
FPURegister ft, FPURegister fs, uint16_t cc = 0); |
|||
|
|||
void bc1f(int16_t offset, uint16_t cc = 0); |
|||
void bc1f(Label* L, uint16_t cc = 0) { bc1f(branch_offset(L, false)>>2, cc); } |
|||
void bc1t(int16_t offset, uint16_t cc = 0); |
|||
void bc1t(Label* L, uint16_t cc = 0) { bc1t(branch_offset(L, false)>>2, cc); } |
|||
|
|||
|
|||
// Check the code size generated from label to here.
|
|||
int InstructionsGeneratedSince(Label* l) { |
|||
return (pc_offset() - l->pos()) / kInstrSize; |
|||
} |
|||
|
|||
// Debugging.
|
|||
|
|||
// Mark address of the ExitJSFrame code.
|
|||
void RecordJSReturn(); |
|||
|
|||
// Record a comment relocation entry that can be used by a disassembler.
|
|||
// Use --debug_code to enable.
|
|||
void RecordComment(const char* msg); |
|||
|
|||
void RecordPosition(int pos); |
|||
void RecordStatementPosition(int pos); |
|||
void WriteRecordedPositions(); |
|||
|
|||
int32_t pc_offset() const { return pc_ - buffer_; } |
|||
int32_t current_position() const { return current_position_; } |
|||
int32_t current_statement_position() const { return current_position_; } |
|||
|
|||
// Check if there is less than kGap bytes available in the buffer.
|
|||
// If this is the case, we need to grow the buffer before emitting
|
|||
// an instruction or relocation information.
|
|||
inline bool overflow() const { return pc_ >= reloc_info_writer.pos() - kGap; } |
|||
|
|||
// Get the number of bytes available in the buffer.
|
|||
inline int available_space() const { return reloc_info_writer.pos() - pc_; } |
|||
|
|||
protected: |
|||
int32_t buffer_space() const { return reloc_info_writer.pos() - pc_; } |
|||
|
|||
// Read/patch instructions.
|
|||
static Instr instr_at(byte* pc) { return *reinterpret_cast<Instr*>(pc); } |
|||
void instr_at_put(byte* pc, Instr instr) { |
|||
*reinterpret_cast<Instr*>(pc) = instr; |
|||
} |
|||
Instr instr_at(int pos) { return *reinterpret_cast<Instr*>(buffer_ + pos); } |
|||
void instr_at_put(int pos, Instr instr) { |
|||
*reinterpret_cast<Instr*>(buffer_ + pos) = instr; |
|||
} |
|||
|
|||
// Check if an instruction is a branch of some kind.
|
|||
bool is_branch(Instr instr); |
|||
|
|||
// Decode branch instruction at pos and return branch target pos.
|
|||
int target_at(int32_t pos); |
|||
|
|||
// Patch branch instruction at pos to branch to given branch target pos.
|
|||
void target_at_put(int32_t pos, int32_t target_pos); |
|||
|
|||
// Say if we need to relocate with this mode.
|
|||
bool MustUseAt(RelocInfo::Mode rmode); |
|||
|
|||
// Record reloc info for current pc_.
|
|||
void RecordRelocInfo(RelocInfo::Mode rmode, intptr_t data = 0); |
|||
|
|||
private: |
|||
// Code buffer:
|
|||
// The buffer into which code and relocation info are generated.
|
|||
byte* buffer_; |
|||
int buffer_size_; |
|||
// True if the assembler owns the buffer, false if buffer is external.
|
|||
bool own_buffer_; |
|||
|
|||
// Buffer size and constant pool distance are checked together at regular
|
|||
// intervals of kBufferCheckInterval emitted bytes.
|
|||
static const int kBufferCheckInterval = 1*KB/2; |
|||
|
|||
// Code generation.
|
|||
// The relocation writer's position is at least kGap bytes below the end of
|
|||
// the generated instructions. This is so that multi-instruction sequences do
|
|||
// not have to check for overflow. The same is true for writes of large
|
|||
// relocation info entries.
|
|||
static const int kGap = 32; |
|||
byte* pc_; // The program counter - moves forward.
|
|||
|
|||
// Relocation information generation.
|
|||
// Each relocation is encoded as a variable size value.
|
|||
static const int kMaxRelocSize = RelocInfoWriter::kMaxSize; |
|||
RelocInfoWriter reloc_info_writer; |
|||
|
|||
// The bound position, before this we cannot do instruction elimination.
|
|||
int last_bound_pos_; |
|||
|
|||
// Source position information.
|
|||
int current_position_; |
|||
int current_statement_position_; |
|||
int written_position_; |
|||
int written_statement_position_; |
|||
|
|||
// Code emission.
|
|||
inline void CheckBuffer(); |
|||
void GrowBuffer(); |
|||
inline void emit(Instr x); |
|||
|
|||
// Instruction generation.
|
|||
// We have 3 different kind of encoding layout on MIPS.
|
|||
// However due to many different types of objects encoded in the same fields
|
|||
// we have quite a few aliases for each mode.
|
|||
// Using the same structure to refer to Register and FPURegister would spare a
|
|||
// few aliases, but mixing both does not look clean to me.
|
|||
// Anyway we could surely implement this differently.
|
|||
|
|||
void GenInstrRegister(Opcode opcode, |
|||
Register rs, |
|||
Register rt, |
|||
Register rd, |
|||
uint16_t sa = 0, |
|||
SecondaryField func = NULLSF); |
|||
|
|||
void GenInstrRegister(Opcode opcode, |
|||
SecondaryField fmt, |
|||
FPURegister ft, |
|||
FPURegister fs, |
|||
FPURegister fd, |
|||
SecondaryField func = NULLSF); |
|||
|
|||
void GenInstrRegister(Opcode opcode, |
|||
SecondaryField fmt, |
|||
Register rt, |
|||
FPURegister fs, |
|||
FPURegister fd, |
|||
SecondaryField func = NULLSF); |
|||
|
|||
|
|||
void GenInstrImmediate(Opcode opcode, |
|||
Register rs, |
|||
Register rt, |
|||
int32_t j); |
|||
void GenInstrImmediate(Opcode opcode, |
|||
Register rs, |
|||
SecondaryField SF, |
|||
int32_t j); |
|||
void GenInstrImmediate(Opcode opcode, |
|||
Register r1, |
|||
FPURegister r2, |
|||
int32_t j); |
|||
|
|||
|
|||
void GenInstrJump(Opcode opcode, |
|||
uint32_t address); |
|||
|
|||
|
|||
// Labels.
|
|||
void print(Label* L); |
|||
void bind_to(Label* L, int pos); |
|||
void link_to(Label* L, Label* appendix); |
|||
void next(Label* L); |
|||
|
|||
friend class RegExpMacroAssemblerMIPS; |
|||
friend class RelocInfo; |
|||
}; |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_ARM_ASSEMBLER_MIPS_H_
|
|||
|
|||
@ -0,0 +1,109 @@ |
|||
// 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 "codegen-inl.h" |
|||
#include "debug.h" |
|||
#include "runtime.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
|
|||
#define __ ACCESS_MASM(masm) |
|||
|
|||
|
|||
void Builtins::Generate_Adaptor(MacroAssembler* masm, |
|||
CFunctionId id, |
|||
BuiltinExtraArguments extra_args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void Builtins::Generate_ArrayCode(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void Builtins::Generate_ArrayConstructCode(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void Builtins::Generate_JSConstructCall(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void Builtins::Generate_JSConstructStubGeneric(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void Builtins::Generate_JSConstructStubApi(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm, |
|||
bool is_construct) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void Builtins::Generate_JSEntryTrampoline(MacroAssembler* masm) { |
|||
Generate_JSEntryTrampolineHelper(masm, false); |
|||
} |
|||
|
|||
|
|||
void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) { |
|||
Generate_JSEntryTrampolineHelper(masm, true); |
|||
} |
|||
|
|||
|
|||
void Builtins::Generate_FunctionCall(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void Builtins::Generate_FunctionApply(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
#undef __ |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
@ -0,0 +1,56 @@ |
|||
// 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_MIPS_CODEGEN_MIPS_INL_H_ |
|||
#define V8_MIPS_CODEGEN_MIPS_INL_H_ |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
#define __ ACCESS_MASM(masm_) |
|||
|
|||
// Platform-specific inline functions.
|
|||
|
|||
void DeferredCode::Jump() { __ b(&entry_label_); } |
|||
|
|||
void CodeGenerator::GenerateMathSin(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateMathCos(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
#undef __ |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_MIPS_CODEGEN_MIPS_INL_H_
|
|||
|
|||
@ -0,0 +1,501 @@ |
|||
// 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 "bootstrapper.h" |
|||
#include "codegen-inl.h" |
|||
#include "debug.h" |
|||
#include "parser.h" |
|||
#include "register-allocator-inl.h" |
|||
#include "runtime.h" |
|||
#include "scopes.h" |
|||
#include "compiler.h" |
|||
|
|||
|
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
#define __ ACCESS_MASM(masm_) |
|||
|
|||
|
|||
|
|||
// -------------------------------------------------------------------------
|
|||
// Platform-specific DeferredCode functions.
|
|||
|
|||
|
|||
void DeferredCode::SaveRegisters() { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void DeferredCode::RestoreRegisters() { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
// -------------------------------------------------------------------------
|
|||
// CodeGenerator implementation
|
|||
|
|||
CodeGenerator::CodeGenerator(MacroAssembler* masm) |
|||
: deferred_(8), |
|||
masm_(masm), |
|||
scope_(NULL), |
|||
frame_(NULL), |
|||
allocator_(NULL), |
|||
cc_reg_(cc_always), |
|||
state_(NULL), |
|||
function_return_is_shadowed_(false) { |
|||
} |
|||
|
|||
|
|||
// Calling conventions:
|
|||
// s8_fp: caller's frame pointer
|
|||
// sp: stack pointer
|
|||
// a1: called JS function
|
|||
// cp: callee's context
|
|||
|
|||
void CodeGenerator::Generate(CompilationInfo* info, Mode mode) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitStatements(ZoneList<Statement*>* statements) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitBlock(Block* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitDeclaration(Declaration* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitExpressionStatement(ExpressionStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitEmptyStatement(EmptyStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitIfStatement(IfStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitContinueStatement(ContinueStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitBreakStatement(BreakStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitReturnStatement(ReturnStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitWithEnterStatement(WithEnterStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitWithExitStatement(WithExitStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitSwitchStatement(SwitchStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitDoWhileStatement(DoWhileStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitWhileStatement(WhileStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitForStatement(ForStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitForInStatement(ForInStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitTryCatchStatement(TryCatchStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitDebuggerStatement(DebuggerStatement* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitFunctionLiteral(FunctionLiteral* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitFunctionBoilerplateLiteral( |
|||
FunctionBoilerplateLiteral* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitConditional(Conditional* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitSlot(Slot* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitVariableProxy(VariableProxy* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitLiteral(Literal* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitRegExpLiteral(RegExpLiteral* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitObjectLiteral(ObjectLiteral* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitArrayLiteral(ArrayLiteral* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitCatchExtensionObject(CatchExtensionObject* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitAssignment(Assignment* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitThrow(Throw* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitProperty(Property* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitCall(Call* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitCallNew(CallNew* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateClassOf(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateValueOf(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateSetValueOf(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateIsSmi(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateLog(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateIsNonNegativeSmi(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
// This should generate code that performs a charCodeAt() call or returns
|
|||
// undefined in order to trigger the slow case, Runtime_StringCharCodeAt.
|
|||
// It is not yet implemented on ARM, so it always goes to the slow case.
|
|||
void CodeGenerator::GenerateFastCharCodeAt(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateIsArray(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateIsConstructCall(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateArgumentsAccess(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateRandomPositiveSmi(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateObjectEquals(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateIsObject(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateIsFunction(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateIsUndetectableObject(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateStringAdd(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateSubString(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateStringCompare(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::GenerateRegExpExec(ZoneList<Expression*>* args) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitCallRuntime(CallRuntime* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitUnaryOperation(UnaryOperation* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitCountOperation(CountOperation* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitBinaryOperation(BinaryOperation* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitThisFunction(ThisFunction* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
void CodeGenerator::VisitCompareOperation(CompareOperation* node) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
} |
|||
|
|||
|
|||
#ifdef DEBUG |
|||
bool CodeGenerator::HasValidEntryRegisters() { return true; } |
|||
#endif |
|||
|
|||
|
|||
#undef __ |
|||
#define __ ACCESS_MASM(masm) |
|||
|
|||
|
|||
// On entry a0 and a1 are the things to be compared. On exit v0 is 0,
|
|||
// positive or negative to indicate the result of the comparison.
|
|||
void CompareStub::Generate(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
__ break_(0x765); |
|||
} |
|||
|
|||
|
|||
void StackCheckStub::Generate(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
__ break_(0x790); |
|||
} |
|||
|
|||
|
|||
void CEntryStub::GenerateThrowTOS(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
__ break_(0x808); |
|||
} |
|||
|
|||
|
|||
void CEntryStub::GenerateThrowUncatchable(MacroAssembler* masm, |
|||
UncatchableExceptionType type) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
__ break_(0x815); |
|||
} |
|||
|
|||
void CEntryStub::GenerateCore(MacroAssembler* masm, |
|||
Label* throw_normal_exception, |
|||
Label* throw_termination_exception, |
|||
Label* throw_out_of_memory_exception, |
|||
bool do_gc, |
|||
bool always_allocate) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
__ break_(0x826); |
|||
} |
|||
|
|||
void CEntryStub::Generate(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
__ break_(0x831); |
|||
} |
|||
|
|||
void JSEntryStub::GenerateBody(MacroAssembler* masm, bool is_construct) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
// Load a result.
|
|||
__ li(v0, Operand(0x1234)); |
|||
__ jr(ra); |
|||
// Return
|
|||
__ nop(); |
|||
} |
|||
|
|||
|
|||
// This stub performs an instanceof, calling the builtin function if
|
|||
// necessary. Uses a1 for the object, a0 for the function that it may
|
|||
// be an instance of (these are fetched from the stack).
|
|||
void InstanceofStub::Generate(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
__ break_(0x845); |
|||
} |
|||
|
|||
|
|||
void ArgumentsAccessStub::GenerateReadLength(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
__ break_(0x851); |
|||
} |
|||
|
|||
|
|||
void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
__ break_(0x857); |
|||
} |
|||
|
|||
|
|||
void ArgumentsAccessStub::GenerateNewObject(MacroAssembler* masm) { |
|||
UNIMPLEMENTED_MIPS(); |
|||
__ break_(0x863); |
|||
} |
|||
|
|||
|
|||
const char* CompareStub::GetName() { |
|||
UNIMPLEMENTED_MIPS(); |
|||
return NULL; // UNIMPLEMENTED RETURN
|
|||
} |
|||
|
|||
|
|||
int CompareStub::MinorKey() { |
|||
// Encode the two parameters in a unique 16 bit value.
|
|||
ASSERT(static_cast<unsigned>(cc_) >> 28 < (1 << 15)); |
|||
return (static_cast<unsigned>(cc_) >> 27) | (strict_ ? 1 : 0); |
|||
} |
|||
|
|||
|
|||
#undef __ |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue