diff options
Diffstat (limited to 'deps/v8/src/x87/macro-assembler-x87.h')
| -rw-r--r-- | deps/v8/src/x87/macro-assembler-x87.h | 84 |
1 files changed, 50 insertions, 34 deletions
diff --git a/deps/v8/src/x87/macro-assembler-x87.h b/deps/v8/src/x87/macro-assembler-x87.h index 9a2c903ab0..f1a8f82fe8 100644 --- a/deps/v8/src/x87/macro-assembler-x87.h +++ b/deps/v8/src/x87/macro-assembler-x87.h @@ -26,6 +26,9 @@ const Register kInterpreterDispatchTableRegister = {kRegister_ebx_Code}; const Register kRuntimeCallFunctionRegister = {kRegister_ebx_Code}; const Register kRuntimeCallArgCountRegister = {kRegister_eax_Code}; +// Spill slots used by interpreter dispatch calling convention. +const int kInterpreterContextSpillSlot = -1; + // Convenience for platform-independent signatures. We do not normally // distinguish memory operands from other operands on ia32. typedef Operand MemOperand; @@ -68,6 +71,16 @@ class MacroAssembler: public Assembler { void Load(Register dst, const Operand& src, Representation r); void Store(Register src, const Operand& dst, Representation r); + // Load a register with a long value as efficiently as possible. + void Set(Register dst, int32_t x) { + if (x == 0) { + xor_(dst, dst); + } else { + mov(dst, Immediate(x)); + } + } + void Set(const Operand& dst, int32_t x) { mov(dst, Immediate(x)); } + // Operations on roots in the root-array. void LoadRoot(Register destination, Heap::RootListIndex index); void StoreRoot(Register source, Register scratch, Heap::RootListIndex index); @@ -76,6 +89,22 @@ class MacroAssembler: public Assembler { // and not in new space). void CompareRoot(Register with, Heap::RootListIndex index); void CompareRoot(const Operand& with, Heap::RootListIndex index); + void PushRoot(Heap::RootListIndex index); + + // Compare the object in a register to a value and jump if they are equal. + void JumpIfRoot(Register with, Heap::RootListIndex index, Label* if_equal, + Label::Distance if_equal_distance = Label::kNear) { + CompareRoot(with, index); + j(equal, if_equal, if_equal_distance); + } + + // Compare the object in a register to a value and jump if they are not equal. + void JumpIfNotRoot(Register with, Heap::RootListIndex index, + Label* if_not_equal, + Label::Distance if_not_equal_distance = Label::kNear) { + CompareRoot(with, index); + j(not_equal, if_not_equal, if_not_equal_distance); + } // --------------------------------------------------------------------------- // GC Support @@ -237,6 +266,9 @@ class MacroAssembler: public Assembler { // Find the function context up the context chain. void LoadContext(Register dst, int context_chain_length); + // Load the global proxy from the current context. + void LoadGlobalProxy(Register dst); + // Conditionally load the cached Array transitioned map of type // transitioned_kind from the native context if the map in register // map_in_out is the cached Array map in the native context of @@ -327,17 +359,15 @@ class MacroAssembler: public Assembler { InvokeFlag flag, const CallWrapper& call_wrapper); - // Invoke specified builtin JavaScript function. Adds an entry to - // the unresolved list if the name does not resolve. - void InvokeBuiltin(Builtins::JavaScript id, - InvokeFlag flag, + // Invoke specified builtin JavaScript function. + void InvokeBuiltin(int native_context_index, InvokeFlag flag, const CallWrapper& call_wrapper = NullCallWrapper()); // Store the function for the given builtin in the target register. - void GetBuiltinFunction(Register target, Builtins::JavaScript id); + void GetBuiltinFunction(Register target, int native_context_index); // Store the code object for the given builtin in the target register. - void GetBuiltinEntry(Register target, Builtins::JavaScript id); + void GetBuiltinEntry(Register target, int native_context_index); // Expression support // Support for constant splitting. @@ -417,18 +447,6 @@ class MacroAssembler: public Assembler { Register map, Register instance_type); - // Check if a heap object's type is in the JSObject range, not including - // JSFunction. The object's map will be loaded in the map register. - // Any or all of the three registers may be the same. - // The contents of the scratch register will always be overwritten. - void IsObjectJSObjectType(Register heap_object, - Register map, - Register scratch, - Label* fail); - - // The contents of the scratch register will be overwritten. - void IsInstanceJSObjectType(Register map, Register scratch, Label* fail); - // FCmp is similar to integer cmp, but requires unsigned // jcc instructions (je, ja, jae, jb, jbe, je, and jz). void FCmp(); @@ -541,6 +559,9 @@ class MacroAssembler: public Assembler { // Abort execution if argument is not a name, enabled via --debug-code. void AssertName(Register object); + // Abort execution if argument is not a JSFunction, enabled via --debug-code. + void AssertFunction(Register object); + // Abort execution if argument is not undefined or an AllocationSite, enabled // via --debug-code. void AssertUndefinedOrAllocationSite(Register object); @@ -693,11 +714,8 @@ class MacroAssembler: public Assembler { // function and jumps to the miss label if the fast checks fail. The // function register will be untouched; the other registers may be // clobbered. - void TryGetFunctionPrototype(Register function, - Register result, - Register scratch, - Label* miss, - bool miss_on_bound_function = false); + void TryGetFunctionPrototype(Register function, Register result, + Register scratch, Label* miss); // Picks out an array index from the hash field. // Register use: @@ -780,8 +798,14 @@ class MacroAssembler: public Assembler { void Drop(int element_count); void Call(Label* target) { call(target); } + void Call(Handle<Code> target, RelocInfo::Mode rmode) { call(target, rmode); } + void Jump(Handle<Code> target, RelocInfo::Mode rmode) { jmp(target, rmode); } void Push(Register src) { push(src); } + void Push(const Operand& src) { push(src); } + void Push(Immediate value) { push(value); } void Pop(Register dst) { pop(dst); } + void PushReturnAddressFrom(Register src) { push(src); } + void PopReturnAddressTo(Register dst) { pop(dst); } void Lzcnt(Register dst, Register src) { Lzcnt(dst, Operand(src)); } void Lzcnt(Register dst, const Operand& src); @@ -853,17 +877,6 @@ class MacroAssembler: public Assembler { // --------------------------------------------------------------------------- // String utilities. - // Generate code to do a lookup in the number string cache. If the number in - // the register object is found in the cache the generated code falls through - // with the result in the result register. The object and the result register - // can be the same. If the number is not found in the cache the code jumps to - // the label not_found with only the content of register object unchanged. - void LookupNumberStringCache(Register object, - Register result, - Register scratch1, - Register scratch2, - Label* not_found); - // Check whether the instance type represents a flat one-byte string. Jump to // the label if not. If the instance type can be scratched specify same // register for both instance type and scratch. @@ -895,6 +908,9 @@ class MacroAssembler: public Assembler { return SafepointRegisterStackIndex(reg.code()); } + // Load the type feedback vector from a JavaScript frame. + void EmitLoadTypeFeedbackVector(Register vector); + // Activation support. void EnterFrame(StackFrame::Type type); void EnterFrame(StackFrame::Type type, bool load_constant_pool_pointer_reg); |