2008-09-09 20:08:45 +00:00
|
|
|
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
2008-07-03 15:10:15 +00:00
|
|
|
// 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_MACRO_ASSEMBLER_ARM_H_
|
|
|
|
#define V8_MACRO_ASSEMBLER_ARM_H_
|
|
|
|
|
|
|
|
#include "assembler.h"
|
|
|
|
|
|
|
|
namespace v8 { namespace internal {
|
|
|
|
|
|
|
|
|
|
|
|
// Give alias names to registers
|
|
|
|
extern Register cp; // JavaScript context pointer
|
|
|
|
extern Register pp; // parameter pointer
|
|
|
|
|
|
|
|
|
|
|
|
// Helper types to make boolean flag easier to read at call-site.
|
2008-08-06 10:02:49 +00:00
|
|
|
enum InvokeFlag {
|
|
|
|
CALL_FUNCTION,
|
|
|
|
JUMP_FUNCTION
|
|
|
|
};
|
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
enum InvokeJSFlags {
|
|
|
|
CALL_JS,
|
|
|
|
JUMP_JS
|
|
|
|
};
|
|
|
|
|
|
|
|
enum ExitJSFlag {
|
|
|
|
RETURN,
|
|
|
|
DO_NOT_RETURN
|
|
|
|
};
|
|
|
|
|
|
|
|
enum CodeLocation {
|
|
|
|
IN_JAVASCRIPT,
|
|
|
|
IN_JS_ENTRY,
|
|
|
|
IN_C_ENTRY
|
|
|
|
};
|
|
|
|
|
|
|
|
enum HandlerType {
|
|
|
|
TRY_CATCH_HANDLER,
|
|
|
|
TRY_FINALLY_HANDLER,
|
|
|
|
JS_ENTRY_HANDLER
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// MacroAssembler implements a collection of frequently used macros.
|
|
|
|
class MacroAssembler: public Assembler {
|
|
|
|
public:
|
|
|
|
MacroAssembler(void* buffer, int size);
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Low-level helpers for compiler
|
|
|
|
|
|
|
|
// Jump, Call, and Ret pseudo instructions implementing inter-working
|
|
|
|
private:
|
2008-09-22 13:57:03 +00:00
|
|
|
void Jump(intptr_t target, RelocInfo::Mode rmode, Condition cond = al);
|
|
|
|
void Call(intptr_t target, RelocInfo::Mode rmode, Condition cond = al);
|
2008-07-03 15:10:15 +00:00
|
|
|
public:
|
|
|
|
void Jump(Register target, Condition cond = al);
|
2008-09-22 13:57:03 +00:00
|
|
|
void Jump(byte* target, RelocInfo::Mode rmode, Condition cond = al);
|
|
|
|
void Jump(Handle<Code> code, RelocInfo::Mode rmode, Condition cond = al);
|
2008-07-03 15:10:15 +00:00
|
|
|
void Call(Register target, Condition cond = al);
|
2008-09-22 13:57:03 +00:00
|
|
|
void Call(byte* target, RelocInfo::Mode rmode, Condition cond = al);
|
|
|
|
void Call(Handle<Code> code, RelocInfo::Mode rmode, Condition cond = al);
|
2009-04-16 09:30:23 +00:00
|
|
|
void Ret(Condition cond = al);
|
2008-12-10 08:37:58 +00:00
|
|
|
// Jumps to the label at the index given by the Smi in "index".
|
|
|
|
void SmiJumpTable(Register index, Vector<Label*> targets);
|
2008-10-03 12:04:59 +00:00
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
// Sets the remembered set bit for [address+offset], where address is the
|
|
|
|
// address of the heap object 'object'. The address must be in the first 8K
|
|
|
|
// of an allocated page. The 'scratch' register is used in the
|
|
|
|
// implementation and all 3 registers are clobbered by the operation, as
|
|
|
|
// well as the ip register.
|
|
|
|
void RecordWrite(Register object, Register offset, Register scratch);
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Activation frames
|
|
|
|
|
2008-10-10 09:09:38 +00:00
|
|
|
void EnterInternalFrame() { EnterFrame(StackFrame::INTERNAL); }
|
|
|
|
void LeaveInternalFrame() { LeaveFrame(StackFrame::INTERNAL); }
|
|
|
|
|
|
|
|
void EnterConstructFrame() { EnterFrame(StackFrame::CONSTRUCT); }
|
|
|
|
void LeaveConstructFrame() { LeaveFrame(StackFrame::CONSTRUCT); }
|
2008-09-23 08:19:26 +00:00
|
|
|
|
|
|
|
// Enter specific kind of exit frame; either EXIT or
|
|
|
|
// EXIT_DEBUG. Expects the number of arguments in register r0 and
|
|
|
|
// the builtin function to call in register r1. Exits with argc in
|
|
|
|
// r4, argv in r6, and and the builtin function to call in r5.
|
|
|
|
void EnterExitFrame(StackFrame::Type type);
|
|
|
|
|
|
|
|
// Leave the current exit frame. Expects the return value in r0.
|
2008-09-23 12:21:54 +00:00
|
|
|
void LeaveExitFrame(StackFrame::Type type);
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
|
2008-08-06 10:02:49 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// JavaScript invokes
|
|
|
|
|
|
|
|
// Invoke the JavaScript function code by either calling or jumping.
|
|
|
|
void InvokeCode(Register code,
|
|
|
|
const ParameterCount& expected,
|
|
|
|
const ParameterCount& actual,
|
|
|
|
InvokeFlag flag);
|
|
|
|
|
|
|
|
void InvokeCode(Handle<Code> code,
|
|
|
|
const ParameterCount& expected,
|
|
|
|
const ParameterCount& actual,
|
2008-09-22 13:57:03 +00:00
|
|
|
RelocInfo::Mode rmode,
|
2008-08-06 10:02:49 +00:00
|
|
|
InvokeFlag flag);
|
|
|
|
|
|
|
|
// Invoke the JavaScript function in the given register. Changes the
|
|
|
|
// current context to the context in the function before invoking.
|
|
|
|
void InvokeFunction(Register function,
|
|
|
|
const ParameterCount& actual,
|
|
|
|
InvokeFlag flag);
|
|
|
|
|
2008-09-12 03:29:06 +00:00
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Debugger Support
|
|
|
|
|
|
|
|
void SaveRegistersToMemory(RegList regs);
|
|
|
|
void RestoreRegistersFromMemory(RegList regs);
|
|
|
|
void CopyRegistersFromMemoryToStack(Register base, RegList regs);
|
|
|
|
void CopyRegistersFromStackToMemory(Register base,
|
|
|
|
Register scratch,
|
|
|
|
RegList regs);
|
|
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Exception handling
|
|
|
|
|
|
|
|
// Push a new try handler and link into try handler chain.
|
|
|
|
// The return address must be passed in register lr.
|
|
|
|
// On exit, r0 contains TOS (code slot).
|
|
|
|
void PushTryHandler(CodeLocation try_location, HandlerType type);
|
|
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Inline caching support
|
|
|
|
|
|
|
|
// Generates code that verifies that the maps of objects in the
|
|
|
|
// prototype chain of object hasn't changed since the code was
|
|
|
|
// generated and branches to the miss label if any map has. If
|
|
|
|
// necessary the function also generates code for security check
|
|
|
|
// in case of global object holders. The scratch and holder
|
|
|
|
// registers are always clobbered, but the object register is only
|
|
|
|
// clobbered if it the same as the holder register. The function
|
|
|
|
// returns a register containing the holder - either object_reg or
|
|
|
|
// holder_reg.
|
|
|
|
Register CheckMaps(JSObject* object, Register object_reg,
|
|
|
|
JSObject* holder, Register holder_reg,
|
|
|
|
Register scratch, Label* miss);
|
|
|
|
|
|
|
|
// Generate code for checking access rights - used for security checks
|
|
|
|
// on access to global objects across environments. The holder register
|
|
|
|
// is left untouched, whereas both scratch registers are clobbered.
|
2008-10-21 20:11:50 +00:00
|
|
|
void CheckAccessGlobalProxy(Register holder_reg,
|
|
|
|
Register scratch,
|
|
|
|
Label* miss);
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
|
2008-10-06 06:41:10 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Support functions.
|
|
|
|
|
|
|
|
// Generates code for reporting that an illegal operation has
|
|
|
|
// occurred.
|
|
|
|
void IllegalOperation(int num_arguments);
|
|
|
|
|
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Runtime calls
|
|
|
|
|
|
|
|
// Call a code stub.
|
|
|
|
void CallStub(CodeStub* stub);
|
|
|
|
void CallJSExitStub(CodeStub* stub);
|
|
|
|
|
|
|
|
// Return from a code stub after popping its arguments.
|
|
|
|
void StubReturn(int argc);
|
|
|
|
|
|
|
|
// Call a runtime routine.
|
|
|
|
// Eventually this should be used for all C calls.
|
|
|
|
void CallRuntime(Runtime::Function* f, int num_arguments);
|
|
|
|
|
|
|
|
// Convenience function: Same as above, but takes the fid instead.
|
|
|
|
void CallRuntime(Runtime::FunctionId fid, int num_arguments);
|
|
|
|
|
|
|
|
// Tail call of a runtime routine (jump).
|
|
|
|
// Like JumpToBuiltin, but also takes care of passing the number
|
2008-08-13 09:32:07 +00:00
|
|
|
// of parameters.
|
|
|
|
void TailCallRuntime(const ExternalReference& ext, int num_arguments);
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
// Jump to the builtin routine.
|
|
|
|
void JumpToBuiltin(const ExternalReference& builtin);
|
|
|
|
|
|
|
|
// Invoke specified builtin JavaScript function. Adds an entry to
|
|
|
|
// the unresolved list if the name does not resolve.
|
2008-09-12 03:29:06 +00:00
|
|
|
void InvokeBuiltin(Builtins::JavaScript id, InvokeJSFlags flags);
|
|
|
|
|
|
|
|
// Store the code object for the given builtin in the target register and
|
|
|
|
// setup the function in r1.
|
|
|
|
void GetBuiltinEntry(Register target, Builtins::JavaScript id);
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
struct Unresolved {
|
|
|
|
int pc;
|
|
|
|
uint32_t flags; // see Bootstrapper::FixupFlags decoders/encoders.
|
|
|
|
const char* name;
|
|
|
|
};
|
|
|
|
List<Unresolved>* unresolved() { return &unresolved_; }
|
|
|
|
|
2009-02-25 16:52:15 +00:00
|
|
|
Handle<Object> CodeObject() { return code_object_; }
|
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2008-11-20 16:59:00 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// StatsCounter support
|
|
|
|
|
|
|
|
void SetCounter(StatsCounter* counter, int value,
|
|
|
|
Register scratch1, Register scratch2);
|
|
|
|
void IncrementCounter(StatsCounter* counter, int value,
|
|
|
|
Register scratch1, Register scratch2);
|
|
|
|
void DecrementCounter(StatsCounter* counter, int value,
|
|
|
|
Register scratch1, Register scratch2);
|
|
|
|
|
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Debugging
|
|
|
|
|
|
|
|
// Calls Abort(msg) if the condition cc is not satisfied.
|
|
|
|
// Use --debug_code to enable.
|
|
|
|
void Assert(Condition cc, const char* msg);
|
|
|
|
|
|
|
|
// Like Assert(), but always enabled.
|
|
|
|
void Check(Condition cc, const char* msg);
|
|
|
|
|
|
|
|
// Print a message to stdout and abort execution.
|
|
|
|
void Abort(const char* msg);
|
|
|
|
|
|
|
|
// Verify restrictions about code generated in stubs.
|
|
|
|
void set_generating_stub(bool value) { generating_stub_ = value; }
|
|
|
|
bool generating_stub() { return generating_stub_; }
|
2008-07-30 08:49:36 +00:00
|
|
|
void set_allow_stub_calls(bool value) { allow_stub_calls_ = value; }
|
|
|
|
bool allow_stub_calls() { return allow_stub_calls_; }
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
List<Unresolved> unresolved_;
|
|
|
|
bool generating_stub_;
|
2008-07-30 08:49:36 +00:00
|
|
|
bool allow_stub_calls_;
|
2009-02-25 16:52:15 +00:00
|
|
|
Handle<Object> code_object_; // This handle will be patched with the code
|
|
|
|
// object on installation.
|
2008-09-12 03:29:06 +00:00
|
|
|
|
|
|
|
// Helper functions for generating invokes.
|
|
|
|
void InvokePrologue(const ParameterCount& expected,
|
|
|
|
const ParameterCount& actual,
|
|
|
|
Handle<Code> code_constant,
|
|
|
|
Register code_reg,
|
|
|
|
Label* done,
|
|
|
|
InvokeFlag flag);
|
|
|
|
|
|
|
|
// Get the code for the given builtin. Returns if able to resolve
|
|
|
|
// the function in the 'resolved' flag.
|
|
|
|
Handle<Code> ResolveBuiltin(Builtins::JavaScript id, bool* resolved);
|
2008-10-10 09:09:38 +00:00
|
|
|
|
|
|
|
// Activation support.
|
|
|
|
void EnterFrame(StackFrame::Type type);
|
|
|
|
void LeaveFrame(StackFrame::Type type);
|
2008-07-03 15:10:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// Static helper functions.
|
|
|
|
|
|
|
|
// Generate a MemOperand for loading a field from an object.
|
|
|
|
static inline MemOperand FieldMemOperand(Register object, int offset) {
|
|
|
|
return MemOperand(object, offset - kHeapObjectTag);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} } // namespace v8::internal
|
|
|
|
|
|
|
|
#endif // V8_MACRO_ASSEMBLER_ARM_H_
|