macro-assembler-x64.cc revision 44f0eee88ff00398ff7f715fab053374d808c90d
1e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch// Copyright 2011 the V8 project authors. All rights reserved. 2a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// Redistribution and use in source and binary forms, with or without 3a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// modification, are permitted provided that the following conditions are 4a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// met: 5a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 6a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// * Redistributions of source code must retain the above copyright 7a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// notice, this list of conditions and the following disclaimer. 8a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// * Redistributions in binary form must reproduce the above 9a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// copyright notice, this list of conditions and the following 10a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// disclaimer in the documentation and/or other materials provided 11a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// with the distribution. 12a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// * Neither the name of Google Inc. nor the names of its 13a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// contributors may be used to endorse or promote products derived 14a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// from this software without specific prior written permission. 15a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 16a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 28a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#include "v8.h" 29a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 30f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke#if defined(V8_TARGET_ARCH_X64) 31f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke 32a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#include "bootstrapper.h" 33a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#include "codegen-inl.h" 34a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#include "assembler-x64.h" 35a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#include "macro-assembler-x64.h" 36a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#include "serialize.h" 37a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#include "debug.h" 389dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen#include "heap.h" 39a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 40a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blocknamespace v8 { 41a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blocknamespace internal { 42a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 43a7e24c173cf37484693b9abb38e494fa7bd7baebSteve BlockMacroAssembler::MacroAssembler(void* buffer, int size) 443ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block : Assembler(buffer, size), 453ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block generating_stub_(false), 463ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block allow_stub_calls_(true), 4744f0eee88ff00398ff7f715fab053374d808c90dSteve Block root_array_available_(true), 4844f0eee88ff00398ff7f715fab053374d808c90dSteve Block code_object_(isolate()->heap()->undefined_value()) { 4944f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 5044f0eee88ff00398ff7f715fab053374d808c90dSteve Block 5144f0eee88ff00398ff7f715fab053374d808c90dSteve Block 5244f0eee88ff00398ff7f715fab053374d808c90dSteve Blockstatic intptr_t RootRegisterDelta(ExternalReference other, Isolate* isolate) { 5344f0eee88ff00398ff7f715fab053374d808c90dSteve Block Address roots_register_value = kRootRegisterBias + 5444f0eee88ff00398ff7f715fab053374d808c90dSteve Block reinterpret_cast<Address>(isolate->heap()->roots_address()); 5544f0eee88ff00398ff7f715fab053374d808c90dSteve Block intptr_t delta = other.address() - roots_register_value; 5644f0eee88ff00398ff7f715fab053374d808c90dSteve Block return delta; 5744f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 5844f0eee88ff00398ff7f715fab053374d808c90dSteve Block 5944f0eee88ff00398ff7f715fab053374d808c90dSteve Block 6044f0eee88ff00398ff7f715fab053374d808c90dSteve BlockOperand MacroAssembler::ExternalOperand(ExternalReference target, 6144f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register scratch) { 6244f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (root_array_available_ && !Serializer::enabled()) { 6344f0eee88ff00398ff7f715fab053374d808c90dSteve Block intptr_t delta = RootRegisterDelta(target, isolate()); 6444f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (is_int32(delta)) { 6544f0eee88ff00398ff7f715fab053374d808c90dSteve Block Serializer::TooLateToEnableNow(); 6644f0eee88ff00398ff7f715fab053374d808c90dSteve Block return Operand(kRootRegister, static_cast<int32_t>(delta)); 6744f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 6844f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 6944f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(scratch, target); 7044f0eee88ff00398ff7f715fab053374d808c90dSteve Block return Operand(scratch, 0); 7144f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 7244f0eee88ff00398ff7f715fab053374d808c90dSteve Block 7344f0eee88ff00398ff7f715fab053374d808c90dSteve Block 7444f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::Load(Register destination, ExternalReference source) { 7544f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (root_array_available_ && !Serializer::enabled()) { 7644f0eee88ff00398ff7f715fab053374d808c90dSteve Block intptr_t delta = RootRegisterDelta(source, isolate()); 7744f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (is_int32(delta)) { 7844f0eee88ff00398ff7f715fab053374d808c90dSteve Block Serializer::TooLateToEnableNow(); 7944f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(destination, Operand(kRootRegister, static_cast<int32_t>(delta))); 8044f0eee88ff00398ff7f715fab053374d808c90dSteve Block return; 8144f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 8244f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 8344f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Safe code. 8444f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (destination.is(rax)) { 8544f0eee88ff00398ff7f715fab053374d808c90dSteve Block load_rax(source); 8644f0eee88ff00398ff7f715fab053374d808c90dSteve Block } else { 8744f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(kScratchRegister, source); 8844f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(destination, Operand(kScratchRegister, 0)); 8944f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 9044f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 9144f0eee88ff00398ff7f715fab053374d808c90dSteve Block 9244f0eee88ff00398ff7f715fab053374d808c90dSteve Block 9344f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::Store(ExternalReference destination, Register source) { 9444f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (root_array_available_ && !Serializer::enabled()) { 9544f0eee88ff00398ff7f715fab053374d808c90dSteve Block intptr_t delta = RootRegisterDelta(destination, isolate()); 9644f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (is_int32(delta)) { 9744f0eee88ff00398ff7f715fab053374d808c90dSteve Block Serializer::TooLateToEnableNow(); 9844f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(Operand(kRootRegister, static_cast<int32_t>(delta)), source); 9944f0eee88ff00398ff7f715fab053374d808c90dSteve Block return; 10044f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 10144f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 10244f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Safe code. 10344f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (source.is(rax)) { 10444f0eee88ff00398ff7f715fab053374d808c90dSteve Block store_rax(destination); 10544f0eee88ff00398ff7f715fab053374d808c90dSteve Block } else { 10644f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(kScratchRegister, destination); 10744f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(Operand(kScratchRegister, 0), source); 10844f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 10944f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 11044f0eee88ff00398ff7f715fab053374d808c90dSteve Block 11144f0eee88ff00398ff7f715fab053374d808c90dSteve Block 11244f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::LoadAddress(Register destination, 11344f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference source) { 11444f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (root_array_available_ && !Serializer::enabled()) { 11544f0eee88ff00398ff7f715fab053374d808c90dSteve Block intptr_t delta = RootRegisterDelta(source, isolate()); 11644f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (is_int32(delta)) { 11744f0eee88ff00398ff7f715fab053374d808c90dSteve Block Serializer::TooLateToEnableNow(); 11844f0eee88ff00398ff7f715fab053374d808c90dSteve Block lea(destination, Operand(kRootRegister, static_cast<int32_t>(delta))); 11944f0eee88ff00398ff7f715fab053374d808c90dSteve Block return; 12044f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 12144f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 12244f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Safe code. 12344f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(destination, source); 12444f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 12544f0eee88ff00398ff7f715fab053374d808c90dSteve Block 12644f0eee88ff00398ff7f715fab053374d808c90dSteve Block 12744f0eee88ff00398ff7f715fab053374d808c90dSteve Blockint MacroAssembler::LoadAddressSize(ExternalReference source) { 12844f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (root_array_available_ && !Serializer::enabled()) { 12944f0eee88ff00398ff7f715fab053374d808c90dSteve Block // This calculation depends on the internals of LoadAddress. 13044f0eee88ff00398ff7f715fab053374d808c90dSteve Block // It's correctness is ensured by the asserts in the Call 13144f0eee88ff00398ff7f715fab053374d808c90dSteve Block // instruction below. 13244f0eee88ff00398ff7f715fab053374d808c90dSteve Block intptr_t delta = RootRegisterDelta(source, isolate()); 13344f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (is_int32(delta)) { 13444f0eee88ff00398ff7f715fab053374d808c90dSteve Block Serializer::TooLateToEnableNow(); 13544f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Operand is lea(scratch, Operand(kRootRegister, delta)); 13644f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Opcodes : REX.W 8D ModRM Disp8/Disp32 - 4 or 7. 13744f0eee88ff00398ff7f715fab053374d808c90dSteve Block int size = 4; 13844f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (!is_int8(static_cast<int32_t>(delta))) { 13944f0eee88ff00398ff7f715fab053374d808c90dSteve Block size += 3; // Need full four-byte displacement in lea. 14044f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 14144f0eee88ff00398ff7f715fab053374d808c90dSteve Block return size; 14244f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 14344f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 14444f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Size of movq(destination, src); 14544f0eee88ff00398ff7f715fab053374d808c90dSteve Block return 10; 146a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 147a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 148a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1493ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::LoadRoot(Register destination, Heap::RootListIndex index) { 15044f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(root_array_available_); 151e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(destination, Operand(kRootRegister, 152e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch (index << kPointerSizeLog2) - kRootRegisterBias)); 153e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 154e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 155e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 156e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::LoadRootIndexed(Register destination, 157e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register variable_offset, 158e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch int fixed_offset) { 15944f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(root_array_available_); 160e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(destination, 161e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Operand(kRootRegister, 162e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch variable_offset, times_pointer_size, 163e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch (fixed_offset << kPointerSizeLog2) - kRootRegisterBias)); 164a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 165a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 166a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 16725f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsenvoid MacroAssembler::StoreRoot(Register source, Heap::RootListIndex index) { 16844f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(root_array_available_); 169e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(Operand(kRootRegister, (index << kPointerSizeLog2) - kRootRegisterBias), 170e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch source); 17125f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen} 17225f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen 17325f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen 174a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::PushRoot(Heap::RootListIndex index) { 17544f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(root_array_available_); 176e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch push(Operand(kRootRegister, (index << kPointerSizeLog2) - kRootRegisterBias)); 177a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 178a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 179a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1803ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::CompareRoot(Register with, Heap::RootListIndex index) { 18144f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(root_array_available_); 182e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch cmpq(with, Operand(kRootRegister, 183e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch (index << kPointerSizeLog2) - kRootRegisterBias)); 184a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 185a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 186a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1871e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::CompareRoot(const Operand& with, 1881e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Heap::RootListIndex index) { 18944f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(root_array_available_); 1901e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ASSERT(!with.AddressUsesRegister(kScratchRegister)); 191a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block LoadRoot(kScratchRegister, index); 192a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmpq(with, kScratchRegister); 193a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 194a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 195a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1966ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::RecordWriteHelper(Register object, 1976ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register addr, 1986ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register scratch) { 19944f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 2006ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Check that the object is not in new space. 2010d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel not_in_new_space; 2026ded16be15dd865a9b21ea304d5273c8be299c87Steve Block InNewSpace(object, scratch, not_equal, ¬_in_new_space); 2036ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Abort("new-space object passed to RecordWriteHelper"); 2046ded16be15dd865a9b21ea304d5273c8be299c87Steve Block bind(¬_in_new_space); 2056ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 2066ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 207a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Compute the page start address from the heap object pointer, and reuse 208a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // the 'object' register for it. 2097f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch and_(object, Immediate(~Page::kPageAlignmentMask)); 2107f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 2117f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // Compute number of region covering addr. See Page::GetRegionNumberForAddress 2127f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // method for more details. 2137f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch shrl(addr, Immediate(Page::kRegionSizeLog2)); 2149dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen andl(addr, Immediate(Page::kPageAlignmentMask >> Page::kRegionSizeLog2)); 2157f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 2167f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // Set dirty mark for region. 2177f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch bts(Operand(object, Page::kDirtyFlagOffset), addr); 2187f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch} 2197f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 2207f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 221a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::RecordWrite(Register object, 222a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int offset, 223a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register value, 2249dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Register index) { 2254515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // The compiled code assumes that record write doesn't change the 2264515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // context register, so we check that none of the clobbered 2274515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // registers are rsi. 2289dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen ASSERT(!object.is(rsi) && !value.is(rsi) && !index.is(rsi)); 2294515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke 2307f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // First, check if a write barrier is even needed. The tests below 23144f0eee88ff00398ff7f715fab053374d808c90dSteve Block // catch stores of smis and stores into the young generation. 232a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label done; 2333ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block JumpIfSmi(value, &done); 234a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2359dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen RecordWriteNonSmi(object, offset, value, index); 2363ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block bind(&done); 2374515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke 2384515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // Clobber all input registers when running with the debug-code flag 2394515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // turned on to provoke errors. This clobbering repeats the 2404515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // clobbering done inside RecordWriteNonSmi but it's necessary to 2414515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // avoid having the fast case for smis leave the registers 2424515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // unchanged. 24344f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 2446ded16be15dd865a9b21ea304d5273c8be299c87Steve Block movq(object, BitCast<int64_t>(kZapValue), RelocInfo::NONE); 2456ded16be15dd865a9b21ea304d5273c8be299c87Steve Block movq(value, BitCast<int64_t>(kZapValue), RelocInfo::NONE); 2469dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen movq(index, BitCast<int64_t>(kZapValue), RelocInfo::NONE); 2474515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke } 2483ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block} 2493ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block 2503ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block 2518defd9ff6930b4e24729971a61cf7469daf119beSteve Blockvoid MacroAssembler::RecordWrite(Register object, 2528defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register address, 2538defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register value) { 2548defd9ff6930b4e24729971a61cf7469daf119beSteve Block // The compiled code assumes that record write doesn't change the 2558defd9ff6930b4e24729971a61cf7469daf119beSteve Block // context register, so we check that none of the clobbered 256e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // registers are rsi. 2578defd9ff6930b4e24729971a61cf7469daf119beSteve Block ASSERT(!object.is(rsi) && !value.is(rsi) && !address.is(rsi)); 2588defd9ff6930b4e24729971a61cf7469daf119beSteve Block 2598defd9ff6930b4e24729971a61cf7469daf119beSteve Block // First, check if a write barrier is even needed. The tests below 26044f0eee88ff00398ff7f715fab053374d808c90dSteve Block // catch stores of smis and stores into the young generation. 2618defd9ff6930b4e24729971a61cf7469daf119beSteve Block Label done; 2628defd9ff6930b4e24729971a61cf7469daf119beSteve Block JumpIfSmi(value, &done); 2638defd9ff6930b4e24729971a61cf7469daf119beSteve Block 2648defd9ff6930b4e24729971a61cf7469daf119beSteve Block InNewSpace(object, value, equal, &done); 2658defd9ff6930b4e24729971a61cf7469daf119beSteve Block 2668defd9ff6930b4e24729971a61cf7469daf119beSteve Block RecordWriteHelper(object, address, value); 2678defd9ff6930b4e24729971a61cf7469daf119beSteve Block 2688defd9ff6930b4e24729971a61cf7469daf119beSteve Block bind(&done); 2698defd9ff6930b4e24729971a61cf7469daf119beSteve Block 2708defd9ff6930b4e24729971a61cf7469daf119beSteve Block // Clobber all input registers when running with the debug-code flag 2718defd9ff6930b4e24729971a61cf7469daf119beSteve Block // turned on to provoke errors. 27244f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 2738defd9ff6930b4e24729971a61cf7469daf119beSteve Block movq(object, BitCast<int64_t>(kZapValue), RelocInfo::NONE); 2748defd9ff6930b4e24729971a61cf7469daf119beSteve Block movq(address, BitCast<int64_t>(kZapValue), RelocInfo::NONE); 2758defd9ff6930b4e24729971a61cf7469daf119beSteve Block movq(value, BitCast<int64_t>(kZapValue), RelocInfo::NONE); 2768defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 2778defd9ff6930b4e24729971a61cf7469daf119beSteve Block} 2788defd9ff6930b4e24729971a61cf7469daf119beSteve Block 2798defd9ff6930b4e24729971a61cf7469daf119beSteve Block 2803ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::RecordWriteNonSmi(Register object, 2813ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block int offset, 2823ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Register scratch, 2839dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Register index) { 2843ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Label done; 2854515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke 28644f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 2870d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel okay; 2884515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke JumpIfNotSmi(object, &okay); 2894515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke Abort("MacroAssembler::RecordWriteNonSmi cannot deal with smis"); 2904515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke bind(&okay); 2919dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 2929dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen if (offset == 0) { 2939dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen // index must be int32. 2949dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Register tmp = index.is(rax) ? rbx : rax; 2959dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen push(tmp); 2969dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen movl(tmp, index); 2979dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen cmpq(tmp, index); 2989dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Check(equal, "Index register for RecordWrite must be untagged int32."); 2999dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen pop(tmp); 3009dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } 3014515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke } 3024515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke 3037f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // Test that the object address is not in the new space. We cannot 3047f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // update page dirty marks for new space pages. 3056ded16be15dd865a9b21ea304d5273c8be299c87Steve Block InNewSpace(object, scratch, equal, &done); 3066ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 3076ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // The offset is relative to a tagged or untagged HeapObject pointer, 3086ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // so either offset or offset + kHeapObjectTag must be a 3096ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // multiple of kPointerSize. 3106ded16be15dd865a9b21ea304d5273c8be299c87Steve Block ASSERT(IsAligned(offset, kPointerSize) || 3116ded16be15dd865a9b21ea304d5273c8be299c87Steve Block IsAligned(offset + kHeapObjectTag, kPointerSize)); 3126ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 3139dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Register dst = index; 3147f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch if (offset != 0) { 3157f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch lea(dst, Operand(object, offset)); 316a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 3177f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // array access: calculate the destination address in the same manner as 3187f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // KeyedStoreIC::GenerateGeneric. 3197f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch lea(dst, FieldOperand(object, 3209dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen index, 3219dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen times_pointer_size, 3227f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch FixedArray::kHeaderSize)); 323a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 3247f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch RecordWriteHelper(object, dst, scratch); 325a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 326a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&done); 3274515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke 3284515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // Clobber all input registers when running with the debug-code flag 3294515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // turned on to provoke errors. 33044f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 3316ded16be15dd865a9b21ea304d5273c8be299c87Steve Block movq(object, BitCast<int64_t>(kZapValue), RelocInfo::NONE); 3326ded16be15dd865a9b21ea304d5273c8be299c87Steve Block movq(scratch, BitCast<int64_t>(kZapValue), RelocInfo::NONE); 3339dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen movq(index, BitCast<int64_t>(kZapValue), RelocInfo::NONE); 3346ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 3356ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 3366ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 337a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Assert(Condition cc, const char* msg) { 33844f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) Check(cc, msg); 339a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 340a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 341a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 342756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrickvoid MacroAssembler::AssertFastElements(Register elements) { 34344f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 3440d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel ok; 345756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick CompareRoot(FieldOperand(elements, HeapObject::kMapOffset), 346756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick Heap::kFixedArrayMapRootIndex); 347756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick j(equal, &ok); 348756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick CompareRoot(FieldOperand(elements, HeapObject::kMapOffset), 349756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick Heap::kFixedCOWArrayMapRootIndex); 350756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick j(equal, &ok); 351756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick Abort("JSObject with fast elements map has slow elements"); 352756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick bind(&ok); 353756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick } 354756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick} 355756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick 356756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick 357a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Check(Condition cc, const char* msg) { 3580d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel L; 359a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(cc, &L); 360a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Abort(msg); 361a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // will not return here 362a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&L); 363a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 364a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 365a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 3666ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::CheckStackAlignment() { 3676ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int frame_alignment = OS::ActivationFrameAlignment(); 3686ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int frame_alignment_mask = frame_alignment - 1; 3696ded16be15dd865a9b21ea304d5273c8be299c87Steve Block if (frame_alignment > kPointerSize) { 3706ded16be15dd865a9b21ea304d5273c8be299c87Steve Block ASSERT(IsPowerOf2(frame_alignment)); 3710d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel alignment_as_expected; 3726ded16be15dd865a9b21ea304d5273c8be299c87Steve Block testq(rsp, Immediate(frame_alignment_mask)); 3736ded16be15dd865a9b21ea304d5273c8be299c87Steve Block j(zero, &alignment_as_expected); 3746ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Abort if stack is not aligned. 3756ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int3(); 3766ded16be15dd865a9b21ea304d5273c8be299c87Steve Block bind(&alignment_as_expected); 3776ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 3786ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 3796ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 3806ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 381a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::NegativeZeroTest(Register result, 382a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register op, 383a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label* then_label) { 3840d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel ok; 385a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block testl(result, result); 386a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(not_zero, &ok); 387a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block testl(op, op); 388a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(sign, then_label); 389a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&ok); 390a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 391a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 392a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 393a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Abort(const char* msg) { 394a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // We want to pass the msg string like a smi to avoid GC 395a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // problems, however msg is not guaranteed to be aligned 396a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // properly. Instead, we pass an aligned pointer that is 397a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // a proper v8 smi, but also pass the alignment difference 398a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // from the real pointer as a smi. 399a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block intptr_t p1 = reinterpret_cast<intptr_t>(msg); 400a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block intptr_t p0 = (p1 & ~kSmiTagMask) + kSmiTag; 401a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Note: p0 might not be a valid Smi *value*, but it has a valid Smi tag. 402a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(reinterpret_cast<Object*>(p0)->IsSmi()); 403a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifdef DEBUG 404a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (msg != NULL) { 405a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block RecordComment("Abort message: "); 406a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block RecordComment(msg); 407a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 408a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 409d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block // Disable stub call restrictions to always allow calls to abort. 410086aeeaae12517475c22695a200be45495516549Ben Murdoch AllowStubCallsScope allow_scope(this, true); 411d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 412a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(rax); 413a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(kScratchRegister, p0, RelocInfo::NONE); 414a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(kScratchRegister); 415a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(kScratchRegister, 416d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(p1 - p0))), 417a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block RelocInfo::NONE); 418a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(kScratchRegister); 419a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CallRuntime(Runtime::kAbort, 2); 420a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // will not return here 421d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block int3(); 422a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 423a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 424a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 425a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::CallStub(CodeStub* stub) { 426a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(allow_stub_calls()); // calls are not allowed in some stubs 427a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Call(stub->GetCode(), RelocInfo::CODE_TARGET); 428a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 429a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 430a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 4315913587db4c6bab03d97bfe44b06289fd6d7270dJohn ReckMaybeObject* MacroAssembler::TryCallStub(CodeStub* stub) { 432bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch ASSERT(allow_stub_calls()); // Calls are not allowed in some stubs. 4335913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck MaybeObject* result = stub->TryGetCode(); 434bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch if (!result->IsFailure()) { 4355913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck call(Handle<Code>(Code::cast(result->ToObjectUnchecked())), 4365913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck RelocInfo::CODE_TARGET); 437bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch } 438bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch return result; 439bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch} 440bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 441bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 442e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarkevoid MacroAssembler::TailCallStub(CodeStub* stub) { 4438a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang ASSERT(allow_stub_calls()); // Calls are not allowed in some stubs. 444e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Jump(stub->GetCode(), RelocInfo::CODE_TARGET); 445e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke} 446e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 447e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 4485913587db4c6bab03d97bfe44b06289fd6d7270dJohn ReckMaybeObject* MacroAssembler::TryTailCallStub(CodeStub* stub) { 449bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch ASSERT(allow_stub_calls()); // Calls are not allowed in some stubs. 4505913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck MaybeObject* result = stub->TryGetCode(); 451bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch if (!result->IsFailure()) { 4525913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck jmp(Handle<Code>(Code::cast(result->ToObjectUnchecked())), 4535913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck RelocInfo::CODE_TARGET); 454bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch } 455bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch return result; 456bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch} 457bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 458bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 459a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::StubReturn(int argc) { 460a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(argc >= 1 && generating_stub()); 461a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ret((argc - 1) * kPointerSize); 462a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 463a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 464a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 465a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::IllegalOperation(int num_arguments) { 466a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (num_arguments > 0) { 467a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block addq(rsp, Immediate(num_arguments * kPointerSize)); 468a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 469a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block LoadRoot(rax, Heap::kUndefinedValueRootIndex); 470a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 471a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 472a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 47380d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsenvoid MacroAssembler::IndexFromHash(Register hash, Register index) { 47480d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // The assert checks that the constants for the maximum number of digits 47580d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // for an array index cached in the hash field and the number of bits 47680d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // reserved for it does not conflict. 47780d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen ASSERT(TenToThe(String::kMaxCachedArrayIndexLength) < 47880d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen (1 << String::kArrayIndexValueBits)); 47980d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // We want the smi-tagged index in key. Even if we subsequently go to 48080d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // the slow case, converting the key to a smi is always valid. 48180d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // key: string key 48280d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // hash: key's hash field, including its array index value. 48380d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen and_(hash, Immediate(String::kArrayIndexValueMask)); 48480d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen shr(hash, Immediate(String::kHashShift)); 48580d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // Here we actually clobber the key which will be used if calling into 48680d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // runtime later. However as the new key is the numeric value of a string key 48780d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // there is no difference in using either key. 48880d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen Integer32ToSmi(index, hash); 48980d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen} 49080d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen 49180d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen 492a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::CallRuntime(Runtime::FunctionId id, int num_arguments) { 493a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CallRuntime(Runtime::FunctionForId(id), num_arguments); 494a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 495a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 496a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 4971e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::CallRuntimeSaveDoubles(Runtime::FunctionId id) { 49844f0eee88ff00398ff7f715fab053374d808c90dSteve Block const Runtime::Function* function = Runtime::FunctionForId(id); 4991e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Set(rax, function->nargs); 50044f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(rbx, ExternalReference(function, isolate())); 5011e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block CEntryStub ces(1); 5021e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ces.SaveDoubles(); 5031e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block CallStub(&ces); 5041e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 5051e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 5061e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 5075913587db4c6bab03d97bfe44b06289fd6d7270dJohn ReckMaybeObject* MacroAssembler::TryCallRuntime(Runtime::FunctionId id, 5085913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck int num_arguments) { 509bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch return TryCallRuntime(Runtime::FunctionForId(id), num_arguments); 510bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch} 511bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 512bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 51344f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::CallRuntime(const Runtime::Function* f, 51444f0eee88ff00398ff7f715fab053374d808c90dSteve Block int num_arguments) { 515a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // If the expected number of arguments of the runtime function is 516a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // constant, we check that the actual number of arguments match the 517a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // expectation. 518a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (f->nargs >= 0 && f->nargs != num_arguments) { 519a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block IllegalOperation(num_arguments); 520a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return; 521a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 522a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 5234515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // TODO(1236192): Most runtime routines don't need the number of 5244515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // arguments passed in because it is constant. At some point we 5254515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // should remove this need and make the runtime routine entry code 5264515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // smarter. 5278defd9ff6930b4e24729971a61cf7469daf119beSteve Block Set(rax, num_arguments); 52844f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(rbx, ExternalReference(f, isolate())); 5294515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke CEntryStub ces(f->result_size); 5304515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke CallStub(&ces); 531a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 532a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 533a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 53444f0eee88ff00398ff7f715fab053374d808c90dSteve BlockMaybeObject* MacroAssembler::TryCallRuntime(const Runtime::Function* f, 5355913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck int num_arguments) { 536bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch if (f->nargs >= 0 && f->nargs != num_arguments) { 537bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch IllegalOperation(num_arguments); 538bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch // Since we did not call the stub, there was no allocation failure. 539bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch // Return some non-failure object. 54044f0eee88ff00398ff7f715fab053374d808c90dSteve Block return HEAP->undefined_value(); 541bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch } 542bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 543bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch // TODO(1236192): Most runtime routines don't need the number of 544bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch // arguments passed in because it is constant. At some point we 545bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch // should remove this need and make the runtime routine entry code 546bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch // smarter. 547bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch Set(rax, num_arguments); 54844f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(rbx, ExternalReference(f, isolate())); 549bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch CEntryStub ces(f->result_size); 550bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch return TryCallStub(&ces); 551bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch} 552bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 553bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 554402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescuvoid MacroAssembler::CallExternalReference(const ExternalReference& ext, 555402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu int num_arguments) { 5568defd9ff6930b4e24729971a61cf7469daf119beSteve Block Set(rax, num_arguments); 55744f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(rbx, ext); 558402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 559402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu CEntryStub stub(1); 560402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu CallStub(&stub); 561402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu} 562402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 563402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 5646ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::TailCallExternalReference(const ExternalReference& ext, 5656ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int num_arguments, 5666ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int result_size) { 567a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // ----------- S t a t e ------------- 568a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // -- rsp[0] : return address 569a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // -- rsp[8] : argument num_arguments - 1 570a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // ... 571a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // -- rsp[8 * num_arguments] : argument 0 (receiver) 572a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // ----------------------------------- 573a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 574a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // TODO(1236192): Most runtime routines don't need the number of 575a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // arguments passed in because it is constant. At some point we 576a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // should remove this need and make the runtime routine entry code 577a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // smarter. 5788defd9ff6930b4e24729971a61cf7469daf119beSteve Block Set(rax, num_arguments); 5796ded16be15dd865a9b21ea304d5273c8be299c87Steve Block JumpToExternalReference(ext, result_size); 580a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 581a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 582a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 5838a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) WangMaybeObject* MacroAssembler::TryTailCallExternalReference( 5848a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang const ExternalReference& ext, int num_arguments, int result_size) { 5858a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // ----------- S t a t e ------------- 5868a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // -- rsp[0] : return address 5878a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // -- rsp[8] : argument num_arguments - 1 5888a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // ... 5898a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // -- rsp[8 * num_arguments] : argument 0 (receiver) 5908a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // ----------------------------------- 5918a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 5928a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // TODO(1236192): Most runtime routines don't need the number of 5938a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // arguments passed in because it is constant. At some point we 5948a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // should remove this need and make the runtime routine entry code 5958a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // smarter. 5968a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang Set(rax, num_arguments); 5978a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang return TryJumpToExternalReference(ext, result_size); 5988a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang} 5998a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 6008a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 6016ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::TailCallRuntime(Runtime::FunctionId fid, 6026ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int num_arguments, 6036ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int result_size) { 60444f0eee88ff00398ff7f715fab053374d808c90dSteve Block TailCallExternalReference(ExternalReference(fid, isolate()), 60544f0eee88ff00398ff7f715fab053374d808c90dSteve Block num_arguments, 60644f0eee88ff00398ff7f715fab053374d808c90dSteve Block result_size); 6076ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 6086ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 6096ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 6108a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) WangMaybeObject* MacroAssembler::TryTailCallRuntime(Runtime::FunctionId fid, 6118a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang int num_arguments, 6128a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang int result_size) { 61344f0eee88ff00398ff7f715fab053374d808c90dSteve Block return TryTailCallExternalReference(ExternalReference(fid, isolate()), 6148a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang num_arguments, 6158a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang result_size); 6168a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang} 6178a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 6188a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 619bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdochstatic int Offset(ExternalReference ref0, ExternalReference ref1) { 620bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch int64_t offset = (ref0.address() - ref1.address()); 621bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch // Check that fits into int. 622bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch ASSERT(static_cast<int>(offset) == offset); 623bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch return static_cast<int>(offset); 624bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch} 625bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 626bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 6278a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wangvoid MacroAssembler::PrepareCallApiFunction(int arg_stack_space) { 6288a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang#ifdef _WIN64 6298a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // We need to prepare a slot for result handle on stack and put 6308a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // a pointer to it into 1st arg register. 6318a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang EnterApiExitFrame(arg_stack_space + 1); 6328a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 6338a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // rcx must be used to pass the pointer to the return value slot. 6348a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang lea(rcx, StackSpaceOperand(arg_stack_space)); 6358a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang#else 6368a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang EnterApiExitFrame(arg_stack_space); 6378a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang#endif 638bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch} 639bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 640bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 6418a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) WangMaybeObject* MacroAssembler::TryCallApiFunctionAndReturn( 6428a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang ApiFunction* function, int stack_space) { 6435913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck Label empty_result; 6445913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck Label prologue; 6455913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck Label promote_scheduled_exception; 6465913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck Label delete_allocated_handles; 6475913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck Label leave_exit_frame; 648bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch Label write_back; 649bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 6505913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck ExternalReference next_address = 6515913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck ExternalReference::handle_scope_next_address(); 6525913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck const int kNextOffset = 0; 6535913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck const int kLimitOffset = Offset( 6545913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck ExternalReference::handle_scope_limit_address(), 6555913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck next_address); 6565913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck const int kLevelOffset = Offset( 6575913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck ExternalReference::handle_scope_level_address(), 6585913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck next_address); 6595913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck ExternalReference scheduled_exception_address = 66044f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::scheduled_exception_address(isolate()); 6615913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck 6625913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // Allocate HandleScope in callee-save registers. 6635913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck Register prev_next_address_reg = r14; 6645913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck Register prev_limit_reg = rbx; 66544f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register base_reg = r15; 6665913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movq(base_reg, next_address); 6675913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movq(prev_next_address_reg, Operand(base_reg, kNextOffset)); 6685913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movq(prev_limit_reg, Operand(base_reg, kLimitOffset)); 6695913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck addl(Operand(base_reg, kLevelOffset), Immediate(1)); 6705913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // Call the api function! 6715913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movq(rax, 6725913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck reinterpret_cast<int64_t>(function->address()), 6735913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck RelocInfo::RUNTIME_ENTRY); 6745913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck call(rax); 675bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 6765913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck#ifdef _WIN64 6775913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // rax keeps a pointer to v8::Handle, unpack it. 6785913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movq(rax, Operand(rax, 0)); 6795913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck#endif 6805913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // Check if the result handle holds 0. 6815913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck testq(rax, rax); 6825913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck j(zero, &empty_result); 6835913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // It was non-zero. Dereference to get the result value. 6845913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movq(rax, Operand(rax, 0)); 6855913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck bind(&prologue); 6865913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck 6875913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // No more valid handles (the result handle was the last one). Restore 6885913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // previous handle scope. 6895913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck subl(Operand(base_reg, kLevelOffset), Immediate(1)); 6905913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movq(Operand(base_reg, kNextOffset), prev_next_address_reg); 6915913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck cmpq(prev_limit_reg, Operand(base_reg, kLimitOffset)); 6925913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck j(not_equal, &delete_allocated_handles); 6935913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck bind(&leave_exit_frame); 6945913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck 6955913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // Check if the function scheduled an exception. 6965913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movq(rsi, scheduled_exception_address); 69744f0eee88ff00398ff7f715fab053374d808c90dSteve Block Cmp(Operand(rsi, 0), FACTORY->the_hole_value()); 6985913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck j(not_equal, &promote_scheduled_exception); 6995913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck 7008a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang LeaveApiExitFrame(); 7018a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang ret(stack_space * kPointerSize); 702bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 7035913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck bind(&promote_scheduled_exception); 7048a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang MaybeObject* result = TryTailCallRuntime(Runtime::kPromoteScheduledException, 7058a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 0, 1); 7068a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang if (result->IsFailure()) { 7078a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang return result; 7088a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang } 709bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 7105913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck bind(&empty_result); 7115913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // It was zero; the result is undefined. 71244f0eee88ff00398ff7f715fab053374d808c90dSteve Block Move(rax, FACTORY->undefined_value()); 7135913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck jmp(&prologue); 714bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 7155913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // HandleScope limit has changed. Delete allocated extensions. 7165913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck bind(&delete_allocated_handles); 7175913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movq(Operand(base_reg, kLimitOffset), prev_limit_reg); 7185913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movq(prev_limit_reg, rax); 71944f0eee88ff00398ff7f715fab053374d808c90dSteve Block#ifdef _WIN64 72044f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(rcx, ExternalReference::isolate_address()); 72144f0eee88ff00398ff7f715fab053374d808c90dSteve Block#else 72244f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(rdi, ExternalReference::isolate_address()); 72344f0eee88ff00398ff7f715fab053374d808c90dSteve Block#endif 72444f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(rax, 72544f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::delete_handle_scope_extensions(isolate())); 7265913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck call(rax); 7275913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movq(rax, prev_limit_reg); 7285913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck jmp(&leave_exit_frame); 7298a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 7308a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang return result; 731bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch} 732bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 733bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 7346ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::JumpToExternalReference(const ExternalReference& ext, 7356ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int result_size) { 736a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Set the entry point and jump to the C entry runtime stub. 73744f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(rbx, ext); 738a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CEntryStub ces(result_size); 7393ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block jmp(ces.GetCode(), RelocInfo::CODE_TARGET); 740a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 741a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 742a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 7438a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) WangMaybeObject* MacroAssembler::TryJumpToExternalReference( 7448a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang const ExternalReference& ext, int result_size) { 7458a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // Set the entry point and jump to the C entry runtime stub. 74644f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(rbx, ext); 7478a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang CEntryStub ces(result_size); 7488a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang return TryTailCallStub(&ces); 7498a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang} 7508a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 7518a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 752e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::InvokeBuiltin(Builtins::JavaScript id, 753e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch InvokeFlag flag, 75444f0eee88ff00398ff7f715fab053374d808c90dSteve Block CallWrapper* call_wrapper) { 755402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu // Calls are not allowed in some stubs. 756402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu ASSERT(flag == JUMP_FUNCTION || allow_stub_calls()); 757a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 758402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu // Rely on the assertion to check that the number of provided 759402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu // arguments match the expected number of arguments. Fake a 760402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu // parameter count to avoid emitting code to do the check. 761402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu ParameterCount expected(0); 762402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu GetBuiltinEntry(rdx, id); 76344f0eee88ff00398ff7f715fab053374d808c90dSteve Block InvokeCode(rdx, expected, expected, flag, call_wrapper); 764a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 765a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 766402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 767791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Blockvoid MacroAssembler::GetBuiltinFunction(Register target, 768791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block Builtins::JavaScript id) { 7696ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Load the builtins object into target register. 7706ded16be15dd865a9b21ea304d5273c8be299c87Steve Block movq(target, Operand(rsi, Context::SlotOffset(Context::GLOBAL_INDEX))); 7716ded16be15dd865a9b21ea304d5273c8be299c87Steve Block movq(target, FieldOperand(target, GlobalObject::kBuiltinsOffset)); 772791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block movq(target, FieldOperand(target, 773791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block JSBuiltinsObject::OffsetOfFunctionWithId(id))); 774791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block} 7756ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 7766ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 777791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Blockvoid MacroAssembler::GetBuiltinEntry(Register target, Builtins::JavaScript id) { 778791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block ASSERT(!target.is(rdi)); 779791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block // Load the JavaScript builtin function from the builtins object. 780791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block GetBuiltinFunction(rdi, id); 781791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block movq(target, FieldOperand(rdi, JSFunction::kCodeEntryOffset)); 782a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 783a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 784a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 785a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Set(Register dst, int64_t x) { 786a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (x == 0) { 7878defd9ff6930b4e24729971a61cf7469daf119beSteve Block xorl(dst, dst); 788a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else if (is_int32(x)) { 789d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block movq(dst, Immediate(static_cast<int32_t>(x))); 790a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else if (is_uint32(x)) { 791d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block movl(dst, Immediate(static_cast<uint32_t>(x))); 792a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 793a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(dst, x, RelocInfo::NONE); 794a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 795a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 796a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 797a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Set(const Operand& dst, int64_t x) { 7989dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen if (is_int32(x)) { 799d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block movq(dst, Immediate(static_cast<int32_t>(x))); 800a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 801a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(kScratchRegister, x, RelocInfo::NONE); 802a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(dst, kScratchRegister); 803a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 804a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 805a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 806a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// ---------------------------------------------------------------------------- 807a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// Smi tagging, untagging and tag detection. 808a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 8098defd9ff6930b4e24729971a61cf7469daf119beSteve BlockRegister MacroAssembler::GetSmiConstant(Smi* source) { 8108defd9ff6930b4e24729971a61cf7469daf119beSteve Block int value = source->value(); 8118defd9ff6930b4e24729971a61cf7469daf119beSteve Block if (value == 0) { 8128defd9ff6930b4e24729971a61cf7469daf119beSteve Block xorl(kScratchRegister, kScratchRegister); 8138defd9ff6930b4e24729971a61cf7469daf119beSteve Block return kScratchRegister; 8148defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 8158defd9ff6930b4e24729971a61cf7469daf119beSteve Block if (value == 1) { 8168defd9ff6930b4e24729971a61cf7469daf119beSteve Block return kSmiConstantRegister; 8178defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 8188defd9ff6930b4e24729971a61cf7469daf119beSteve Block LoadSmiConstant(kScratchRegister, source); 8198defd9ff6930b4e24729971a61cf7469daf119beSteve Block return kScratchRegister; 8208defd9ff6930b4e24729971a61cf7469daf119beSteve Block} 8218defd9ff6930b4e24729971a61cf7469daf119beSteve Block 8228defd9ff6930b4e24729971a61cf7469daf119beSteve Blockvoid MacroAssembler::LoadSmiConstant(Register dst, Smi* source) { 82344f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 8248defd9ff6930b4e24729971a61cf7469daf119beSteve Block movq(dst, 8258defd9ff6930b4e24729971a61cf7469daf119beSteve Block reinterpret_cast<uint64_t>(Smi::FromInt(kSmiConstantRegisterValue)), 8268defd9ff6930b4e24729971a61cf7469daf119beSteve Block RelocInfo::NONE); 8278defd9ff6930b4e24729971a61cf7469daf119beSteve Block cmpq(dst, kSmiConstantRegister); 8288defd9ff6930b4e24729971a61cf7469daf119beSteve Block if (allow_stub_calls()) { 8298defd9ff6930b4e24729971a61cf7469daf119beSteve Block Assert(equal, "Uninitialized kSmiConstantRegister"); 8308defd9ff6930b4e24729971a61cf7469daf119beSteve Block } else { 8310d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel ok; 8328defd9ff6930b4e24729971a61cf7469daf119beSteve Block j(equal, &ok); 8338defd9ff6930b4e24729971a61cf7469daf119beSteve Block int3(); 8348defd9ff6930b4e24729971a61cf7469daf119beSteve Block bind(&ok); 8358defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 8368defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 83744f0eee88ff00398ff7f715fab053374d808c90dSteve Block int value = source->value(); 83844f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (value == 0) { 8398defd9ff6930b4e24729971a61cf7469daf119beSteve Block xorl(dst, dst); 8408defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 8418defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 8428defd9ff6930b4e24729971a61cf7469daf119beSteve Block bool negative = value < 0; 8438defd9ff6930b4e24729971a61cf7469daf119beSteve Block unsigned int uvalue = negative ? -value : value; 8448defd9ff6930b4e24729971a61cf7469daf119beSteve Block 8458defd9ff6930b4e24729971a61cf7469daf119beSteve Block switch (uvalue) { 8468defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 9: 8478defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(kSmiConstantRegister, kSmiConstantRegister, times_8, 0)); 8488defd9ff6930b4e24729971a61cf7469daf119beSteve Block break; 8498defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 8: 8508defd9ff6930b4e24729971a61cf7469daf119beSteve Block xorl(dst, dst); 8518defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(dst, kSmiConstantRegister, times_8, 0)); 8528defd9ff6930b4e24729971a61cf7469daf119beSteve Block break; 8538defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 4: 8548defd9ff6930b4e24729971a61cf7469daf119beSteve Block xorl(dst, dst); 8558defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(dst, kSmiConstantRegister, times_4, 0)); 8568defd9ff6930b4e24729971a61cf7469daf119beSteve Block break; 8578defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 5: 8588defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(kSmiConstantRegister, kSmiConstantRegister, times_4, 0)); 8598defd9ff6930b4e24729971a61cf7469daf119beSteve Block break; 8608defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 3: 8618defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(kSmiConstantRegister, kSmiConstantRegister, times_2, 0)); 8628defd9ff6930b4e24729971a61cf7469daf119beSteve Block break; 8638defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 2: 8648defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(kSmiConstantRegister, kSmiConstantRegister, times_1, 0)); 8658defd9ff6930b4e24729971a61cf7469daf119beSteve Block break; 8668defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 1: 8678defd9ff6930b4e24729971a61cf7469daf119beSteve Block movq(dst, kSmiConstantRegister); 8688defd9ff6930b4e24729971a61cf7469daf119beSteve Block break; 8698defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 0: 8708defd9ff6930b4e24729971a61cf7469daf119beSteve Block UNREACHABLE(); 8718defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 8728defd9ff6930b4e24729971a61cf7469daf119beSteve Block default: 8738defd9ff6930b4e24729971a61cf7469daf119beSteve Block movq(dst, reinterpret_cast<uint64_t>(source), RelocInfo::NONE); 8748defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 8758defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 8768defd9ff6930b4e24729971a61cf7469daf119beSteve Block if (negative) { 8778defd9ff6930b4e24729971a61cf7469daf119beSteve Block neg(dst); 8788defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 8798defd9ff6930b4e24729971a61cf7469daf119beSteve Block} 8808defd9ff6930b4e24729971a61cf7469daf119beSteve Block 881a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 8820d5e116f6aee03185f237311a943491bb079a768Kristian Monsenvoid MacroAssembler::Integer32ToSmi(Register dst, Register src) { 883a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT_EQ(0, kSmiTag); 884a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (!dst.is(src)) { 885a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movl(dst, src); 886a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 8873ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block shl(dst, Immediate(kSmiShift)); 888a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 889a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 890a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 8919dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsenvoid MacroAssembler::Integer32ToSmiField(const Operand& dst, Register src) { 89244f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 8939dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen testb(dst, Immediate(0x01)); 8940d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel ok; 8959dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen j(zero, &ok); 8969dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen if (allow_stub_calls()) { 8979dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Abort("Integer32ToSmiField writing to non-smi location"); 8989dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } else { 8999dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen int3(); 9009dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } 9019dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen bind(&ok); 9029dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } 9039dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen ASSERT(kSmiShift % kBitsPerByte == 0); 9049dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen movl(Operand(dst, kSmiShift / kBitsPerByte), src); 9059dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen} 9069dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 9079dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 9083ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::Integer64PlusConstantToSmi(Register dst, 9093ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Register src, 9103ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block int constant) { 9113ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (dst.is(src)) { 91244f0eee88ff00398ff7f715fab053374d808c90dSteve Block addl(dst, Immediate(constant)); 9133ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else { 91444f0eee88ff00398ff7f715fab053374d808c90dSteve Block leal(dst, Operand(src, constant)); 9153ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 9163ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block shl(dst, Immediate(kSmiShift)); 917a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 918a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 919a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 920a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::SmiToInteger32(Register dst, Register src) { 921a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT_EQ(0, kSmiTag); 922a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (!dst.is(src)) { 9233ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src); 924a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 9253ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block shr(dst, Immediate(kSmiShift)); 926a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 927a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 928a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 9297f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdochvoid MacroAssembler::SmiToInteger32(Register dst, const Operand& src) { 9307f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch movl(dst, Operand(src, kSmiShift / kBitsPerByte)); 9317f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch} 9327f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 9337f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 934a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::SmiToInteger64(Register dst, Register src) { 935a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT_EQ(0, kSmiTag); 9363ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (!dst.is(src)) { 9373ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src); 938a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 9393ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block sar(dst, Immediate(kSmiShift)); 940a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 941a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 942a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 9439dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsenvoid MacroAssembler::SmiToInteger64(Register dst, const Operand& src) { 9449dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen movsxlq(dst, Operand(src, kSmiShift / kBitsPerByte)); 9459dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen} 9469dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 9479dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 9483ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::SmiTest(Register src) { 9493ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block testq(src, src); 950a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 951a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 952a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 95344f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::SmiCompare(Register smi1, Register smi2) { 95444f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 95544f0eee88ff00398ff7f715fab053374d808c90dSteve Block AbortIfNotSmi(smi1); 95644f0eee88ff00398ff7f715fab053374d808c90dSteve Block AbortIfNotSmi(smi2); 95744f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 95844f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmpq(smi1, smi2); 959a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 960a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 961a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 9623ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::SmiCompare(Register dst, Smi* src) { 96344f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 96444f0eee88ff00398ff7f715fab053374d808c90dSteve Block AbortIfNotSmi(dst); 96544f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 96644f0eee88ff00398ff7f715fab053374d808c90dSteve Block Cmp(dst, src); 96744f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 96844f0eee88ff00398ff7f715fab053374d808c90dSteve Block 96944f0eee88ff00398ff7f715fab053374d808c90dSteve Block 97044f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::Cmp(Register dst, Smi* src) { 9713ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!dst.is(kScratchRegister)); 9723ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (src->value() == 0) { 9733ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block testq(dst, dst); 9743ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else { 975756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick Register constant_reg = GetSmiConstant(src); 976756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick cmpq(dst, constant_reg); 977a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 978a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 979a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 980a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 981f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarkevoid MacroAssembler::SmiCompare(Register dst, const Operand& src) { 98244f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 98344f0eee88ff00398ff7f715fab053374d808c90dSteve Block AbortIfNotSmi(dst); 98444f0eee88ff00398ff7f715fab053374d808c90dSteve Block AbortIfNotSmi(src); 98544f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 9866ded16be15dd865a9b21ea304d5273c8be299c87Steve Block cmpq(dst, src); 9876ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 9886ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 9896ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 9903ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::SmiCompare(const Operand& dst, Register src) { 99144f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 99244f0eee88ff00398ff7f715fab053374d808c90dSteve Block AbortIfNotSmi(dst); 99344f0eee88ff00398ff7f715fab053374d808c90dSteve Block AbortIfNotSmi(src); 99444f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 9953ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block cmpq(dst, src); 996a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 997a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 998a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 9993ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::SmiCompare(const Operand& dst, Smi* src) { 100044f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 100144f0eee88ff00398ff7f715fab053374d808c90dSteve Block AbortIfNotSmi(dst); 100244f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 10037f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch cmpl(Operand(dst, kSmiShift / kBitsPerByte), Immediate(src->value())); 1004a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1005a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1006a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 100744f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::Cmp(const Operand& dst, Smi* src) { 100844f0eee88ff00398ff7f715fab053374d808c90dSteve Block // The Operand cannot use the smi register. 100944f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register smi_reg = GetSmiConstant(src); 101044f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(!dst.AddressUsesRegister(smi_reg)); 101144f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmpq(dst, smi_reg); 101244f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 101344f0eee88ff00398ff7f715fab053374d808c90dSteve Block 101444f0eee88ff00398ff7f715fab053374d808c90dSteve Block 10159dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsenvoid MacroAssembler::SmiCompareInteger32(const Operand& dst, Register src) { 10169dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen cmpl(Operand(dst, kSmiShift / kBitsPerByte), src); 10179dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen} 10189dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 10199dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 10203ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::PositiveSmiTimesPowerOfTwoToInteger64(Register dst, 10213ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Register src, 10223ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block int power) { 10233ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(power >= 0); 10243ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(power < 64); 10253ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (power == 0) { 10263ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block SmiToInteger64(dst, src); 10273ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block return; 10283ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 10293ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (!dst.is(src)) { 10303ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src); 10313ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 10323ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (power < kSmiShift) { 10333ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block sar(dst, Immediate(kSmiShift - power)); 10343ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else if (power > kSmiShift) { 10353ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block shl(dst, Immediate(power - kSmiShift)); 10363ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 1037a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1038a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1039a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 10407f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdochvoid MacroAssembler::PositiveSmiDivPowerOfTwoToInteger32(Register dst, 10417f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch Register src, 10427f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch int power) { 10437f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch ASSERT((0 <= power) && (power < 32)); 10447f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch if (dst.is(src)) { 10457f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch shr(dst, Immediate(power + kSmiShift)); 10467f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch } else { 10477f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch UNIMPLEMENTED(); // Not used. 10487f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch } 10497f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch} 10507f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 10517f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 10523ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve BlockCondition MacroAssembler::CheckSmi(Register src) { 1053a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT_EQ(0, kSmiTag); 1054a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block testb(src, Immediate(kSmiTagMask)); 10553ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block return zero; 1056a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1057a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1058a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 10591e0659c275bb392c045087af4f6b0d7565cb3d77Steve BlockCondition MacroAssembler::CheckSmi(const Operand& src) { 10601e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ASSERT_EQ(0, kSmiTag); 10611e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block testb(src, Immediate(kSmiTagMask)); 10621e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block return zero; 10631e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 10641e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 10651e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 1066f87a203d89e1bbb6708282e0b64dbd13d59b723dBen MurdochCondition MacroAssembler::CheckNonNegativeSmi(Register src) { 1067a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT_EQ(0, kSmiTag); 1068e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Test that both bits of the mask 0x8000000000000001 are zero. 10693ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(kScratchRegister, src); 10703ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block rol(kScratchRegister, Immediate(1)); 10718defd9ff6930b4e24729971a61cf7469daf119beSteve Block testb(kScratchRegister, Immediate(3)); 1072a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return zero; 1073a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1074a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1075a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1076a7e24c173cf37484693b9abb38e494fa7bd7baebSteve BlockCondition MacroAssembler::CheckBothSmi(Register first, Register second) { 1077a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (first.is(second)) { 1078a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return CheckSmi(first); 1079a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 10808defd9ff6930b4e24729971a61cf7469daf119beSteve Block ASSERT(kSmiTag == 0 && kHeapObjectTag == 1 && kHeapObjectTagMask == 3); 10818defd9ff6930b4e24729971a61cf7469daf119beSteve Block leal(kScratchRegister, Operand(first, second, times_1, 0)); 10828defd9ff6930b4e24729971a61cf7469daf119beSteve Block testb(kScratchRegister, Immediate(0x03)); 10833ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block return zero; 1084a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1085a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1086a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1087f87a203d89e1bbb6708282e0b64dbd13d59b723dBen MurdochCondition MacroAssembler::CheckBothNonNegativeSmi(Register first, 1088f87a203d89e1bbb6708282e0b64dbd13d59b723dBen Murdoch Register second) { 1089d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke if (first.is(second)) { 1090f87a203d89e1bbb6708282e0b64dbd13d59b723dBen Murdoch return CheckNonNegativeSmi(first); 1091d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke } 10928defd9ff6930b4e24729971a61cf7469daf119beSteve Block movq(kScratchRegister, first); 10938defd9ff6930b4e24729971a61cf7469daf119beSteve Block or_(kScratchRegister, second); 1094d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke rol(kScratchRegister, Immediate(1)); 1095f87a203d89e1bbb6708282e0b64dbd13d59b723dBen Murdoch testl(kScratchRegister, Immediate(3)); 1096d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke return zero; 1097d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke} 1098d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke 1099d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke 1100bb769b257e753aafcbd96767abb2abc645eaa20cBen MurdochCondition MacroAssembler::CheckEitherSmi(Register first, 1101bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch Register second, 1102bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch Register scratch) { 1103e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke if (first.is(second)) { 1104e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke return CheckSmi(first); 1105e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke } 1106bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch if (scratch.is(second)) { 1107bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch andl(scratch, first); 1108bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch } else { 1109bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch if (!scratch.is(first)) { 1110bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch movl(scratch, first); 1111bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch } 1112bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch andl(scratch, second); 1113bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch } 1114bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch testb(scratch, Immediate(kSmiTagMask)); 1115e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke return zero; 1116e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke} 1117e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 1118e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 1119a7e24c173cf37484693b9abb38e494fa7bd7baebSteve BlockCondition MacroAssembler::CheckIsMinSmi(Register src) { 11208defd9ff6930b4e24729971a61cf7469daf119beSteve Block ASSERT(!src.is(kScratchRegister)); 11218defd9ff6930b4e24729971a61cf7469daf119beSteve Block // If we overflow by subtracting one, it's the minimal smi value. 11228defd9ff6930b4e24729971a61cf7469daf119beSteve Block cmpq(src, kSmiConstantRegister); 11238defd9ff6930b4e24729971a61cf7469daf119beSteve Block return overflow; 1124a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1125a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1126a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 11273ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve BlockCondition MacroAssembler::CheckInteger32ValidSmiValue(Register src) { 11283ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block // A 32-bit integer value can always be converted to a smi. 11293ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block return always; 1130a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1131a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1132a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 11333ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve BlockCondition MacroAssembler::CheckUInteger32ValidSmiValue(Register src) { 11343ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block // An unsigned 32-bit integer value is valid as long as the high bit 11353ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block // is not set. 11368defd9ff6930b4e24729971a61cf7469daf119beSteve Block testl(src, src); 11378defd9ff6930b4e24729971a61cf7469daf119beSteve Block return positive; 1138a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1139a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1140a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 11411e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::CheckSmiToIndicator(Register dst, Register src) { 11421e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block if (dst.is(src)) { 11431e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block andl(dst, Immediate(kSmiTagMask)); 11441e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } else { 11451e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block movl(dst, Immediate(kSmiTagMask)); 11461e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block andl(dst, src); 11471e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } 11481e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 11491e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 11501e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 11511e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::CheckSmiToIndicator(Register dst, const Operand& src) { 11521e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block if (!(src.AddressUsesRegister(dst))) { 11531e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block movl(dst, Immediate(kSmiTagMask)); 11541e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block andl(dst, src); 11551e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } else { 11561e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block movl(dst, src); 11571e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block andl(dst, Immediate(kSmiTagMask)); 11581e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } 11591e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 11601e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 11611e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 11623ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::SmiAddConstant(Register dst, Register src, Smi* constant) { 11633ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (constant->value() == 0) { 11643ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (!dst.is(src)) { 11653ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src); 11663ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 11678defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 11683ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else if (dst.is(src)) { 11693ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!dst.is(kScratchRegister)); 11708defd9ff6930b4e24729971a61cf7469daf119beSteve Block switch (constant->value()) { 11718defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 1: 11728defd9ff6930b4e24729971a61cf7469daf119beSteve Block addq(dst, kSmiConstantRegister); 11738defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 11748defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 2: 11758defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(src, kSmiConstantRegister, times_2, 0)); 11768defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 11778defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 4: 11788defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(src, kSmiConstantRegister, times_4, 0)); 11798defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 11808defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 8: 11818defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(src, kSmiConstantRegister, times_8, 0)); 11828defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 11838defd9ff6930b4e24729971a61cf7469daf119beSteve Block default: 11848defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register constant_reg = GetSmiConstant(constant); 11858defd9ff6930b4e24729971a61cf7469daf119beSteve Block addq(dst, constant_reg); 11868defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 11878defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 1188a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 11898defd9ff6930b4e24729971a61cf7469daf119beSteve Block switch (constant->value()) { 11908defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 1: 11918defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(src, kSmiConstantRegister, times_1, 0)); 11928defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 11938defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 2: 11948defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(src, kSmiConstantRegister, times_2, 0)); 11958defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 11968defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 4: 11978defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(src, kSmiConstantRegister, times_4, 0)); 11988defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 11998defd9ff6930b4e24729971a61cf7469daf119beSteve Block case 8: 12008defd9ff6930b4e24729971a61cf7469daf119beSteve Block lea(dst, Operand(src, kSmiConstantRegister, times_8, 0)); 12018defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 12028defd9ff6930b4e24729971a61cf7469daf119beSteve Block default: 12038defd9ff6930b4e24729971a61cf7469daf119beSteve Block LoadSmiConstant(dst, constant); 12048defd9ff6930b4e24729971a61cf7469daf119beSteve Block addq(dst, src); 12058defd9ff6930b4e24729971a61cf7469daf119beSteve Block return; 12068defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 1207a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1208a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1209a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1210a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1211f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarkevoid MacroAssembler::SmiAddConstant(const Operand& dst, Smi* constant) { 1212f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke if (constant->value() != 0) { 12137f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch addl(Operand(dst, kSmiShift / kBitsPerByte), Immediate(constant->value())); 1214f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke } 1215f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke} 1216f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke 1217f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke 12183ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::SmiSubConstant(Register dst, Register src, Smi* constant) { 12193ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (constant->value() == 0) { 1220a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (!dst.is(src)) { 12213ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src); 1222a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 12233ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else if (dst.is(src)) { 12243ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!dst.is(kScratchRegister)); 12258defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register constant_reg = GetSmiConstant(constant); 12268defd9ff6930b4e24729971a61cf7469daf119beSteve Block subq(dst, constant_reg); 12273ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else { 12283ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (constant->value() == Smi::kMinValue) { 12298defd9ff6930b4e24729971a61cf7469daf119beSteve Block LoadSmiConstant(dst, constant); 12309dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen // Adding and subtracting the min-value gives the same result, it only 12319dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen // differs on the overflow bit, which we don't check here. 12329dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen addq(dst, src); 1233a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 12349dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen // Subtract by adding the negation. 12358defd9ff6930b4e24729971a61cf7469daf119beSteve Block LoadSmiConstant(dst, Smi::FromInt(-constant->value())); 12363ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block addq(dst, src); 1237a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1238a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1239a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1240a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1241a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 12420d5e116f6aee03185f237311a943491bb079a768Kristian Monsenvoid MacroAssembler::SmiAdd(Register dst, 12430d5e116f6aee03185f237311a943491bb079a768Kristian Monsen Register src1, 12440d5e116f6aee03185f237311a943491bb079a768Kristian Monsen Register src2) { 12450d5e116f6aee03185f237311a943491bb079a768Kristian Monsen // No overflow checking. Use only when it's known that 12460d5e116f6aee03185f237311a943491bb079a768Kristian Monsen // overflowing is impossible. 12470d5e116f6aee03185f237311a943491bb079a768Kristian Monsen ASSERT(!dst.is(src2)); 124844f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (!dst.is(src1)) { 12490d5e116f6aee03185f237311a943491bb079a768Kristian Monsen movq(dst, src1); 1250a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 125144f0eee88ff00398ff7f715fab053374d808c90dSteve Block addq(dst, src2); 12520d5e116f6aee03185f237311a943491bb079a768Kristian Monsen Assert(no_overflow, "Smi addition overflow"); 1253a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1254a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1255a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 12560d5e116f6aee03185f237311a943491bb079a768Kristian Monsenvoid MacroAssembler::SmiSub(Register dst, Register src1, Register src2) { 12570d5e116f6aee03185f237311a943491bb079a768Kristian Monsen // No overflow checking. Use only when it's known that 12580d5e116f6aee03185f237311a943491bb079a768Kristian Monsen // overflowing is impossible (e.g., subtracting two positive smis). 12590d5e116f6aee03185f237311a943491bb079a768Kristian Monsen ASSERT(!dst.is(src2)); 126044f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (!dst.is(src1)) { 12610d5e116f6aee03185f237311a943491bb079a768Kristian Monsen movq(dst, src1); 12623ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 126344f0eee88ff00398ff7f715fab053374d808c90dSteve Block subq(dst, src2); 12640d5e116f6aee03185f237311a943491bb079a768Kristian Monsen Assert(no_overflow, "Smi subtraction overflow"); 1265a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1266a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1267a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 12680d5e116f6aee03185f237311a943491bb079a768Kristian Monsenvoid MacroAssembler::SmiSub(Register dst, 1269a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register src1, 12700d5e116f6aee03185f237311a943491bb079a768Kristian Monsen const Operand& src2) { 12710d5e116f6aee03185f237311a943491bb079a768Kristian Monsen // No overflow checking. Use only when it's known that 12720d5e116f6aee03185f237311a943491bb079a768Kristian Monsen // overflowing is impossible (e.g., subtracting two positive smis). 127344f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (!dst.is(src1)) { 12740d5e116f6aee03185f237311a943491bb079a768Kristian Monsen movq(dst, src1); 1275a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 127644f0eee88ff00398ff7f715fab053374d808c90dSteve Block subq(dst, src2); 12770d5e116f6aee03185f237311a943491bb079a768Kristian Monsen Assert(no_overflow, "Smi subtraction overflow"); 1278a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1279a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1280a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1281a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::SmiNot(Register dst, Register src) { 12823ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!dst.is(kScratchRegister)); 12833ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!src.is(kScratchRegister)); 12843ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block // Set tag and padding bits before negating, so that they are zero afterwards. 12853ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movl(kScratchRegister, Immediate(~0)); 1286a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (dst.is(src)) { 12873ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block xor_(dst, kScratchRegister); 1288a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 12893ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block lea(dst, Operand(src, kScratchRegister, times_1, 0)); 1290a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 12913ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block not_(dst); 1292a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1293a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1294a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1295a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::SmiAnd(Register dst, Register src1, Register src2) { 12963ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!dst.is(src2)); 1297a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (!dst.is(src1)) { 12983ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src1); 1299a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1300a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block and_(dst, src2); 1301a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1302a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1303a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 13043ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::SmiAndConstant(Register dst, Register src, Smi* constant) { 13053ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (constant->value() == 0) { 13069fac840a46e8b7e26894f4792ba26dde14c56b04Steve Block Set(dst, 0); 13073ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else if (dst.is(src)) { 13083ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!dst.is(kScratchRegister)); 13098defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register constant_reg = GetSmiConstant(constant); 13108defd9ff6930b4e24729971a61cf7469daf119beSteve Block and_(dst, constant_reg); 13113ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else { 13128defd9ff6930b4e24729971a61cf7469daf119beSteve Block LoadSmiConstant(dst, constant); 13133ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block and_(dst, src); 1314a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1315a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1316a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1317a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1318a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::SmiOr(Register dst, Register src1, Register src2) { 1319a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (!dst.is(src1)) { 13203ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src1); 1321a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1322a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block or_(dst, src2); 1323a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1324a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1325a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 13263ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::SmiOrConstant(Register dst, Register src, Smi* constant) { 13273ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (dst.is(src)) { 13283ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!dst.is(kScratchRegister)); 13298defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register constant_reg = GetSmiConstant(constant); 13308defd9ff6930b4e24729971a61cf7469daf119beSteve Block or_(dst, constant_reg); 13313ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else { 13328defd9ff6930b4e24729971a61cf7469daf119beSteve Block LoadSmiConstant(dst, constant); 13333ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block or_(dst, src); 1334a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1335a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1336a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 13373ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block 1338a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::SmiXor(Register dst, Register src1, Register src2) { 1339a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (!dst.is(src1)) { 13403ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src1); 1341a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1342a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block xor_(dst, src2); 1343a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1344a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1345a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 13463ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::SmiXorConstant(Register dst, Register src, Smi* constant) { 13473ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (dst.is(src)) { 13483ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!dst.is(kScratchRegister)); 13498defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register constant_reg = GetSmiConstant(constant); 13508defd9ff6930b4e24729971a61cf7469daf119beSteve Block xor_(dst, constant_reg); 13513ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else { 13528defd9ff6930b4e24729971a61cf7469daf119beSteve Block LoadSmiConstant(dst, constant); 13533ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block xor_(dst, src); 1354a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1355a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1356a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1357a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1358a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::SmiShiftArithmeticRightConstant(Register dst, 1359a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register src, 1360a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int shift_value) { 13613ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(is_uint5(shift_value)); 1362a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (shift_value > 0) { 1363a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (dst.is(src)) { 13643ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block sar(dst, Immediate(shift_value + kSmiShift)); 13653ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block shl(dst, Immediate(kSmiShift)); 1366a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 1367a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block UNIMPLEMENTED(); // Not used. 1368a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1369a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1370a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1371a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1372a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1373a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::SmiShiftLeftConstant(Register dst, 1374a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register src, 137525f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen int shift_value) { 13763ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (!dst.is(src)) { 13773ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src); 13783ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 13793ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (shift_value > 0) { 13803ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block shl(dst, Immediate(shift_value)); 1381a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1382a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1383a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1384a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1385a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::SmiShiftLeft(Register dst, 1386a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register src1, 138725f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen Register src2) { 1388a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!dst.is(rcx)); 13890d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel result_ok; 13903ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block // Untag shift amount. 13913ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (!dst.is(src1)) { 13923ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src1); 1393a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 13943ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block SmiToInteger32(rcx, src2); 13953ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block // Shift amount specified by lower 5 bits, not six as the shl opcode. 13963ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block and_(rcx, Immediate(0x1f)); 1397d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block shl_cl(dst); 1398a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1399a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1400a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1401a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::SmiShiftArithmeticRight(Register dst, 1402a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register src1, 1403a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register src2) { 14043ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!dst.is(kScratchRegister)); 14053ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!src1.is(kScratchRegister)); 14063ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!src2.is(kScratchRegister)); 1407a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!dst.is(rcx)); 14083ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (src1.is(rcx)) { 14093ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(kScratchRegister, src1); 14103ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else if (src2.is(rcx)) { 14113ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(kScratchRegister, src2); 14123ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 14133ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (!dst.is(src1)) { 14143ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src1); 14153ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 1416a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block SmiToInteger32(rcx, src2); 14173ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block orl(rcx, Immediate(kSmiShift)); 1418d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block sar_cl(dst); // Shift 32 + original rcx & 0x1f. 14193ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block shl(dst, Immediate(kSmiShift)); 14203ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (src1.is(rcx)) { 14213ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(src1, kScratchRegister); 14223ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else if (src2.is(rcx)) { 14233ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(src2, kScratchRegister); 14243ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 1425a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1426a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1427a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 14283ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve BlockSmiIndex MacroAssembler::SmiToIndex(Register dst, 14293ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Register src, 14303ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block int shift) { 1431a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(is_uint6(shift)); 14323ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block // There is a possible optimization if shift is in the range 60-63, but that 14333ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block // will (and must) never happen. 14343ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (!dst.is(src)) { 14353ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src); 14363ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 14373ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (shift < kSmiShift) { 14383ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block sar(dst, Immediate(kSmiShift - shift)); 14393ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else { 14403ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block shl(dst, Immediate(shift - kSmiShift)); 14413ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 1442a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return SmiIndex(dst, times_1); 1443a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1444a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1445a7e24c173cf37484693b9abb38e494fa7bd7baebSteve BlockSmiIndex MacroAssembler::SmiToNegativeIndex(Register dst, 1446a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register src, 1447a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int shift) { 1448a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Register src holds a positive smi. 1449a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(is_uint6(shift)); 14503ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (!dst.is(src)) { 14513ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(dst, src); 1452a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1453a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block neg(dst); 14543ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (shift < kSmiShift) { 14553ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block sar(dst, Immediate(kSmiShift - shift)); 14563ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else { 14573ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block shl(dst, Immediate(shift - kSmiShift)); 14583ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 1459a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return SmiIndex(dst, times_1); 1460a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1461a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1462a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 146344f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::AddSmiField(Register dst, const Operand& src) { 146444f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT_EQ(0, kSmiShift % kBitsPerByte); 146544f0eee88ff00398ff7f715fab053374d808c90dSteve Block addl(dst, Operand(src, kSmiShift / kBitsPerByte)); 146644f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 146744f0eee88ff00398ff7f715fab053374d808c90dSteve Block 146844f0eee88ff00398ff7f715fab053374d808c90dSteve Block 146944f0eee88ff00398ff7f715fab053374d808c90dSteve Block 14700d5e116f6aee03185f237311a943491bb079a768Kristian Monsenvoid MacroAssembler::Move(Register dst, Register src) { 14710d5e116f6aee03185f237311a943491bb079a768Kristian Monsen if (!dst.is(src)) { 14720d5e116f6aee03185f237311a943491bb079a768Kristian Monsen movq(dst, src); 14736ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 14746ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 14756ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 14766ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 1477a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Move(Register dst, Handle<Object> source) { 1478a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!source->IsFailure()); 1479a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (source->IsSmi()) { 14803ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Move(dst, Smi::cast(*source)); 1481a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 1482a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(dst, source, RelocInfo::EMBEDDED_OBJECT); 1483a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1484a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1485a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1486a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1487a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Move(const Operand& dst, Handle<Object> source) { 14883ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(!source->IsFailure()); 1489a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (source->IsSmi()) { 14903ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Move(dst, Smi::cast(*source)); 1491a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 1492a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(kScratchRegister, source, RelocInfo::EMBEDDED_OBJECT); 1493a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(dst, kScratchRegister); 1494a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1495a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1496a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1497a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1498a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Cmp(Register dst, Handle<Object> source) { 14993ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (source->IsSmi()) { 150044f0eee88ff00398ff7f715fab053374d808c90dSteve Block Cmp(dst, Smi::cast(*source)); 15013ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else { 15023ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Move(kScratchRegister, source); 15033ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block cmpq(dst, kScratchRegister); 15043ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 1505a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1506a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1507a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1508a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Cmp(const Operand& dst, Handle<Object> source) { 1509a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (source->IsSmi()) { 151044f0eee88ff00398ff7f715fab053374d808c90dSteve Block Cmp(dst, Smi::cast(*source)); 1511a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 1512a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(source->IsHeapObject()); 1513a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(kScratchRegister, source, RelocInfo::EMBEDDED_OBJECT); 1514a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmpq(dst, kScratchRegister); 1515a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1516a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1517a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1518a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1519a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Push(Handle<Object> source) { 1520a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (source->IsSmi()) { 15213ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Push(Smi::cast(*source)); 1522a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 1523a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(source->IsHeapObject()); 1524a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(kScratchRegister, source, RelocInfo::EMBEDDED_OBJECT); 1525a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(kScratchRegister); 1526a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1527a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1528a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1529a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1530a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Push(Smi* source) { 15313ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block intptr_t smi = reinterpret_cast<intptr_t>(source); 15323ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block if (is_int32(smi)) { 15333ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block push(Immediate(static_cast<int32_t>(smi))); 15343ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } else { 15358defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register constant = GetSmiConstant(source); 15368defd9ff6930b4e24729971a61cf7469daf119beSteve Block push(constant); 15373ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block } 15383ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block} 15393ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block 15403ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block 1541e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarkevoid MacroAssembler::Drop(int stack_elements) { 1542e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke if (stack_elements > 0) { 1543e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke addq(rsp, Immediate(stack_elements * kPointerSize)); 1544e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke } 1545e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke} 1546e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 1547e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 15483ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::Test(const Operand& src, Smi* source) { 1549f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke testl(Operand(src, kIntSize), Immediate(source->value())); 1550a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1551a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1552a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1553a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Jump(ExternalReference ext) { 155444f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(kScratchRegister, ext); 1555a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block jmp(kScratchRegister); 1556a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1557a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1558a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1559a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Jump(Address destination, RelocInfo::Mode rmode) { 1560a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(kScratchRegister, destination, rmode); 1561a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block jmp(kScratchRegister); 1562a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1563a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1564a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1565a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Jump(Handle<Code> code_object, RelocInfo::Mode rmode) { 15663ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block // TODO(X64): Inline this 15673ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block jmp(code_object, rmode); 1568a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1569a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1570a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 157144f0eee88ff00398ff7f715fab053374d808c90dSteve Blockint MacroAssembler::CallSize(ExternalReference ext) { 157244f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Opcode for call kScratchRegister is: Rex.B FF D4 (three bytes). 157344f0eee88ff00398ff7f715fab053374d808c90dSteve Block const int kCallInstructionSize = 3; 157444f0eee88ff00398ff7f715fab053374d808c90dSteve Block return LoadAddressSize(ext) + kCallInstructionSize; 157544f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 157644f0eee88ff00398ff7f715fab053374d808c90dSteve Block 157744f0eee88ff00398ff7f715fab053374d808c90dSteve Block 1578a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Call(ExternalReference ext) { 157944f0eee88ff00398ff7f715fab053374d808c90dSteve Block#ifdef DEBUG 158044f0eee88ff00398ff7f715fab053374d808c90dSteve Block int end_position = pc_offset() + CallSize(ext); 158144f0eee88ff00398ff7f715fab053374d808c90dSteve Block#endif 158244f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(kScratchRegister, ext); 1583a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block call(kScratchRegister); 158444f0eee88ff00398ff7f715fab053374d808c90dSteve Block#ifdef DEBUG 158544f0eee88ff00398ff7f715fab053374d808c90dSteve Block CHECK_EQ(end_position, pc_offset()); 158644f0eee88ff00398ff7f715fab053374d808c90dSteve Block#endif 1587a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1588a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1589a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1590a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Call(Address destination, RelocInfo::Mode rmode) { 159144f0eee88ff00398ff7f715fab053374d808c90dSteve Block#ifdef DEBUG 159244f0eee88ff00398ff7f715fab053374d808c90dSteve Block int end_position = pc_offset() + CallSize(destination, rmode); 159344f0eee88ff00398ff7f715fab053374d808c90dSteve Block#endif 1594a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(kScratchRegister, destination, rmode); 1595a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block call(kScratchRegister); 159644f0eee88ff00398ff7f715fab053374d808c90dSteve Block#ifdef DEBUG 159744f0eee88ff00398ff7f715fab053374d808c90dSteve Block CHECK_EQ(pc_offset(), end_position); 159844f0eee88ff00398ff7f715fab053374d808c90dSteve Block#endif 1599a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1600a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1601a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1602a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Call(Handle<Code> code_object, RelocInfo::Mode rmode) { 160344f0eee88ff00398ff7f715fab053374d808c90dSteve Block#ifdef DEBUG 160444f0eee88ff00398ff7f715fab053374d808c90dSteve Block int end_position = pc_offset() + CallSize(code_object); 160544f0eee88ff00398ff7f715fab053374d808c90dSteve Block#endif 1606a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(RelocInfo::IsCodeTarget(rmode)); 16073ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block call(code_object, rmode); 160844f0eee88ff00398ff7f715fab053374d808c90dSteve Block#ifdef DEBUG 160944f0eee88ff00398ff7f715fab053374d808c90dSteve Block CHECK_EQ(end_position, pc_offset()); 161044f0eee88ff00398ff7f715fab053374d808c90dSteve Block#endif 1611a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1612a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1613a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 16141e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::Pushad() { 16151e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block push(rax); 16161e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block push(rcx); 16171e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block push(rdx); 16181e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block push(rbx); 16191e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Not pushing rsp or rbp. 16201e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block push(rsi); 16211e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block push(rdi); 16221e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block push(r8); 16231e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block push(r9); 16241e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // r10 is kScratchRegister. 16251e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block push(r11); 162644f0eee88ff00398ff7f715fab053374d808c90dSteve Block // r12 is kSmiConstantRegister. 16271e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // r13 is kRootRegister. 16281e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block push(r14); 162944f0eee88ff00398ff7f715fab053374d808c90dSteve Block push(r15); 1630e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch STATIC_ASSERT(11 == kNumSafepointSavedRegisters); 1631e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Use lea for symmetry with Popad. 1632e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch int sp_delta = 1633e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch (kNumSafepointRegisters - kNumSafepointSavedRegisters) * kPointerSize; 1634e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch lea(rsp, Operand(rsp, -sp_delta)); 16351e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 16361e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 16371e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 16381e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::Popad() { 1639e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Popad must not change the flags, so use lea instead of addq. 1640e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch int sp_delta = 1641e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch (kNumSafepointRegisters - kNumSafepointSavedRegisters) * kPointerSize; 1642e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch lea(rsp, Operand(rsp, sp_delta)); 164344f0eee88ff00398ff7f715fab053374d808c90dSteve Block pop(r15); 16441e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block pop(r14); 16451e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block pop(r11); 16461e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block pop(r9); 16471e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block pop(r8); 16481e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block pop(rdi); 16491e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block pop(rsi); 16501e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block pop(rbx); 16511e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block pop(rdx); 16521e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block pop(rcx); 16531e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block pop(rax); 16541e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 16551e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 16561e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 16571e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::Dropad() { 1658e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch addq(rsp, Immediate(kNumSafepointRegisters * kPointerSize)); 16591e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 16601e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 16611e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 16621e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block// Order general registers are pushed by Pushad: 166344f0eee88ff00398ff7f715fab053374d808c90dSteve Block// rax, rcx, rdx, rbx, rsi, rdi, r8, r9, r11, r14, r15. 16641e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockint MacroAssembler::kSafepointPushRegisterIndices[Register::kNumRegisters] = { 16651e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 0, 16661e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 1, 16671e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 2, 16681e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 3, 16691e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block -1, 16701e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block -1, 16711e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 4, 16721e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 5, 16731e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 6, 16741e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 7, 16751e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block -1, 16761e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 8, 16771e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block -1, 167844f0eee88ff00398ff7f715fab053374d808c90dSteve Block -1, 167944f0eee88ff00398ff7f715fab053374d808c90dSteve Block 9, 168044f0eee88ff00398ff7f715fab053374d808c90dSteve Block 10 16811e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block}; 16821e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 16831e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 1684e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::StoreToSafepointRegisterSlot(Register dst, Register src) { 1685e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(SafepointRegisterSlot(dst), src); 1686e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 1687e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1688e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1689e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::LoadFromSafepointRegisterSlot(Register dst, Register src) { 1690e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(dst, SafepointRegisterSlot(src)); 1691e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 1692e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1693e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1694e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen MurdochOperand MacroAssembler::SafepointRegisterSlot(Register reg) { 1695e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch return Operand(rsp, SafepointRegisterStackIndex(reg.code()) * kPointerSize); 1696e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 1697e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1698e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1699a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::PushTryHandler(CodeLocation try_location, 1700a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block HandlerType type) { 1701a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Adjust this code if not the case. 1702a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(StackHandlerConstants::kSize == 4 * kPointerSize); 1703a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1704a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // The pc (return address) is already on TOS. This code pushes state, 1705a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // frame pointer and current handler. Check that they are expected 1706a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // next on the stack, in that order. 1707a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT_EQ(StackHandlerConstants::kStateOffset, 1708a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block StackHandlerConstants::kPCOffset - kPointerSize); 1709a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT_EQ(StackHandlerConstants::kFPOffset, 1710a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block StackHandlerConstants::kStateOffset - kPointerSize); 1711a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT_EQ(StackHandlerConstants::kNextOffset, 1712a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block StackHandlerConstants::kFPOffset - kPointerSize); 1713a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1714a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (try_location == IN_JAVASCRIPT) { 1715a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (type == TRY_CATCH_HANDLER) { 1716a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(Immediate(StackHandler::TRY_CATCH)); 1717a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 1718a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(Immediate(StackHandler::TRY_FINALLY)); 1719a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1720a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(rbp); 1721a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 1722a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(try_location == IN_JS_ENTRY); 1723a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // The frame pointer does not point to a JS frame so we save NULL 1724a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // for rbp. We expect the code throwing an exception to check rbp 1725a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // before dereferencing it to restore the context. 1726a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(Immediate(StackHandler::ENTRY)); 1727a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(Immediate(0)); // NULL frame pointer. 1728a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1729a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Save the current handler. 173044f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand handler_operand = 173144f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalOperand(ExternalReference(Isolate::k_handler_address, isolate())); 173244f0eee88ff00398ff7f715fab053374d808c90dSteve Block push(handler_operand); 1733a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Link this handler. 173444f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(handler_operand, rsp); 1735a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1736a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1737a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1738e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarkevoid MacroAssembler::PopTryHandler() { 1739e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke ASSERT_EQ(0, StackHandlerConstants::kNextOffset); 1740e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Unlink this handler. 174144f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand handler_operand = 174244f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalOperand(ExternalReference(Isolate::k_handler_address, isolate())); 174344f0eee88ff00398ff7f715fab053374d808c90dSteve Block pop(handler_operand); 1744e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Remove the remaining fields. 1745e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke addq(rsp, Immediate(StackHandlerConstants::kSize - kPointerSize)); 1746e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke} 1747e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 1748e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 1749e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::Throw(Register value) { 1750e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Check that stack should contain next handler, frame pointer, state and 1751e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // return address in that order. 1752e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch STATIC_ASSERT(StackHandlerConstants::kFPOffset + kPointerSize == 1753e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch StackHandlerConstants::kStateOffset); 1754e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch STATIC_ASSERT(StackHandlerConstants::kStateOffset + kPointerSize == 1755e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch StackHandlerConstants::kPCOffset); 1756e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Keep thrown value in rax. 1757e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch if (!value.is(rax)) { 1758e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(rax, value); 1759e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } 1760e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 176144f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference handler_address(Isolate::k_handler_address, isolate()); 176244f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand handler_operand = ExternalOperand(handler_address); 176344f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(rsp, handler_operand); 1764e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // get next in chain 176544f0eee88ff00398ff7f715fab053374d808c90dSteve Block pop(handler_operand); 1766e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch pop(rbp); // pop frame pointer 1767e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch pop(rdx); // remove state 1768e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1769e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Before returning we restore the context from the frame pointer if not NULL. 1770e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // The frame pointer is NULL in the exception handler of a JS entry frame. 1771e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Set(rsi, 0); // Tentatively set context pointer to NULL 1772e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch NearLabel skip; 1773e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch cmpq(rbp, Immediate(0)); 1774e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch j(equal, &skip); 1775e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset)); 1776e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch bind(&skip); 1777e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ret(0); 1778e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 1779e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1780e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1781e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::ThrowUncatchable(UncatchableExceptionType type, 1782e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register value) { 1783e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Keep thrown value in rax. 1784e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch if (!value.is(rax)) { 1785e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(rax, value); 1786e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } 1787e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Fetch top stack handler. 178844f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference handler_address(Isolate::k_handler_address, isolate()); 178944f0eee88ff00398ff7f715fab053374d808c90dSteve Block Load(rsp, handler_address); 1790e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1791e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Unwind the handlers until the ENTRY handler is found. 1792e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch NearLabel loop, done; 1793e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch bind(&loop); 1794e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Load the type of the current stack handler. 1795e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch const int kStateOffset = StackHandlerConstants::kStateOffset; 1796e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch cmpq(Operand(rsp, kStateOffset), Immediate(StackHandler::ENTRY)); 1797e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch j(equal, &done); 1798e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Fetch the next handler in the list. 1799e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch const int kNextOffset = StackHandlerConstants::kNextOffset; 1800e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(rsp, Operand(rsp, kNextOffset)); 1801e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch jmp(&loop); 1802e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch bind(&done); 1803e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1804e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Set the top handler address to next handler past the current ENTRY handler. 180544f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand handler_operand = ExternalOperand(handler_address); 180644f0eee88ff00398ff7f715fab053374d808c90dSteve Block pop(handler_operand); 1807e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1808e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch if (type == OUT_OF_MEMORY) { 1809e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Set external caught exception to false. 181044f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference external_caught( 181144f0eee88ff00398ff7f715fab053374d808c90dSteve Block Isolate::k_external_caught_exception_address, isolate()); 1812e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(rax, Immediate(false)); 181344f0eee88ff00398ff7f715fab053374d808c90dSteve Block Store(external_caught, rax); 1814e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1815e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Set pending exception and rax to out of memory exception. 181644f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference pending_exception(Isolate::k_pending_exception_address, 181744f0eee88ff00398ff7f715fab053374d808c90dSteve Block isolate()); 1818e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(rax, Failure::OutOfMemoryException(), RelocInfo::NONE); 181944f0eee88ff00398ff7f715fab053374d808c90dSteve Block Store(pending_exception, rax); 1820e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } 1821e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1822e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Clear the context pointer. 1823e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Set(rsi, 0); 1824e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1825e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Restore registers from handler. 1826e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch STATIC_ASSERT(StackHandlerConstants::kNextOffset + kPointerSize == 182744f0eee88ff00398ff7f715fab053374d808c90dSteve Block StackHandlerConstants::kFPOffset); 1828e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch pop(rbp); // FP 1829e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch STATIC_ASSERT(StackHandlerConstants::kFPOffset + kPointerSize == 183044f0eee88ff00398ff7f715fab053374d808c90dSteve Block StackHandlerConstants::kStateOffset); 1831e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch pop(rdx); // State 1832e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1833e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch STATIC_ASSERT(StackHandlerConstants::kStateOffset + kPointerSize == 183444f0eee88ff00398ff7f715fab053374d808c90dSteve Block StackHandlerConstants::kPCOffset); 1835e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ret(0); 1836e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 1837e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1838e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1839a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Ret() { 1840a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ret(0); 1841a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1842a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1843a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 18441e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::Ret(int bytes_dropped, Register scratch) { 18451e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block if (is_uint16(bytes_dropped)) { 18461e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ret(bytes_dropped); 18471e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } else { 18481e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block pop(scratch); 18491e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block addq(rsp, Immediate(bytes_dropped)); 18501e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block push(scratch); 18511e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ret(0); 18521e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } 18531e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 18541e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 18551e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 1856a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::FCmp() { 18573ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block fucomip(); 18588defd9ff6930b4e24729971a61cf7469daf119beSteve Block fstp(0); 1859a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1860a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1861a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1862a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::CmpObjectType(Register heap_object, 1863a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block InstanceType type, 1864a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register map) { 1865a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(map, FieldOperand(heap_object, HeapObject::kMapOffset)); 1866a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CmpInstanceType(map, type); 1867a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1868a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1869a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1870a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::CmpInstanceType(Register map, InstanceType type) { 1871a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmpb(FieldOperand(map, Map::kInstanceTypeOffset), 1872a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Immediate(static_cast<int8_t>(type))); 1873a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1874a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1875a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 18763100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescuvoid MacroAssembler::CheckMap(Register obj, 18773100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Handle<Map> map, 18783100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Label* fail, 18793100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu bool is_heap_object) { 18803100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu if (!is_heap_object) { 18813100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu JumpIfSmi(obj, fail); 18823100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu } 18833100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Cmp(FieldOperand(obj, HeapObject::kMapOffset), map); 18843100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu j(not_equal, fail); 18853100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu} 18863100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 18873100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 1888f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarkevoid MacroAssembler::AbortIfNotNumber(Register object) { 18890d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel ok; 1890402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu Condition is_smi = CheckSmi(object); 1891402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu j(is_smi, &ok); 1892402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu Cmp(FieldOperand(object, HeapObject::kMapOffset), 189344f0eee88ff00398ff7f715fab053374d808c90dSteve Block FACTORY->heap_number_map()); 1894f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke Assert(equal, "Operand not a number"); 1895402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu bind(&ok); 1896402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu} 1897402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 1898402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 1899756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrickvoid MacroAssembler::AbortIfSmi(Register object) { 19000d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel ok; 1901756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick Condition is_smi = CheckSmi(object); 1902756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick Assert(NegateCondition(is_smi), "Operand is a smi"); 1903756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick} 1904756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick 1905756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick 1906f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarkevoid MacroAssembler::AbortIfNotSmi(Register object) { 190744f0eee88ff00398ff7f715fab053374d808c90dSteve Block Condition is_smi = CheckSmi(object); 190844f0eee88ff00398ff7f715fab053374d808c90dSteve Block Assert(is_smi, "Operand is not a smi"); 190944f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 191044f0eee88ff00398ff7f715fab053374d808c90dSteve Block 191144f0eee88ff00398ff7f715fab053374d808c90dSteve Block 191244f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::AbortIfNotSmi(const Operand& object) { 19136ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Condition is_smi = CheckSmi(object); 1914756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick Assert(is_smi, "Operand is not a smi"); 19156ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 19166ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 19176ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 1918e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::AbortIfNotString(Register object) { 1919e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch testb(object, Immediate(kSmiTagMask)); 1920e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Assert(not_equal, "Operand is not a string"); 1921e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch push(object); 1922e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(object, FieldOperand(object, HeapObject::kMapOffset)); 1923e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch CmpInstanceType(object, FIRST_NONSTRING_TYPE); 1924e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch pop(object); 1925e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Assert(below, "Operand is not a string"); 1926e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 1927e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1928e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 19299dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsenvoid MacroAssembler::AbortIfNotRootValue(Register src, 19309dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Heap::RootListIndex root_value_index, 19319dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen const char* message) { 19329dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen ASSERT(!src.is(kScratchRegister)); 19339dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen LoadRoot(kScratchRegister, root_value_index); 19349dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen cmpq(src, kScratchRegister); 19359dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Check(equal, message); 19369dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen} 19379dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 19389dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 19399dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 1940d91b9f7d46489a9ee00f9cb415630299c76a502bLeon ClarkeCondition MacroAssembler::IsObjectStringType(Register heap_object, 1941d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke Register map, 1942d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke Register instance_type) { 1943d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke movq(map, FieldOperand(heap_object, HeapObject::kMapOffset)); 19444515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke movzxbl(instance_type, FieldOperand(map, Map::kInstanceTypeOffset)); 1945d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke ASSERT(kNotStringTag != 0); 1946d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke testb(instance_type, Immediate(kIsNotStringMask)); 1947d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke return zero; 1948d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke} 1949d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke 1950d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke 1951a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::TryGetFunctionPrototype(Register function, 1952a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register result, 1953a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label* miss) { 1954a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check that the receiver isn't a smi. 1955a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block testl(function, Immediate(kSmiTagMask)); 1956a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(zero, miss); 1957a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1958a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check that the function really is a function. 1959a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CmpObjectType(function, JS_FUNCTION_TYPE, result); 1960a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(not_equal, miss); 1961a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1962a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Make sure that the function has an instance prototype. 19630d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel non_instance; 1964a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block testb(FieldOperand(result, Map::kBitFieldOffset), 1965a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Immediate(1 << Map::kHasNonInstancePrototype)); 1966a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(not_zero, &non_instance); 1967a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1968a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Get the prototype or initial map from the function. 1969a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(result, 1970a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block FieldOperand(function, JSFunction::kPrototypeOrInitialMapOffset)); 1971a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1972a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // If the prototype or initial map is the hole, don't return it and 1973a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // simply miss the cache instead. This will allow us to allocate a 1974a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // prototype object on-demand in the runtime system. 1975a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CompareRoot(result, Heap::kTheHoleValueRootIndex); 1976a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(equal, miss); 1977a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1978a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // If the function does not have an initial map, we're done. 19790d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel done; 1980a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CmpObjectType(result, MAP_TYPE, kScratchRegister); 1981a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(not_equal, &done); 1982a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1983a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Get the prototype from the initial map. 1984a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(result, FieldOperand(result, Map::kPrototypeOffset)); 1985a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block jmp(&done); 1986a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1987a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Non-instance prototype: Fetch prototype from constructor field 1988a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // in initial map. 1989a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&non_instance); 1990a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(result, FieldOperand(result, Map::kConstructorOffset)); 1991a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1992a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // All done. 1993a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&done); 1994a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1995a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1996a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1997a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::SetCounter(StatsCounter* counter, int value) { 1998a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (FLAG_native_code_counters && counter->Enabled()) { 199944f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand counter_operand = ExternalOperand(ExternalReference(counter)); 200044f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(counter_operand, Immediate(value)); 2001a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2002a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2003a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2004a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2005a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::IncrementCounter(StatsCounter* counter, int value) { 2006a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(value > 0); 2007a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (FLAG_native_code_counters && counter->Enabled()) { 200844f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand counter_operand = ExternalOperand(ExternalReference(counter)); 2009a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (value == 1) { 201044f0eee88ff00398ff7f715fab053374d808c90dSteve Block incl(counter_operand); 2011a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 201244f0eee88ff00398ff7f715fab053374d808c90dSteve Block addl(counter_operand, Immediate(value)); 2013a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2014a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2015a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2016a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2017a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2018a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::DecrementCounter(StatsCounter* counter, int value) { 2019a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(value > 0); 2020a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (FLAG_native_code_counters && counter->Enabled()) { 202144f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand counter_operand = ExternalOperand(ExternalReference(counter)); 2022a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (value == 1) { 202344f0eee88ff00398ff7f715fab053374d808c90dSteve Block decl(counter_operand); 2024a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 202544f0eee88ff00398ff7f715fab053374d808c90dSteve Block subl(counter_operand, Immediate(value)); 2026a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2027a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2028a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2029a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2030a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 203180d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen#ifdef ENABLE_DEBUGGER_SUPPORT 2032402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescuvoid MacroAssembler::DebugBreak() { 2033402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu ASSERT(allow_stub_calls()); 20349fac840a46e8b7e26894f4792ba26dde14c56b04Steve Block Set(rax, 0); // No arguments. 203544f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(rbx, ExternalReference(Runtime::kDebugBreak, isolate())); 2036402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu CEntryStub ces(1); 2037402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu Call(ces.GetCode(), RelocInfo::DEBUG_BREAK); 2038a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2039402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu#endif // ENABLE_DEBUGGER_SUPPORT 2040a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2041a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2042a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::InvokeCode(Register code, 2043a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const ParameterCount& expected, 2044a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const ParameterCount& actual, 2045e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch InvokeFlag flag, 204644f0eee88ff00398ff7f715fab053374d808c90dSteve Block CallWrapper* call_wrapper) { 20470d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel done; 2048e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch InvokePrologue(expected, 2049e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch actual, 2050e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Handle<Code>::null(), 2051e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch code, 2052e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch &done, 2053e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch flag, 205444f0eee88ff00398ff7f715fab053374d808c90dSteve Block call_wrapper); 2055a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (flag == CALL_FUNCTION) { 205644f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (call_wrapper != NULL) call_wrapper->BeforeCall(CallSize(code)); 2057a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block call(code); 205844f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (call_wrapper != NULL) call_wrapper->AfterCall(); 2059a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 2060a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(flag == JUMP_FUNCTION); 2061a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block jmp(code); 2062a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2063a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&done); 2064a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2065a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2066a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2067a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::InvokeCode(Handle<Code> code, 2068a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const ParameterCount& expected, 2069a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const ParameterCount& actual, 2070a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block RelocInfo::Mode rmode, 2071e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch InvokeFlag flag, 207244f0eee88ff00398ff7f715fab053374d808c90dSteve Block CallWrapper* call_wrapper) { 20730d5e116f6aee03185f237311a943491bb079a768Kristian Monsen NearLabel done; 2074a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register dummy = rax; 2075e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch InvokePrologue(expected, 2076e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch actual, 2077e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch code, 2078e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch dummy, 2079e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch &done, 2080e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch flag, 208144f0eee88ff00398ff7f715fab053374d808c90dSteve Block call_wrapper); 2082a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (flag == CALL_FUNCTION) { 208344f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (call_wrapper != NULL) call_wrapper->BeforeCall(CallSize(code)); 2084a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Call(code, rmode); 208544f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (call_wrapper != NULL) call_wrapper->AfterCall(); 2086a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 2087a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(flag == JUMP_FUNCTION); 2088a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Jump(code, rmode); 2089a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2090a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&done); 2091a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2092a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2093a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2094a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::InvokeFunction(Register function, 2095a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const ParameterCount& actual, 2096e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch InvokeFlag flag, 209744f0eee88ff00398ff7f715fab053374d808c90dSteve Block CallWrapper* call_wrapper) { 2098a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(function.is(rdi)); 2099a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(rdx, FieldOperand(function, JSFunction::kSharedFunctionInfoOffset)); 2100a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(rsi, FieldOperand(function, JSFunction::kContextOffset)); 2101a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movsxlq(rbx, 2102a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block FieldOperand(rdx, SharedFunctionInfo::kFormalParameterCountOffset)); 2103a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Advances rdx to the end of the Code object header, to the start of 2104a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // the executable code. 2105791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block movq(rdx, FieldOperand(rdi, JSFunction::kCodeEntryOffset)); 2106a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2107a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ParameterCount expected(rbx); 210844f0eee88ff00398ff7f715fab053374d808c90dSteve Block InvokeCode(rdx, expected, actual, flag, call_wrapper); 2109a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2110a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2111a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2112402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescuvoid MacroAssembler::InvokeFunction(JSFunction* function, 2113402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu const ParameterCount& actual, 2114e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch InvokeFlag flag, 211544f0eee88ff00398ff7f715fab053374d808c90dSteve Block CallWrapper* call_wrapper) { 2116402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu ASSERT(function->is_compiled()); 2117402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu // Get the function and setup the context. 2118402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu Move(rdi, Handle<JSFunction>(function)); 2119402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu movq(rsi, FieldOperand(rdi, JSFunction::kContextOffset)); 2120402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 21211e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block if (V8::UseCrankshaft()) { 21221e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Since Crankshaft can recompile a function, we need to load 21231e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // the Code object every time we call the function. 21241e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block movq(rdx, FieldOperand(rdi, JSFunction::kCodeEntryOffset)); 21251e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ParameterCount expected(function->shared()->formal_parameter_count()); 212644f0eee88ff00398ff7f715fab053374d808c90dSteve Block InvokeCode(rdx, expected, actual, flag, call_wrapper); 21271e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } else { 21281e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Invoke the cached code. 21291e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Handle<Code> code(function->code()); 21301e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ParameterCount expected(function->shared()->formal_parameter_count()); 2131e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch InvokeCode(code, 2132e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch expected, 2133e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch actual, 2134e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch RelocInfo::CODE_TARGET, 2135e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch flag, 213644f0eee88ff00398ff7f715fab053374d808c90dSteve Block call_wrapper); 21371e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } 2138402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu} 2139402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 2140402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 2141a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::EnterFrame(StackFrame::Type type) { 2142a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(rbp); 2143a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(rbp, rsp); 2144a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(rsi); // Context. 21453ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Push(Smi::FromInt(type)); 2146a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(kScratchRegister, CodeObject(), RelocInfo::EMBEDDED_OBJECT); 2147a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(kScratchRegister); 214844f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 2149a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(kScratchRegister, 215044f0eee88ff00398ff7f715fab053374d808c90dSteve Block FACTORY->undefined_value(), 2151a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block RelocInfo::EMBEDDED_OBJECT); 2152a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmpq(Operand(rsp, 0), kScratchRegister); 2153a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(not_equal, "code object not properly patched"); 2154a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2155a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2156a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2157a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2158a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::LeaveFrame(StackFrame::Type type) { 215944f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 21603ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Move(kScratchRegister, Smi::FromInt(type)); 2161a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmpq(Operand(rbp, StandardFrameConstants::kMarkerOffset), kScratchRegister); 2162a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(equal, "stack frame types must match"); 2163a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2164a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(rsp, rbp); 2165a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block pop(rbp); 2166a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2167a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2168a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 216980d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsenvoid MacroAssembler::EnterExitFramePrologue(bool save_rax) { 2170a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Setup the frame structure on the stack. 2171a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // All constants are relative to the frame pointer of the exit frame. 2172a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(ExitFrameConstants::kCallerSPDisplacement == +2 * kPointerSize); 2173a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(ExitFrameConstants::kCallerPCOffset == +1 * kPointerSize); 2174a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(ExitFrameConstants::kCallerFPOffset == 0 * kPointerSize); 2175a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(rbp); 2176a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(rbp, rsp); 2177a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 217880d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // Reserve room for entry stack pointer and push the code object. 21793ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block ASSERT(ExitFrameConstants::kSPOffset == -1 * kPointerSize); 2180402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu push(Immediate(0)); // Saved entry sp, patched before call. 2181402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu movq(kScratchRegister, CodeObject(), RelocInfo::EMBEDDED_OBJECT); 2182402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu push(kScratchRegister); // Accessed from EditFrame::code_slot. 2183a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2184a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Save the frame pointer and the context in top. 2185bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch if (save_rax) { 218644f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(r14, rax); // Backup rax in callee-save register. 2187bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch } 2188a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 218944f0eee88ff00398ff7f715fab053374d808c90dSteve Block Store(ExternalReference(Isolate::k_c_entry_fp_address, isolate()), rbp); 219044f0eee88ff00398ff7f715fab053374d808c90dSteve Block Store(ExternalReference(Isolate::k_context_address, isolate()), rsi); 2191bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch} 2192a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 21938a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 21941e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::EnterExitFrameEpilogue(int arg_stack_space, 21951e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block bool save_doubles) { 2196a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifdef _WIN64 21971e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block const int kShadowSpace = 4; 21981e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block arg_stack_space += kShadowSpace; 2199a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 22001e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Optionally save all XMM registers. 22011e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block if (save_doubles) { 22021e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block CpuFeatures::Scope scope(SSE2); 22031e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block int space = XMMRegister::kNumRegisters * kDoubleSize + 22041e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block arg_stack_space * kPointerSize; 22051e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block subq(rsp, Immediate(space)); 22061e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block int offset = -2 * kPointerSize; 22071e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block for (int i = 0; i < XMMRegister::kNumAllocatableRegisters; i++) { 22081e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block XMMRegister reg = XMMRegister::FromAllocationIndex(i); 22091e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block movsd(Operand(rbp, offset - ((i + 1) * kDoubleSize)), reg); 22101e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } 22111e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } else if (arg_stack_space > 0) { 22128a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang subq(rsp, Immediate(arg_stack_space * kPointerSize)); 22138a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang } 2214a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2215a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Get the required frame alignment for the OS. 221644f0eee88ff00398ff7f715fab053374d808c90dSteve Block const int kFrameAlignment = OS::ActivationFrameAlignment(); 2217a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (kFrameAlignment > 0) { 2218a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(IsPowerOf2(kFrameAlignment)); 2219a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(kScratchRegister, Immediate(-kFrameAlignment)); 2220a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block and_(rsp, kScratchRegister); 2221a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2222a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2223a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Patch the saved entry sp. 2224a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(Operand(rbp, ExitFrameConstants::kSPOffset), rsp); 2225a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2226a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2227a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 22281e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::EnterExitFrame(int arg_stack_space, bool save_doubles) { 222980d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen EnterExitFramePrologue(true); 2230bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 223144f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Setup argv in callee-saved register r15. It is reused in LeaveExitFrame, 2232bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch // so it must be retained across the C-call. 2233bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch int offset = StandardFrameConstants::kCallerSPOffset - kPointerSize; 223444f0eee88ff00398ff7f715fab053374d808c90dSteve Block lea(r15, Operand(rbp, r14, times_pointer_size, offset)); 2235bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 22361e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block EnterExitFrameEpilogue(arg_stack_space, save_doubles); 2237bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch} 2238bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 2239bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 22408a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wangvoid MacroAssembler::EnterApiExitFrame(int arg_stack_space) { 224180d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen EnterExitFramePrologue(false); 22421e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block EnterExitFrameEpilogue(arg_stack_space, false); 2243bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch} 2244bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 2245bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 22461e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::LeaveExitFrame(bool save_doubles) { 2247a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Registers: 224844f0eee88ff00398ff7f715fab053374d808c90dSteve Block // r15 : argv 22491e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block if (save_doubles) { 22501e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block int offset = -2 * kPointerSize; 22511e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block for (int i = 0; i < XMMRegister::kNumAllocatableRegisters; i++) { 22521e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block XMMRegister reg = XMMRegister::FromAllocationIndex(i); 22531e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block movsd(reg, Operand(rbp, offset - ((i + 1) * kDoubleSize))); 22541e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } 22551e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } 2256a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Get the return address from the stack and restore the frame pointer. 2257a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(rcx, Operand(rbp, 1 * kPointerSize)); 2258a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(rbp, Operand(rbp, 0 * kPointerSize)); 2259a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 22601e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Drop everything up to and including the arguments and the receiver 2261a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // from the caller stack. 226244f0eee88ff00398ff7f715fab053374d808c90dSteve Block lea(rsp, Operand(r15, 1 * kPointerSize)); 2263a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 22648a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // Push the return address to get ready to return. 22658a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang push(rcx); 22668a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 22678a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang LeaveExitFrameEpilogue(); 22688a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang} 22698a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 22708a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 22718a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wangvoid MacroAssembler::LeaveApiExitFrame() { 22728a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang movq(rsp, rbp); 22738a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang pop(rbp); 22748a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 22758a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang LeaveExitFrameEpilogue(); 22768a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang} 22778a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 22788a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 22798a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wangvoid MacroAssembler::LeaveExitFrameEpilogue() { 2280a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Restore current context from top and clear it in debug mode. 228144f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference context_address(Isolate::k_context_address, isolate()); 228244f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand context_operand = ExternalOperand(context_address); 228344f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(rsi, context_operand); 2284a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifdef DEBUG 228544f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(context_operand, Immediate(0)); 2286a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 2287a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2288a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Clear the top frame. 228944f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference c_entry_fp_address(Isolate::k_c_entry_fp_address, 229044f0eee88ff00398ff7f715fab053374d808c90dSteve Block isolate()); 229144f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand c_entry_fp_operand = ExternalOperand(c_entry_fp_address); 229244f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(c_entry_fp_operand, Immediate(0)); 2293a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2294a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2295a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2296a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::CheckAccessGlobalProxy(Register holder_reg, 2297a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch, 2298a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label* miss) { 2299a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label same_contexts; 2300a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2301a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!holder_reg.is(scratch)); 2302a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!scratch.is(kScratchRegister)); 2303a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Load current lexical context from the stack frame. 2304a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(scratch, Operand(rbp, StandardFrameConstants::kContextOffset)); 2305a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2306a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // When generating debug code, make sure the lexical context is set. 230744f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 2308a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmpq(scratch, Immediate(0)); 2309a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(not_equal, "we should not have an empty lexical context"); 2310a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2311a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Load the global context of the current context. 2312a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int offset = Context::kHeaderSize + Context::GLOBAL_INDEX * kPointerSize; 2313a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(scratch, FieldOperand(scratch, offset)); 2314a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(scratch, FieldOperand(scratch, GlobalObject::kGlobalContextOffset)); 2315a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2316a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check the context is a global context. 231744f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 2318a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Cmp(FieldOperand(scratch, HeapObject::kMapOffset), 231944f0eee88ff00398ff7f715fab053374d808c90dSteve Block FACTORY->global_context_map()); 2320a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(equal, "JSGlobalObject::global_context should be a global context."); 2321a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2322a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2323a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check if both contexts are the same. 2324a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmpq(scratch, FieldOperand(holder_reg, JSGlobalProxy::kContextOffset)); 2325a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(equal, &same_contexts); 2326a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2327a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Compare security tokens. 2328a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check that the security token in the calling global object is 2329a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // compatible with the security token in the receiving global 2330a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // object. 2331a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2332a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check the context is a global context. 233344f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 2334a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Preserve original value of holder_reg. 2335a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(holder_reg); 2336a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(holder_reg, FieldOperand(holder_reg, JSGlobalProxy::kContextOffset)); 2337a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CompareRoot(holder_reg, Heap::kNullValueRootIndex); 2338a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(not_equal, "JSGlobalProxy::context() should not be null."); 2339a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2340a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Read the first word and compare to global_context_map(), 2341a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(holder_reg, FieldOperand(holder_reg, HeapObject::kMapOffset)); 2342a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CompareRoot(holder_reg, Heap::kGlobalContextMapRootIndex); 2343a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(equal, "JSGlobalObject::global_context should be a global context."); 2344a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block pop(holder_reg); 2345a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2346a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2347a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(kScratchRegister, 2348a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block FieldOperand(holder_reg, JSGlobalProxy::kContextOffset)); 23493ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block int token_offset = 23503ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Context::kHeaderSize + Context::SECURITY_TOKEN_INDEX * kPointerSize; 2351a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(scratch, FieldOperand(scratch, token_offset)); 2352a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmpq(scratch, FieldOperand(kScratchRegister, token_offset)); 2353a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(not_equal, miss); 2354a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2355a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&same_contexts); 2356a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2357a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2358a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2359a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::LoadAllocationTopHelper(Register result, 2360a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch, 2361a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block AllocationFlags flags) { 2362a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ExternalReference new_space_allocation_top = 236344f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::new_space_allocation_top_address(isolate()); 2364a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2365a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Just return if allocation top is already known. 2366a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if ((flags & RESULT_CONTAINS_TOP) != 0) { 2367a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // No use of scratch if allocation top is provided. 23686ded16be15dd865a9b21ea304d5273c8be299c87Steve Block ASSERT(!scratch.is_valid()); 2369a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifdef DEBUG 2370a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Assert that result actually contains top on entry. 237144f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand top_operand = ExternalOperand(new_space_allocation_top); 237244f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmpq(result, top_operand); 2373a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(equal, "Unexpected allocation top"); 2374a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 2375a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return; 2376a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2377a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 23786ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Move address of new object to result. Use scratch register if available, 23796ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // and keep address in scratch until call to UpdateAllocationTopHelper. 23806ded16be15dd865a9b21ea304d5273c8be299c87Steve Block if (scratch.is_valid()) { 238144f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(scratch, new_space_allocation_top); 2382a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(result, Operand(scratch, 0)); 23836ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } else { 238444f0eee88ff00398ff7f715fab053374d808c90dSteve Block Load(result, new_space_allocation_top); 2385a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2386a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2387a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2388a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2389a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::UpdateAllocationTopHelper(Register result_end, 2390a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch) { 239144f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 2392d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block testq(result_end, Immediate(kObjectAlignmentMask)); 2393d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block Check(zero, "Unaligned allocation in new space"); 2394d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block } 2395d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 2396a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ExternalReference new_space_allocation_top = 239744f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::new_space_allocation_top_address(isolate()); 2398a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2399a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Update new top. 240044f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (scratch.is_valid()) { 240144f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Scratch already contains address of allocation top. 240244f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(Operand(scratch, 0), result_end); 2403a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 240444f0eee88ff00398ff7f715fab053374d808c90dSteve Block Store(new_space_allocation_top, result_end); 2405a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2406a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2407a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2408a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2409a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::AllocateInNewSpace(int object_size, 2410a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register result, 2411a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register result_end, 2412a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch, 2413a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label* gc_required, 2414a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block AllocationFlags flags) { 24155913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck if (!FLAG_inline_new) { 241644f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 24175913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // Trash the registers to simulate an allocation failure. 24185913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movl(result, Immediate(0x7091)); 24195913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck if (result_end.is_valid()) { 24205913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movl(result_end, Immediate(0x7191)); 24215913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 24225913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck if (scratch.is_valid()) { 24235913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movl(scratch, Immediate(0x7291)); 24245913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 24255913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 24265913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck jmp(gc_required); 24275913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck return; 24285913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 2429a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!result.is(result_end)); 2430a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2431a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Load address of new object into result. 24328a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang LoadAllocationTopHelper(result, scratch, flags); 2433a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2434a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Calculate new top and bail out if new space is exhausted. 2435a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ExternalReference new_space_allocation_limit = 243644f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::new_space_allocation_limit_address(isolate()); 24376ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 24386ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register top_reg = result_end.is_valid() ? result_end : result; 24396ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 24401e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block if (!top_reg.is(result)) { 24411e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block movq(top_reg, result); 24426ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 24431e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block addq(top_reg, Immediate(object_size)); 24441e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block j(carry, gc_required); 244544f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand limit_operand = ExternalOperand(new_space_allocation_limit); 244644f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmpq(top_reg, limit_operand); 2447a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(above, gc_required); 2448a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2449a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Update allocation top. 24506ded16be15dd865a9b21ea304d5273c8be299c87Steve Block UpdateAllocationTopHelper(top_reg, scratch); 2451a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 24526ded16be15dd865a9b21ea304d5273c8be299c87Steve Block if (top_reg.is(result)) { 24536ded16be15dd865a9b21ea304d5273c8be299c87Steve Block if ((flags & TAG_OBJECT) != 0) { 24546ded16be15dd865a9b21ea304d5273c8be299c87Steve Block subq(result, Immediate(object_size - kHeapObjectTag)); 24556ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } else { 24566ded16be15dd865a9b21ea304d5273c8be299c87Steve Block subq(result, Immediate(object_size)); 24576ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 24586ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } else if ((flags & TAG_OBJECT) != 0) { 24596ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Tag the result if requested. 2460a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block addq(result, Immediate(kHeapObjectTag)); 2461a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2462a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2463a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2464a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2465a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::AllocateInNewSpace(int header_size, 2466a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ScaleFactor element_size, 2467a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register element_count, 2468a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register result, 2469a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register result_end, 2470a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch, 2471a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label* gc_required, 2472a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block AllocationFlags flags) { 24735913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck if (!FLAG_inline_new) { 247444f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 24755913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // Trash the registers to simulate an allocation failure. 24765913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movl(result, Immediate(0x7091)); 24775913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movl(result_end, Immediate(0x7191)); 24785913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck if (scratch.is_valid()) { 24795913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movl(scratch, Immediate(0x7291)); 24805913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 24815913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // Register element_count is not modified by the function. 24825913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 24835913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck jmp(gc_required); 24845913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck return; 24855913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 2486a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!result.is(result_end)); 2487a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2488a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Load address of new object into result. 24898a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang LoadAllocationTopHelper(result, scratch, flags); 2490a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2491a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Calculate new top and bail out if new space is exhausted. 2492a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ExternalReference new_space_allocation_limit = 249344f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::new_space_allocation_limit_address(isolate()); 24941e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 24951e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // We assume that element_count*element_size + header_size does not 24961e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // overflow. 24971e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block lea(result_end, Operand(element_count, element_size, header_size)); 24981e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block addq(result_end, result); 24991e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block j(carry, gc_required); 250044f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand limit_operand = ExternalOperand(new_space_allocation_limit); 250144f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmpq(result_end, limit_operand); 2502a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(above, gc_required); 2503a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2504a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Update allocation top. 2505a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block UpdateAllocationTopHelper(result_end, scratch); 2506a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2507a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Tag the result if requested. 2508a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if ((flags & TAG_OBJECT) != 0) { 2509a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block addq(result, Immediate(kHeapObjectTag)); 2510a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2511a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2512a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2513a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2514a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::AllocateInNewSpace(Register object_size, 2515a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register result, 2516a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register result_end, 2517a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch, 2518a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label* gc_required, 2519a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block AllocationFlags flags) { 25205913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck if (!FLAG_inline_new) { 252144f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 25225913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // Trash the registers to simulate an allocation failure. 25235913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movl(result, Immediate(0x7091)); 25245913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movl(result_end, Immediate(0x7191)); 25255913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck if (scratch.is_valid()) { 25265913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck movl(scratch, Immediate(0x7291)); 25275913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 25285913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // object_size is left unchanged by this function. 25295913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 25305913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck jmp(gc_required); 25315913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck return; 25325913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 25335913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck ASSERT(!result.is(result_end)); 25345913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck 2535a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Load address of new object into result. 25368a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang LoadAllocationTopHelper(result, scratch, flags); 2537a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2538a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Calculate new top and bail out if new space is exhausted. 2539a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ExternalReference new_space_allocation_limit = 254044f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::new_space_allocation_limit_address(isolate()); 2541a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (!object_size.is(result_end)) { 2542a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block movq(result_end, object_size); 2543a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2544a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block addq(result_end, result); 25451e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block j(carry, gc_required); 254644f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand limit_operand = ExternalOperand(new_space_allocation_limit); 254744f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmpq(result_end, limit_operand); 2548a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block j(above, gc_required); 2549a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2550a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Update allocation top. 2551a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block UpdateAllocationTopHelper(result_end, scratch); 2552a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2553a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Tag the result if requested. 2554a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if ((flags & TAG_OBJECT) != 0) { 2555a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block addq(result, Immediate(kHeapObjectTag)); 2556a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2557a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2558a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2559a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2560a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::UndoAllocationInNewSpace(Register object) { 2561a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ExternalReference new_space_allocation_top = 256244f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::new_space_allocation_top_address(isolate()); 2563a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2564a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Make sure the object has no tag before resetting top. 2565a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block and_(object, Immediate(~kHeapObjectTagMask)); 256644f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand top_operand = ExternalOperand(new_space_allocation_top); 2567a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifdef DEBUG 256844f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmpq(object, top_operand); 2569a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(below, "Undo allocation of non allocated memory"); 2570a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 257144f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(top_operand, object); 2572a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2573a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2574a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 25753ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Blockvoid MacroAssembler::AllocateHeapNumber(Register result, 25763ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Register scratch, 25773ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block Label* gc_required) { 25783ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block // Allocate heap number in new space. 25793ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block AllocateInNewSpace(HeapNumber::kSize, 25803ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block result, 25813ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block scratch, 25823ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block no_reg, 25833ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block gc_required, 25843ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block TAG_OBJECT); 25853ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block 25863ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block // Set the map. 25873ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block LoadRoot(kScratchRegister, Heap::kHeapNumberMapRootIndex); 25883ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block movq(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister); 25893ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block} 25903ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block 25913ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block 2592e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarkevoid MacroAssembler::AllocateTwoByteString(Register result, 2593e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Register length, 2594e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Register scratch1, 2595e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Register scratch2, 2596e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Register scratch3, 2597e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Label* gc_required) { 2598e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Calculate the number of bytes needed for the characters in the string while 2599e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // observing object alignment. 26006ded16be15dd865a9b21ea304d5273c8be299c87Steve Block const int kHeaderAlignment = SeqTwoByteString::kHeaderSize & 26016ded16be15dd865a9b21ea304d5273c8be299c87Steve Block kObjectAlignmentMask; 2602e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke ASSERT(kShortSize == 2); 2603e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // scratch1 = length * 2 + kObjectAlignmentMask. 26046ded16be15dd865a9b21ea304d5273c8be299c87Steve Block lea(scratch1, Operand(length, length, times_1, kObjectAlignmentMask + 26056ded16be15dd865a9b21ea304d5273c8be299c87Steve Block kHeaderAlignment)); 2606e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke and_(scratch1, Immediate(~kObjectAlignmentMask)); 26076ded16be15dd865a9b21ea304d5273c8be299c87Steve Block if (kHeaderAlignment > 0) { 26086ded16be15dd865a9b21ea304d5273c8be299c87Steve Block subq(scratch1, Immediate(kHeaderAlignment)); 26096ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 2610e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2611e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Allocate two byte string in new space. 2612e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke AllocateInNewSpace(SeqTwoByteString::kHeaderSize, 2613e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke times_1, 2614e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke scratch1, 2615e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke result, 2616e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke scratch2, 2617e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke scratch3, 2618e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke gc_required, 2619e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke TAG_OBJECT); 2620e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2621e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Set the map, length and hash field. 2622e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke LoadRoot(kScratchRegister, Heap::kStringMapRootIndex); 2623e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke movq(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister); 26246ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Integer32ToSmi(scratch1, length); 26256ded16be15dd865a9b21ea304d5273c8be299c87Steve Block movq(FieldOperand(result, String::kLengthOffset), scratch1); 26267f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch movq(FieldOperand(result, String::kHashFieldOffset), 2627e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Immediate(String::kEmptyHashField)); 2628e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke} 2629e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2630e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2631e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarkevoid MacroAssembler::AllocateAsciiString(Register result, 2632e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Register length, 2633e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Register scratch1, 2634e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Register scratch2, 2635e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Register scratch3, 2636e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Label* gc_required) { 2637e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Calculate the number of bytes needed for the characters in the string while 2638e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // observing object alignment. 26396ded16be15dd865a9b21ea304d5273c8be299c87Steve Block const int kHeaderAlignment = SeqAsciiString::kHeaderSize & 26406ded16be15dd865a9b21ea304d5273c8be299c87Steve Block kObjectAlignmentMask; 2641e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke movl(scratch1, length); 2642e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke ASSERT(kCharSize == 1); 26436ded16be15dd865a9b21ea304d5273c8be299c87Steve Block addq(scratch1, Immediate(kObjectAlignmentMask + kHeaderAlignment)); 2644e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke and_(scratch1, Immediate(~kObjectAlignmentMask)); 26456ded16be15dd865a9b21ea304d5273c8be299c87Steve Block if (kHeaderAlignment > 0) { 26466ded16be15dd865a9b21ea304d5273c8be299c87Steve Block subq(scratch1, Immediate(kHeaderAlignment)); 26476ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 2648e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2649e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Allocate ascii string in new space. 2650e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke AllocateInNewSpace(SeqAsciiString::kHeaderSize, 2651e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke times_1, 2652e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke scratch1, 2653e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke result, 2654e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke scratch2, 2655e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke scratch3, 2656e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke gc_required, 2657e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke TAG_OBJECT); 2658e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2659e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Set the map, length and hash field. 2660e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke LoadRoot(kScratchRegister, Heap::kAsciiStringMapRootIndex); 2661e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke movq(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister); 26626ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Integer32ToSmi(scratch1, length); 26636ded16be15dd865a9b21ea304d5273c8be299c87Steve Block movq(FieldOperand(result, String::kLengthOffset), scratch1); 26647f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch movq(FieldOperand(result, String::kHashFieldOffset), 2665e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Immediate(String::kEmptyHashField)); 2666e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke} 2667e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2668e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2669e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarkevoid MacroAssembler::AllocateConsString(Register result, 2670e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Register scratch1, 2671e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Register scratch2, 2672e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Label* gc_required) { 2673e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Allocate heap number in new space. 2674e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke AllocateInNewSpace(ConsString::kSize, 2675e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke result, 2676e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke scratch1, 2677e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke scratch2, 2678e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke gc_required, 2679e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke TAG_OBJECT); 2680e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2681e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Set the map. The other fields are left uninitialized. 2682e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke LoadRoot(kScratchRegister, Heap::kConsStringMapRootIndex); 2683e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke movq(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister); 2684e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke} 2685e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2686e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2687e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarkevoid MacroAssembler::AllocateAsciiConsString(Register result, 2688e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Register scratch1, 2689e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Register scratch2, 2690e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke Label* gc_required) { 2691e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Allocate heap number in new space. 2692e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke AllocateInNewSpace(ConsString::kSize, 2693e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke result, 2694e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke scratch1, 2695e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke scratch2, 2696e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke gc_required, 2697e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke TAG_OBJECT); 2698e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2699e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Set the map. The other fields are left uninitialized. 2700e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke LoadRoot(kScratchRegister, Heap::kConsAsciiStringMapRootIndex); 2701e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke movq(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister); 2702e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke} 2703e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2704e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 270544f0eee88ff00398ff7f715fab053374d808c90dSteve Block// Copy memory, byte-by-byte, from source to destination. Not optimized for 270644f0eee88ff00398ff7f715fab053374d808c90dSteve Block// long or aligned copies. The contents of scratch and length are destroyed. 270744f0eee88ff00398ff7f715fab053374d808c90dSteve Block// Destination is incremented by length, source, length and scratch are 270844f0eee88ff00398ff7f715fab053374d808c90dSteve Block// clobbered. 270944f0eee88ff00398ff7f715fab053374d808c90dSteve Block// A simpler loop is faster on small copies, but slower on large ones. 271044f0eee88ff00398ff7f715fab053374d808c90dSteve Block// The cld() instruction must have been emitted, to set the direction flag(), 271144f0eee88ff00398ff7f715fab053374d808c90dSteve Block// before calling this function. 271244f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::CopyBytes(Register destination, 271344f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register source, 271444f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register length, 271544f0eee88ff00398ff7f715fab053374d808c90dSteve Block int min_length, 271644f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register scratch) { 271744f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(min_length >= 0); 271844f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (FLAG_debug_code) { 271944f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmpl(length, Immediate(min_length)); 272044f0eee88ff00398ff7f715fab053374d808c90dSteve Block Assert(greater_equal, "Invalid min_length"); 272144f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 272244f0eee88ff00398ff7f715fab053374d808c90dSteve Block Label loop, done, short_string, short_loop; 272344f0eee88ff00398ff7f715fab053374d808c90dSteve Block 272444f0eee88ff00398ff7f715fab053374d808c90dSteve Block const int kLongStringLimit = 20; 272544f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (min_length <= kLongStringLimit) { 272644f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmpl(length, Immediate(kLongStringLimit)); 272744f0eee88ff00398ff7f715fab053374d808c90dSteve Block j(less_equal, &short_string); 272844f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 272944f0eee88ff00398ff7f715fab053374d808c90dSteve Block 273044f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(source.is(rsi)); 273144f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(destination.is(rdi)); 273244f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(length.is(rcx)); 273344f0eee88ff00398ff7f715fab053374d808c90dSteve Block 273444f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Because source is 8-byte aligned in our uses of this function, 273544f0eee88ff00398ff7f715fab053374d808c90dSteve Block // we keep source aligned for the rep movs operation by copying the odd bytes 273644f0eee88ff00398ff7f715fab053374d808c90dSteve Block // at the end of the ranges. 273744f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(scratch, length); 273844f0eee88ff00398ff7f715fab053374d808c90dSteve Block shrl(length, Immediate(3)); 273944f0eee88ff00398ff7f715fab053374d808c90dSteve Block repmovsq(); 274044f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Move remaining bytes of length. 274144f0eee88ff00398ff7f715fab053374d808c90dSteve Block andl(scratch, Immediate(0x7)); 274244f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(length, Operand(source, scratch, times_1, -8)); 274344f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(Operand(destination, scratch, times_1, -8), length); 274444f0eee88ff00398ff7f715fab053374d808c90dSteve Block addq(destination, scratch); 274544f0eee88ff00398ff7f715fab053374d808c90dSteve Block 274644f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (min_length <= kLongStringLimit) { 274744f0eee88ff00398ff7f715fab053374d808c90dSteve Block jmp(&done); 274844f0eee88ff00398ff7f715fab053374d808c90dSteve Block 274944f0eee88ff00398ff7f715fab053374d808c90dSteve Block bind(&short_string); 275044f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (min_length == 0) { 275144f0eee88ff00398ff7f715fab053374d808c90dSteve Block testl(length, length); 275244f0eee88ff00398ff7f715fab053374d808c90dSteve Block j(zero, &done); 275344f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 275444f0eee88ff00398ff7f715fab053374d808c90dSteve Block lea(scratch, Operand(destination, length, times_1, 0)); 275544f0eee88ff00398ff7f715fab053374d808c90dSteve Block 275644f0eee88ff00398ff7f715fab053374d808c90dSteve Block bind(&short_loop); 275744f0eee88ff00398ff7f715fab053374d808c90dSteve Block movb(length, Operand(source, 0)); 275844f0eee88ff00398ff7f715fab053374d808c90dSteve Block movb(Operand(destination, 0), length); 275944f0eee88ff00398ff7f715fab053374d808c90dSteve Block incq(source); 276044f0eee88ff00398ff7f715fab053374d808c90dSteve Block incq(destination); 276144f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmpq(destination, scratch); 276244f0eee88ff00398ff7f715fab053374d808c90dSteve Block j(not_equal, &short_loop); 276344f0eee88ff00398ff7f715fab053374d808c90dSteve Block 276444f0eee88ff00398ff7f715fab053374d808c90dSteve Block bind(&done); 276544f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 276644f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 276744f0eee88ff00398ff7f715fab053374d808c90dSteve Block 276844f0eee88ff00398ff7f715fab053374d808c90dSteve Block 2769d0582a6c46733687d045e4188a1bcd0123c758a1Steve Blockvoid MacroAssembler::LoadContext(Register dst, int context_chain_length) { 2770d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block if (context_chain_length > 0) { 2771d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block // Move up the chain of contexts to the context containing the slot. 2772d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block movq(dst, Operand(rsi, Context::SlotOffset(Context::CLOSURE_INDEX))); 2773d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block // Load the function context (which is the incoming, outer context). 2774e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke movq(dst, FieldOperand(dst, JSFunction::kContextOffset)); 2775d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block for (int i = 1; i < context_chain_length; i++) { 2776d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block movq(dst, Operand(dst, Context::SlotOffset(Context::CLOSURE_INDEX))); 2777d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block movq(dst, FieldOperand(dst, JSFunction::kContextOffset)); 2778d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block } 2779d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block // The context may be an intermediate context, not a function context. 2780d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block movq(dst, Operand(dst, Context::SlotOffset(Context::FCONTEXT_INDEX))); 2781e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } else { 2782e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Slot is in the current function context. Move it into the 2783e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // destination register in case we store into it (the write barrier 2784e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // cannot be allowed to destroy the context in rsi). 2785e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch movq(dst, rsi); 2786e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } 2787e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 2788e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // We should not have found a 'with' context by walking the context chain 2789e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // (i.e., the static scope chain and runtime context chain do not agree). 2790e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // A variable occurring in such a scope should have slot type LOOKUP and 2791e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // not CONTEXT. 279244f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 2793e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch cmpq(dst, Operand(dst, Context::SlotOffset(Context::FCONTEXT_INDEX))); 2794e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Check(equal, "Yo dawg, I heard you liked function contexts " 2795e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch "so I put function contexts in all your contexts"); 2796d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block } 2797d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block} 2798d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 279944f0eee88ff00398ff7f715fab053374d808c90dSteve Block#ifdef _WIN64 280044f0eee88ff00398ff7f715fab053374d808c90dSteve Blockstatic const int kRegisterPassedArguments = 4; 280144f0eee88ff00398ff7f715fab053374d808c90dSteve Block#else 280244f0eee88ff00398ff7f715fab053374d808c90dSteve Blockstatic const int kRegisterPassedArguments = 6; 280344f0eee88ff00398ff7f715fab053374d808c90dSteve Block#endif 28047f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 2805b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdochvoid MacroAssembler::LoadGlobalFunction(int index, Register function) { 2806b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Load the global or builtins object from the current context. 2807b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch movq(function, Operand(rsi, Context::SlotOffset(Context::GLOBAL_INDEX))); 2808b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Load the global context from the global or builtins object. 2809b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch movq(function, FieldOperand(function, GlobalObject::kGlobalContextOffset)); 2810b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Load the function from the global context. 2811b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch movq(function, Operand(function, Context::SlotOffset(index))); 2812b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch} 2813b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 2814b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 2815b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdochvoid MacroAssembler::LoadGlobalFunctionInitialMap(Register function, 2816b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Register map) { 2817b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Load the initial map. The global functions all have initial maps. 2818b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch movq(map, FieldOperand(function, JSFunction::kPrototypeOrInitialMapOffset)); 281944f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 2820b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Label ok, fail; 282144f0eee88ff00398ff7f715fab053374d808c90dSteve Block CheckMap(map, FACTORY->meta_map(), &fail, false); 2822b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch jmp(&ok); 2823b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch bind(&fail); 2824b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Abort("Global functions must have initial map"); 2825b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch bind(&ok); 2826b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch } 2827b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch} 2828b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 2829b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 28304515c472dc3e5ed2448a564600976759e569a0a8Leon Clarkeint MacroAssembler::ArgumentStackSlotsForCFunctionCall(int num_arguments) { 28317f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // On Windows 64 stack slots are reserved by the caller for all arguments 28327f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // including the ones passed in registers, and space is always allocated for 28337f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // the four register arguments even if the function takes fewer than four 28347f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // arguments. 28357f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // On AMD64 ABI (Linux/Mac) the first six arguments are passed in registers 28367f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // and the caller does not reserve stack slots for them. 28374515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke ASSERT(num_arguments >= 0); 28384515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke#ifdef _WIN64 283944f0eee88ff00398ff7f715fab053374d808c90dSteve Block const int kMinimumStackSlots = kRegisterPassedArguments; 28407f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch if (num_arguments < kMinimumStackSlots) return kMinimumStackSlots; 28417f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch return num_arguments; 28424515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke#else 28437f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch if (num_arguments < kRegisterPassedArguments) return 0; 28447f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch return num_arguments - kRegisterPassedArguments; 28454515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke#endif 28464515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke} 28474515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke 28487f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 28494515c472dc3e5ed2448a564600976759e569a0a8Leon Clarkevoid MacroAssembler::PrepareCallCFunction(int num_arguments) { 28504515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke int frame_alignment = OS::ActivationFrameAlignment(); 28514515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke ASSERT(frame_alignment != 0); 28524515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke ASSERT(num_arguments >= 0); 285344f0eee88ff00398ff7f715fab053374d808c90dSteve Block 285444f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Reserve space for Isolate address which is always passed as last parameter 285544f0eee88ff00398ff7f715fab053374d808c90dSteve Block num_arguments += 1; 285644f0eee88ff00398ff7f715fab053374d808c90dSteve Block 28574515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // Make stack end at alignment and allocate space for arguments and old rsp. 28584515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke movq(kScratchRegister, rsp); 28594515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke ASSERT(IsPowerOf2(frame_alignment)); 28604515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke int argument_slots_on_stack = 28614515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke ArgumentStackSlotsForCFunctionCall(num_arguments); 28624515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke subq(rsp, Immediate((argument_slots_on_stack + 1) * kPointerSize)); 28634515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke and_(rsp, Immediate(-frame_alignment)); 28644515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke movq(Operand(rsp, argument_slots_on_stack * kPointerSize), kScratchRegister); 28654515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke} 28664515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke 28674515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke 28684515c472dc3e5ed2448a564600976759e569a0a8Leon Clarkevoid MacroAssembler::CallCFunction(ExternalReference function, 28694515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke int num_arguments) { 287044f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(rax, function); 28714515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke CallCFunction(rax, num_arguments); 28724515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke} 28734515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke 28744515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke 28754515c472dc3e5ed2448a564600976759e569a0a8Leon Clarkevoid MacroAssembler::CallCFunction(Register function, int num_arguments) { 287644f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Pass current isolate address as additional parameter. 287744f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (num_arguments < kRegisterPassedArguments) { 287844f0eee88ff00398ff7f715fab053374d808c90dSteve Block#ifdef _WIN64 287944f0eee88ff00398ff7f715fab053374d808c90dSteve Block // First four arguments are passed in registers on Windows. 288044f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register arg_to_reg[] = {rcx, rdx, r8, r9}; 288144f0eee88ff00398ff7f715fab053374d808c90dSteve Block#else 288244f0eee88ff00398ff7f715fab053374d808c90dSteve Block // First six arguments are passed in registers on other platforms. 288344f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register arg_to_reg[] = {rdi, rsi, rdx, rcx, r8, r9}; 288444f0eee88ff00398ff7f715fab053374d808c90dSteve Block#endif 288544f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register reg = arg_to_reg[num_arguments]; 288644f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(reg, ExternalReference::isolate_address()); 288744f0eee88ff00398ff7f715fab053374d808c90dSteve Block } else { 288844f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Push Isolate pointer after all parameters. 288944f0eee88ff00398ff7f715fab053374d808c90dSteve Block int argument_slots_on_stack = 289044f0eee88ff00398ff7f715fab053374d808c90dSteve Block ArgumentStackSlotsForCFunctionCall(num_arguments); 289144f0eee88ff00398ff7f715fab053374d808c90dSteve Block LoadAddress(kScratchRegister, ExternalReference::isolate_address()); 289244f0eee88ff00398ff7f715fab053374d808c90dSteve Block movq(Operand(rsp, argument_slots_on_stack * kPointerSize), 289344f0eee88ff00398ff7f715fab053374d808c90dSteve Block kScratchRegister); 289444f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 289544f0eee88ff00398ff7f715fab053374d808c90dSteve Block 28966ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Check stack alignment. 289744f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 28986ded16be15dd865a9b21ea304d5273c8be299c87Steve Block CheckStackAlignment(); 28996ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 29006ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 29014515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke call(function); 29024515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke ASSERT(OS::ActivationFrameAlignment() != 0); 29034515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke ASSERT(num_arguments >= 0); 290444f0eee88ff00398ff7f715fab053374d808c90dSteve Block num_arguments += 1; 29054515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke int argument_slots_on_stack = 29064515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke ArgumentStackSlotsForCFunctionCall(num_arguments); 29074515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke movq(rsp, Operand(rsp, argument_slots_on_stack * kPointerSize)); 29084515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke} 29094515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke 2910d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 2911a7e24c173cf37484693b9abb38e494fa7bd7baebSteve BlockCodePatcher::CodePatcher(byte* address, int size) 2912a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block : address_(address), size_(size), masm_(address, size + Assembler::kGap) { 2913a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Create a new macro assembler pointing to the address of the code to patch. 2914a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // The size is adjusted with kGap on order for the assembler to generate size 2915a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // bytes of instructions without failing with buffer size constraints. 2916a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap); 2917a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2918a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2919a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2920a7e24c173cf37484693b9abb38e494fa7bd7baebSteve BlockCodePatcher::~CodePatcher() { 2921a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Indicate that code has changed. 2922a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CPU::FlushICache(address_, size_); 2923a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2924a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check that the code was patched as expected. 2925a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(masm_.pc_ == address_ + size_); 2926a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap); 2927a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2928a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2929a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} } // namespace v8::internal 2930f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke 2931f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke#endif // V8_TARGET_ARCH_X64 2932