macro-assembler-arm.cc revision c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9
1c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch// Copyright 2012 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 289ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick#include <limits.h> // For LONG_MIN, LONG_MAX. 299ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick 30a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#include "v8.h" 31a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 32f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke#if defined(V8_TARGET_ARCH_ARM) 33f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke 34a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#include "bootstrapper.h" 358b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch#include "codegen.h" 36a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#include "debug.h" 37a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#include "runtime.h" 38a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 39a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blocknamespace v8 { 40a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blocknamespace internal { 41a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 428b112d2025046f85ef7f6be087c6129c872ebad2Ben MurdochMacroAssembler::MacroAssembler(Isolate* arg_isolate, void* buffer, int size) 438b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch : Assembler(arg_isolate, buffer, size), 44a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block generating_stub_(false), 45592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch allow_stub_calls_(true), 46592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch has_frame_(false) { 478b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch if (isolate() != NULL) { 488b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch code_object_ = Handle<Object>(isolate()->heap()->undefined_value(), 498b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch isolate()); 508b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch } 51a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 52a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 53a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 54a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// We always generate arm code, never thumb code, even if V8 is compiled to 55a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// thumb, so we require inter-working support 56a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#if defined(__thumb__) && !defined(USE_THUMB_INTERWORK) 57a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#error "flag -mthumb-interwork missing" 58a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 59a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 60a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 61a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// We do not support thumb inter-working with an arm architecture not supporting 62a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// the blx instruction (below v5t). If you know what CPU you are compiling for 63a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// you can use -march=armv7 or similar. 64a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#if defined(USE_THUMB_INTERWORK) && !defined(CAN_USE_THUMB_INSTRUCTIONS) 65a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block# error "For thumb inter-working we require an architecture which supports blx" 66a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 67a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 68a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 69a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// Using bx does not yield better code, so use it only when required 70a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#if defined(USE_THUMB_INTERWORK) 71a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#define USE_BX 1 72a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 73a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 74a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 75a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Jump(Register target, Condition cond) { 76a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#if USE_BX 77a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bx(target, cond); 78a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#else 79a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(pc, Operand(target), LeaveCC, cond); 80a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 81a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 82a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 83a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 84a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Jump(intptr_t target, RelocInfo::Mode rmode, 85a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Condition cond) { 86a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#if USE_BX 87257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch mov(ip, Operand(target, rmode)); 88a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bx(ip, cond); 89a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#else 90a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(pc, Operand(target, rmode), LeaveCC, cond); 91a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 92a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 93a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 94a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 953fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdochvoid MacroAssembler::Jump(Address target, RelocInfo::Mode rmode, 96a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Condition cond) { 97a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!RelocInfo::IsCodeTarget(rmode)); 98a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Jump(reinterpret_cast<intptr_t>(target), rmode, cond); 99a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 100a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 101a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 102a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Jump(Handle<Code> code, RelocInfo::Mode rmode, 103a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Condition cond) { 104a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(RelocInfo::IsCodeTarget(rmode)); 105a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // 'code' is always generated ARM code, never THUMB code 106a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Jump(reinterpret_cast<intptr_t>(code.location()), rmode, cond); 107a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 108a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 109a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 11044f0eee88ff00398ff7f715fab053374d808c90dSteve Blockint MacroAssembler::CallSize(Register target, Condition cond) { 11144f0eee88ff00398ff7f715fab053374d808c90dSteve Block#if USE_BLX 11244f0eee88ff00398ff7f715fab053374d808c90dSteve Block return kInstrSize; 11344f0eee88ff00398ff7f715fab053374d808c90dSteve Block#else 11444f0eee88ff00398ff7f715fab053374d808c90dSteve Block return 2 * kInstrSize; 11544f0eee88ff00398ff7f715fab053374d808c90dSteve Block#endif 11644f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 11744f0eee88ff00398ff7f715fab053374d808c90dSteve Block 11844f0eee88ff00398ff7f715fab053374d808c90dSteve Block 119a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Call(Register target, Condition cond) { 12044f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Block constant pool for the call instruction sequence. 12144f0eee88ff00398ff7f715fab053374d808c90dSteve Block BlockConstPoolScope block_const_pool(this); 1223fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Label start; 1233fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch bind(&start); 124a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#if USE_BLX 125a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block blx(target, cond); 126a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#else 127a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // set lr for return at current pc + 8 128a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(lr, Operand(pc), LeaveCC, cond); 129a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(pc, Operand(target), LeaveCC, cond); 130a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 1313fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ASSERT_EQ(CallSize(target, cond), SizeOfCodeGeneratedSince(&start)); 132a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 133a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 134a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 13544f0eee88ff00398ff7f715fab053374d808c90dSteve Blockint MacroAssembler::CallSize( 1363fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Address target, RelocInfo::Mode rmode, Condition cond) { 13744f0eee88ff00398ff7f715fab053374d808c90dSteve Block int size = 2 * kInstrSize; 13844f0eee88ff00398ff7f715fab053374d808c90dSteve Block Instr mov_instr = cond | MOV | LeaveCC; 1393fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch intptr_t immediate = reinterpret_cast<intptr_t>(target); 1403fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch if (!Operand(immediate, rmode).is_single_instruction(mov_instr)) { 14144f0eee88ff00398ff7f715fab053374d808c90dSteve Block size += kInstrSize; 14244f0eee88ff00398ff7f715fab053374d808c90dSteve Block } 14344f0eee88ff00398ff7f715fab053374d808c90dSteve Block return size; 14444f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 14544f0eee88ff00398ff7f715fab053374d808c90dSteve Block 14644f0eee88ff00398ff7f715fab053374d808c90dSteve Block 1473fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdochvoid MacroAssembler::Call(Address target, 148257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch RelocInfo::Mode rmode, 149257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Condition cond) { 15044f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Block constant pool for the call instruction sequence. 15144f0eee88ff00398ff7f715fab053374d808c90dSteve Block BlockConstPoolScope block_const_pool(this); 1523fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Label start; 1533fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch bind(&start); 1546ded16be15dd865a9b21ea304d5273c8be299c87Steve Block#if USE_BLX 1556ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // On ARMv5 and after the recommended call sequence is: 1566ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // ldr ip, [pc, #...] 1576ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // blx ip 1586ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 15944f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Statement positions are expected to be recorded when the target 16044f0eee88ff00398ff7f715fab053374d808c90dSteve Block // address is loaded. The mov method will automatically record 16144f0eee88ff00398ff7f715fab053374d808c90dSteve Block // positions when pc is the target, since this is not the case here 16244f0eee88ff00398ff7f715fab053374d808c90dSteve Block // we have to do it explicitly. 16344f0eee88ff00398ff7f715fab053374d808c90dSteve Block positions_recorder()->WriteRecordedPositions(); 1646ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 1653fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch mov(ip, Operand(reinterpret_cast<int32_t>(target), rmode)); 16644f0eee88ff00398ff7f715fab053374d808c90dSteve Block blx(ip, cond); 1676ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 1686ded16be15dd865a9b21ea304d5273c8be299c87Steve Block ASSERT(kCallTargetAddressOffset == 2 * kInstrSize); 1696ded16be15dd865a9b21ea304d5273c8be299c87Steve Block#else 170a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Set lr for return at current pc + 8. 171a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(lr, Operand(pc), LeaveCC, cond); 172a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Emit a ldr<cond> pc, [pc + offset of target in constant pool]. 1733fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch mov(pc, Operand(reinterpret_cast<int32_t>(target), rmode), LeaveCC, cond); 174a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(kCallTargetAddressOffset == kInstrSize); 1756ded16be15dd865a9b21ea304d5273c8be299c87Steve Block#endif 1763fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ASSERT_EQ(CallSize(target, rmode, cond), SizeOfCodeGeneratedSince(&start)); 177a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 178a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 179a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1803fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdochint MacroAssembler::CallSize(Handle<Code> code, 1813fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch RelocInfo::Mode rmode, 1823fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch unsigned ast_id, 1833fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Condition cond) { 1843fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch return CallSize(reinterpret_cast<Address>(code.location()), rmode, cond); 185257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 186257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 187257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 188257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::Call(Handle<Code> code, 189257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch RelocInfo::Mode rmode, 1903fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch unsigned ast_id, 191257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Condition cond) { 1923fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Label start; 1933fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch bind(&start); 194a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(RelocInfo::IsCodeTarget(rmode)); 1953fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch if (rmode == RelocInfo::CODE_TARGET && ast_id != kNoASTId) { 1963fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch SetRecordedAstId(ast_id); 1973fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch rmode = RelocInfo::CODE_TARGET_WITH_ID; 1983fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } 199a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // 'code' is always generated ARM code, never THUMB code 2003fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Call(reinterpret_cast<Address>(code.location()), rmode, cond); 2013fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ASSERT_EQ(CallSize(code, rmode, ast_id, cond), 2023fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch SizeOfCodeGeneratedSince(&start)); 203a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 204a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 205a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 206a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Ret(Condition cond) { 207a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#if USE_BX 208a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bx(lr, cond); 209a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#else 210a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(pc, Operand(lr), LeaveCC, cond); 211a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 212a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 213a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 214a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 215e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarkevoid MacroAssembler::Drop(int count, Condition cond) { 216e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke if (count > 0) { 217e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke add(sp, sp, Operand(count * kPointerSize), LeaveCC, cond); 218e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke } 219e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke} 220e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 221e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 222b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdochvoid MacroAssembler::Ret(int drop, Condition cond) { 223b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Drop(drop, cond); 224b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Ret(cond); 225b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch} 226b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 227b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 2287f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdochvoid MacroAssembler::Swap(Register reg1, 2297f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch Register reg2, 2307f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch Register scratch, 2317f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch Condition cond) { 2326ded16be15dd865a9b21ea304d5273c8be299c87Steve Block if (scratch.is(no_reg)) { 2337f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch eor(reg1, reg1, Operand(reg2), LeaveCC, cond); 2347f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch eor(reg2, reg2, Operand(reg1), LeaveCC, cond); 2357f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch eor(reg1, reg1, Operand(reg2), LeaveCC, cond); 2366ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } else { 2377f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch mov(scratch, reg1, LeaveCC, cond); 2387f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch mov(reg1, reg2, LeaveCC, cond); 2397f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch mov(reg2, scratch, LeaveCC, cond); 2406ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 2416ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 2426ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 2436ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 244e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarkevoid MacroAssembler::Call(Label* target) { 245e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke bl(target); 246e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke} 247e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 248e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 2493fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdochvoid MacroAssembler::Push(Handle<Object> handle) { 2503fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch mov(ip, Operand(handle)); 2513fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch push(ip); 2523fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch} 2533fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 2543fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 255e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarkevoid MacroAssembler::Move(Register dst, Handle<Object> value) { 256e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke mov(dst, Operand(value)); 257e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke} 258d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 259d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 2603fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdochvoid MacroAssembler::Move(Register dst, Register src, Condition cond) { 2616ded16be15dd865a9b21ea304d5273c8be299c87Steve Block if (!dst.is(src)) { 2623fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch mov(dst, src, LeaveCC, cond); 2636ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 2646ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 2656ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 2666ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 267257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::Move(DoubleRegister dst, DoubleRegister src) { 268257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch ASSERT(CpuFeatures::IsSupported(VFP3)); 269257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch CpuFeatures::Scope scope(VFP3); 270257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (!dst.is(src)) { 271257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch vmov(dst, src); 272257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } 273257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 274257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 275257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 2769dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsenvoid MacroAssembler::And(Register dst, Register src1, const Operand& src2, 2779dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Condition cond) { 2783e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu if (!src2.is_reg() && 2793e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu !src2.must_use_constant_pool() && 2803e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu src2.immediate() == 0) { 2819ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick mov(dst, Operand(0, RelocInfo::NONE), LeaveCC, cond); 2823e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu 2833e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu } else if (!src2.is_single_instruction() && 2843e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu !src2.must_use_constant_pool() && 2858b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch CpuFeatures::IsSupported(ARMv7) && 2863e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu IsPowerOf2(src2.immediate() + 1)) { 2873fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ubfx(dst, src1, 0, 2883fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch WhichPowerOf2(static_cast<uint32_t>(src2.immediate()) + 1), cond); 2893e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu 2903e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu } else { 2913e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu and_(dst, src1, src2, LeaveCC, cond); 2929dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } 2939dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen} 2949dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 2959dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 2969dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsenvoid MacroAssembler::Ubfx(Register dst, Register src1, int lsb, int width, 2979dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Condition cond) { 2989dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen ASSERT(lsb < 32); 2998b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch if (!CpuFeatures::IsSupported(ARMv7)) { 3009dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen int mask = (1 << (width + lsb)) - 1 - ((1 << lsb) - 1); 3019dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen and_(dst, src1, Operand(mask), LeaveCC, cond); 3029dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen if (lsb != 0) { 3039dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen mov(dst, Operand(dst, LSR, lsb), LeaveCC, cond); 3049dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } 3059dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } else { 3069dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen ubfx(dst, src1, lsb, width, cond); 3079dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } 3089dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen} 3099dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 3109dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 3119dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsenvoid MacroAssembler::Sbfx(Register dst, Register src1, int lsb, int width, 3129dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Condition cond) { 3139dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen ASSERT(lsb < 32); 3148b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch if (!CpuFeatures::IsSupported(ARMv7)) { 3159dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen int mask = (1 << (width + lsb)) - 1 - ((1 << lsb) - 1); 3169dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen and_(dst, src1, Operand(mask), LeaveCC, cond); 3179dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen int shift_up = 32 - lsb - width; 3189dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen int shift_down = lsb + shift_up; 3199dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen if (shift_up != 0) { 3209dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen mov(dst, Operand(dst, LSL, shift_up), LeaveCC, cond); 3219dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } 3229dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen if (shift_down != 0) { 3239dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen mov(dst, Operand(dst, ASR, shift_down), LeaveCC, cond); 3249dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } 3259dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } else { 3269dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen sbfx(dst, src1, lsb, width, cond); 3279dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } 3289dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen} 3299dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 3309dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 331e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::Bfi(Register dst, 332e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register src, 333e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register scratch, 334e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch int lsb, 335e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch int width, 336e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Condition cond) { 337e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ASSERT(0 <= lsb && lsb < 32); 338e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ASSERT(0 <= width && width < 32); 339e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ASSERT(lsb + width < 32); 340e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ASSERT(!scratch.is(dst)); 341e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch if (width == 0) return; 3428b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch if (!CpuFeatures::IsSupported(ARMv7)) { 343e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch int mask = (1 << (width + lsb)) - 1 - ((1 << lsb) - 1); 344e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch bic(dst, dst, Operand(mask)); 345e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch and_(scratch, src, Operand((1 << width) - 1)); 346e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch mov(scratch, Operand(scratch, LSL, lsb)); 347e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch orr(dst, dst, scratch); 348e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } else { 349e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch bfi(dst, src, lsb, width, cond); 350e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } 351e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 352e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 353e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 3549dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsenvoid MacroAssembler::Bfc(Register dst, int lsb, int width, Condition cond) { 3559dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen ASSERT(lsb < 32); 3568b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch if (!CpuFeatures::IsSupported(ARMv7)) { 3579dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen int mask = (1 << (width + lsb)) - 1 - ((1 << lsb) - 1); 3589dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen bic(dst, dst, Operand(mask)); 3599dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } else { 3609dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen bfc(dst, lsb, width, cond); 3619dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } 3629dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen} 3639dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 3649dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 36550ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsenvoid MacroAssembler::Usat(Register dst, int satpos, const Operand& src, 36650ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen Condition cond) { 3678b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch if (!CpuFeatures::IsSupported(ARMv7)) { 36850ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen ASSERT(!dst.is(pc) && !src.rm().is(pc)); 36950ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen ASSERT((satpos >= 0) && (satpos <= 31)); 37050ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen 37150ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen // These asserts are required to ensure compatibility with the ARMv7 37250ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen // implementation. 37350ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen ASSERT((src.shift_op() == ASR) || (src.shift_op() == LSL)); 37450ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen ASSERT(src.rs().is(no_reg)); 37550ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen 37650ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen Label done; 37750ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen int satval = (1 << satpos) - 1; 37850ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen 37950ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen if (cond != al) { 38050ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen b(NegateCondition(cond), &done); // Skip saturate if !condition. 38150ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen } 38250ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen if (!(src.is_reg() && dst.is(src.rm()))) { 38350ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen mov(dst, src); 38450ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen } 38550ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen tst(dst, Operand(~satval)); 38650ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen b(eq, &done); 3879ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick mov(dst, Operand(0, RelocInfo::NONE), LeaveCC, mi); // 0 if negative. 38850ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen mov(dst, Operand(satval), LeaveCC, pl); // satval if positive. 38950ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen bind(&done); 39050ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen } else { 39150ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen usat(dst, satpos, src, cond); 39250ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen } 39350ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen} 39450ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen 39550ef84f5fad2def87d3fbc737bec4a32711fdef4Kristian Monsen 396a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::LoadRoot(Register destination, 397a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Heap::RootListIndex index, 398a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Condition cond) { 399c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch ldr(destination, MemOperand(kRootRegister, index << kPointerSizeLog2), cond); 400a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 401a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 402a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 40325f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsenvoid MacroAssembler::StoreRoot(Register source, 40425f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen Heap::RootListIndex index, 40525f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen Condition cond) { 406c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch str(source, MemOperand(kRootRegister, index << kPointerSizeLog2), cond); 407c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch} 408c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch 409c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch 410c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdochvoid MacroAssembler::LoadHeapObject(Register result, 411c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Handle<HeapObject> object) { 412c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch if (isolate()->heap()->InNewSpace(*object)) { 413c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Handle<JSGlobalPropertyCell> cell = 414c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch isolate()->factory()->NewJSGlobalPropertyCell(object); 415c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch mov(result, Operand(cell)); 416c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch ldr(result, FieldMemOperand(result, JSGlobalPropertyCell::kValueOffset)); 417c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch } else { 418c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch mov(result, Operand(object)); 419c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch } 4206ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 4216ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 4226ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 4236ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::InNewSpace(Register object, 4246ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register scratch, 4251e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Condition cond, 4266ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Label* branch) { 4271e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ASSERT(cond == eq || cond == ne); 42844f0eee88ff00398ff7f715fab053374d808c90dSteve Block and_(scratch, object, Operand(ExternalReference::new_space_mask(isolate()))); 42944f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmp(scratch, Operand(ExternalReference::new_space_start(isolate()))); 4301e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block b(cond, branch); 4316ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 4326ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 4336ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 434592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::RecordWriteField( 435592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register object, 436592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch int offset, 437592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register value, 438592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register dst, 439592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch LinkRegisterStatus lr_status, 440592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch SaveFPRegsMode save_fp, 441592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch RememberedSetAction remembered_set_action, 442592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch SmiCheck smi_check) { 443592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // First, check if a write barrier is even needed. The tests below 444592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // catch stores of Smis. 4456ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Label done; 4466ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 447592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Skip barrier if writing a smi. 448592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (smi_check == INLINE_SMI_CHECK) { 449592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch JumpIfSmi(value, &done); 450592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 4516ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 452592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Although the object register is tagged, the offset is relative to the start 453592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // of the object, so so offset must be a multiple of kPointerSize. 454592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(IsAligned(offset, kPointerSize)); 4558defd9ff6930b4e24729971a61cf7469daf119beSteve Block 456592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch add(dst, object, Operand(offset - kHeapObjectTag)); 457592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (emit_debug_code()) { 458592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label ok; 459592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(dst, Operand((1 << kPointerSizeLog2) - 1)); 460592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(eq, &ok); 461592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch stop("Unaligned cell in write barrier"); 462592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&ok); 463592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 464592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 465592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch RecordWrite(object, 466592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch dst, 467592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch value, 468592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch lr_status, 469592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch save_fp, 470592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch remembered_set_action, 471592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch OMIT_SMI_CHECK); 472a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 473a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&done); 4744515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke 475592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Clobber clobbered input registers when running with the debug-code flag 4764515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // turned on to provoke errors. 47744f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 478592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(value, Operand(BitCast<int32_t>(kZapValue + 4))); 479592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(dst, Operand(BitCast<int32_t>(kZapValue + 8))); 4804515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke } 481a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 482a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 483a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 4848defd9ff6930b4e24729971a61cf7469daf119beSteve Block// Will clobber 4 registers: object, address, scratch, ip. The 4858defd9ff6930b4e24729971a61cf7469daf119beSteve Block// register 'object' contains a heap object pointer. The heap object 4868defd9ff6930b4e24729971a61cf7469daf119beSteve Block// tag is shifted away. 4878defd9ff6930b4e24729971a61cf7469daf119beSteve Blockvoid MacroAssembler::RecordWrite(Register object, 4888defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register address, 489592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register value, 490592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch LinkRegisterStatus lr_status, 491592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch SaveFPRegsMode fp_mode, 492592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch RememberedSetAction remembered_set_action, 493592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch SmiCheck smi_check) { 4948defd9ff6930b4e24729971a61cf7469daf119beSteve Block // The compiled code assumes that record write doesn't change the 4958defd9ff6930b4e24729971a61cf7469daf119beSteve Block // context register, so we check that none of the clobbered 4968defd9ff6930b4e24729971a61cf7469daf119beSteve Block // registers are cp. 497592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(!address.is(cp) && !value.is(cp)); 498592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 499c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch if (emit_debug_code()) { 500592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(ip, MemOperand(address)); 501592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch cmp(ip, value); 502c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Check(eq, "Wrong address or value passed to RecordWrite"); 503592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 5048defd9ff6930b4e24729971a61cf7469daf119beSteve Block 5058defd9ff6930b4e24729971a61cf7469daf119beSteve Block Label done; 5068defd9ff6930b4e24729971a61cf7469daf119beSteve Block 507592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (smi_check == INLINE_SMI_CHECK) { 508592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT_EQ(0, kSmiTag); 509592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(value, Operand(kSmiTagMask)); 510592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(eq, &done); 511592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 512592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 513592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CheckPageFlag(value, 514592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch value, // Used as scratch. 515592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch MemoryChunk::kPointersToHereAreInterestingMask, 516592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch eq, 517592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch &done); 518592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CheckPageFlag(object, 519592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch value, // Used as scratch. 520592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch MemoryChunk::kPointersFromHereAreInterestingMask, 521592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch eq, 522592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch &done); 5238defd9ff6930b4e24729971a61cf7469daf119beSteve Block 5248defd9ff6930b4e24729971a61cf7469daf119beSteve Block // Record the actual write. 525592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (lr_status == kLRHasNotBeenSaved) { 526592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch push(lr); 527592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 528592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch RecordWriteStub stub(object, value, address, remembered_set_action, fp_mode); 529592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CallStub(&stub); 530592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (lr_status == kLRHasNotBeenSaved) { 531592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch pop(lr); 532592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 5338defd9ff6930b4e24729971a61cf7469daf119beSteve Block 5348defd9ff6930b4e24729971a61cf7469daf119beSteve Block bind(&done); 5358defd9ff6930b4e24729971a61cf7469daf119beSteve Block 536592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Clobber clobbered registers when running with the debug-code flag 5378defd9ff6930b4e24729971a61cf7469daf119beSteve Block // turned on to provoke errors. 53844f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 539592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(address, Operand(BitCast<int32_t>(kZapValue + 12))); 540592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(value, Operand(BitCast<int32_t>(kZapValue + 16))); 541592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 542592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 543592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 544592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 545592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::RememberedSetHelper(Register object, // For debug tests. 546592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register address, 547592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register scratch, 548592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch SaveFPRegsMode fp_mode, 549592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch RememberedSetFinalAction and_then) { 550592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label done; 551c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch if (emit_debug_code()) { 552592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label ok; 553592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch JumpIfNotInNewSpace(object, scratch, &ok); 554592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch stop("Remembered set pointer is in new space"); 555592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&ok); 556592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 557592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Load store buffer top. 558592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ExternalReference store_buffer = 559592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ExternalReference::store_buffer_top(isolate()); 560592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(ip, Operand(store_buffer)); 561592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(scratch, MemOperand(ip)); 562592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Store pointer to buffer and increment buffer top. 563592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch str(address, MemOperand(scratch, kPointerSize, PostIndex)); 564592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Write back new top of buffer. 565592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch str(scratch, MemOperand(ip)); 566592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Call stub on end of buffer. 567592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Check for end of buffer. 568592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(scratch, Operand(StoreBuffer::kStoreBufferOverflowBit)); 569592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (and_then == kFallThroughAtEnd) { 570592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(eq, &done); 571592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } else { 572592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(and_then == kReturnAtEnd); 573592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Ret(eq); 574592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 575592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch push(lr); 576592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch StoreBufferOverflowStub store_buffer_overflow = 577592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch StoreBufferOverflowStub(fp_mode); 578592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CallStub(&store_buffer_overflow); 579592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch pop(lr); 580592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&done); 581592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (and_then == kReturnAtEnd) { 582592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Ret(); 5838defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 5848defd9ff6930b4e24729971a61cf7469daf119beSteve Block} 5858defd9ff6930b4e24729971a61cf7469daf119beSteve Block 5868defd9ff6930b4e24729971a61cf7469daf119beSteve Block 587b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch// Push and pop all registers that can hold pointers. 588b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdochvoid MacroAssembler::PushSafepointRegisters() { 589b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Safepoints expect a block of contiguous register values starting with r0: 590b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT(((1 << kNumSafepointSavedRegisters) - 1) == kSafepointSavedRegisters); 591b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Safepoints expect a block of kNumSafepointRegisters values on the 592b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // stack, so adjust the stack for unsaved registers. 593b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch const int num_unsaved = kNumSafepointRegisters - kNumSafepointSavedRegisters; 594b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT(num_unsaved >= 0); 595b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch sub(sp, sp, Operand(num_unsaved * kPointerSize)); 596b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch stm(db_w, sp, kSafepointSavedRegisters); 597b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch} 598b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 599b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 600b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdochvoid MacroAssembler::PopSafepointRegisters() { 601b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch const int num_unsaved = kNumSafepointRegisters - kNumSafepointSavedRegisters; 602b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ldm(ia_w, sp, kSafepointSavedRegisters); 603b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch add(sp, sp, Operand(num_unsaved * kPointerSize)); 604b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch} 605b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 606b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 607b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdochvoid MacroAssembler::PushSafepointRegistersAndDoubles() { 608b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch PushSafepointRegisters(); 609b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch sub(sp, sp, Operand(DwVfpRegister::kNumAllocatableRegisters * 610b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch kDoubleSize)); 611b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch for (int i = 0; i < DwVfpRegister::kNumAllocatableRegisters; i++) { 612b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch vstr(DwVfpRegister::FromAllocationIndex(i), sp, i * kDoubleSize); 613b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch } 614b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch} 615b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch 616b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch 617b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdochvoid MacroAssembler::PopSafepointRegistersAndDoubles() { 618b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch for (int i = 0; i < DwVfpRegister::kNumAllocatableRegisters; i++) { 619b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch vldr(DwVfpRegister::FromAllocationIndex(i), sp, i * kDoubleSize); 620b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch } 621b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch add(sp, sp, Operand(DwVfpRegister::kNumAllocatableRegisters * 622b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch kDoubleSize)); 623b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch PopSafepointRegisters(); 624b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch} 625b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch 626e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::StoreToSafepointRegistersAndDoublesSlot(Register src, 627e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register dst) { 628e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch str(src, SafepointRegistersAndDoublesSlot(dst)); 6291e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 6301e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 6311e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 632e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::StoreToSafepointRegisterSlot(Register src, Register dst) { 633e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch str(src, SafepointRegisterSlot(dst)); 6341e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 6351e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 6361e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 637e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::LoadFromSafepointRegisterSlot(Register dst, Register src) { 638e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ldr(dst, SafepointRegisterSlot(src)); 6391e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 6401e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 6411e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 642b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdochint MacroAssembler::SafepointRegisterStackIndex(int reg_code) { 643b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // The registers are pushed starting with the highest encoding, 644b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // which means that lowest encodings are closest to the stack pointer. 645b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT(reg_code >= 0 && reg_code < kNumSafepointRegisters); 646b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch return reg_code; 647b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch} 648b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 649b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 6501e0659c275bb392c045087af4f6b0d7565cb3d77Steve BlockMemOperand MacroAssembler::SafepointRegisterSlot(Register reg) { 6511e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block return MemOperand(sp, SafepointRegisterStackIndex(reg.code()) * kPointerSize); 6521e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 6531e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 6541e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 6551e0659c275bb392c045087af4f6b0d7565cb3d77Steve BlockMemOperand MacroAssembler::SafepointRegistersAndDoublesSlot(Register reg) { 6561e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // General purpose registers are pushed last on the stack. 6571e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block int doubles_size = DwVfpRegister::kNumAllocatableRegisters * kDoubleSize; 6581e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block int register_offset = SafepointRegisterStackIndex(reg.code()) * kPointerSize; 6591e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block return MemOperand(sp, doubles_size + register_offset); 6601e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 6611e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 6621e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 663f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarkevoid MacroAssembler::Ldrd(Register dst1, Register dst2, 664f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke const MemOperand& src, Condition cond) { 665f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke ASSERT(src.rm().is(no_reg)); 666f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke ASSERT(!dst1.is(lr)); // r14. 667f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke ASSERT_EQ(0, dst1.code() % 2); 668f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke ASSERT_EQ(dst1.code() + 1, dst2.code()); 669f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke 6703fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // V8 does not use this addressing mode, so the fallback code 6713fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // below doesn't support it yet. 6723fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ASSERT((src.am() != PreIndex) && (src.am() != NegPreIndex)); 6733fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 674f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke // Generate two ldr instructions if ldrd is not available. 6758b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch if (CpuFeatures::IsSupported(ARMv7)) { 676f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke CpuFeatures::Scope scope(ARMv7); 677f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke ldrd(dst1, dst2, src, cond); 678f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke } else { 6793fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch if ((src.am() == Offset) || (src.am() == NegOffset)) { 6803fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch MemOperand src2(src); 6813fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch src2.set_offset(src2.offset() + 4); 6823fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch if (dst1.is(src.rn())) { 6833fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldr(dst2, src2, cond); 6843fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldr(dst1, src, cond); 6853fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } else { 6863fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldr(dst1, src, cond); 6873fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldr(dst2, src2, cond); 6883fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } 6893fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } else { // PostIndex or NegPostIndex. 6903fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ASSERT((src.am() == PostIndex) || (src.am() == NegPostIndex)); 6913fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch if (dst1.is(src.rn())) { 6923fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldr(dst2, MemOperand(src.rn(), 4, Offset), cond); 6933fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldr(dst1, src, cond); 6943fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } else { 6953fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch MemOperand src2(src); 6963fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch src2.set_offset(src2.offset() - 4); 6973fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldr(dst1, MemOperand(src.rn(), 4, PostIndex), cond); 6983fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldr(dst2, src2, cond); 6993fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } 700f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke } 701f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke } 702f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke} 703f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke 704f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke 705f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarkevoid MacroAssembler::Strd(Register src1, Register src2, 706f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke const MemOperand& dst, Condition cond) { 707f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke ASSERT(dst.rm().is(no_reg)); 708f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke ASSERT(!src1.is(lr)); // r14. 709f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke ASSERT_EQ(0, src1.code() % 2); 710f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke ASSERT_EQ(src1.code() + 1, src2.code()); 711f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke 7123fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // V8 does not use this addressing mode, so the fallback code 7133fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // below doesn't support it yet. 7143fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ASSERT((dst.am() != PreIndex) && (dst.am() != NegPreIndex)); 7153fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 716f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke // Generate two str instructions if strd is not available. 7178b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch if (CpuFeatures::IsSupported(ARMv7)) { 718f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke CpuFeatures::Scope scope(ARMv7); 719f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke strd(src1, src2, dst, cond); 720f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke } else { 721f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke MemOperand dst2(dst); 7223fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch if ((dst.am() == Offset) || (dst.am() == NegOffset)) { 7233fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch dst2.set_offset(dst2.offset() + 4); 7243fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch str(src1, dst, cond); 7253fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch str(src2, dst2, cond); 7263fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } else { // PostIndex or NegPostIndex. 7273fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ASSERT((dst.am() == PostIndex) || (dst.am() == NegPostIndex)); 7283fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch dst2.set_offset(dst2.offset() - 4); 7293fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch str(src1, MemOperand(dst.rn(), 4, PostIndex), cond); 7303fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch str(src2, dst2, cond); 7313fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } 732f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke } 733f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke} 734f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke 735f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke 736b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdochvoid MacroAssembler::ClearFPSCRBits(const uint32_t bits_to_clear, 737b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch const Register scratch, 738b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch const Condition cond) { 739b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch vmrs(scratch, cond); 740b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch bic(scratch, scratch, Operand(bits_to_clear), LeaveCC, cond); 741b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch vmsr(scratch, cond); 742b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch} 743b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch 744b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch 745b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdochvoid MacroAssembler::VFPCompareAndSetFlags(const DwVfpRegister src1, 746b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch const DwVfpRegister src2, 747b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch const Condition cond) { 748b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch // Compare and move FPSCR flags to the normal condition flags. 749b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch VFPCompareAndLoadFlags(src1, src2, pc, cond); 750b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch} 751b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch 752b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdochvoid MacroAssembler::VFPCompareAndSetFlags(const DwVfpRegister src1, 753b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch const double src2, 754b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch const Condition cond) { 755b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch // Compare and move FPSCR flags to the normal condition flags. 756b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch VFPCompareAndLoadFlags(src1, src2, pc, cond); 757b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch} 758b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch 759b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch 760b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdochvoid MacroAssembler::VFPCompareAndLoadFlags(const DwVfpRegister src1, 761b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch const DwVfpRegister src2, 762b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch const Register fpscr_flags, 763b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch const Condition cond) { 764b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch // Compare and load FPSCR. 765b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch vcmp(src1, src2, cond); 766b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch vmrs(fpscr_flags, cond); 767b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch} 768b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch 769b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdochvoid MacroAssembler::VFPCompareAndLoadFlags(const DwVfpRegister src1, 770b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch const double src2, 771b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch const Register fpscr_flags, 772b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch const Condition cond) { 773b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch // Compare and load FPSCR. 774b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch vcmp(src1, src2, cond); 775b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch vmrs(fpscr_flags, cond); 776086aeeaae12517475c22695a200be45495516549Ben Murdoch} 777086aeeaae12517475c22695a200be45495516549Ben Murdoch 7783fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdochvoid MacroAssembler::Vmov(const DwVfpRegister dst, 7793fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch const double imm, 7803fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch const Condition cond) { 7813fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ASSERT(CpuFeatures::IsEnabled(VFP3)); 7823fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch static const DoubleRepresentation minus_zero(-0.0); 7833fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch static const DoubleRepresentation zero(0.0); 7843fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch DoubleRepresentation value(imm); 7853fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Handle special values first. 7863fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch if (value.bits == zero.bits) { 7873fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch vmov(dst, kDoubleRegZero, cond); 7883fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } else if (value.bits == minus_zero.bits) { 7893fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch vneg(dst, kDoubleRegZero, cond); 7903fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } else { 7913fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch vmov(dst, imm, cond); 7923fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } 7933fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch} 7943fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 795086aeeaae12517475c22695a200be45495516549Ben Murdoch 796a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::EnterFrame(StackFrame::Type type) { 797a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // r0-r3: preserved 798a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block stm(db_w, sp, cp.bit() | fp.bit() | lr.bit()); 799a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(ip, Operand(Smi::FromInt(type))); 800a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(ip); 801a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(ip, Operand(CodeObject())); 802a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(ip); 803a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block add(fp, sp, Operand(3 * kPointerSize)); // Adjust FP to point to saved FP. 804a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 805a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 806a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 807a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::LeaveFrame(StackFrame::Type type) { 808a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // r0: preserved 809a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // r1: preserved 810a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // r2: preserved 811a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 812a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Drop the execution stack down to the frame pointer and restore 813a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // the caller frame pointer and return address. 814a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(sp, fp); 815a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldm(ia_w, sp, fp.bit() | lr.bit()); 816a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 817a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 818a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 8191e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::EnterExitFrame(bool save_doubles, int stack_space) { 820c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // Set up the frame structure on the stack. 8211e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ASSERT_EQ(2 * kPointerSize, ExitFrameConstants::kCallerSPDisplacement); 8221e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ASSERT_EQ(1 * kPointerSize, ExitFrameConstants::kCallerPCOffset); 8231e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ASSERT_EQ(0 * kPointerSize, ExitFrameConstants::kCallerFPOffset); 8241e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Push(lr, fp); 825c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch mov(fp, Operand(sp)); // Set up new frame pointer. 8261e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Reserve room for saved entry sp and code object. 8271e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block sub(sp, sp, Operand(2 * kPointerSize)); 82844f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 8291e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block mov(ip, Operand(0)); 8301e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block str(ip, MemOperand(fp, ExitFrameConstants::kSPOffset)); 8311e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } 832402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu mov(ip, Operand(CodeObject())); 8331e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block str(ip, MemOperand(fp, ExitFrameConstants::kCodeOffset)); 834a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 835a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Save the frame pointer and the context in top. 836589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch mov(ip, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate()))); 837a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block str(fp, MemOperand(ip)); 838589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch mov(ip, Operand(ExternalReference(Isolate::kContextAddress, isolate()))); 839a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block str(cp, MemOperand(ip)); 840a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 841b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Optionally save all double registers. 842b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch if (save_doubles) { 8438b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch DwVfpRegister first = d0; 8448b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch DwVfpRegister last = 8458b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch DwVfpRegister::from_code(DwVfpRegister::kNumRegisters - 1); 8468b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch vstm(db_w, sp, first, last); 8471e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Note that d0 will be accessible at 8481e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // fp - 2 * kPointerSize - DwVfpRegister::kNumRegisters * kDoubleSize, 8491e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // since the sp slot and code slot were pushed after the fp. 850b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch } 8511e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 8521e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Reserve place for the return address and stack space and align the frame 8531e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // preparing for calling the runtime function. 8541e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block const int frame_alignment = MacroAssembler::ActivationFrameAlignment(); 8551e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block sub(sp, sp, Operand((stack_space + 1) * kPointerSize)); 8561e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block if (frame_alignment > 0) { 8571e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ASSERT(IsPowerOf2(frame_alignment)); 8581e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block and_(sp, sp, Operand(-frame_alignment)); 8591e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } 8601e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 8611e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Set the exit frame sp value to point just before the return address 8621e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // location. 8631e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block add(ip, sp, Operand(kPointerSize)); 8641e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block str(ip, MemOperand(fp, ExitFrameConstants::kSPOffset)); 865a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 866a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 867a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 8686ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::InitializeNewString(Register string, 8696ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register length, 8706ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Heap::RootListIndex map_index, 8716ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register scratch1, 8726ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register scratch2) { 8736ded16be15dd865a9b21ea304d5273c8be299c87Steve Block mov(scratch1, Operand(length, LSL, kSmiTagSize)); 8746ded16be15dd865a9b21ea304d5273c8be299c87Steve Block LoadRoot(scratch2, map_index); 8756ded16be15dd865a9b21ea304d5273c8be299c87Steve Block str(scratch1, FieldMemOperand(string, String::kLengthOffset)); 8766ded16be15dd865a9b21ea304d5273c8be299c87Steve Block mov(scratch1, Operand(String::kEmptyHashField)); 8776ded16be15dd865a9b21ea304d5273c8be299c87Steve Block str(scratch2, FieldMemOperand(string, HeapObject::kMapOffset)); 8786ded16be15dd865a9b21ea304d5273c8be299c87Steve Block str(scratch1, FieldMemOperand(string, String::kHashFieldOffset)); 8796ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 8806ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 8816ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 8826ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockint MacroAssembler::ActivationFrameAlignment() { 883a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#if defined(V8_HOST_ARCH_ARM) 884a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Running on the real platform. Use the alignment as mandated by the local 885a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // environment. 886a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Note: This will break if we ever start generating snapshots on one ARM 887a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // platform for another ARM platform with a different alignment. 8886ded16be15dd865a9b21ea304d5273c8be299c87Steve Block return OS::ActivationFrameAlignment(); 889a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#else // defined(V8_HOST_ARCH_ARM) 890a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // If we are using the simulator then we should always align to the expected 891a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // alignment. As the simulator is used to generate snapshots we do not know 8926ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // if the target platform will need alignment, so this is controlled from a 8936ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // flag. 8946ded16be15dd865a9b21ea304d5273c8be299c87Steve Block return FLAG_sim_stack_alignment; 895a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif // defined(V8_HOST_ARCH_ARM) 896a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 897a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 898a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 899e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::LeaveExitFrame(bool save_doubles, 900e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register argument_count) { 901b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Optionally restore all double registers. 902b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch if (save_doubles) { 9038b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch // Calculate the stack location of the saved doubles and restore them. 9048b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch const int offset = 2 * kPointerSize; 9058b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch sub(r3, fp, Operand(offset + DwVfpRegister::kNumRegisters * kDoubleSize)); 9068b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch DwVfpRegister first = d0; 9078b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch DwVfpRegister last = 9088b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch DwVfpRegister::from_code(DwVfpRegister::kNumRegisters - 1); 9098b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch vldm(ia, r3, first, last); 910b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch } 911b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 912a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Clear top frame. 9139ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick mov(r3, Operand(0, RelocInfo::NONE)); 914589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch mov(ip, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate()))); 915a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block str(r3, MemOperand(ip)); 916a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 917a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Restore current context from top and clear it in debug mode. 918589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch mov(ip, Operand(ExternalReference(Isolate::kContextAddress, isolate()))); 919a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(cp, MemOperand(ip)); 920a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifdef DEBUG 921a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block str(r3, MemOperand(ip)); 922a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 923a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 924e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Tear down the exit frame, pop the arguments, and return. 9251e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block mov(sp, Operand(fp)); 9261e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ldm(ia_w, sp, fp.bit() | lr.bit()); 927e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch if (argument_count.is_valid()) { 928e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch add(sp, sp, Operand(argument_count, LSL, kPointerSizeLog2)); 929e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } 930e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 931e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 932e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::GetCFunctionDoubleResult(const DoubleRegister dst) { 933257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (use_eabi_hardfloat()) { 934257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Move(dst, d0); 935257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } else { 936257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch vmov(dst, r0, r1); 937257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } 938257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 939257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 940257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 941257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::SetCallKind(Register dst, CallKind call_kind) { 942257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch // This macro takes the dst register to make the code more readable 943257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch // at the call sites. However, the dst register has to be r5 to 944257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch // follow the calling convention which requires the call type to be 945257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch // in r5. 946257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch ASSERT(dst.is(r5)); 947257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (call_kind == CALL_AS_FUNCTION) { 948257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch mov(dst, Operand(Smi::FromInt(1))); 949257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } else { 950257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch mov(dst, Operand(Smi::FromInt(0))); 951257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } 952a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 953a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 954a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 955a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::InvokePrologue(const ParameterCount& expected, 956a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const ParameterCount& actual, 957a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Handle<Code> code_constant, 958a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register code_reg, 959a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label* done, 960c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch bool* definitely_mismatches, 961b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch InvokeFlag flag, 962257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch const CallWrapper& call_wrapper, 963257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch CallKind call_kind) { 964a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bool definitely_matches = false; 965c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch *definitely_mismatches = false; 966a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label regular_invoke; 967a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 968a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check whether the expected and actual arguments count match. If not, 969a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // setup registers according to contract with ArgumentsAdaptorTrampoline: 970a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // r0: actual arguments count 971a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // r1: function (passed through to callee) 972a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // r2: expected arguments count 973a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // r3: callee code entry 974a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 975a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // The code below is made a lot easier because the calling code already sets 976a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // up actual and expected registers according to the contract if values are 977a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // passed in registers. 978a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(actual.is_immediate() || actual.reg().is(r0)); 979a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(expected.is_immediate() || expected.reg().is(r2)); 980a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT((!code_constant.is_null() && code_reg.is(no_reg)) || code_reg.is(r3)); 981a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 982a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (expected.is_immediate()) { 983a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(actual.is_immediate()); 984a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (expected.immediate() == actual.immediate()) { 985a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block definitely_matches = true; 986a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 987a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(r0, Operand(actual.immediate())); 988a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const int sentinel = SharedFunctionInfo::kDontAdaptArgumentsSentinel; 989a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (expected.immediate() == sentinel) { 990a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Don't worry about adapting arguments for builtins that 991a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // don't want that done. Skip adaption code by making it look 992a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // like we have a match between expected and actual number of 993a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // arguments. 994a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block definitely_matches = true; 995a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 996c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch *definitely_mismatches = true; 997a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(r2, Operand(expected.immediate())); 998a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 999a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1000a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 1001a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (actual.is_immediate()) { 1002a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmp(expected.reg(), Operand(actual.immediate())); 1003a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block b(eq, ®ular_invoke); 1004a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(r0, Operand(actual.immediate())); 1005a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 1006a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmp(expected.reg(), Operand(actual.reg())); 1007a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block b(eq, ®ular_invoke); 1008a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1009a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1010a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1011a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (!definitely_matches) { 1012a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (!code_constant.is_null()) { 1013a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(r3, Operand(code_constant)); 1014a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag)); 1015a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1016a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1017a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Handle<Code> adaptor = 101844f0eee88ff00398ff7f715fab053374d808c90dSteve Block isolate()->builtins()->ArgumentsAdaptorTrampoline(); 1019a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (flag == CALL_FUNCTION) { 10203fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch call_wrapper.BeforeCall(CallSize(adaptor)); 1021257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch SetCallKind(r5, call_kind); 10223fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Call(adaptor); 1023257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch call_wrapper.AfterCall(); 1024c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch if (!*definitely_mismatches) { 1025c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch b(done); 1026c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch } 1027a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 1028257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch SetCallKind(r5, call_kind); 1029a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Jump(adaptor, RelocInfo::CODE_TARGET); 1030a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1031a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(®ular_invoke); 1032a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1033a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1034a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1035a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1036a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::InvokeCode(Register code, 1037a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const ParameterCount& expected, 1038a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const ParameterCount& actual, 1039b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch InvokeFlag flag, 1040257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch const CallWrapper& call_wrapper, 1041257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch CallKind call_kind) { 1042592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // You can't call a function without a valid frame. 1043592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(flag == JUMP_FUNCTION || has_frame()); 1044592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1045a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label done; 1046c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch bool definitely_mismatches = false; 1047c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch InvokePrologue(expected, actual, Handle<Code>::null(), code, 1048c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch &done, &definitely_mismatches, flag, 1049257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch call_wrapper, call_kind); 1050c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch if (!definitely_mismatches) { 1051c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch if (flag == CALL_FUNCTION) { 1052c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch call_wrapper.BeforeCall(CallSize(code)); 1053c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch SetCallKind(r5, call_kind); 1054c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Call(code); 1055c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch call_wrapper.AfterCall(); 1056c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch } else { 1057c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch ASSERT(flag == JUMP_FUNCTION); 1058c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch SetCallKind(r5, call_kind); 1059c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Jump(code); 1060c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch } 1061a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1062c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // Continue here if InvokePrologue does handle the invocation due to 1063c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // mismatched parameter counts. 1064c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch bind(&done); 1065c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch } 1066a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1067a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1068a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1069a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::InvokeCode(Handle<Code> code, 1070a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const ParameterCount& expected, 1071a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const ParameterCount& actual, 1072a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block RelocInfo::Mode rmode, 1073257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch InvokeFlag flag, 1074257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch CallKind call_kind) { 1075592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // You can't call a function without a valid frame. 1076592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(flag == JUMP_FUNCTION || has_frame()); 1077592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1078a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label done; 1079c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch bool definitely_mismatches = false; 1080c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch InvokePrologue(expected, actual, code, no_reg, 1081c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch &done, &definitely_mismatches, flag, 1082257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch NullCallWrapper(), call_kind); 1083c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch if (!definitely_mismatches) { 1084c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch if (flag == CALL_FUNCTION) { 1085c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch SetCallKind(r5, call_kind); 1086c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Call(code, rmode); 1087c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch } else { 1088c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch SetCallKind(r5, call_kind); 1089c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Jump(code, rmode); 1090c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch } 1091a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1092c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // Continue here if InvokePrologue does handle the invocation due to 1093c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // mismatched parameter counts. 1094c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch bind(&done); 1095c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch } 1096a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1097a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1098a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1099a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::InvokeFunction(Register fun, 1100a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const ParameterCount& actual, 1101b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch InvokeFlag flag, 1102257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch const CallWrapper& call_wrapper, 1103257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch CallKind call_kind) { 1104592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // You can't call a function without a valid frame. 1105592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(flag == JUMP_FUNCTION || has_frame()); 1106592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1107a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Contract with called JS functions requires that function is passed in r1. 1108a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(fun.is(r1)); 1109a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1110a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register expected_reg = r2; 1111a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register code_reg = r3; 1112a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1113a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(code_reg, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset)); 1114a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(cp, FieldMemOperand(r1, JSFunction::kContextOffset)); 1115a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(expected_reg, 1116a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block FieldMemOperand(code_reg, 1117a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block SharedFunctionInfo::kFormalParameterCountOffset)); 11187f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch mov(expected_reg, Operand(expected_reg, ASR, kSmiTagSize)); 1119a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(code_reg, 1120791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block FieldMemOperand(r1, JSFunction::kCodeEntryOffset)); 1121a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1122a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ParameterCount expected(expected_reg); 1123257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch InvokeCode(code_reg, expected, actual, flag, call_wrapper, call_kind); 1124a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1125a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1126a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1127592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::InvokeFunction(Handle<JSFunction> function, 1128402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu const ParameterCount& actual, 1129257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch InvokeFlag flag, 1130c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch const CallWrapper& call_wrapper, 1131257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch CallKind call_kind) { 1132592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // You can't call a function without a valid frame. 1133592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(flag == JUMP_FUNCTION || has_frame()); 1134402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 1135402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu // Get the function and setup the context. 1136c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch LoadHeapObject(r1, function); 1137402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu ldr(cp, FieldMemOperand(r1, JSFunction::kContextOffset)); 1138402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 1139402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu ParameterCount expected(function->shared()->formal_parameter_count()); 1140592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // We call indirectly through the code field in the function to 1141592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // allow recompilation to take effect without changing any of the 1142592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // call sites. 1143592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(r3, FieldMemOperand(r1, JSFunction::kCodeEntryOffset)); 1144c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch InvokeCode(r3, expected, actual, flag, call_wrapper, call_kind); 1145b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch} 1146b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 1147b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 1148b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdochvoid MacroAssembler::IsObjectJSObjectType(Register heap_object, 1149b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Register map, 1150b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Register scratch, 1151b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Label* fail) { 1152b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ldr(map, FieldMemOperand(heap_object, HeapObject::kMapOffset)); 1153b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch IsInstanceJSObjectType(map, scratch, fail); 1154b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch} 1155b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 1156b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 1157b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdochvoid MacroAssembler::IsInstanceJSObjectType(Register map, 1158b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Register scratch, 1159b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Label* fail) { 1160b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ldrb(scratch, FieldMemOperand(map, Map::kInstanceTypeOffset)); 11613fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch cmp(scratch, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE)); 1162b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch b(lt, fail); 11633fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch cmp(scratch, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE)); 1164b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch b(gt, fail); 1165b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch} 1166b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 1167b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 1168b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdochvoid MacroAssembler::IsObjectJSStringType(Register object, 1169e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register scratch, 1170e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Label* fail) { 1171b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT(kNotStringTag != 0); 1172b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 1173b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ldr(scratch, FieldMemOperand(object, HeapObject::kMapOffset)); 1174b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ldrb(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset)); 1175b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch tst(scratch, Operand(kIsNotStringMask)); 11761e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block b(ne, fail); 1177402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu} 1178402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 1179402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 118080d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen#ifdef ENABLE_DEBUGGER_SUPPORT 1181402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescuvoid MacroAssembler::DebugBreak() { 11829ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick mov(r0, Operand(0, RelocInfo::NONE)); 118344f0eee88ff00398ff7f715fab053374d808c90dSteve Block mov(r1, Operand(ExternalReference(Runtime::kDebugBreak, isolate()))); 1184402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu CEntryStub ces(1); 1185592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(AllowThisStubCall(&ces)); 1186402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu Call(ces.GetCode(), RelocInfo::DEBUG_BREAK); 1187402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu} 1188a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 1189a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1190a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1191a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::PushTryHandler(CodeLocation try_location, 1192592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch HandlerType type, 1193592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch int handler_index) { 1194a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Adjust this code if not the case. 119569a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch STATIC_ASSERT(StackHandlerConstants::kSize == 5 * kPointerSize); 119669a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0 * kPointerSize); 1197592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize); 1198592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize); 1199592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize); 1200592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize); 1201592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1202592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // For the JSEntry handler, we must preserve r0-r4, r5-r7 are available. 1203592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // We will build up the handler from the bottom by pushing on the stack. 1204592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // First compute the state. 1205592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch unsigned state = StackHandler::OffsetField::encode(handler_index); 1206a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (try_location == IN_JAVASCRIPT) { 1207592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch state |= (type == TRY_CATCH_HANDLER) 1208592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ? StackHandler::KindField::encode(StackHandler::TRY_CATCH) 1209592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch : StackHandler::KindField::encode(StackHandler::TRY_FINALLY); 1210a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 1211a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(try_location == IN_JS_ENTRY); 1212592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch state |= StackHandler::KindField::encode(StackHandler::ENTRY); 1213a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1214592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1215592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Set up the code object (r5) and the state (r6) for pushing. 1216592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(r5, Operand(CodeObject())); 1217592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(r6, Operand(state)); 1218592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1219592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Push the frame pointer, context, state, and code object. 1220592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (try_location == IN_JAVASCRIPT) { 1221592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch stm(db_w, sp, r5.bit() | r6.bit() | cp.bit() | fp.bit()); 1222592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } else { 1223592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(r7, Operand(Smi::FromInt(0))); // Indicates no context. 1224592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(ip, Operand(0, RelocInfo::NONE)); // NULL frame pointer. 1225592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch stm(db_w, sp, r5.bit() | r6.bit() | r7.bit() | ip.bit()); 1226592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 1227592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1228592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Link the current handler as the next handler. 1229592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(r6, Operand(ExternalReference(Isolate::kHandlerAddress, isolate()))); 1230592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(r5, MemOperand(r6)); 1231592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch push(r5); 1232592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Set this new handler as the current one. 1233592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch str(sp, MemOperand(r6)); 1234a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1235a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1236a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1237e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarkevoid MacroAssembler::PopTryHandler() { 123869a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0); 1239e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke pop(r1); 1240589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch mov(ip, Operand(ExternalReference(Isolate::kHandlerAddress, isolate()))); 1241e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke add(sp, sp, Operand(StackHandlerConstants::kSize - kPointerSize)); 1242e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke str(r1, MemOperand(ip)); 1243e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke} 1244e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 1245e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 1246592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::JumpToHandlerEntry() { 1247592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Compute the handler entry address and jump to it. The handler table is 1248592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // a fixed array of (smi-tagged) code offsets. 1249592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // r0 = exception, r1 = code object, r2 = state. 1250592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(r3, FieldMemOperand(r1, Code::kHandlerTableOffset)); // Handler table. 1251592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch add(r3, r3, Operand(FixedArray::kHeaderSize - kHeapObjectTag)); 1252592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(r2, Operand(r2, LSR, StackHandler::kKindWidth)); // Handler index. 1253592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(r2, MemOperand(r3, r2, LSL, kPointerSizeLog2)); // Smi-tagged offset. 1254592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch add(r1, r1, Operand(Code::kHeaderSize - kHeapObjectTag)); // Code start. 1255592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch add(pc, r1, Operand(r2, ASR, kSmiTagSize)); // Jump. 1256592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 1257592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1258592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1259e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::Throw(Register value) { 126069a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch // Adjust this code if not the case. 126169a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch STATIC_ASSERT(StackHandlerConstants::kSize == 5 * kPointerSize); 1262592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0); 1263592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize); 1264592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize); 1265592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize); 1266592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize); 1267592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1268592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // The exception is expected in r0. 1269e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch if (!value.is(r0)) { 1270e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch mov(r0, value); 1271e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } 1272592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Drop the stack pointer to the top of the top handler. 1273589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch mov(r3, Operand(ExternalReference(Isolate::kHandlerAddress, isolate()))); 1274e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ldr(sp, MemOperand(r3)); 127569a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch // Restore the next handler. 1276e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch pop(r2); 1277e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch str(r2, MemOperand(r3)); 127869a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch 1279592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Get the code object (r1) and state (r2). Restore the context and frame 1280592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // pointer. 1281592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldm(ia_w, sp, r1.bit() | r2.bit() | cp.bit() | fp.bit()); 128269a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch 128369a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch // If the handler is a JS frame, restore the context to the frame. 1284592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // (kind == ENTRY) == (fp == 0) == (cp == 0), so we could test either fp 1285592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // or cp. 1286592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(cp, cp); 128769a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch str(cp, MemOperand(fp, StandardFrameConstants::kContextOffset), ne); 128869a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch 1289592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch JumpToHandlerEntry(); 1290e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 1291e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1292e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1293e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::ThrowUncatchable(UncatchableExceptionType type, 1294e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register value) { 1295e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Adjust this code if not the case. 129669a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch STATIC_ASSERT(StackHandlerConstants::kSize == 5 * kPointerSize); 129769a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0 * kPointerSize); 1298592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize); 1299592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize); 1300592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize); 1301592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize); 1302e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1303592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // The exception is expected in r0. 1304e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch if (type == OUT_OF_MEMORY) { 1305e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Set external caught exception to false. 1306592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ExternalReference external_caught(Isolate::kExternalCaughtExceptionAddress, 1307592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch isolate()); 1308e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch mov(r0, Operand(false, RelocInfo::NONE)); 1309e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch mov(r2, Operand(external_caught)); 1310e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch str(r0, MemOperand(r2)); 1311e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1312e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Set pending exception and r0 to out of memory exception. 1313e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Failure* out_of_memory = Failure::OutOfMemoryException(); 1314e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch mov(r0, Operand(reinterpret_cast<int32_t>(out_of_memory))); 1315589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch mov(r2, Operand(ExternalReference(Isolate::kPendingExceptionAddress, 131644f0eee88ff00398ff7f715fab053374d808c90dSteve Block isolate()))); 1317e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch str(r0, MemOperand(r2)); 1318592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } else if (!value.is(r0)) { 1319592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(r0, value); 1320e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } 1321e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1322592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Drop the stack pointer to the top of the top stack handler. 1323592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(r3, Operand(ExternalReference(Isolate::kHandlerAddress, isolate()))); 1324592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(sp, MemOperand(r3)); 1325e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1326592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Unwind the handlers until the ENTRY handler is found. 1327592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label fetch_next, check_kind; 1328592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch jmp(&check_kind); 1329592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&fetch_next); 1330592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(sp, MemOperand(sp, StackHandlerConstants::kNextOffset)); 1331592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1332592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&check_kind); 1333592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(StackHandler::ENTRY == 0); 1334592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(r2, MemOperand(sp, StackHandlerConstants::kStateOffset)); 1335592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(r2, Operand(StackHandler::KindField::kMask)); 1336592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(ne, &fetch_next); 1337592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1338592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Set the top handler address to next handler past the top ENTRY handler. 1339592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch pop(r2); 1340592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch str(r2, MemOperand(r3)); 1341592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Get the code object (r1) and state (r2). Clear the context and frame 1342592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // pointer (0 was saved in the handler). 1343592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldm(ia_w, sp, r1.bit() | r2.bit() | cp.bit() | fp.bit()); 1344592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1345592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch JumpToHandlerEntry(); 1346e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 1347e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1348e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1349a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::CheckAccessGlobalProxy(Register holder_reg, 1350a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch, 1351a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label* miss) { 1352a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label same_contexts; 1353a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1354a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!holder_reg.is(scratch)); 1355a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!holder_reg.is(ip)); 1356a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!scratch.is(ip)); 1357a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1358a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Load current lexical context from the stack frame. 1359a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(scratch, MemOperand(fp, StandardFrameConstants::kContextOffset)); 1360a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // In debug mode, make sure the lexical context is set. 1361a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifdef DEBUG 13629ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick cmp(scratch, Operand(0, RelocInfo::NONE)); 1363a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(ne, "we should not have an empty lexical context"); 1364a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 1365a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1366a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Load the global context of the current context. 1367a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int offset = Context::kHeaderSize + Context::GLOBAL_INDEX * kPointerSize; 1368a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(scratch, FieldMemOperand(scratch, offset)); 1369a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(scratch, FieldMemOperand(scratch, GlobalObject::kGlobalContextOffset)); 1370a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1371a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check the context is a global context. 137244f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 1373a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // TODO(119): avoid push(holder_reg)/pop(holder_reg) 1374a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Cannot use ip as a temporary in this verification code. Due to the fact 1375a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // that ip is clobbered as part of cmp with an object Operand. 1376a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(holder_reg); // Temporarily save holder on the stack. 1377a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Read the first word and compare to the global_context_map. 1378a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(holder_reg, FieldMemOperand(scratch, HeapObject::kMapOffset)); 1379a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block LoadRoot(ip, Heap::kGlobalContextMapRootIndex); 1380a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmp(holder_reg, ip); 1381a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(eq, "JSGlobalObject::global_context should be a global context."); 1382a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block pop(holder_reg); // Restore holder. 1383a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1384a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1385a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check if both contexts are the same. 1386a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(ip, FieldMemOperand(holder_reg, JSGlobalProxy::kContextOffset)); 1387a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmp(scratch, Operand(ip)); 1388a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block b(eq, &same_contexts); 1389a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1390a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check the context is a global context. 139144f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 1392a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // TODO(119): avoid push(holder_reg)/pop(holder_reg) 1393a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Cannot use ip as a temporary in this verification code. Due to the fact 1394a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // that ip is clobbered as part of cmp with an object Operand. 1395a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(holder_reg); // Temporarily save holder on the stack. 1396a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(holder_reg, ip); // Move ip to its holding place. 1397a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block LoadRoot(ip, Heap::kNullValueRootIndex); 1398a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmp(holder_reg, ip); 1399a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(ne, "JSGlobalProxy::context() should not be null."); 1400a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1401a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(holder_reg, FieldMemOperand(holder_reg, HeapObject::kMapOffset)); 1402a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block LoadRoot(ip, Heap::kGlobalContextMapRootIndex); 1403a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmp(holder_reg, ip); 1404a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(eq, "JSGlobalObject::global_context should be a global context."); 1405a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Restore ip is not needed. ip is reloaded below. 1406a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block pop(holder_reg); // Restore holder. 1407a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Restore ip to holder's context. 1408a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(ip, FieldMemOperand(holder_reg, JSGlobalProxy::kContextOffset)); 1409a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1410a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1411a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check that the security token in the calling global object is 1412a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // compatible with the security token in the receiving global 1413a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // object. 1414a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int token_offset = Context::kHeaderSize + 1415a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Context::SECURITY_TOKEN_INDEX * kPointerSize; 1416a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1417a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(scratch, FieldMemOperand(scratch, token_offset)); 1418a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(ip, FieldMemOperand(ip, token_offset)); 1419a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmp(scratch, Operand(ip)); 1420a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block b(ne, miss); 1421a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1422a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&same_contexts); 1423a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1424a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1425a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1426c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdochvoid MacroAssembler::GetNumberHash(Register t0, Register scratch) { 1427c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // First of all we assign the hash seed to scratch. 1428c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch LoadRoot(scratch, Heap::kHashSeedRootIndex); 1429c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch SmiUntag(scratch); 1430c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch 1431c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // Xor original key with a seed. 1432c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch eor(t0, t0, Operand(scratch)); 1433c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch 1434c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // Compute the hash code from the untagged key. This must be kept in sync 1435c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // with ComputeIntegerHash in utils.h. 1436c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // 1437c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // hash = ~hash + (hash << 15); 1438c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch mvn(scratch, Operand(t0)); 1439c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch add(t0, scratch, Operand(t0, LSL, 15)); 1440c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // hash = hash ^ (hash >> 12); 1441c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch eor(t0, t0, Operand(t0, LSR, 12)); 1442c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // hash = hash + (hash << 2); 1443c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch add(t0, t0, Operand(t0, LSL, 2)); 1444c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // hash = hash ^ (hash >> 4); 1445c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch eor(t0, t0, Operand(t0, LSR, 4)); 1446c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // hash = hash * 2057; 1447c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch mov(scratch, Operand(t0, LSL, 11)); 1448c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch add(t0, t0, Operand(t0, LSL, 3)); 1449c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch add(t0, t0, scratch); 1450c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // hash = hash ^ (hash >> 16); 1451c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch eor(t0, t0, Operand(t0, LSR, 16)); 1452c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch} 1453c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch 1454c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch 14553fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdochvoid MacroAssembler::LoadFromNumberDictionary(Label* miss, 14563fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Register elements, 14573fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Register key, 14583fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Register result, 14593fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Register t0, 14603fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Register t1, 14613fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Register t2) { 14623fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Register use: 14633fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // 14643fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // elements - holds the slow-case elements of the receiver on entry. 14653fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Unchanged unless 'result' is the same register. 14663fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // 14673fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // key - holds the smi key on entry. 14683fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Unchanged unless 'result' is the same register. 14693fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // 14703fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // result - holds the result on exit if the load succeeded. 14713fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Allowed to be the same as 'key' or 'result'. 14723fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Unchanged on bailout so 'key' or 'result' can be used 14733fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // in further computation. 14743fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // 14753fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Scratch registers: 14763fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // 14773fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // t0 - holds the untagged key on entry and holds the hash once computed. 14783fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // 14793fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // t1 - used to hold the capacity mask of the dictionary 14803fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // 14813fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // t2 - used for the index into the dictionary. 14823fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Label done; 14833fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 1484c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch GetNumberHash(t0, t1); 14853fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 14863fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Compute the capacity mask. 1487c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch ldr(t1, FieldMemOperand(elements, SeededNumberDictionary::kCapacityOffset)); 14883fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch mov(t1, Operand(t1, ASR, kSmiTagSize)); // convert smi to int 14893fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch sub(t1, t1, Operand(1)); 14903fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 14913fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Generate an unrolled loop that performs a few probes before giving up. 14923fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch static const int kProbes = 4; 14933fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch for (int i = 0; i < kProbes; i++) { 14943fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Use t2 for index calculations and keep the hash intact in t0. 14953fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch mov(t2, t0); 14963fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Compute the masked index: (hash + i + i * i) & mask. 14973fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch if (i > 0) { 1498c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch add(t2, t2, Operand(SeededNumberDictionary::GetProbeOffset(i))); 14993fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } 15003fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch and_(t2, t2, Operand(t1)); 15013fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 15023fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Scale the index by multiplying by the element size. 1503c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch ASSERT(SeededNumberDictionary::kEntrySize == 3); 15043fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch add(t2, t2, Operand(t2, LSL, 1)); // t2 = t2 * 3 15053fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 15063fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Check if the key is identical to the name. 15073fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch add(t2, elements, Operand(t2, LSL, kPointerSizeLog2)); 1508c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch ldr(ip, FieldMemOperand(t2, SeededNumberDictionary::kElementsStartOffset)); 15093fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch cmp(key, Operand(ip)); 15103fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch if (i != kProbes - 1) { 15113fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch b(eq, &done); 15123fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } else { 15133fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch b(ne, miss); 15143fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } 15153fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } 15163fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 15173fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch bind(&done); 15183fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Check that the value is a normal property. 15193fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // t2: elements + (index * kPointerSize) 15203fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch const int kDetailsOffset = 1521c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch SeededNumberDictionary::kElementsStartOffset + 2 * kPointerSize; 15223fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldr(t1, FieldMemOperand(t2, kDetailsOffset)); 1523589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch tst(t1, Operand(Smi::FromInt(PropertyDetails::TypeField::kMask))); 15243fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch b(ne, miss); 15253fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 15263fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch // Get the value at the masked, scaled index and return. 15273fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch const int kValueOffset = 1528c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch SeededNumberDictionary::kElementsStartOffset + kPointerSize; 15293fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldr(result, FieldMemOperand(t2, kValueOffset)); 15303fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch} 15313fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 15323fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 1533a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::AllocateInNewSpace(int object_size, 1534a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register result, 1535a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch1, 1536a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch2, 1537a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label* gc_required, 1538a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block AllocationFlags flags) { 15395913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck if (!FLAG_inline_new) { 154044f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 15415913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // Trash the registers to simulate an allocation failure. 15425913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck mov(result, Operand(0x7091)); 15435913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck mov(scratch1, Operand(0x7191)); 15445913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck mov(scratch2, Operand(0x7291)); 15455913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 15465913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck jmp(gc_required); 15475913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck return; 15485913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 15495913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck 1550a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!result.is(scratch1)); 1551b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT(!result.is(scratch2)); 1552a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!scratch1.is(scratch2)); 1553e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ASSERT(!scratch1.is(ip)); 1554e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ASSERT(!scratch2.is(ip)); 1555a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 155625f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen // Make object size into bytes. 155725f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen if ((flags & SIZE_IN_WORDS) != 0) { 155825f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen object_size *= kPointerSize; 155925f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen } 156025f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen ASSERT_EQ(0, object_size & kObjectAlignmentMask); 156125f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen 1562b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Check relative positions of allocation top and limit addresses. 1563b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // The values must be adjacent in memory to allow the use of LDM. 1564b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Also, assert that the registers are numbered such that the values 1565b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // are loaded in the correct order. 1566a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ExternalReference new_space_allocation_top = 156744f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::new_space_allocation_top_address(isolate()); 1568b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ExternalReference new_space_allocation_limit = 156944f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::new_space_allocation_limit_address(isolate()); 1570b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch intptr_t top = 1571b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch reinterpret_cast<intptr_t>(new_space_allocation_top.address()); 1572b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch intptr_t limit = 1573b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch reinterpret_cast<intptr_t>(new_space_allocation_limit.address()); 1574b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT((limit - top) == kPointerSize); 1575b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT(result.code() < ip.code()); 1576b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 1577b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Set up allocation top address and object size registers. 1578b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Register topaddr = scratch1; 1579b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Register obj_size_reg = scratch2; 1580b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch mov(topaddr, Operand(new_space_allocation_top)); 1581b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch mov(obj_size_reg, Operand(object_size)); 1582b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 1583b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // This code stores a temporary value in ip. This is OK, as the code below 1584b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // does not need ip for implicit literal generation. 1585a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if ((flags & RESULT_CONTAINS_TOP) == 0) { 1586b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Load allocation top into result and allocation limit into ip. 1587b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ldm(ia, topaddr, result.bit() | ip.bit()); 1588b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch } else { 158944f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 1590b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Assert that result actually contains top on entry. ip is used 1591b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // immediately below so this use of ip does not cause difference with 1592b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // respect to register content between debug and release mode. 1593b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ldr(ip, MemOperand(topaddr)); 1594b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch cmp(result, ip); 1595b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Check(eq, "Unexpected allocation top"); 1596b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch } 1597b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Load allocation limit into ip. Result already contains allocation top. 1598b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ldr(ip, MemOperand(topaddr, limit - top)); 1599a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1600a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1601a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Calculate new top and bail out if new space is exhausted. Use result 1602a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // to calculate the new top. 16031e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block add(scratch2, result, Operand(obj_size_reg), SetCC); 16041e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block b(cs, gc_required); 1605b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch cmp(scratch2, Operand(ip)); 1606a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block b(hi, gc_required); 1607b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch str(scratch2, MemOperand(topaddr)); 1608a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1609b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Tag object if requested. 1610a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if ((flags & TAG_OBJECT) != 0) { 1611b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch add(result, result, Operand(kHeapObjectTag)); 1612a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1613a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1614a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1615a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1616a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::AllocateInNewSpace(Register object_size, 1617a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register result, 1618a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch1, 1619a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch2, 1620a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label* gc_required, 1621a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block AllocationFlags flags) { 16225913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck if (!FLAG_inline_new) { 162344f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 16245913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck // Trash the registers to simulate an allocation failure. 16255913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck mov(result, Operand(0x7091)); 16265913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck mov(scratch1, Operand(0x7191)); 16275913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck mov(scratch2, Operand(0x7291)); 16285913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 16295913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck jmp(gc_required); 16305913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck return; 16315913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck } 16325913587db4c6bab03d97bfe44b06289fd6d7270dJohn Reck 1633b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Assert that the register arguments are different and that none of 1634b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // them are ip. ip is used explicitly in the code generated below. 1635a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!result.is(scratch1)); 1636b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT(!result.is(scratch2)); 1637a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(!scratch1.is(scratch2)); 1638592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(!object_size.is(ip)); 1639b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT(!result.is(ip)); 1640b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT(!scratch1.is(ip)); 1641b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT(!scratch2.is(ip)); 1642b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 1643b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Check relative positions of allocation top and limit addresses. 1644b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // The values must be adjacent in memory to allow the use of LDM. 1645b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Also, assert that the registers are numbered such that the values 1646b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // are loaded in the correct order. 1647a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ExternalReference new_space_allocation_top = 164844f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::new_space_allocation_top_address(isolate()); 1649b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ExternalReference new_space_allocation_limit = 165044f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::new_space_allocation_limit_address(isolate()); 1651b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch intptr_t top = 1652b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch reinterpret_cast<intptr_t>(new_space_allocation_top.address()); 1653b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch intptr_t limit = 1654b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch reinterpret_cast<intptr_t>(new_space_allocation_limit.address()); 1655b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT((limit - top) == kPointerSize); 1656b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ASSERT(result.code() < ip.code()); 1657b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 1658b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Set up allocation top address. 1659b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Register topaddr = scratch1; 1660b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch mov(topaddr, Operand(new_space_allocation_top)); 1661b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 1662b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // This code stores a temporary value in ip. This is OK, as the code below 1663b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // does not need ip for implicit literal generation. 1664a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if ((flags & RESULT_CONTAINS_TOP) == 0) { 1665b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Load allocation top into result and allocation limit into ip. 1666b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ldm(ia, topaddr, result.bit() | ip.bit()); 1667b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch } else { 166844f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 1669b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Assert that result actually contains top on entry. ip is used 1670b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // immediately below so this use of ip does not cause difference with 1671b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // respect to register content between debug and release mode. 1672b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ldr(ip, MemOperand(topaddr)); 1673b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch cmp(result, ip); 1674b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Check(eq, "Unexpected allocation top"); 1675b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch } 1676b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Load allocation limit into ip. Result already contains allocation top. 1677b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch ldr(ip, MemOperand(topaddr, limit - top)); 1678a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1679a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1680a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Calculate new top and bail out if new space is exhausted. Use result 1681b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // to calculate the new top. Object size may be in words so a shift is 1682b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // required to get the number of bytes. 168325f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen if ((flags & SIZE_IN_WORDS) != 0) { 16841e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block add(scratch2, result, Operand(object_size, LSL, kPointerSizeLog2), SetCC); 168525f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen } else { 16861e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block add(scratch2, result, Operand(object_size), SetCC); 168725f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen } 16881e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block b(cs, gc_required); 1689b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch cmp(scratch2, Operand(ip)); 1690a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block b(hi, gc_required); 1691a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1692d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block // Update allocation top. result temporarily holds the new top. 169344f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 1694b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch tst(scratch2, Operand(kObjectAlignmentMask)); 1695d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block Check(eq, "Unaligned allocation in new space"); 1696d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block } 1697b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch str(scratch2, MemOperand(topaddr)); 1698a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1699a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Tag object if requested. 1700a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if ((flags & TAG_OBJECT) != 0) { 1701a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block add(result, result, Operand(kHeapObjectTag)); 1702a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1703a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1704a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1705a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1706a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::UndoAllocationInNewSpace(Register object, 1707a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch) { 1708a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ExternalReference new_space_allocation_top = 170944f0eee88ff00398ff7f715fab053374d808c90dSteve Block ExternalReference::new_space_allocation_top_address(isolate()); 1710a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1711a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Make sure the object has no tag before resetting top. 1712a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block and_(object, object, Operand(~kHeapObjectTagMask)); 1713a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifdef DEBUG 1714a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check that the object un-allocated is below the current top. 1715a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(scratch, Operand(new_space_allocation_top)); 1716a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(scratch, MemOperand(scratch)); 1717a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmp(object, scratch); 1718a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Check(lt, "Undo allocation of non allocated memory"); 1719a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 1720a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Write the address of the object to un-allocate as the current top. 1721a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(scratch, Operand(new_space_allocation_top)); 1722a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block str(object, MemOperand(scratch)); 1723a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1724a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1725a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 17263100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescuvoid MacroAssembler::AllocateTwoByteString(Register result, 17273100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register length, 17283100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register scratch1, 17293100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register scratch2, 17303100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register scratch3, 17313100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Label* gc_required) { 17323100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu // Calculate the number of bytes needed for the characters in the string while 17333100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu // observing object alignment. 17343100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu ASSERT((SeqTwoByteString::kHeaderSize & kObjectAlignmentMask) == 0); 17353100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu mov(scratch1, Operand(length, LSL, 1)); // Length in bytes, not chars. 17363100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu add(scratch1, scratch1, 17373100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Operand(kObjectAlignmentMask + SeqTwoByteString::kHeaderSize)); 173825f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen and_(scratch1, scratch1, Operand(~kObjectAlignmentMask)); 17393100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 17403100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu // Allocate two-byte string in new space. 17413100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu AllocateInNewSpace(scratch1, 17423100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu result, 17433100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu scratch2, 17443100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu scratch3, 17453100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu gc_required, 17463100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu TAG_OBJECT); 17473100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 17483100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu // Set the map, length and hash field. 17496ded16be15dd865a9b21ea304d5273c8be299c87Steve Block InitializeNewString(result, 17506ded16be15dd865a9b21ea304d5273c8be299c87Steve Block length, 17516ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Heap::kStringMapRootIndex, 17526ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch1, 17536ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch2); 17543100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu} 17553100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 17563100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 17573100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescuvoid MacroAssembler::AllocateAsciiString(Register result, 17583100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register length, 17593100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register scratch1, 17603100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register scratch2, 17613100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register scratch3, 17623100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Label* gc_required) { 17633100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu // Calculate the number of bytes needed for the characters in the string while 17643100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu // observing object alignment. 17653100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu ASSERT((SeqAsciiString::kHeaderSize & kObjectAlignmentMask) == 0); 17663100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu ASSERT(kCharSize == 1); 17673100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu add(scratch1, length, 17683100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Operand(kObjectAlignmentMask + SeqAsciiString::kHeaderSize)); 176925f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen and_(scratch1, scratch1, Operand(~kObjectAlignmentMask)); 17703100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 17713100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu // Allocate ASCII string in new space. 17723100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu AllocateInNewSpace(scratch1, 17733100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu result, 17743100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu scratch2, 17753100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu scratch3, 17763100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu gc_required, 17773100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu TAG_OBJECT); 17783100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 17793100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu // Set the map, length and hash field. 17806ded16be15dd865a9b21ea304d5273c8be299c87Steve Block InitializeNewString(result, 17816ded16be15dd865a9b21ea304d5273c8be299c87Steve Block length, 17826ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Heap::kAsciiStringMapRootIndex, 17836ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch1, 17846ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch2); 17853100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu} 17863100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 17873100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 17883100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescuvoid MacroAssembler::AllocateTwoByteConsString(Register result, 17893100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register length, 17903100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register scratch1, 17913100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register scratch2, 17923100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Label* gc_required) { 179325f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen AllocateInNewSpace(ConsString::kSize, 17943100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu result, 17953100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu scratch1, 17963100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu scratch2, 17973100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu gc_required, 17983100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu TAG_OBJECT); 17996ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 18006ded16be15dd865a9b21ea304d5273c8be299c87Steve Block InitializeNewString(result, 18016ded16be15dd865a9b21ea304d5273c8be299c87Steve Block length, 18026ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Heap::kConsStringMapRootIndex, 18036ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch1, 18046ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch2); 18053100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu} 18063100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 18073100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 18083100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescuvoid MacroAssembler::AllocateAsciiConsString(Register result, 18093100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register length, 18103100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register scratch1, 18113100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register scratch2, 18123100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Label* gc_required) { 181325f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen AllocateInNewSpace(ConsString::kSize, 18143100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu result, 18153100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu scratch1, 18163100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu scratch2, 18173100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu gc_required, 18183100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu TAG_OBJECT); 18196ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 18206ded16be15dd865a9b21ea304d5273c8be299c87Steve Block InitializeNewString(result, 18216ded16be15dd865a9b21ea304d5273c8be299c87Steve Block length, 18226ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Heap::kConsAsciiStringMapRootIndex, 18236ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch1, 18246ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch2); 18253100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu} 18263100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 18273100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 1828589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdochvoid MacroAssembler::AllocateTwoByteSlicedString(Register result, 1829589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch Register length, 1830589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch Register scratch1, 1831589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch Register scratch2, 1832589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch Label* gc_required) { 1833589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch AllocateInNewSpace(SlicedString::kSize, 1834589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch result, 1835589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch scratch1, 1836589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch scratch2, 1837589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch gc_required, 1838589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch TAG_OBJECT); 1839589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch 1840589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch InitializeNewString(result, 1841589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch length, 1842589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch Heap::kSlicedStringMapRootIndex, 1843589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch scratch1, 1844589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch scratch2); 1845589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch} 1846589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch 1847589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch 1848589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdochvoid MacroAssembler::AllocateAsciiSlicedString(Register result, 1849589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch Register length, 1850589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch Register scratch1, 1851589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch Register scratch2, 1852589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch Label* gc_required) { 1853589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch AllocateInNewSpace(SlicedString::kSize, 1854589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch result, 1855589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch scratch1, 1856589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch scratch2, 1857589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch gc_required, 1858589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch TAG_OBJECT); 1859589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch 1860589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch InitializeNewString(result, 1861589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch length, 1862589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch Heap::kSlicedAsciiStringMapRootIndex, 1863589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch scratch1, 1864589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch scratch2); 1865589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch} 1866589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch 1867589d6979ff2ef66fca2d8fa51404c369ca5e9250Ben Murdoch 18686ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::CompareObjectType(Register object, 1869a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register map, 1870a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register type_reg, 1871a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block InstanceType type) { 18726ded16be15dd865a9b21ea304d5273c8be299c87Steve Block ldr(map, FieldMemOperand(object, HeapObject::kMapOffset)); 1873a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CompareInstanceType(map, type_reg, type); 1874a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1875a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1876a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1877a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::CompareInstanceType(Register map, 1878a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register type_reg, 1879a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block InstanceType type) { 1880a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldrb(type_reg, FieldMemOperand(map, Map::kInstanceTypeOffset)); 1881a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmp(type_reg, Operand(type)); 1882a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 1883a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1884a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1885e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::CompareRoot(Register obj, 1886e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Heap::RootListIndex index) { 1887e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ASSERT(!obj.is(ip)); 1888e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch LoadRoot(ip, index); 1889e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch cmp(obj, ip); 1890e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 1891e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1892e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 18933fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdochvoid MacroAssembler::CheckFastElements(Register map, 18943fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Register scratch, 18953fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Label* fail) { 1896592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(FAST_SMI_ONLY_ELEMENTS == 0); 1897592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(FAST_ELEMENTS == 1); 1898592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldrb(scratch, FieldMemOperand(map, Map::kBitField2Offset)); 1899592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch cmp(scratch, Operand(Map::kMaximumBitField2FastElementValue)); 1900592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(hi, fail); 1901592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 1902592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1903592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1904592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::CheckFastObjectElements(Register map, 1905592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register scratch, 1906592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label* fail) { 1907592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(FAST_SMI_ONLY_ELEMENTS == 0); 1908592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(FAST_ELEMENTS == 1); 19093fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldrb(scratch, FieldMemOperand(map, Map::kBitField2Offset)); 1910592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch cmp(scratch, Operand(Map::kMaximumBitField2FastSmiOnlyElementValue)); 1911592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(ls, fail); 19123fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch cmp(scratch, Operand(Map::kMaximumBitField2FastElementValue)); 19133fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch b(hi, fail); 19143fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch} 19153fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 19163fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch 1917592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::CheckFastSmiOnlyElements(Register map, 1918592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register scratch, 1919592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label* fail) { 1920592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch STATIC_ASSERT(FAST_SMI_ONLY_ELEMENTS == 0); 1921592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldrb(scratch, FieldMemOperand(map, Map::kBitField2Offset)); 1922592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch cmp(scratch, Operand(Map::kMaximumBitField2FastSmiOnlyElementValue)); 1923592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(hi, fail); 1924592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 1925592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1926592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1927592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::StoreNumberToDoubleElements(Register value_reg, 1928592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register key_reg, 1929592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register receiver_reg, 1930592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register elements_reg, 1931592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register scratch1, 1932592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register scratch2, 1933592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register scratch3, 1934592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register scratch4, 1935592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label* fail) { 1936592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label smi_value, maybe_nan, have_double_value, is_nan, done; 1937592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register mantissa_reg = scratch2; 1938592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register exponent_reg = scratch3; 1939592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1940592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Handle smi values specially. 1941592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch JumpIfSmi(value_reg, &smi_value); 1942592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1943592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Ensure that the object is a heap number 1944592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CheckMap(value_reg, 1945592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch scratch1, 1946592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch isolate()->factory()->heap_number_map(), 1947592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch fail, 1948592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch DONT_DO_SMI_CHECK); 1949592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1950592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Check for nan: all NaN values have a value greater (signed) than 0x7ff00000 1951592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // in the exponent. 1952592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(scratch1, Operand(kNaNOrInfinityLowerBoundUpper32)); 1953592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(exponent_reg, FieldMemOperand(value_reg, HeapNumber::kExponentOffset)); 1954592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch cmp(exponent_reg, scratch1); 1955592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(ge, &maybe_nan); 1956592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1957592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(mantissa_reg, FieldMemOperand(value_reg, HeapNumber::kMantissaOffset)); 1958592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1959592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&have_double_value); 1960592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch add(scratch1, elements_reg, 1961592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Operand(key_reg, LSL, kDoubleSizeLog2 - kSmiTagSize)); 1962592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch str(mantissa_reg, FieldMemOperand(scratch1, FixedDoubleArray::kHeaderSize)); 1963592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch uint32_t offset = FixedDoubleArray::kHeaderSize + sizeof(kHoleNanLower32); 1964592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch str(exponent_reg, FieldMemOperand(scratch1, offset)); 1965592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch jmp(&done); 1966592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1967592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&maybe_nan); 1968592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Could be NaN or Infinity. If fraction is not zero, it's NaN, otherwise 1969592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // it's an Infinity, and the non-NaN code path applies. 1970592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(gt, &is_nan); 1971592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(mantissa_reg, FieldMemOperand(value_reg, HeapNumber::kMantissaOffset)); 1972592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch cmp(mantissa_reg, Operand(0)); 1973592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(eq, &have_double_value); 1974592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&is_nan); 1975592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Load canonical NaN for storing into the double array. 1976592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch uint64_t nan_int64 = BitCast<uint64_t>( 1977592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch FixedDoubleArray::canonical_not_the_hole_nan_as_double()); 1978592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(mantissa_reg, Operand(static_cast<uint32_t>(nan_int64))); 1979592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(exponent_reg, Operand(static_cast<uint32_t>(nan_int64 >> 32))); 1980592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch jmp(&have_double_value); 1981592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1982592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&smi_value); 1983592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch add(scratch1, elements_reg, 1984592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Operand(FixedDoubleArray::kHeaderSize - kHeapObjectTag)); 1985592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch add(scratch1, scratch1, 1986592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Operand(key_reg, LSL, kDoubleSizeLog2 - kSmiTagSize)); 1987592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // scratch1 is now effective address of the double element 1988592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1989592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch FloatingPointHelper::Destination destination; 1990592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (CpuFeatures::IsSupported(VFP3)) { 1991592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch destination = FloatingPointHelper::kVFPRegisters; 1992592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } else { 1993592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch destination = FloatingPointHelper::kCoreRegisters; 1994592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 1995592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1996592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register untagged_value = receiver_reg; 1997592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch SmiUntag(untagged_value, value_reg); 1998592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch FloatingPointHelper::ConvertIntToDouble(this, 1999592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch untagged_value, 2000592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch destination, 2001592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch d0, 2002592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mantissa_reg, 2003592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch exponent_reg, 2004592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch scratch4, 2005592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch s2); 2006592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (destination == FloatingPointHelper::kVFPRegisters) { 2007592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CpuFeatures::Scope scope(VFP3); 2008592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch vstr(d0, scratch1, 0); 2009592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } else { 2010592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch str(mantissa_reg, MemOperand(scratch1, 0)); 2011592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch str(exponent_reg, MemOperand(scratch1, Register::kSizeInBytes)); 2012592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 2013592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&done); 2014592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 2015592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 2016592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 2017c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdochvoid MacroAssembler::CompareMap(Register obj, 2018c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Register scratch, 2019c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Handle<Map> map, 2020c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Label* early_success, 2021c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch CompareMapMode mode) { 2022c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch ldr(scratch, FieldMemOperand(obj, HeapObject::kMapOffset)); 2023c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch cmp(scratch, Operand(map)); 2024c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch if (mode == ALLOW_ELEMENT_TRANSITION_MAPS) { 2025c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Map* transitioned_fast_element_map( 2026c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch map->LookupElementsTransitionMap(FAST_ELEMENTS, NULL)); 2027c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch ASSERT(transitioned_fast_element_map == NULL || 2028c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch map->elements_kind() != FAST_ELEMENTS); 2029c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch if (transitioned_fast_element_map != NULL) { 2030c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch b(eq, early_success); 2031c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch cmp(scratch, Operand(Handle<Map>(transitioned_fast_element_map))); 2032c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch } 2033c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch 2034c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Map* transitioned_double_map( 2035c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch map->LookupElementsTransitionMap(FAST_DOUBLE_ELEMENTS, NULL)); 2036c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch ASSERT(transitioned_double_map == NULL || 2037c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch map->elements_kind() == FAST_SMI_ONLY_ELEMENTS); 2038c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch if (transitioned_double_map != NULL) { 2039c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch b(eq, early_success); 2040c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch cmp(scratch, Operand(Handle<Map>(transitioned_double_map))); 2041c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch } 2042c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch } 2043c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch} 2044c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch 2045c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch 20463100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescuvoid MacroAssembler::CheckMap(Register obj, 20473100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register scratch, 20483100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Handle<Map> map, 20493100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Label* fail, 2050c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch SmiCheckType smi_check_type, 2051c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch CompareMapMode mode) { 2052257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (smi_check_type == DO_SMI_CHECK) { 20531e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block JumpIfSmi(obj, fail); 20543100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu } 2055c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch 2056c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch Label success; 2057c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch CompareMap(obj, scratch, map, &success, mode); 20583100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu b(ne, fail); 2059c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch bind(&success); 20603100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu} 20613100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 20623100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 20637f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdochvoid MacroAssembler::CheckMap(Register obj, 20647f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch Register scratch, 20657f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch Heap::RootListIndex index, 20667f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch Label* fail, 2067257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch SmiCheckType smi_check_type) { 2068257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (smi_check_type == DO_SMI_CHECK) { 20691e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block JumpIfSmi(obj, fail); 20707f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch } 20717f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch ldr(scratch, FieldMemOperand(obj, HeapObject::kMapOffset)); 20727f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch LoadRoot(ip, index); 20737f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch cmp(scratch, ip); 20747f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch b(ne, fail); 20757f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch} 20767f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 20777f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 2078257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::DispatchMap(Register obj, 2079257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Register scratch, 2080257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Handle<Map> map, 2081257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Handle<Code> success, 2082257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch SmiCheckType smi_check_type) { 2083257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Label fail; 2084257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (smi_check_type == DO_SMI_CHECK) { 2085257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch JumpIfSmi(obj, &fail); 2086257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } 2087257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch ldr(scratch, FieldMemOperand(obj, HeapObject::kMapOffset)); 2088257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch mov(ip, Operand(map)); 2089257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch cmp(scratch, ip); 2090257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Jump(success, RelocInfo::CODE_TARGET, eq); 2091257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch bind(&fail); 2092257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 2093257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 2094257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 2095a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::TryGetFunctionPrototype(Register function, 2096a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register result, 2097a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch, 2098592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label* miss, 2099592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bool miss_on_bound_function) { 2100a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check that the receiver isn't a smi. 21011e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block JumpIfSmi(function, miss); 2102a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2103a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check that the function really is a function. Load map into result reg. 2104a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CompareObjectType(function, result, scratch, JS_FUNCTION_TYPE); 2105a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block b(ne, miss); 2106a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2107592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (miss_on_bound_function) { 2108592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(scratch, 2109592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch FieldMemOperand(function, JSFunction::kSharedFunctionInfoOffset)); 2110592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(scratch, 2111592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch FieldMemOperand(scratch, SharedFunctionInfo::kCompilerHintsOffset)); 2112592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(scratch, 2113592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Operand(Smi::FromInt(1 << SharedFunctionInfo::kBoundFunction))); 2114592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(ne, miss); 2115592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 2116592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 2117a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Make sure that the function has an instance prototype. 2118a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label non_instance; 2119a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldrb(scratch, FieldMemOperand(result, Map::kBitFieldOffset)); 2120a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block tst(scratch, Operand(1 << Map::kHasNonInstancePrototype)); 2121a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block b(ne, &non_instance); 2122a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2123a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Get the prototype or initial map from the function. 2124a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(result, 2125a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block FieldMemOperand(function, JSFunction::kPrototypeOrInitialMapOffset)); 2126a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2127a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // If the prototype or initial map is the hole, don't return it and 2128a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // simply miss the cache instead. This will allow us to allocate a 2129a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // prototype object on-demand in the runtime system. 2130a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block LoadRoot(ip, Heap::kTheHoleValueRootIndex); 2131a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block cmp(result, ip); 2132a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block b(eq, miss); 2133a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2134a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // If the function does not have an initial map, we're done. 2135a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label done; 2136a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CompareObjectType(result, scratch, scratch, MAP_TYPE); 2137a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block b(ne, &done); 2138a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2139a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Get the prototype from the initial map. 2140a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(result, FieldMemOperand(result, Map::kPrototypeOffset)); 2141a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block jmp(&done); 2142a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2143a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Non-instance prototype: Fetch prototype from constructor field 2144a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // in initial map. 2145a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&non_instance); 2146a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(result, FieldMemOperand(result, Map::kConstructorOffset)); 2147a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2148a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // All done. 2149a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&done); 2150a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2151a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2152a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2153a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::CallStub(CodeStub* stub, Condition cond) { 2154592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(AllowThisStubCall(stub)); // Stub calls are not allowed in some stubs. 21553fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Call(stub->GetCode(), RelocInfo::CODE_TARGET, kNoASTId, cond); 2156a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2157a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2158a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 21593100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescuvoid MacroAssembler::TailCallStub(CodeStub* stub, Condition cond) { 2160592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(allow_stub_calls_ || stub->CompilingCallsToThisStubIsGCSafe()); 21611e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Jump(stub->GetCode(), RelocInfo::CODE_TARGET, cond); 21621e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 21631e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 21641e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 21651e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockstatic int AddressOffset(ExternalReference ref0, ExternalReference ref1) { 21661e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block return ref0.address() - ref1.address(); 21671e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 21681e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 21691e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 2170592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::CallApiFunctionAndReturn(ExternalReference function, 2171592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch int stack_space) { 21721e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ExternalReference next_address = 21731e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ExternalReference::handle_scope_next_address(); 21741e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block const int kNextOffset = 0; 21751e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block const int kLimitOffset = AddressOffset( 21761e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ExternalReference::handle_scope_limit_address(), 21771e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block next_address); 21781e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block const int kLevelOffset = AddressOffset( 21791e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ExternalReference::handle_scope_level_address(), 21801e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block next_address); 21811e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 21821e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Allocate HandleScope in callee-save registers. 21831e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block mov(r7, Operand(next_address)); 21841e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ldr(r4, MemOperand(r7, kNextOffset)); 21851e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ldr(r5, MemOperand(r7, kLimitOffset)); 21861e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ldr(r6, MemOperand(r7, kLevelOffset)); 21871e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block add(r6, r6, Operand(1)); 21881e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block str(r6, MemOperand(r7, kLevelOffset)); 21891e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 21901e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Native call returns to the DirectCEntry stub which redirects to the 21911e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // return address pushed on stack (could have moved after GC). 21921e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // DirectCEntry stub itself is generated early and never moves. 21931e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block DirectCEntryStub stub; 21941e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block stub.GenerateCall(this, function); 21951e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 21961e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Label promote_scheduled_exception; 21971e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Label delete_allocated_handles; 21981e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Label leave_exit_frame; 21991e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 22001e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // If result is non-zero, dereference to get the result value 22011e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // otherwise set it to undefined. 22021e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block cmp(r0, Operand(0)); 22031e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block LoadRoot(r0, Heap::kUndefinedValueRootIndex, eq); 22041e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ldr(r0, MemOperand(r0), ne); 22051e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 22061e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // No more valid handles (the result handle was the last one). Restore 22071e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // previous handle scope. 22081e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block str(r4, MemOperand(r7, kNextOffset)); 220944f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 22101e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ldr(r1, MemOperand(r7, kLevelOffset)); 22111e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block cmp(r1, r6); 22121e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Check(eq, "Unexpected level after return from api call"); 22131e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } 22141e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block sub(r6, r6, Operand(1)); 22151e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block str(r6, MemOperand(r7, kLevelOffset)); 22161e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ldr(ip, MemOperand(r7, kLimitOffset)); 22171e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block cmp(r5, ip); 22181e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block b(ne, &delete_allocated_handles); 22191e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 22201e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Check if the function scheduled an exception. 22211e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block bind(&leave_exit_frame); 22221e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block LoadRoot(r4, Heap::kTheHoleValueRootIndex); 222344f0eee88ff00398ff7f715fab053374d808c90dSteve Block mov(ip, Operand(ExternalReference::scheduled_exception_address(isolate()))); 22241e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ldr(r5, MemOperand(ip)); 22251e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block cmp(r4, r5); 22261e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block b(ne, &promote_scheduled_exception); 22271e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 2228e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // LeaveExitFrame expects unwind space to be in a register. 22291e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block mov(r4, Operand(stack_space)); 2230e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch LeaveExitFrame(false, r4); 2231e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch mov(pc, lr); 22321e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 22331e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block bind(&promote_scheduled_exception); 2234592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch TailCallExternalReference( 2235592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ExternalReference(Runtime::kPromoteScheduledException, isolate()), 2236592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 0, 2237592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 1); 22381e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 22391e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // HandleScope limit has changed. Delete allocated extensions. 22401e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block bind(&delete_allocated_handles); 22411e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block str(r5, MemOperand(r7, kLimitOffset)); 22421e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block mov(r4, r0); 22438b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch PrepareCallCFunction(1, r5); 22448b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch mov(r0, Operand(ExternalReference::isolate_address())); 224544f0eee88ff00398ff7f715fab053374d808c90dSteve Block CallCFunction( 22468b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch ExternalReference::delete_handle_scope_extensions(isolate()), 1); 22471e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block mov(r0, r4); 22481e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block jmp(&leave_exit_frame); 2249592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 22501e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 2251592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 2252592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochbool MacroAssembler::AllowThisStubCall(CodeStub* stub) { 2253592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (!has_frame_ && stub->SometimesSetsUpAFrame()) return false; 2254592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch return allow_stub_calls_ || stub->CompilingCallsToThisStubIsGCSafe(); 22553100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu} 22563100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 22573100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 2258a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::IllegalOperation(int num_arguments) { 2259a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (num_arguments > 0) { 2260a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block add(sp, sp, Operand(num_arguments * kPointerSize)); 2261a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2262a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block LoadRoot(r0, Heap::kUndefinedValueRootIndex); 2263a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2264a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2265a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 226680d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsenvoid MacroAssembler::IndexFromHash(Register hash, Register index) { 226780d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // If the hash field contains an array index pick it out. The assert checks 226880d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // that the constants for the maximum number of digits for an array index 226980d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // cached in the hash field and the number of bits reserved for it does not 227080d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // conflict. 227180d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen ASSERT(TenToThe(String::kMaxCachedArrayIndexLength) < 227280d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen (1 << String::kArrayIndexValueBits)); 227380d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // We want the smi-tagged index in key. kArrayIndexValueMask has zeros in 227480d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen // the low kHashShift bits. 227580d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen STATIC_ASSERT(kSmiTag == 0); 227680d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen Ubfx(hash, hash, String::kHashShift, String::kArrayIndexValueBits); 227780d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen mov(index, Operand(hash, LSL, kSmiTagSize)); 227880d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen} 227980d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen 228080d68eab642096c1a48b6474d6ec33064b0ad1f5Kristian Monsen 2281d0582a6c46733687d045e4188a1bcd0123c758a1Steve Blockvoid MacroAssembler::IntegerToDoubleConversionWithVFP3(Register inReg, 2282d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block Register outHighReg, 2283d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block Register outLowReg) { 2284d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block // ARMv7 VFP3 instructions to implement integer to double conversion. 2285d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block mov(r7, Operand(inReg, ASR, kSmiTagSize)); 2286e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke vmov(s15, r7); 22876ded16be15dd865a9b21ea304d5273c8be299c87Steve Block vcvt_f64_s32(d7, s15); 2288e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke vmov(outLowReg, outHighReg, d7); 2289d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block} 2290d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 2291d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 22928defd9ff6930b4e24729971a61cf7469daf119beSteve Blockvoid MacroAssembler::ObjectToDoubleVFPRegister(Register object, 22938defd9ff6930b4e24729971a61cf7469daf119beSteve Block DwVfpRegister result, 22948defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register scratch1, 22958defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register scratch2, 22968defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register heap_number_map, 22978defd9ff6930b4e24729971a61cf7469daf119beSteve Block SwVfpRegister scratch3, 22988defd9ff6930b4e24729971a61cf7469daf119beSteve Block Label* not_number, 22998defd9ff6930b4e24729971a61cf7469daf119beSteve Block ObjectToDoubleFlags flags) { 23008defd9ff6930b4e24729971a61cf7469daf119beSteve Block Label done; 23018defd9ff6930b4e24729971a61cf7469daf119beSteve Block if ((flags & OBJECT_NOT_SMI) == 0) { 23028defd9ff6930b4e24729971a61cf7469daf119beSteve Block Label not_smi; 23031e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block JumpIfNotSmi(object, ¬_smi); 23048defd9ff6930b4e24729971a61cf7469daf119beSteve Block // Remove smi tag and convert to double. 23058defd9ff6930b4e24729971a61cf7469daf119beSteve Block mov(scratch1, Operand(object, ASR, kSmiTagSize)); 23068defd9ff6930b4e24729971a61cf7469daf119beSteve Block vmov(scratch3, scratch1); 23078defd9ff6930b4e24729971a61cf7469daf119beSteve Block vcvt_f64_s32(result, scratch3); 23088defd9ff6930b4e24729971a61cf7469daf119beSteve Block b(&done); 23098defd9ff6930b4e24729971a61cf7469daf119beSteve Block bind(¬_smi); 23108defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 23118defd9ff6930b4e24729971a61cf7469daf119beSteve Block // Check for heap number and load double value from it. 23128defd9ff6930b4e24729971a61cf7469daf119beSteve Block ldr(scratch1, FieldMemOperand(object, HeapObject::kMapOffset)); 23138defd9ff6930b4e24729971a61cf7469daf119beSteve Block sub(scratch2, object, Operand(kHeapObjectTag)); 23148defd9ff6930b4e24729971a61cf7469daf119beSteve Block cmp(scratch1, heap_number_map); 23158defd9ff6930b4e24729971a61cf7469daf119beSteve Block b(ne, not_number); 23168defd9ff6930b4e24729971a61cf7469daf119beSteve Block if ((flags & AVOID_NANS_AND_INFINITIES) != 0) { 23178defd9ff6930b4e24729971a61cf7469daf119beSteve Block // If exponent is all ones the number is either a NaN or +/-Infinity. 23188defd9ff6930b4e24729971a61cf7469daf119beSteve Block ldr(scratch1, FieldMemOperand(object, HeapNumber::kExponentOffset)); 23198defd9ff6930b4e24729971a61cf7469daf119beSteve Block Sbfx(scratch1, 23208defd9ff6930b4e24729971a61cf7469daf119beSteve Block scratch1, 23218defd9ff6930b4e24729971a61cf7469daf119beSteve Block HeapNumber::kExponentShift, 23228defd9ff6930b4e24729971a61cf7469daf119beSteve Block HeapNumber::kExponentBits); 23238defd9ff6930b4e24729971a61cf7469daf119beSteve Block // All-one value sign extend to -1. 23248defd9ff6930b4e24729971a61cf7469daf119beSteve Block cmp(scratch1, Operand(-1)); 23258defd9ff6930b4e24729971a61cf7469daf119beSteve Block b(eq, not_number); 23268defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 23278defd9ff6930b4e24729971a61cf7469daf119beSteve Block vldr(result, scratch2, HeapNumber::kValueOffset); 23288defd9ff6930b4e24729971a61cf7469daf119beSteve Block bind(&done); 23298defd9ff6930b4e24729971a61cf7469daf119beSteve Block} 23308defd9ff6930b4e24729971a61cf7469daf119beSteve Block 23318defd9ff6930b4e24729971a61cf7469daf119beSteve Block 23328defd9ff6930b4e24729971a61cf7469daf119beSteve Blockvoid MacroAssembler::SmiToDoubleVFPRegister(Register smi, 23338defd9ff6930b4e24729971a61cf7469daf119beSteve Block DwVfpRegister value, 23348defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register scratch1, 23358defd9ff6930b4e24729971a61cf7469daf119beSteve Block SwVfpRegister scratch2) { 23368defd9ff6930b4e24729971a61cf7469daf119beSteve Block mov(scratch1, Operand(smi, ASR, kSmiTagSize)); 23378defd9ff6930b4e24729971a61cf7469daf119beSteve Block vmov(scratch2, scratch1); 23388defd9ff6930b4e24729971a61cf7469daf119beSteve Block vcvt_f64_s32(value, scratch2); 23398defd9ff6930b4e24729971a61cf7469daf119beSteve Block} 23408defd9ff6930b4e24729971a61cf7469daf119beSteve Block 23418defd9ff6930b4e24729971a61cf7469daf119beSteve Block 23429ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick// Tries to get a signed int32 out of a double precision floating point heap 23439ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick// number. Rounds towards 0. Branch to 'not_int32' if the double is out of the 23449ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick// 32bits signed integer range. 23459ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrickvoid MacroAssembler::ConvertToInt32(Register source, 23469ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick Register dest, 23479ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick Register scratch, 23489ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick Register scratch2, 23491e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block DwVfpRegister double_scratch, 23509ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick Label *not_int32) { 23518b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch if (CpuFeatures::IsSupported(VFP3)) { 23529ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick CpuFeatures::Scope scope(VFP3); 23539ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick sub(scratch, source, Operand(kHeapObjectTag)); 23541e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block vldr(double_scratch, scratch, HeapNumber::kValueOffset); 23551e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block vcvt_s32_f64(double_scratch.low(), double_scratch); 23561e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block vmov(dest, double_scratch.low()); 23579ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Signed vcvt instruction will saturate to the minimum (0x80000000) or 23589ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // maximun (0x7fffffff) signed 32bits integer when the double is out of 23599ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // range. When substracting one, the minimum signed integer becomes the 23609ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // maximun signed integer. 23619ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick sub(scratch, dest, Operand(1)); 23629ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick cmp(scratch, Operand(LONG_MAX - 1)); 23639ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // If equal then dest was LONG_MAX, if greater dest was LONG_MIN. 23649ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick b(ge, not_int32); 23659ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick } else { 23669ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // This code is faster for doubles that are in the ranges -0x7fffffff to 23679ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // -0x40000000 or 0x40000000 to 0x7fffffff. This corresponds almost to 23689ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // the range of signed int32 values that are not Smis. Jumps to the label 23699ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // 'not_int32' if the double isn't in the range -0x80000000.0 to 23709ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // 0x80000000.0 (excluding the endpoints). 23719ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick Label right_exponent, done; 23729ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Get exponent word. 23739ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick ldr(scratch, FieldMemOperand(source, HeapNumber::kExponentOffset)); 23749ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Get exponent alone in scratch2. 23759ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick Ubfx(scratch2, 2376e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch scratch, 2377e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch HeapNumber::kExponentShift, 2378e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch HeapNumber::kExponentBits); 23799ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Load dest with zero. We use this either for the final shift or 23809ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // for the answer. 23819ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick mov(dest, Operand(0, RelocInfo::NONE)); 23829ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Check whether the exponent matches a 32 bit signed int that is not a Smi. 23839ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // A non-Smi integer is 1.xxx * 2^30 so the exponent is 30 (biased). This is 23849ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // the exponent that we are fastest at and also the highest exponent we can 23859ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // handle here. 23869ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick const uint32_t non_smi_exponent = HeapNumber::kExponentBias + 30; 23879ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // The non_smi_exponent, 0x41d, is too big for ARM's immediate field so we 23889ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // split it up to avoid a constant pool entry. You can't do that in general 23899ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // for cmp because of the overflow flag, but we know the exponent is in the 23909ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // range 0-2047 so there is no overflow. 23919ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick int fudge_factor = 0x400; 23929ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick sub(scratch2, scratch2, Operand(fudge_factor)); 23939ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick cmp(scratch2, Operand(non_smi_exponent - fudge_factor)); 23949ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // If we have a match of the int32-but-not-Smi exponent then skip some 23959ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // logic. 23969ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick b(eq, &right_exponent); 23979ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // If the exponent is higher than that then go to slow case. This catches 23989ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // numbers that don't fit in a signed int32, infinities and NaNs. 23999ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick b(gt, not_int32); 24009ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick 24019ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // We know the exponent is smaller than 30 (biased). If it is less than 2402c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch // 0 (biased) then the number is smaller in magnitude than 1.0 * 2^0, i.e. 24039ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // it rounds to zero. 24049ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick const uint32_t zero_exponent = HeapNumber::kExponentBias + 0; 24059ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick sub(scratch2, scratch2, Operand(zero_exponent - fudge_factor), SetCC); 24069ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Dest already has a Smi zero. 24079ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick b(lt, &done); 24089ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick 24099ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // We have an exponent between 0 and 30 in scratch2. Subtract from 30 to 24109ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // get how much to shift down. 24119ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick rsb(dest, scratch2, Operand(30)); 24129ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick 24139ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick bind(&right_exponent); 24149ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Get the top bits of the mantissa. 24159ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick and_(scratch2, scratch, Operand(HeapNumber::kMantissaMask)); 24169ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Put back the implicit 1. 24179ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick orr(scratch2, scratch2, Operand(1 << HeapNumber::kExponentShift)); 24189ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Shift up the mantissa bits to take up the space the exponent used to 24199ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // take. We just orred in the implicit bit so that took care of one and 24209ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // we want to leave the sign bit 0 so we subtract 2 bits from the shift 24219ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // distance. 24229ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick const int shift_distance = HeapNumber::kNonMantissaBitsInTopWord - 2; 24239ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick mov(scratch2, Operand(scratch2, LSL, shift_distance)); 24249ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Put sign in zero flag. 24259ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick tst(scratch, Operand(HeapNumber::kSignMask)); 24269ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Get the second half of the double. For some exponents we don't 24279ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // actually need this because the bits get shifted out again, but 24289ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // it's probably slower to test than just to do it. 24299ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick ldr(scratch, FieldMemOperand(source, HeapNumber::kMantissaOffset)); 24309ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Shift down 22 bits to get the last 10 bits. 24319ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick orr(scratch, scratch2, Operand(scratch, LSR, 32 - shift_distance)); 24329ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Move down according to the exponent. 24339ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick mov(dest, Operand(scratch, LSR, dest)); 24349ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick // Fix sign if sign bit was set. 24359ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick rsb(dest, dest, Operand(0, RelocInfo::NONE), LeaveCC, ne); 24369ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick bind(&done); 24379ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick } 24389ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick} 24399ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick 24409ac36c9faca11611ada13b4054edbaa0738661d0Iain Merrick 2441e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::EmitVFPTruncate(VFPRoundingMode rounding_mode, 2442e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch SwVfpRegister result, 2443e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch DwVfpRegister double_input, 2444e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register scratch1, 2445e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register scratch2, 2446e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch CheckForInexactConversion check_inexact) { 24478b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch ASSERT(CpuFeatures::IsSupported(VFP3)); 2448e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch CpuFeatures::Scope scope(VFP3); 2449e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register prev_fpscr = scratch1; 2450e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register scratch = scratch2; 2451e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 2452e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch int32_t check_inexact_conversion = 2453e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch (check_inexact == kCheckForInexactConversion) ? kVFPInexactExceptionBit : 0; 2454e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 2455e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Set custom FPCSR: 2456e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // - Set rounding mode. 2457e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // - Clear vfp cumulative exception flags. 2458e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // - Make sure Flush-to-zero mode control bit is unset. 2459e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch vmrs(prev_fpscr); 2460e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch bic(scratch, 2461e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch prev_fpscr, 2462e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Operand(kVFPExceptionMask | 2463e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch check_inexact_conversion | 2464e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch kVFPRoundingModeMask | 2465e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch kVFPFlushToZeroMask)); 2466e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // 'Round To Nearest' is encoded by 0b00 so no bits need to be set. 2467e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch if (rounding_mode != kRoundToNearest) { 2468e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch orr(scratch, scratch, Operand(rounding_mode)); 2469e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } 2470e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch vmsr(scratch); 2471e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 2472e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Convert the argument to an integer. 2473e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch vcvt_s32_f64(result, 2474e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch double_input, 2475e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch (rounding_mode == kRoundToZero) ? kDefaultRoundToZero 2476e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch : kFPSCRRounding); 2477e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 2478e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Retrieve FPSCR. 2479e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch vmrs(scratch); 2480e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Restore FPSCR. 2481e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch vmsr(prev_fpscr); 2482e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Check for vfp exceptions. 2483e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch tst(scratch, Operand(kVFPExceptionMask | check_inexact_conversion)); 2484e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 2485e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 2486e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 248744f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::EmitOutOfInt32RangeTruncate(Register result, 248844f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register input_high, 248944f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register input_low, 249044f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register scratch) { 249144f0eee88ff00398ff7f715fab053374d808c90dSteve Block Label done, normal_exponent, restore_sign; 249244f0eee88ff00398ff7f715fab053374d808c90dSteve Block 249344f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Extract the biased exponent in result. 249444f0eee88ff00398ff7f715fab053374d808c90dSteve Block Ubfx(result, 249544f0eee88ff00398ff7f715fab053374d808c90dSteve Block input_high, 249644f0eee88ff00398ff7f715fab053374d808c90dSteve Block HeapNumber::kExponentShift, 249744f0eee88ff00398ff7f715fab053374d808c90dSteve Block HeapNumber::kExponentBits); 249844f0eee88ff00398ff7f715fab053374d808c90dSteve Block 249944f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Check for Infinity and NaNs, which should return 0. 250044f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmp(result, Operand(HeapNumber::kExponentMask)); 250144f0eee88ff00398ff7f715fab053374d808c90dSteve Block mov(result, Operand(0), LeaveCC, eq); 250244f0eee88ff00398ff7f715fab053374d808c90dSteve Block b(eq, &done); 250344f0eee88ff00398ff7f715fab053374d808c90dSteve Block 250444f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Express exponent as delta to (number of mantissa bits + 31). 250544f0eee88ff00398ff7f715fab053374d808c90dSteve Block sub(result, 250644f0eee88ff00398ff7f715fab053374d808c90dSteve Block result, 250744f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand(HeapNumber::kExponentBias + HeapNumber::kMantissaBits + 31), 250844f0eee88ff00398ff7f715fab053374d808c90dSteve Block SetCC); 250944f0eee88ff00398ff7f715fab053374d808c90dSteve Block 251044f0eee88ff00398ff7f715fab053374d808c90dSteve Block // If the delta is strictly positive, all bits would be shifted away, 251144f0eee88ff00398ff7f715fab053374d808c90dSteve Block // which means that we can return 0. 251244f0eee88ff00398ff7f715fab053374d808c90dSteve Block b(le, &normal_exponent); 251344f0eee88ff00398ff7f715fab053374d808c90dSteve Block mov(result, Operand(0)); 251444f0eee88ff00398ff7f715fab053374d808c90dSteve Block b(&done); 251544f0eee88ff00398ff7f715fab053374d808c90dSteve Block 251644f0eee88ff00398ff7f715fab053374d808c90dSteve Block bind(&normal_exponent); 251744f0eee88ff00398ff7f715fab053374d808c90dSteve Block const int kShiftBase = HeapNumber::kNonMantissaBitsInTopWord - 1; 251844f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Calculate shift. 251944f0eee88ff00398ff7f715fab053374d808c90dSteve Block add(scratch, result, Operand(kShiftBase + HeapNumber::kMantissaBits), SetCC); 252044f0eee88ff00398ff7f715fab053374d808c90dSteve Block 252144f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Save the sign. 252244f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register sign = result; 252344f0eee88ff00398ff7f715fab053374d808c90dSteve Block result = no_reg; 252444f0eee88ff00398ff7f715fab053374d808c90dSteve Block and_(sign, input_high, Operand(HeapNumber::kSignMask)); 252544f0eee88ff00398ff7f715fab053374d808c90dSteve Block 252644f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Set the implicit 1 before the mantissa part in input_high. 252744f0eee88ff00398ff7f715fab053374d808c90dSteve Block orr(input_high, 252844f0eee88ff00398ff7f715fab053374d808c90dSteve Block input_high, 252944f0eee88ff00398ff7f715fab053374d808c90dSteve Block Operand(1 << HeapNumber::kMantissaBitsInTopWord)); 253044f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Shift the mantissa bits to the correct position. 253144f0eee88ff00398ff7f715fab053374d808c90dSteve Block // We don't need to clear non-mantissa bits as they will be shifted away. 253244f0eee88ff00398ff7f715fab053374d808c90dSteve Block // If they weren't, it would mean that the answer is in the 32bit range. 253344f0eee88ff00398ff7f715fab053374d808c90dSteve Block mov(input_high, Operand(input_high, LSL, scratch)); 253444f0eee88ff00398ff7f715fab053374d808c90dSteve Block 253544f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Replace the shifted bits with bits from the lower mantissa word. 253644f0eee88ff00398ff7f715fab053374d808c90dSteve Block Label pos_shift, shift_done; 253744f0eee88ff00398ff7f715fab053374d808c90dSteve Block rsb(scratch, scratch, Operand(32), SetCC); 253844f0eee88ff00398ff7f715fab053374d808c90dSteve Block b(&pos_shift, ge); 253944f0eee88ff00398ff7f715fab053374d808c90dSteve Block 254044f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Negate scratch. 254144f0eee88ff00398ff7f715fab053374d808c90dSteve Block rsb(scratch, scratch, Operand(0)); 254244f0eee88ff00398ff7f715fab053374d808c90dSteve Block mov(input_low, Operand(input_low, LSL, scratch)); 254344f0eee88ff00398ff7f715fab053374d808c90dSteve Block b(&shift_done); 254444f0eee88ff00398ff7f715fab053374d808c90dSteve Block 254544f0eee88ff00398ff7f715fab053374d808c90dSteve Block bind(&pos_shift); 254644f0eee88ff00398ff7f715fab053374d808c90dSteve Block mov(input_low, Operand(input_low, LSR, scratch)); 254744f0eee88ff00398ff7f715fab053374d808c90dSteve Block 254844f0eee88ff00398ff7f715fab053374d808c90dSteve Block bind(&shift_done); 254944f0eee88ff00398ff7f715fab053374d808c90dSteve Block orr(input_high, input_high, Operand(input_low)); 255044f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Restore sign if necessary. 255144f0eee88ff00398ff7f715fab053374d808c90dSteve Block cmp(sign, Operand(0)); 255244f0eee88ff00398ff7f715fab053374d808c90dSteve Block result = sign; 255344f0eee88ff00398ff7f715fab053374d808c90dSteve Block sign = no_reg; 255444f0eee88ff00398ff7f715fab053374d808c90dSteve Block rsb(result, input_high, Operand(0), LeaveCC, ne); 255544f0eee88ff00398ff7f715fab053374d808c90dSteve Block mov(result, input_high, LeaveCC, eq); 255644f0eee88ff00398ff7f715fab053374d808c90dSteve Block bind(&done); 255744f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 255844f0eee88ff00398ff7f715fab053374d808c90dSteve Block 255944f0eee88ff00398ff7f715fab053374d808c90dSteve Block 256044f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::EmitECMATruncate(Register result, 256144f0eee88ff00398ff7f715fab053374d808c90dSteve Block DwVfpRegister double_input, 256244f0eee88ff00398ff7f715fab053374d808c90dSteve Block SwVfpRegister single_scratch, 256344f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register scratch, 256444f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register input_high, 256544f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register input_low) { 256644f0eee88ff00398ff7f715fab053374d808c90dSteve Block CpuFeatures::Scope scope(VFP3); 256744f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(!input_high.is(result)); 256844f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(!input_low.is(result)); 256944f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(!input_low.is(input_high)); 257044f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(!scratch.is(result) && 257144f0eee88ff00398ff7f715fab053374d808c90dSteve Block !scratch.is(input_high) && 257244f0eee88ff00398ff7f715fab053374d808c90dSteve Block !scratch.is(input_low)); 257344f0eee88ff00398ff7f715fab053374d808c90dSteve Block ASSERT(!single_scratch.is(double_input.low()) && 257444f0eee88ff00398ff7f715fab053374d808c90dSteve Block !single_scratch.is(double_input.high())); 257544f0eee88ff00398ff7f715fab053374d808c90dSteve Block 257644f0eee88ff00398ff7f715fab053374d808c90dSteve Block Label done; 257744f0eee88ff00398ff7f715fab053374d808c90dSteve Block 257844f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Clear cumulative exception flags. 257944f0eee88ff00398ff7f715fab053374d808c90dSteve Block ClearFPSCRBits(kVFPExceptionMask, scratch); 258044f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Try a conversion to a signed integer. 258144f0eee88ff00398ff7f715fab053374d808c90dSteve Block vcvt_s32_f64(single_scratch, double_input); 258244f0eee88ff00398ff7f715fab053374d808c90dSteve Block vmov(result, single_scratch); 258344f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Retrieve he FPSCR. 258444f0eee88ff00398ff7f715fab053374d808c90dSteve Block vmrs(scratch); 258544f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Check for overflow and NaNs. 258644f0eee88ff00398ff7f715fab053374d808c90dSteve Block tst(scratch, Operand(kVFPOverflowExceptionBit | 258744f0eee88ff00398ff7f715fab053374d808c90dSteve Block kVFPUnderflowExceptionBit | 258844f0eee88ff00398ff7f715fab053374d808c90dSteve Block kVFPInvalidOpExceptionBit)); 258944f0eee88ff00398ff7f715fab053374d808c90dSteve Block // If we had no exceptions we are done. 259044f0eee88ff00398ff7f715fab053374d808c90dSteve Block b(eq, &done); 259144f0eee88ff00398ff7f715fab053374d808c90dSteve Block 259244f0eee88ff00398ff7f715fab053374d808c90dSteve Block // Load the double value and perform a manual truncation. 259344f0eee88ff00398ff7f715fab053374d808c90dSteve Block vmov(input_low, input_high, double_input); 259444f0eee88ff00398ff7f715fab053374d808c90dSteve Block EmitOutOfInt32RangeTruncate(result, 259544f0eee88ff00398ff7f715fab053374d808c90dSteve Block input_high, 259644f0eee88ff00398ff7f715fab053374d808c90dSteve Block input_low, 259744f0eee88ff00398ff7f715fab053374d808c90dSteve Block scratch); 259844f0eee88ff00398ff7f715fab053374d808c90dSteve Block bind(&done); 259944f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 260044f0eee88ff00398ff7f715fab053374d808c90dSteve Block 260144f0eee88ff00398ff7f715fab053374d808c90dSteve Block 26023100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescuvoid MacroAssembler::GetLeastBitsFromSmi(Register dst, 26033100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register src, 26043100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu int num_least_bits) { 26058b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch if (CpuFeatures::IsSupported(ARMv7)) { 26067f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch ubfx(dst, src, kSmiTagSize, num_least_bits); 26073100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu } else { 26083100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu mov(dst, Operand(src, ASR, kSmiTagSize)); 26093100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu and_(dst, dst, Operand((1 << num_least_bits) - 1)); 26103100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu } 26113100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu} 26123100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 26133100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 26141e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::GetLeastBitsFromInt32(Register dst, 26151e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Register src, 26161e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block int num_least_bits) { 26171e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block and_(dst, src, Operand((1 << num_least_bits) - 1)); 26181e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 26191e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 26201e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 262144f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::CallRuntime(const Runtime::Function* f, 262244f0eee88ff00398ff7f715fab053374d808c90dSteve Block int num_arguments) { 2623a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // All parameters are on the stack. r0 has the return value after call. 2624a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2625a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // If the expected number of arguments of the runtime function is 2626a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // constant, we check that the actual number of arguments match the 2627a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // expectation. 2628a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (f->nargs >= 0 && f->nargs != num_arguments) { 2629a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block IllegalOperation(num_arguments); 2630a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return; 2631a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2632a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 26334515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // TODO(1236192): Most runtime routines don't need the number of 26344515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // arguments passed in because it is constant. At some point we 26354515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // should remove this need and make the runtime routine entry code 26364515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke // smarter. 26374515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke mov(r0, Operand(num_arguments)); 263844f0eee88ff00398ff7f715fab053374d808c90dSteve Block mov(r1, Operand(ExternalReference(f, isolate()))); 26394515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke CEntryStub stub(1); 2640a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CallStub(&stub); 2641a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2642a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2643a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2644a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::CallRuntime(Runtime::FunctionId fid, int num_arguments) { 2645a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CallRuntime(Runtime::FunctionForId(fid), num_arguments); 2646a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2647a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2648a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2649b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdochvoid MacroAssembler::CallRuntimeSaveDoubles(Runtime::FunctionId id) { 265044f0eee88ff00398ff7f715fab053374d808c90dSteve Block const Runtime::Function* function = Runtime::FunctionForId(id); 2651b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch mov(r0, Operand(function->nargs)); 265244f0eee88ff00398ff7f715fab053374d808c90dSteve Block mov(r1, Operand(ExternalReference(function, isolate()))); 2653592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CEntryStub stub(1, kSaveFPRegs); 2654b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch CallStub(&stub); 2655b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch} 2656b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 2657b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 2658402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescuvoid MacroAssembler::CallExternalReference(const ExternalReference& ext, 2659402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu int num_arguments) { 2660402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu mov(r0, Operand(num_arguments)); 2661402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu mov(r1, Operand(ext)); 2662402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 2663402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu CEntryStub stub(1); 2664402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu CallStub(&stub); 2665402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu} 2666402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 2667402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu 26686ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::TailCallExternalReference(const ExternalReference& ext, 26696ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int num_arguments, 26706ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int result_size) { 2671a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // TODO(1236192): Most runtime routines don't need the number of 2672a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // arguments passed in because it is constant. At some point we 2673a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // should remove this need and make the runtime routine entry code 2674a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // smarter. 2675a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(r0, Operand(num_arguments)); 26766ded16be15dd865a9b21ea304d5273c8be299c87Steve Block JumpToExternalReference(ext); 2677a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2678a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2679a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 26806ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::TailCallRuntime(Runtime::FunctionId fid, 26816ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int num_arguments, 26826ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int result_size) { 268344f0eee88ff00398ff7f715fab053374d808c90dSteve Block TailCallExternalReference(ExternalReference(fid, isolate()), 268444f0eee88ff00398ff7f715fab053374d808c90dSteve Block num_arguments, 268544f0eee88ff00398ff7f715fab053374d808c90dSteve Block result_size); 26866ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 26876ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 26886ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 26896ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::JumpToExternalReference(const ExternalReference& builtin) { 2690a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#if defined(__thumb__) 2691a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Thumb mode builtin. 2692a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT((reinterpret_cast<intptr_t>(builtin.address()) & 1) == 1); 2693a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 2694a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(r1, Operand(builtin)); 2695a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CEntryStub stub(1); 2696a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Jump(stub.GetCode(), RelocInfo::CODE_TARGET); 2697a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2698a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2699a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2700a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::InvokeBuiltin(Builtins::JavaScript id, 2701257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch InvokeFlag flag, 2702257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch const CallWrapper& call_wrapper) { 2703592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // You can't call a builtin without a valid frame. 2704592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(flag == JUMP_FUNCTION || has_frame()); 2705592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 2706402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu GetBuiltinEntry(r2, id); 2707257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (flag == CALL_FUNCTION) { 2708257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch call_wrapper.BeforeCall(CallSize(r2)); 2709257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch SetCallKind(r5, CALL_AS_METHOD); 2710402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu Call(r2); 2711257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch call_wrapper.AfterCall(); 2712a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } else { 2713257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch ASSERT(flag == JUMP_FUNCTION); 2714257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch SetCallKind(r5, CALL_AS_METHOD); 2715402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu Jump(r2); 2716a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2717a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2718a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2719a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2720791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Blockvoid MacroAssembler::GetBuiltinFunction(Register target, 2721791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block Builtins::JavaScript id) { 27226ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Load the builtins object into target register. 27236ded16be15dd865a9b21ea304d5273c8be299c87Steve Block ldr(target, MemOperand(cp, Context::SlotOffset(Context::GLOBAL_INDEX))); 27246ded16be15dd865a9b21ea304d5273c8be299c87Steve Block ldr(target, FieldMemOperand(target, GlobalObject::kBuiltinsOffset)); 2725402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu // Load the JavaScript builtin function from the builtins object. 2726791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block ldr(target, FieldMemOperand(target, 27276ded16be15dd865a9b21ea304d5273c8be299c87Steve Block JSBuiltinsObject::OffsetOfFunctionWithId(id))); 2728791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block} 2729791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block 27306ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 2731791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Blockvoid MacroAssembler::GetBuiltinEntry(Register target, Builtins::JavaScript id) { 2732791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block ASSERT(!target.is(r1)); 2733791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block GetBuiltinFunction(r1, id); 27346ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Load the code entry point from the builtins object. 2735791712a13f1814dd3ab5d1a5ab8ff5dbc476f6d6Steve Block ldr(target, FieldMemOperand(r1, JSFunction::kCodeEntryOffset)); 2736a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2737a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2738a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2739a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::SetCounter(StatsCounter* counter, int value, 2740a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch1, Register scratch2) { 2741a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (FLAG_native_code_counters && counter->Enabled()) { 2742a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(scratch1, Operand(value)); 2743a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(scratch2, Operand(ExternalReference(counter))); 2744a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block str(scratch1, MemOperand(scratch2)); 2745a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2746a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2747a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2748a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2749a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::IncrementCounter(StatsCounter* counter, int value, 2750a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch1, Register scratch2) { 2751a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(value > 0); 2752a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (FLAG_native_code_counters && counter->Enabled()) { 2753a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(scratch2, Operand(ExternalReference(counter))); 2754a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(scratch1, MemOperand(scratch2)); 2755a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block add(scratch1, scratch1, Operand(value)); 2756a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block str(scratch1, MemOperand(scratch2)); 2757a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2758a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2759a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2760a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2761a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::DecrementCounter(StatsCounter* counter, int value, 2762a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register scratch1, Register scratch2) { 2763a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(value > 0); 2764a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (FLAG_native_code_counters && counter->Enabled()) { 2765a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(scratch2, Operand(ExternalReference(counter))); 2766a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ldr(scratch1, MemOperand(scratch2)); 2767a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block sub(scratch1, scratch1, Operand(value)); 2768a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block str(scratch1, MemOperand(scratch2)); 2769a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2770a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2771a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2772a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 27731e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::Assert(Condition cond, const char* msg) { 277444f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) 27751e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Check(cond, msg); 2776a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2777a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2778a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 27799dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsenvoid MacroAssembler::AssertRegisterIsRoot(Register reg, 27809dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Heap::RootListIndex index) { 278144f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 27829dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen LoadRoot(ip, index); 27839dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen cmp(reg, ip); 27849dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Check(eq, "Register did not match expected root"); 27859dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen } 27869dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen} 27879dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 27889dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 2789756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrickvoid MacroAssembler::AssertFastElements(Register elements) { 279044f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 2791756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick ASSERT(!elements.is(ip)); 2792756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick Label ok; 2793756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick push(elements); 2794756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick ldr(elements, FieldMemOperand(elements, HeapObject::kMapOffset)); 2795756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick LoadRoot(ip, Heap::kFixedArrayMapRootIndex); 2796756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick cmp(elements, ip); 2797756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick b(eq, &ok); 27983fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch LoadRoot(ip, Heap::kFixedDoubleArrayMapRootIndex); 27993fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch cmp(elements, ip); 28003fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch b(eq, &ok); 2801756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick LoadRoot(ip, Heap::kFixedCOWArrayMapRootIndex); 2802756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick cmp(elements, ip); 2803756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick b(eq, &ok); 2804756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick Abort("JSObject with fast elements map has slow elements"); 2805756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick bind(&ok); 2806756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick pop(elements); 2807756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick } 2808756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick} 2809756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick 2810756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick 28111e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::Check(Condition cond, const char* msg) { 2812a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Label L; 28131e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block b(cond, &L); 2814a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Abort(msg); 2815a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // will not return here 2816a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bind(&L); 2817a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2818a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2819a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2820a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid MacroAssembler::Abort(const char* msg) { 28218defd9ff6930b4e24729971a61cf7469daf119beSteve Block Label abort_start; 28228defd9ff6930b4e24729971a61cf7469daf119beSteve Block bind(&abort_start); 2823a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // We want to pass the msg string like a smi to avoid GC 2824a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // problems, however msg is not guaranteed to be aligned 2825a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // properly. Instead, we pass an aligned pointer that is 2826a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // a proper v8 smi, but also pass the alignment difference 2827a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // from the real pointer as a smi. 2828a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block intptr_t p1 = reinterpret_cast<intptr_t>(msg); 2829a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block intptr_t p0 = (p1 & ~kSmiTagMask) + kSmiTag; 2830a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(reinterpret_cast<Object*>(p0)->IsSmi()); 2831a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifdef DEBUG 2832a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block if (msg != NULL) { 2833a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block RecordComment("Abort message: "); 2834a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block RecordComment(msg); 2835a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 2836a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 2837d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 2838a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(r0, Operand(p0)); 2839a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(r0); 2840a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block mov(r0, Operand(Smi::FromInt(p1 - p0))); 2841a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block push(r0); 2842592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Disable stub call restrictions to always allow calls to abort. 2843592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (!has_frame_) { 2844592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // We don't actually want to generate a pile of code for this, so just 2845592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // claim there is a stack frame, without generating one. 2846592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch FrameScope scope(this, StackFrame::NONE); 2847592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CallRuntime(Runtime::kAbort, 2); 2848592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } else { 2849592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CallRuntime(Runtime::kAbort, 2); 2850592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 2851a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // will not return here 28528defd9ff6930b4e24729971a61cf7469daf119beSteve Block if (is_const_pool_blocked()) { 28538defd9ff6930b4e24729971a61cf7469daf119beSteve Block // If the calling code cares about the exact number of 28548defd9ff6930b4e24729971a61cf7469daf119beSteve Block // instructions generated, we insert padding here to keep the size 28558defd9ff6930b4e24729971a61cf7469daf119beSteve Block // of the Abort macro constant. 28568defd9ff6930b4e24729971a61cf7469daf119beSteve Block static const int kExpectedAbortInstructions = 10; 28578defd9ff6930b4e24729971a61cf7469daf119beSteve Block int abort_instructions = InstructionsGeneratedSince(&abort_start); 28588defd9ff6930b4e24729971a61cf7469daf119beSteve Block ASSERT(abort_instructions <= kExpectedAbortInstructions); 28598defd9ff6930b4e24729971a61cf7469daf119beSteve Block while (abort_instructions++ < kExpectedAbortInstructions) { 28608defd9ff6930b4e24729971a61cf7469daf119beSteve Block nop(); 28618defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 28628defd9ff6930b4e24729971a61cf7469daf119beSteve Block } 2863a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 2864a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2865a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2866d0582a6c46733687d045e4188a1bcd0123c758a1Steve Blockvoid MacroAssembler::LoadContext(Register dst, int context_chain_length) { 2867d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block if (context_chain_length > 0) { 2868d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block // Move up the chain of contexts to the context containing the slot. 28693fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldr(dst, MemOperand(cp, Context::SlotOffset(Context::PREVIOUS_INDEX))); 2870d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block for (int i = 1; i < context_chain_length; i++) { 28713fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch ldr(dst, MemOperand(dst, Context::SlotOffset(Context::PREVIOUS_INDEX))); 2872d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block } 2873e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } else { 2874e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Slot is in the current function context. Move it into the 2875e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // destination register in case we store into it (the write barrier 2876e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // cannot be allowed to destroy the context in esi). 2877e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch mov(dst, cp); 2878e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } 2879d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block} 2880d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 2881d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 28828a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wangvoid MacroAssembler::LoadGlobalFunction(int index, Register function) { 28838a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // Load the global or builtins object from the current context. 28848a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang ldr(function, MemOperand(cp, Context::SlotOffset(Context::GLOBAL_INDEX))); 28858a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // Load the global context from the global or builtins object. 28868a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang ldr(function, FieldMemOperand(function, 28878a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang GlobalObject::kGlobalContextOffset)); 28888a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // Load the function from the global context. 28898a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang ldr(function, MemOperand(function, Context::SlotOffset(index))); 28908a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang} 28918a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 28928a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 28938a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wangvoid MacroAssembler::LoadGlobalFunctionInitialMap(Register function, 28948a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang Register map, 28958a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang Register scratch) { 28968a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang // Load the initial map. The global functions all have initial maps. 28978a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang ldr(map, FieldMemOperand(function, JSFunction::kPrototypeOrInitialMapOffset)); 289844f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 28998a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang Label ok, fail; 2900257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch CheckMap(map, scratch, Heap::kMetaMapRootIndex, &fail, DO_SMI_CHECK); 29018a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang b(&ok); 29028a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang bind(&fail); 29038a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang Abort("Global functions must have initial map"); 29048a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang bind(&ok); 29058a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang } 29068a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang} 29078a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 29088a31eba00023874d4a1dcdc5f411cc4336776874Shimeng (Simon) Wang 29091e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::JumpIfNotPowerOfTwoOrZero( 29101e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Register reg, 29111e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Register scratch, 29121e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Label* not_power_of_two_or_zero) { 29131e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block sub(scratch, reg, Operand(1), SetCC); 29141e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block b(mi, not_power_of_two_or_zero); 29151e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block tst(scratch, reg); 29161e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block b(ne, not_power_of_two_or_zero); 29171e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 29181e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 29191e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 292044f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::JumpIfNotPowerOfTwoOrZeroAndNeg( 292144f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register reg, 292244f0eee88ff00398ff7f715fab053374d808c90dSteve Block Register scratch, 292344f0eee88ff00398ff7f715fab053374d808c90dSteve Block Label* zero_and_neg, 292444f0eee88ff00398ff7f715fab053374d808c90dSteve Block Label* not_power_of_two) { 292544f0eee88ff00398ff7f715fab053374d808c90dSteve Block sub(scratch, reg, Operand(1), SetCC); 292644f0eee88ff00398ff7f715fab053374d808c90dSteve Block b(mi, zero_and_neg); 292744f0eee88ff00398ff7f715fab053374d808c90dSteve Block tst(scratch, reg); 292844f0eee88ff00398ff7f715fab053374d808c90dSteve Block b(ne, not_power_of_two); 292944f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 293044f0eee88ff00398ff7f715fab053374d808c90dSteve Block 293144f0eee88ff00398ff7f715fab053374d808c90dSteve Block 29323100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescuvoid MacroAssembler::JumpIfNotBothSmi(Register reg1, 29333100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register reg2, 29343100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Label* on_not_both_smi) { 29351e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block STATIC_ASSERT(kSmiTag == 0); 29363100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu tst(reg1, Operand(kSmiTagMask)); 29373100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu tst(reg2, Operand(kSmiTagMask), eq); 29383100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu b(ne, on_not_both_smi); 29393100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu} 29403100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 29413100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 29423100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescuvoid MacroAssembler::JumpIfEitherSmi(Register reg1, 29433100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Register reg2, 29443100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu Label* on_either_smi) { 29451e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block STATIC_ASSERT(kSmiTag == 0); 29463100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu tst(reg1, Operand(kSmiTagMask)); 29473100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu tst(reg2, Operand(kSmiTagMask), ne); 29483100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu b(eq, on_either_smi); 29493100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu} 29503100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 29513100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu 2952756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrickvoid MacroAssembler::AbortIfSmi(Register object) { 29531e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block STATIC_ASSERT(kSmiTag == 0); 2954756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick tst(object, Operand(kSmiTagMask)); 2955756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick Assert(ne, "Operand is a smi"); 2956756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick} 2957756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick 2958756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick 29591e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::AbortIfNotSmi(Register object) { 29601e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block STATIC_ASSERT(kSmiTag == 0); 29611e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block tst(object, Operand(kSmiTagMask)); 29621e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Assert(eq, "Operand is not smi"); 29631e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 29641e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 29651e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 2966e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::AbortIfNotString(Register object) { 2967e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch STATIC_ASSERT(kSmiTag == 0); 2968e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch tst(object, Operand(kSmiTagMask)); 2969e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Assert(ne, "Operand is not a string"); 2970e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch push(object); 2971e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ldr(object, FieldMemOperand(object, HeapObject::kMapOffset)); 2972e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch CompareInstanceType(object, object, FIRST_NONSTRING_TYPE); 2973e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch pop(object); 2974e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Assert(lo, "Operand is not a string"); 2975e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 2976e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 2977e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 2978e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 29791e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::AbortIfNotRootValue(Register src, 29801e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Heap::RootListIndex root_value_index, 29811e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block const char* message) { 2982e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch CompareRoot(src, root_value_index); 29831e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Assert(eq, message); 29841e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 29851e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 29861e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 29871e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::JumpIfNotHeapNumber(Register object, 29881e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Register heap_number_map, 29891e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Register scratch, 29901e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Label* on_not_heap_number) { 29911e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ldr(scratch, FieldMemOperand(object, HeapObject::kMapOffset)); 29921e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block AssertRegisterIsRoot(heap_number_map, Heap::kHeapNumberMapRootIndex); 29931e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block cmp(scratch, heap_number_map); 29941e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block b(ne, on_not_heap_number); 29951e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 29961e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 29971e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 2998d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarkevoid MacroAssembler::JumpIfNonSmisNotBothSequentialAsciiStrings( 2999d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke Register first, 3000d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke Register second, 3001d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke Register scratch1, 3002d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke Register scratch2, 3003d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke Label* failure) { 3004d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke // Test that both first and second are sequential ASCII strings. 3005d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke // Assume that they are non-smis. 3006d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke ldr(scratch1, FieldMemOperand(first, HeapObject::kMapOffset)); 3007d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke ldr(scratch2, FieldMemOperand(second, HeapObject::kMapOffset)); 3008d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke ldrb(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset)); 3009d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke ldrb(scratch2, FieldMemOperand(scratch2, Map::kInstanceTypeOffset)); 30106ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 30116ded16be15dd865a9b21ea304d5273c8be299c87Steve Block JumpIfBothInstanceTypesAreNotSequentialAscii(scratch1, 30126ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch2, 30136ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch1, 30146ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch2, 30156ded16be15dd865a9b21ea304d5273c8be299c87Steve Block failure); 3016d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke} 3017d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke 3018d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarkevoid MacroAssembler::JumpIfNotBothSequentialAsciiStrings(Register first, 3019d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke Register second, 3020d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke Register scratch1, 3021d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke Register scratch2, 3022d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke Label* failure) { 3023d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke // Check that neither is a smi. 30241e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block STATIC_ASSERT(kSmiTag == 0); 3025d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke and_(scratch1, first, Operand(second)); 30263fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch JumpIfSmi(scratch1, failure); 3027d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke JumpIfNonSmisNotBothSequentialAsciiStrings(first, 3028d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke second, 3029d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke scratch1, 3030d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke scratch2, 3031d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke failure); 3032d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke} 3033d91b9f7d46489a9ee00f9cb415630299c76a502bLeon Clarke 3034d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 30356ded16be15dd865a9b21ea304d5273c8be299c87Steve Block// Allocates a heap number or jumps to the need_gc label if the young space 30366ded16be15dd865a9b21ea304d5273c8be299c87Steve Block// is full and a scavenge is needed. 30376ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::AllocateHeapNumber(Register result, 30386ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register scratch1, 30396ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register scratch2, 30409dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen Register heap_number_map, 30416ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Label* gc_required) { 30426ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Allocate an object in the heap for the heap number and tag it as a heap 30436ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // object. 304425f6136652d8341ed047e7fc1a450af5bd218ea9Kristian Monsen AllocateInNewSpace(HeapNumber::kSize, 30456ded16be15dd865a9b21ea304d5273c8be299c87Steve Block result, 30466ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch1, 30476ded16be15dd865a9b21ea304d5273c8be299c87Steve Block scratch2, 30486ded16be15dd865a9b21ea304d5273c8be299c87Steve Block gc_required, 30496ded16be15dd865a9b21ea304d5273c8be299c87Steve Block TAG_OBJECT); 30506ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 30519dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen // Store heap number map in the allocated object. 30529dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen AssertRegisterIsRoot(heap_number_map, Heap::kHeapNumberMapRootIndex); 30539dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen str(heap_number_map, FieldMemOperand(result, HeapObject::kMapOffset)); 30546ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 30556ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 30566ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 30578defd9ff6930b4e24729971a61cf7469daf119beSteve Blockvoid MacroAssembler::AllocateHeapNumberWithValue(Register result, 30588defd9ff6930b4e24729971a61cf7469daf119beSteve Block DwVfpRegister value, 30598defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register scratch1, 30608defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register scratch2, 30618defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register heap_number_map, 30628defd9ff6930b4e24729971a61cf7469daf119beSteve Block Label* gc_required) { 30638defd9ff6930b4e24729971a61cf7469daf119beSteve Block AllocateHeapNumber(result, scratch1, scratch2, heap_number_map, gc_required); 30648defd9ff6930b4e24729971a61cf7469daf119beSteve Block sub(scratch1, result, Operand(kHeapObjectTag)); 30658defd9ff6930b4e24729971a61cf7469daf119beSteve Block vstr(value, scratch1, HeapNumber::kValueOffset); 30668defd9ff6930b4e24729971a61cf7469daf119beSteve Block} 30678defd9ff6930b4e24729971a61cf7469daf119beSteve Block 30688defd9ff6930b4e24729971a61cf7469daf119beSteve Block 3069bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch// Copies a fixed number of fields of heap objects from src to dst. 3070bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdochvoid MacroAssembler::CopyFields(Register dst, 3071bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch Register src, 3072bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch RegList temps, 3073bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch int field_count) { 3074bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch // At least one bit set in the first 15 registers. 3075bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch ASSERT((temps & ((1 << 15) - 1)) != 0); 3076bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch ASSERT((temps & dst.bit()) == 0); 3077bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch ASSERT((temps & src.bit()) == 0); 3078bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch // Primitive implementation using only one temporary register. 3079bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 3080bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch Register tmp = no_reg; 3081bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch // Find a temp register in temps list. 3082bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch for (int i = 0; i < 15; i++) { 3083bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch if ((temps & (1 << i)) != 0) { 3084bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch tmp.set_code(i); 3085bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch break; 3086bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch } 3087bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch } 3088bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch ASSERT(!tmp.is(no_reg)); 3089bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 3090bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch for (int i = 0; i < field_count; i++) { 3091bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch ldr(tmp, FieldMemOperand(src, i * kPointerSize)); 3092bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch str(tmp, FieldMemOperand(dst, i * kPointerSize)); 3093bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch } 3094bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch} 3095bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 3096bb769b257e753aafcbd96767abb2abc645eaa20cBen Murdoch 3097e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdochvoid MacroAssembler::CopyBytes(Register src, 3098e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register dst, 3099e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register length, 3100e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Register scratch) { 3101e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Label align_loop, align_loop_1, word_loop, byte_loop, byte_loop_1, done; 3102e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 3103e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Align src before copying in word size chunks. 3104e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch bind(&align_loop); 3105e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch cmp(length, Operand(0)); 3106e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch b(eq, &done); 3107e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch bind(&align_loop_1); 3108e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch tst(src, Operand(kPointerSize - 1)); 3109e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch b(eq, &word_loop); 3110e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ldrb(scratch, MemOperand(src, 1, PostIndex)); 3111e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch strb(scratch, MemOperand(dst, 1, PostIndex)); 3112e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch sub(length, length, Operand(1), SetCC); 3113e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch b(ne, &byte_loop_1); 3114e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 3115e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Copy bytes in word size chunks. 3116e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch bind(&word_loop); 311744f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 3118e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch tst(src, Operand(kPointerSize - 1)); 3119e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch Assert(eq, "Expecting alignment for CopyBytes"); 3120e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } 3121e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch cmp(length, Operand(kPointerSize)); 3122e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch b(lt, &byte_loop); 3123e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ldr(scratch, MemOperand(src, kPointerSize, PostIndex)); 3124e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch#if CAN_USE_UNALIGNED_ACCESSES 3125e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch str(scratch, MemOperand(dst, kPointerSize, PostIndex)); 3126e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch#else 3127e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch strb(scratch, MemOperand(dst, 1, PostIndex)); 3128e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch mov(scratch, Operand(scratch, LSR, 8)); 3129e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch strb(scratch, MemOperand(dst, 1, PostIndex)); 3130e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch mov(scratch, Operand(scratch, LSR, 8)); 3131e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch strb(scratch, MemOperand(dst, 1, PostIndex)); 3132e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch mov(scratch, Operand(scratch, LSR, 8)); 3133e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch strb(scratch, MemOperand(dst, 1, PostIndex)); 3134e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch#endif 3135e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch sub(length, length, Operand(kPointerSize)); 3136e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch b(&word_loop); 3137e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 3138e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Copy the last bytes if any left. 3139e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch bind(&byte_loop); 3140e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch cmp(length, Operand(0)); 3141e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch b(eq, &done); 3142e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch bind(&byte_loop_1); 3143e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch ldrb(scratch, MemOperand(src, 1, PostIndex)); 3144e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch strb(scratch, MemOperand(dst, 1, PostIndex)); 3145e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch sub(length, length, Operand(1), SetCC); 3146e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch b(ne, &byte_loop_1); 3147e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch bind(&done); 3148e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch} 3149e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 3150e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 3151592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::InitializeFieldsWithFiller(Register start_offset, 3152592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register end_offset, 3153592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register filler) { 3154592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label loop, entry; 3155592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(&entry); 3156592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&loop); 3157592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch str(filler, MemOperand(start_offset, kPointerSize, PostIndex)); 3158592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&entry); 3159592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch cmp(start_offset, end_offset); 3160592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(lt, &loop); 3161592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 3162592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3163592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 31648defd9ff6930b4e24729971a61cf7469daf119beSteve Blockvoid MacroAssembler::CountLeadingZeros(Register zeros, // Answer. 31658defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register source, // Input. 31668defd9ff6930b4e24729971a61cf7469daf119beSteve Block Register scratch) { 31671e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ASSERT(!zeros.is(source) || !source.is(scratch)); 31688defd9ff6930b4e24729971a61cf7469daf119beSteve Block ASSERT(!zeros.is(scratch)); 31698defd9ff6930b4e24729971a61cf7469daf119beSteve Block ASSERT(!scratch.is(ip)); 31708defd9ff6930b4e24729971a61cf7469daf119beSteve Block ASSERT(!source.is(ip)); 31718defd9ff6930b4e24729971a61cf7469daf119beSteve Block ASSERT(!zeros.is(ip)); 31726ded16be15dd865a9b21ea304d5273c8be299c87Steve Block#ifdef CAN_USE_ARMV5_INSTRUCTIONS 31736ded16be15dd865a9b21ea304d5273c8be299c87Steve Block clz(zeros, source); // This instruction is only supported after ARM5. 31746ded16be15dd865a9b21ea304d5273c8be299c87Steve Block#else 3175592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Order of the next two lines is important: zeros register 3176592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // can be the same as source register. 31778defd9ff6930b4e24729971a61cf7469daf119beSteve Block Move(scratch, source); 3178592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(zeros, Operand(0, RelocInfo::NONE)); 31796ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Top 16. 31806ded16be15dd865a9b21ea304d5273c8be299c87Steve Block tst(scratch, Operand(0xffff0000)); 31816ded16be15dd865a9b21ea304d5273c8be299c87Steve Block add(zeros, zeros, Operand(16), LeaveCC, eq); 31826ded16be15dd865a9b21ea304d5273c8be299c87Steve Block mov(scratch, Operand(scratch, LSL, 16), LeaveCC, eq); 31836ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Top 8. 31846ded16be15dd865a9b21ea304d5273c8be299c87Steve Block tst(scratch, Operand(0xff000000)); 31856ded16be15dd865a9b21ea304d5273c8be299c87Steve Block add(zeros, zeros, Operand(8), LeaveCC, eq); 31866ded16be15dd865a9b21ea304d5273c8be299c87Steve Block mov(scratch, Operand(scratch, LSL, 8), LeaveCC, eq); 31876ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Top 4. 31886ded16be15dd865a9b21ea304d5273c8be299c87Steve Block tst(scratch, Operand(0xf0000000)); 31896ded16be15dd865a9b21ea304d5273c8be299c87Steve Block add(zeros, zeros, Operand(4), LeaveCC, eq); 31906ded16be15dd865a9b21ea304d5273c8be299c87Steve Block mov(scratch, Operand(scratch, LSL, 4), LeaveCC, eq); 31916ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Top 2. 31926ded16be15dd865a9b21ea304d5273c8be299c87Steve Block tst(scratch, Operand(0xc0000000)); 31936ded16be15dd865a9b21ea304d5273c8be299c87Steve Block add(zeros, zeros, Operand(2), LeaveCC, eq); 31946ded16be15dd865a9b21ea304d5273c8be299c87Steve Block mov(scratch, Operand(scratch, LSL, 2), LeaveCC, eq); 31956ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Top bit. 31966ded16be15dd865a9b21ea304d5273c8be299c87Steve Block tst(scratch, Operand(0x80000000u)); 31976ded16be15dd865a9b21ea304d5273c8be299c87Steve Block add(zeros, zeros, Operand(1), LeaveCC, eq); 31986ded16be15dd865a9b21ea304d5273c8be299c87Steve Block#endif 31996ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 32006ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 32016ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 32026ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::JumpIfBothInstanceTypesAreNotSequentialAscii( 32036ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register first, 32046ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register second, 32056ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register scratch1, 32066ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register scratch2, 32076ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Label* failure) { 32086ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int kFlatAsciiStringMask = 32096ded16be15dd865a9b21ea304d5273c8be299c87Steve Block kIsNotStringMask | kStringEncodingMask | kStringRepresentationMask; 32106ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int kFlatAsciiStringTag = ASCII_STRING_TYPE; 32116ded16be15dd865a9b21ea304d5273c8be299c87Steve Block and_(scratch1, first, Operand(kFlatAsciiStringMask)); 32126ded16be15dd865a9b21ea304d5273c8be299c87Steve Block and_(scratch2, second, Operand(kFlatAsciiStringMask)); 32136ded16be15dd865a9b21ea304d5273c8be299c87Steve Block cmp(scratch1, Operand(kFlatAsciiStringTag)); 32146ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Ignore second test if first test failed. 32156ded16be15dd865a9b21ea304d5273c8be299c87Steve Block cmp(scratch2, Operand(kFlatAsciiStringTag), eq); 32166ded16be15dd865a9b21ea304d5273c8be299c87Steve Block b(ne, failure); 32176ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 32186ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 32196ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 32206ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::JumpIfInstanceTypeIsNotSequentialAscii(Register type, 32216ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Register scratch, 32226ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Label* failure) { 32236ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int kFlatAsciiStringMask = 32246ded16be15dd865a9b21ea304d5273c8be299c87Steve Block kIsNotStringMask | kStringEncodingMask | kStringRepresentationMask; 32256ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int kFlatAsciiStringTag = ASCII_STRING_TYPE; 32266ded16be15dd865a9b21ea304d5273c8be299c87Steve Block and_(scratch, type, Operand(kFlatAsciiStringMask)); 32276ded16be15dd865a9b21ea304d5273c8be299c87Steve Block cmp(scratch, Operand(kFlatAsciiStringTag)); 32286ded16be15dd865a9b21ea304d5273c8be299c87Steve Block b(ne, failure); 32296ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 32306ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 323144f0eee88ff00398ff7f715fab053374d808c90dSteve Blockstatic const int kRegisterPassedArguments = 4; 32326ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 323344f0eee88ff00398ff7f715fab053374d808c90dSteve Block 3234257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochint MacroAssembler::CalculateStackPassedWords(int num_reg_arguments, 3235257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int num_double_arguments) { 3236257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int stack_passed_words = 0; 3237257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (use_eabi_hardfloat()) { 3238257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch // In the hard floating point calling convention, we can use 3239257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch // all double registers to pass doubles. 3240257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (num_double_arguments > DoubleRegister::kNumRegisters) { 3241257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch stack_passed_words += 3242257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 2 * (num_double_arguments - DoubleRegister::kNumRegisters); 3243257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } 3244257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } else { 3245257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch // In the soft floating point calling convention, every double 3246257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch // argument is passed using two registers. 3247257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch num_reg_arguments += 2 * num_double_arguments; 3248257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } 32496ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Up to four simple arguments are passed in registers r0..r3. 3250257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (num_reg_arguments > kRegisterPassedArguments) { 3251257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch stack_passed_words += num_reg_arguments - kRegisterPassedArguments; 3252257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } 3253257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch return stack_passed_words; 3254257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 3255257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3256257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3257257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::PrepareCallCFunction(int num_reg_arguments, 3258257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int num_double_arguments, 3259257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Register scratch) { 3260257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int frame_alignment = ActivationFrameAlignment(); 3261257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int stack_passed_arguments = CalculateStackPassedWords( 3262257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch num_reg_arguments, num_double_arguments); 32636ded16be15dd865a9b21ea304d5273c8be299c87Steve Block if (frame_alignment > kPointerSize) { 32646ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Make stack end at alignment and make room for num_arguments - 4 words 32656ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // and the original value of sp. 32666ded16be15dd865a9b21ea304d5273c8be299c87Steve Block mov(scratch, sp); 32676ded16be15dd865a9b21ea304d5273c8be299c87Steve Block sub(sp, sp, Operand((stack_passed_arguments + 1) * kPointerSize)); 32686ded16be15dd865a9b21ea304d5273c8be299c87Steve Block ASSERT(IsPowerOf2(frame_alignment)); 32696ded16be15dd865a9b21ea304d5273c8be299c87Steve Block and_(sp, sp, Operand(-frame_alignment)); 32706ded16be15dd865a9b21ea304d5273c8be299c87Steve Block str(scratch, MemOperand(sp, stack_passed_arguments * kPointerSize)); 32716ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } else { 32726ded16be15dd865a9b21ea304d5273c8be299c87Steve Block sub(sp, sp, Operand(stack_passed_arguments * kPointerSize)); 32736ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 32746ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 32756ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 32766ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 3277257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::PrepareCallCFunction(int num_reg_arguments, 3278257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Register scratch) { 3279257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch PrepareCallCFunction(num_reg_arguments, 0, scratch); 3280257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 3281257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3282257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3283257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::SetCallCDoubleArguments(DoubleRegister dreg) { 3284257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (use_eabi_hardfloat()) { 3285257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Move(d0, dreg); 3286257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } else { 3287257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch vmov(r0, r1, dreg); 3288257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } 3289257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 3290257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3291257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3292257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::SetCallCDoubleArguments(DoubleRegister dreg1, 3293257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch DoubleRegister dreg2) { 3294257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (use_eabi_hardfloat()) { 3295257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (dreg2.is(d0)) { 3296257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch ASSERT(!dreg1.is(d1)); 3297257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Move(d1, dreg2); 3298257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Move(d0, dreg1); 3299257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } else { 3300257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Move(d0, dreg1); 3301257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Move(d1, dreg2); 3302257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } 3303257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } else { 3304257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch vmov(r0, r1, dreg1); 3305257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch vmov(r2, r3, dreg2); 3306257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } 3307257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 3308257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3309257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3310257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::SetCallCDoubleArguments(DoubleRegister dreg, 3311257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Register reg) { 3312257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (use_eabi_hardfloat()) { 3313257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Move(d0, dreg); 3314257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Move(r0, reg); 3315257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } else { 3316257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Move(r2, reg); 3317257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch vmov(r0, r1, dreg); 3318257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch } 3319257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 3320257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3321257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 33226ded16be15dd865a9b21ea304d5273c8be299c87Steve Blockvoid MacroAssembler::CallCFunction(ExternalReference function, 3323257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int num_reg_arguments, 3324257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int num_double_arguments) { 3325592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(ip, Operand(function)); 3326592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CallCFunctionHelper(ip, num_reg_arguments, num_double_arguments); 33276ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 33286ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 3329257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 333044f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::CallCFunction(Register function, 3331592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch int num_reg_arguments, 3332592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch int num_double_arguments) { 3333592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CallCFunctionHelper(function, num_reg_arguments, num_double_arguments); 3334257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 3335257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3336257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3337257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::CallCFunction(ExternalReference function, 3338257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int num_arguments) { 3339257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch CallCFunction(function, num_arguments, 0); 3340257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 3341257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3342257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3343257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::CallCFunction(Register function, 3344257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int num_arguments) { 3345592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CallCFunction(function, num_arguments, 0); 334644f0eee88ff00398ff7f715fab053374d808c90dSteve Block} 334744f0eee88ff00398ff7f715fab053374d808c90dSteve Block 334844f0eee88ff00398ff7f715fab053374d808c90dSteve Block 334944f0eee88ff00398ff7f715fab053374d808c90dSteve Blockvoid MacroAssembler::CallCFunctionHelper(Register function, 3350257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int num_reg_arguments, 3351257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int num_double_arguments) { 3352592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(has_frame()); 33536ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Make sure that the stack is aligned before calling a C function unless 33546ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // running in the simulator. The simulator has its own alignment check which 33556ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // provides more information. 33566ded16be15dd865a9b21ea304d5273c8be299c87Steve Block#if defined(V8_HOST_ARCH_ARM) 335744f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 33586ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int frame_alignment = OS::ActivationFrameAlignment(); 33596ded16be15dd865a9b21ea304d5273c8be299c87Steve Block int frame_alignment_mask = frame_alignment - 1; 33606ded16be15dd865a9b21ea304d5273c8be299c87Steve Block if (frame_alignment > kPointerSize) { 33616ded16be15dd865a9b21ea304d5273c8be299c87Steve Block ASSERT(IsPowerOf2(frame_alignment)); 33626ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Label alignment_as_expected; 33636ded16be15dd865a9b21ea304d5273c8be299c87Steve Block tst(sp, Operand(frame_alignment_mask)); 33646ded16be15dd865a9b21ea304d5273c8be299c87Steve Block b(eq, &alignment_as_expected); 33656ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Don't use Check here, as it will call Runtime_Abort possibly 33666ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // re-entering here. 33676ded16be15dd865a9b21ea304d5273c8be299c87Steve Block stop("Unexpected alignment"); 33686ded16be15dd865a9b21ea304d5273c8be299c87Steve Block bind(&alignment_as_expected); 33696ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 33706ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 33716ded16be15dd865a9b21ea304d5273c8be299c87Steve Block#endif 33726ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 33736ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Just call directly. The function called cannot cause a GC, or 33746ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // allow preemption, so the return address in the link register 33756ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // stays correct. 33766ded16be15dd865a9b21ea304d5273c8be299c87Steve Block Call(function); 3377257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int stack_passed_arguments = CalculateStackPassedWords( 3378257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch num_reg_arguments, num_double_arguments); 3379257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch if (ActivationFrameAlignment() > kPointerSize) { 33806ded16be15dd865a9b21ea304d5273c8be299c87Steve Block ldr(sp, MemOperand(sp, stack_passed_arguments * kPointerSize)); 33816ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } else { 33826ded16be15dd865a9b21ea304d5273c8be299c87Steve Block add(sp, sp, Operand(stack_passed_arguments * sizeof(kPointerSize))); 33836ded16be15dd865a9b21ea304d5273c8be299c87Steve Block } 33846ded16be15dd865a9b21ea304d5273c8be299c87Steve Block} 33856ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 33866ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 33871e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid MacroAssembler::GetRelocatedValueLocation(Register ldr_location, 33881e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Register result) { 33891e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block const uint32_t kLdrOffsetMask = (1 << 12) - 1; 33901e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block const int32_t kPCRegOffset = 2 * kPointerSize; 33911e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ldr(result, MemOperand(ldr_location)); 339244f0eee88ff00398ff7f715fab053374d808c90dSteve Block if (emit_debug_code()) { 33931e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Check that the instruction is a ldr reg, [pc + offset] . 33941e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block and_(result, result, Operand(kLdrPCPattern)); 33951e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block cmp(result, Operand(kLdrPCPattern)); 33961e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Check(eq, "The instruction to patch should be a load from pc."); 33971e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Result was clobbered. Restore it. 33981e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block ldr(result, MemOperand(ldr_location)); 33991e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block } 34001e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // Get the address of the constant. 34011e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block and_(result, result, Operand(kLdrOffsetMask)); 34021e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block add(result, ldr_location, Operand(result)); 34031e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block add(result, result, Operand(kPCRegOffset)); 34041e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 34051e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 34061e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 3407592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::CheckPageFlag( 3408592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register object, 3409592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register scratch, 3410592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch int mask, 3411592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Condition cc, 3412592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label* condition_met) { 3413592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch and_(scratch, object, Operand(~Page::kPageAlignmentMask)); 3414592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(scratch, MemOperand(scratch, MemoryChunk::kFlagsOffset)); 3415592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(scratch, Operand(mask)); 3416592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(cc, condition_met); 3417592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 3418592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3419592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3420592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::JumpIfBlack(Register object, 3421592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register scratch0, 3422592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register scratch1, 3423592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label* on_black) { 3424592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch HasColor(object, scratch0, scratch1, on_black, 1, 0); // kBlackBitPattern. 3425592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0); 3426592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 3427592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3428592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3429592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::HasColor(Register object, 3430592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register bitmap_scratch, 3431592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register mask_scratch, 3432592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label* has_color, 3433592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch int first_bit, 3434592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch int second_bit) { 3435592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(!AreAliased(object, bitmap_scratch, mask_scratch, no_reg)); 3436592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3437592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch GetMarkBits(object, bitmap_scratch, mask_scratch); 3438592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3439592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label other_color, word_boundary; 3440592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(ip, MemOperand(bitmap_scratch, MemoryChunk::kHeaderSize)); 3441592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(ip, Operand(mask_scratch)); 3442592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(first_bit == 1 ? eq : ne, &other_color); 3443592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Shift left 1 by adding. 3444592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch add(mask_scratch, mask_scratch, Operand(mask_scratch), SetCC); 3445592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(eq, &word_boundary); 3446592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(ip, Operand(mask_scratch)); 3447592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(second_bit == 1 ? ne : eq, has_color); 3448592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch jmp(&other_color); 3449592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3450592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&word_boundary); 3451592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(ip, MemOperand(bitmap_scratch, MemoryChunk::kHeaderSize + kPointerSize)); 3452592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(ip, Operand(1)); 3453592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(second_bit == 1 ? ne : eq, has_color); 3454592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&other_color); 3455592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 3456592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3457592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3458592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch// Detect some, but not all, common pointer-free objects. This is used by the 3459592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch// incremental write barrier which doesn't care about oddballs (they are always 3460592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch// marked black immediately so this code is not hit). 3461592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::JumpIfDataObject(Register value, 3462592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register scratch, 3463592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label* not_data_object) { 3464592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label is_data_object; 3465592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(scratch, FieldMemOperand(value, HeapObject::kMapOffset)); 3466592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CompareRoot(scratch, Heap::kHeapNumberMapRootIndex); 3467592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(eq, &is_data_object); 3468592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(kIsIndirectStringTag == 1 && kIsIndirectStringMask == 1); 3469592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(kNotStringTag == 0x80 && kIsNotStringMask == 0x80); 3470592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // If it's a string and it's not a cons string then it's an object containing 3471592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // no GC pointers. 3472592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldrb(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset)); 3473592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(scratch, Operand(kIsIndirectStringMask | kIsNotStringMask)); 3474592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(ne, not_data_object); 3475592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&is_data_object); 3476592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 3477592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3478592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3479592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::GetMarkBits(Register addr_reg, 3480592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register bitmap_reg, 3481592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register mask_reg) { 3482592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(!AreAliased(addr_reg, bitmap_reg, mask_reg, no_reg)); 3483592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch and_(bitmap_reg, addr_reg, Operand(~Page::kPageAlignmentMask)); 3484592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Ubfx(mask_reg, addr_reg, kPointerSizeLog2, Bitmap::kBitsPerCellLog2); 3485592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch const int kLowBits = kPointerSizeLog2 + Bitmap::kBitsPerCellLog2; 3486592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Ubfx(ip, addr_reg, kLowBits, kPageSizeBits - kLowBits); 3487592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch add(bitmap_reg, bitmap_reg, Operand(ip, LSL, kPointerSizeLog2)); 3488592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(ip, Operand(1)); 3489592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(mask_reg, Operand(ip, LSL, mask_reg)); 3490592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 3491592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3492592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3493592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochvoid MacroAssembler::EnsureNotWhite( 3494592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register value, 3495592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register bitmap_scratch, 3496592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register mask_scratch, 3497592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register load_scratch, 3498592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label* value_is_white_and_not_data) { 3499592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(!AreAliased(value, bitmap_scratch, mask_scratch, ip)); 3500592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch GetMarkBits(value, bitmap_scratch, mask_scratch); 3501592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3502592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // If the value is black or grey we don't need to do anything. 3503592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(strcmp(Marking::kWhiteBitPattern, "00") == 0); 3504592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0); 3505592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(strcmp(Marking::kGreyBitPattern, "11") == 0); 3506592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(strcmp(Marking::kImpossibleBitPattern, "01") == 0); 3507592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3508592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label done; 3509592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3510592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Since both black and grey have a 1 in the first position and white does 3511592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // not have a 1 there we only need to check one bit. 3512592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(load_scratch, MemOperand(bitmap_scratch, MemoryChunk::kHeaderSize)); 3513592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(mask_scratch, load_scratch); 3514592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(ne, &done); 3515592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3516c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9Ben Murdoch if (emit_debug_code()) { 3517592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Check for impossible bit pattern. 3518592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label ok; 3519592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // LSL may overflow, making the check conservative. 3520592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(load_scratch, Operand(mask_scratch, LSL, 1)); 3521592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(eq, &ok); 3522592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch stop("Impossible marking bit pattern"); 3523592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&ok); 3524592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch } 3525592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3526592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Value is white. We check whether it is data that doesn't need scanning. 3527592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Currently only checks for HeapNumber and non-cons strings. 3528592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register map = load_scratch; // Holds map while checking type. 3529592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register length = load_scratch; // Holds length of object after testing type. 3530592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Label is_data_object; 3531592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3532592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Check for heap-number 3533592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(map, FieldMemOperand(value, HeapObject::kMapOffset)); 3534592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch CompareRoot(map, Heap::kHeapNumberMapRootIndex); 3535592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(length, Operand(HeapNumber::kSize), LeaveCC, eq); 3536592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(eq, &is_data_object); 3537592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3538592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Check for strings. 3539592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(kIsIndirectStringTag == 1 && kIsIndirectStringMask == 1); 3540592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(kNotStringTag == 0x80 && kIsNotStringMask == 0x80); 3541592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // If it's a string and it's not a cons string then it's an object containing 3542592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // no GC pointers. 3543592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch Register instance_type = load_scratch; 3544592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldrb(instance_type, FieldMemOperand(map, Map::kInstanceTypeOffset)); 3545592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(instance_type, Operand(kIsIndirectStringMask | kIsNotStringMask)); 3546592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(ne, value_is_white_and_not_data); 3547592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // It's a non-indirect (non-cons and non-slice) string. 3548592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // If it's external, the length is just ExternalString::kSize. 3549592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Otherwise it's String::kHeaderSize + string->length() * (1 or 2). 3550592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // External strings are the only ones with the kExternalStringTag bit 3551592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // set. 3552592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT_EQ(0, kSeqStringTag & kExternalStringTag); 3553592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT_EQ(0, kConsStringTag & kExternalStringTag); 3554592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(instance_type, Operand(kExternalStringTag)); 3555592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(length, Operand(ExternalString::kSize), LeaveCC, ne); 3556592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch b(ne, &is_data_object); 3557592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3558592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Sequential string, either ASCII or UC16. 3559592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // For ASCII (char-size of 1) we shift the smi tag away to get the length. 3560592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // For UC16 (char-size of 2) we just leave the smi tag in place, thereby 3561592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // getting the length multiplied by 2. 3562592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(kAsciiStringTag == 4 && kStringEncodingMask == 4); 3563592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ASSERT(kSmiTag == 0 && kSmiTagSize == 1); 3564592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(ip, FieldMemOperand(value, String::kLengthOffset)); 3565592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch tst(instance_type, Operand(kStringEncodingMask)); 3566592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch mov(ip, Operand(ip, LSR, 1), LeaveCC, ne); 3567592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch add(length, ip, Operand(SeqString::kHeaderSize + kObjectAlignmentMask)); 3568592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch and_(length, length, Operand(~kObjectAlignmentMask)); 3569592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3570592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&is_data_object); 3571592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // Value is a data object, and it is white. Mark it black. Since we know 3572592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch // that the object is white we can make it black by flipping one bit. 3573592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(ip, MemOperand(bitmap_scratch, MemoryChunk::kHeaderSize)); 3574592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch orr(ip, ip, Operand(mask_scratch)); 3575592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch str(ip, MemOperand(bitmap_scratch, MemoryChunk::kHeaderSize)); 3576592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3577592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch and_(bitmap_scratch, bitmap_scratch, Operand(~Page::kPageAlignmentMask)); 3578592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch ldr(ip, MemOperand(bitmap_scratch, MemoryChunk::kLiveBytesOffset)); 3579592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch add(ip, ip, Operand(length)); 3580592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch str(ip, MemOperand(bitmap_scratch, MemoryChunk::kLiveBytesOffset)); 3581592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3582592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch bind(&done); 3583592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 3584592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3585592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3586257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::ClampUint8(Register output_reg, Register input_reg) { 3587257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Usat(output_reg, 8, Operand(input_reg)); 3588257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 3589257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3590257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3591257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::ClampDoubleToUint8(Register result_reg, 3592257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch DoubleRegister input_reg, 3593257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch DoubleRegister temp_double_reg) { 3594257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Label above_zero; 3595257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Label done; 3596257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Label in_bounds; 3597257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 35983fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Vmov(temp_double_reg, 0.0); 3599257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch VFPCompareAndSetFlags(input_reg, temp_double_reg); 3600257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch b(gt, &above_zero); 3601257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3602257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch // Double value is less than zero, NaN or Inf, return 0. 3603257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch mov(result_reg, Operand(0)); 3604257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch b(al, &done); 3605257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3606257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch // Double value is >= 255, return 255. 3607257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch bind(&above_zero); 36083fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Vmov(temp_double_reg, 255.0); 3609257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch VFPCompareAndSetFlags(input_reg, temp_double_reg); 3610257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch b(le, &in_bounds); 3611257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch mov(result_reg, Operand(255)); 3612257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch b(al, &done); 3613257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3614257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch // In 0-255 range, round and truncate. 3615257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch bind(&in_bounds); 36163fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch Vmov(temp_double_reg, 0.5); 3617257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch vadd(temp_double_reg, input_reg, temp_double_reg); 3618257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch vcvt_u32_f64(s0, temp_double_reg); 3619257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch vmov(result_reg, s0); 3620257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch bind(&done); 3621257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 3622257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3623257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3624257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdochvoid MacroAssembler::LoadInstanceDescriptors(Register map, 3625257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Register descriptors) { 3626257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch ldr(descriptors, 3627257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch FieldMemOperand(map, Map::kInstanceDescriptorsOrBitField3Offset)); 3628257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Label not_smi; 3629257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch JumpIfNotSmi(descriptors, ¬_smi); 3630257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch mov(descriptors, Operand(FACTORY->empty_descriptor_array())); 3631257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch bind(¬_smi); 3632257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch} 3633257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3634257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch 3635592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdochbool AreAliased(Register r1, Register r2, Register r3, Register r4) { 3636592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (r1.is(r2)) return true; 3637592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (r1.is(r3)) return true; 3638592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (r1.is(r4)) return true; 3639592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (r2.is(r3)) return true; 3640592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (r2.is(r4)) return true; 3641592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch if (r3.is(r4)) return true; 3642592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch return false; 3643592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch} 3644592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3645592a9fc1d8ea420377a2e7efd0600e20b058be2bBen Murdoch 3646a7e24c173cf37484693b9abb38e494fa7bd7baebSteve BlockCodePatcher::CodePatcher(byte* address, int instructions) 3647a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block : address_(address), 3648a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block instructions_(instructions), 3649a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block size_(instructions * Assembler::kInstrSize), 36508b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch masm_(Isolate::Current(), address, size_ + Assembler::kGap) { 3651a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Create a new macro assembler pointing to the address of the code to patch. 3652a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // The size is adjusted with kGap on order for the assembler to generate size 3653a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // bytes of instructions without failing with buffer size constraints. 3654a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap); 3655a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 3656a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 3657a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 3658a7e24c173cf37484693b9abb38e494fa7bd7baebSteve BlockCodePatcher::~CodePatcher() { 3659a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Indicate that code has changed. 3660a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CPU::FlushICache(address_, size_); 3661a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 3662a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check that the code was patched as expected. 3663a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(masm_.pc_ == address_ + size_); 3664a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap); 3665a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 3666a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 3667a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 36681e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid CodePatcher::Emit(Instr instr) { 36691e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block masm()->emit(instr); 3670a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 3671a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 3672a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 3673a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockvoid CodePatcher::Emit(Address addr) { 3674a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block masm()->emit(reinterpret_cast<Instr>(addr)); 3675a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 36761e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 36771e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 36781e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockvoid CodePatcher::EmitCondition(Condition cond) { 36791e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block Instr instr = Assembler::instr_at(masm_.pc_); 36801e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block instr = (instr & ~kCondMask) | cond; 36811e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block masm_.emit(instr); 36821e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 3683a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 3684a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 3685a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} } // namespace v8::internal 3686f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke 3687f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke#endif // V8_TARGET_ARCH_ARM 3688