1a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// Copyright (c) 1994-2006 Sun Microsystems Inc. 2a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// All Rights Reserved. 3a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 4a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// Redistribution and use in source and binary forms, with or without 5a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// modification, are permitted provided that the following conditions are 6a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// met: 7a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 8a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// - Redistributions of source code must retain the above copyright notice, 9a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// this list of conditions and the following disclaimer. 10a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 11a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// - Redistribution in binary form must reproduce the above copyright 12a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// notice, this list of conditions and the following disclaimer in the 13a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// documentation and/or other materials provided with the distribution. 14a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 15a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// - Neither the name of Sun Microsystems or the names of contributors may 16a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// be used to endorse or promote products derived from this software without 17a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// specific prior written permission. 18a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 19a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 20a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 21a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 23a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 24a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 25a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 26a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 27a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 28a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 29a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 31a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// The original source code covered by the above license above has been 32a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// modified significantly by Google Inc. 331e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block// Copyright 2011 the V8 project authors. All rights reserved. 34a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 35a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// A light-weight IA32 Assembler. 36a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 37a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifndef V8_IA32_ASSEMBLER_IA32_H_ 38a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#define V8_IA32_ASSEMBLER_IA32_H_ 39a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 40b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#include "src/isolate.h" 41b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#include "src/serialize.h" 42d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 43a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blocknamespace v8 { 44a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blocknamespace internal { 45a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 46a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// CPU Registers. 47a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 48a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 1) We would prefer to use an enum, but enum values are assignment- 49a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// compatible with int, which has caused code-generation bugs. 50a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 51a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 2) We would prefer to use a class instead of a struct but we don't like 52a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// the register initialization to depend on the particular initialization 53a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// order (which appears to be different on OS X, Linux, and Windows for the 54a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// installed versions of C++ we tried). Using a struct permits C-style 55a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// "initialization". Also, the Register objects cannot be const as this 56a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// forces initialization stubs in MSVC, making us dependent on initialization 57a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// order. 58a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 59a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 3) By not using an enum, we are possibly preventing the compiler from 60a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// doing certain constant folds, which may significantly reduce the 61a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// code generated for some assembly instructions (because they boil down 62a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// to a few constants). If this is a problem, we could change the code 63a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// such that we use an enum in optimized mode, and the struct in debug 64a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// mode. This way we get the compile-time error checking in debug mode 65a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// and best performance in optimized code. 66a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 67a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockstruct Register { 68b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static const int kMaxNumAllocatableRegisters = 6; 69b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static int NumAllocatableRegisters() { 70b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return kMaxNumAllocatableRegisters; 71b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 72b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch static const int kNumRegisters = 8; 73b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 741e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block static inline const char* AllocationIndexToString(int index); 75b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 761e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block static inline int ToAllocationIndex(Register reg); 77b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 781e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block static inline Register FromAllocationIndex(int index); 79b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 80b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch static Register from_code(int code) { 81b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(code >= 0); 82b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(code < kNumRegisters); 83b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch Register r = { code }; 84b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch return r; 85b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch } 86b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch bool is_valid() const { return 0 <= code_ && code_ < kNumRegisters; } 870d5e116f6aee03185f237311a943491bb079a768Kristian Monsen bool is(Register reg) const { return code_ == reg.code_; } 88a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // eax, ebx, ecx and edx are byte registers, the rest are not. 890d5e116f6aee03185f237311a943491bb079a768Kristian Monsen bool is_byte_register() const { return code_ <= 3; } 900d5e116f6aee03185f237311a943491bb079a768Kristian Monsen int code() const { 91b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(is_valid()); 92a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return code_; 93a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 940d5e116f6aee03185f237311a943491bb079a768Kristian Monsen int bit() const { 95b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(is_valid()); 96a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return 1 << code_; 97a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 98a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 993100271588b61cbc1dc472a3f2f105d2eed8497fAndrei Popescu // Unfortunately we can't make this private in a struct. 100a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int code_; 101a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block}; 102a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1033ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst int kRegister_eax_Code = 0; 1043ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst int kRegister_ecx_Code = 1; 1053ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst int kRegister_edx_Code = 2; 1063ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst int kRegister_ebx_Code = 3; 1073ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst int kRegister_esp_Code = 4; 1083ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst int kRegister_ebp_Code = 5; 1093ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst int kRegister_esi_Code = 6; 1103ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst int kRegister_edi_Code = 7; 1113ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst int kRegister_no_reg_Code = -1; 1123ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch 1133ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst Register eax = { kRegister_eax_Code }; 1143ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst Register ecx = { kRegister_ecx_Code }; 1153ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst Register edx = { kRegister_edx_Code }; 1163ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst Register ebx = { kRegister_ebx_Code }; 1173ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst Register esp = { kRegister_esp_Code }; 1183ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst Register ebp = { kRegister_ebp_Code }; 1193ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst Register esi = { kRegister_esi_Code }; 1203ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst Register edi = { kRegister_edi_Code }; 1213ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdochconst Register no_reg = { kRegister_no_reg_Code }; 122a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 123a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1241e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockinline const char* Register::AllocationIndexToString(int index) { 125b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(index >= 0 && index < kMaxNumAllocatableRegisters); 1261e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block // This is the mapping of allocation indices to registers. 1271e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block const char* const kNames[] = { "eax", "ecx", "edx", "ebx", "esi", "edi" }; 1281e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block return kNames[index]; 1291e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 1301e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 1311e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 1321e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockinline int Register::ToAllocationIndex(Register reg) { 133b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(reg.is_valid() && !reg.is(esp) && !reg.is(ebp)); 1341e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block return (reg.code() >= 6) ? reg.code() - 2 : reg.code(); 1351e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 1361e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 1371e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 1381e0659c275bb392c045087af4f6b0d7565cb3d77Steve Blockinline Register Register::FromAllocationIndex(int index) { 139b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(index >= 0 && index < kMaxNumAllocatableRegisters); 1401e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block return (index >= 4) ? from_code(index + 2) : from_code(index); 1411e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block} 1421e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 1431e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block 144a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockstruct XMMRegister { 145b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static const int kMaxNumAllocatableRegisters = 7; 146b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static const int kMaxNumRegisters = 8; 147b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static int NumAllocatableRegisters() { 148b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return kMaxNumAllocatableRegisters; 149b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 150b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 151b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch static int ToAllocationIndex(XMMRegister reg) { 152b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(reg.code() != 0); 153b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch return reg.code() - 1; 154b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch } 155b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 156b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch static XMMRegister FromAllocationIndex(int index) { 157b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(index >= 0 && index < kMaxNumAllocatableRegisters); 158b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch return from_code(index + 1); 159b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch } 160b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 161b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static XMMRegister from_code(int code) { 162b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch XMMRegister result = { code }; 163b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return result; 164b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 165b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 166b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool is_valid() const { 167b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return 0 <= code_ && code_ < kMaxNumRegisters; 168b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 169b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 170b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch int code() const { 171b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(is_valid()); 172b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return code_; 173b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 174b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 175b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool is(XMMRegister reg) const { return code_ == reg.code_; } 176b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 177b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch static const char* AllocationIndexToString(int index) { 178b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(index >= 0 && index < kMaxNumAllocatableRegisters); 179b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch const char* const names[] = { 180b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch "xmm1", 181b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch "xmm2", 182b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch "xmm3", 183b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch "xmm4", 184b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch "xmm5", 185b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch "xmm6", 186b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch "xmm7" 187b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch }; 188b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch return names[index]; 189b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch } 190b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 191a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int code_; 192a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block}; 193a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 194b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 195b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtypedef XMMRegister DoubleRegister; 196b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 197b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 198a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockconst XMMRegister xmm0 = { 0 }; 199a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockconst XMMRegister xmm1 = { 1 }; 200a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockconst XMMRegister xmm2 = { 2 }; 201a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockconst XMMRegister xmm3 = { 3 }; 202a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockconst XMMRegister xmm4 = { 4 }; 203a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockconst XMMRegister xmm5 = { 5 }; 204a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockconst XMMRegister xmm6 = { 6 }; 205a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockconst XMMRegister xmm7 = { 7 }; 206b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochconst XMMRegister no_xmm_reg = { -1 }; 207b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 208b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 209a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockenum Condition { 210a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // any value < 0 is considered no_condition 211a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block no_condition = -1, 212a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 213a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block overflow = 0, 214a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block no_overflow = 1, 215a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block below = 2, 216a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block above_equal = 3, 217a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block equal = 4, 218a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block not_equal = 5, 219a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block below_equal = 6, 220a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block above = 7, 221a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block negative = 8, 222a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block positive = 9, 223a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block parity_even = 10, 224a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block parity_odd = 11, 225a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block less = 12, 226a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block greater_equal = 13, 227a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block less_equal = 14, 228a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block greater = 15, 229a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 230a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // aliases 231a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block carry = below, 232a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block not_carry = above_equal, 233a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block zero = equal, 234a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block not_zero = not_equal, 235a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block sign = negative, 236a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block not_sign = positive 237a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block}; 238a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 239a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 240a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// Returns the equivalent of !cc. 241a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// Negation of the default no_condition (-1) results in a non-default 242a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// no_condition value (-2). As long as tests for no_condition check 243a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// for condition < 0, this will work as expected. 2449dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monseninline Condition NegateCondition(Condition cc) { 2459dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen return static_cast<Condition>(cc ^ 1); 2469dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen} 2479dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 248a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 249b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Commute a condition such that {a cond b == b cond' a}. 250b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochinline Condition CommuteCondition(Condition cc) { 251a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block switch (cc) { 252a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block case below: 253a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return above; 254a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block case above: 255a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return below; 256a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block case above_equal: 257a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return below_equal; 258a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block case below_equal: 259a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return above_equal; 260a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block case less: 261a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return greater; 262a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block case greater: 263a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return less; 264a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block case greater_equal: 265a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return less_equal; 266a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block case less_equal: 267a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return greater_equal; 268a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block default: 269a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return cc; 270b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 271a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} 272a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 2739dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen 274a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// ----------------------------------------------------------------------------- 275a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// Machine instruction Immediates 276a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 277a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockclass Immediate BASE_EMBEDDED { 278a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block public: 279a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline explicit Immediate(int x); 280a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline explicit Immediate(const ExternalReference& ext); 281a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline explicit Immediate(Handle<Object> handle); 282a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline explicit Immediate(Smi* value); 283b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch inline explicit Immediate(Address addr); 284a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 285a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block static Immediate CodeRelativeOffset(Label* label) { 286a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return Immediate(label); 287a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 288a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 289b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool is_zero() const { return x_ == 0 && RelocInfo::IsNone(rmode_); } 290a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bool is_int8() const { 291b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return -128 <= x_ && x_ < 128 && RelocInfo::IsNone(rmode_); 292a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 293a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bool is_int16() const { 294b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return -32768 <= x_ && x_ < 32768 && RelocInfo::IsNone(rmode_); 295a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 296a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 297a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block private: 298a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline explicit Immediate(Label* value); 299a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 300a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int x_; 301a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block RelocInfo::Mode rmode_; 302a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 303b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch friend class Operand; 304a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block friend class Assembler; 305053d10c438f14580aaf4ab1b2aad93a5a4fe8b82Steve Block friend class MacroAssembler; 306a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block}; 307a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 308a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 309a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// ----------------------------------------------------------------------------- 310a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// Machine instruction Operands 311a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 312a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockenum ScaleFactor { 313a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block times_1 = 0, 314a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block times_2 = 1, 315a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block times_4 = 2, 316a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block times_8 = 3, 3174515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke times_int_size = times_4, 3184515c472dc3e5ed2448a564600976759e569a0a8Leon Clarke times_half_pointer_size = times_2, 319402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu times_pointer_size = times_4, 320402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu times_twice_pointer_size = times_8 321a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block}; 322a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 323a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 324a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockclass Operand BASE_EMBEDDED { 325a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block public: 326b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // reg 327b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch INLINE(explicit Operand(Register reg)); 328b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 3296ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // XMM reg 3306ded16be15dd865a9b21ea304d5273c8be299c87Steve Block INLINE(explicit Operand(XMMRegister xmm_reg)); 3316ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 332a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // [disp/r] 333a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block INLINE(explicit Operand(int32_t disp, RelocInfo::Mode rmode)); 334b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 335b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // [disp/r] 336b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch INLINE(explicit Operand(Immediate imm)); 337a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 338a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // [base + disp/r] 339a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block explicit Operand(Register base, int32_t disp, 340b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch RelocInfo::Mode rmode = RelocInfo::NONE32); 341a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 342a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // [base + index*scale + disp/r] 343a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block explicit Operand(Register base, 344a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Register index, 345a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ScaleFactor scale, 346a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int32_t disp, 347b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch RelocInfo::Mode rmode = RelocInfo::NONE32); 348a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 349a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // [index*scale + disp/r] 350a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block explicit Operand(Register index, 351a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ScaleFactor scale, 352a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int32_t disp, 353b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch RelocInfo::Mode rmode = RelocInfo::NONE32); 354a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 355a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block static Operand StaticVariable(const ExternalReference& ext) { 356a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return Operand(reinterpret_cast<int32_t>(ext.address()), 357a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block RelocInfo::EXTERNAL_REFERENCE); 358a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 359a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 360a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block static Operand StaticArray(Register index, 361a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ScaleFactor scale, 362a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block const ExternalReference& arr) { 363a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return Operand(index, scale, reinterpret_cast<int32_t>(arr.address()), 364a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block RelocInfo::EXTERNAL_REFERENCE); 365a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 366a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 367b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static Operand ForCell(Handle<Cell> cell) { 368b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch AllowDeferredHandleDereference embedding_raw_address; 369b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch return Operand(reinterpret_cast<int32_t>(cell.location()), 370b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch RelocInfo::CELL); 371b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 372b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 373b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static Operand ForRegisterPlusImmediate(Register base, Immediate imm) { 374b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Operand(base, imm.x_, imm.rmode_); 375b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch } 376b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 377a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Returns true if this Operand is a wrapper for the specified register. 378a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block bool is_reg(Register reg) const; 379a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 3803ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch // Returns true if this Operand is a wrapper for one register. 3813ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch bool is_reg_only() const; 3823ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch 3833ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch // Asserts that this Operand is a wrapper for one register and returns the 3843ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch // register. 3853ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch Register reg() const; 3863ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch 387a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block private: 388a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Set the ModRM byte without an encoded 'reg' register. The 389a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // register is encoded later as part of the emit_operand operation. 390a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline void set_modrm(int mod, Register rm); 391a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 392a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline void set_sib(ScaleFactor scale, Register index, Register base); 393a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline void set_disp8(int8_t disp); 394a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline void set_dispr(int32_t disp, RelocInfo::Mode rmode); 395a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 3963ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch byte buf_[6]; 3973ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch // The number of bytes in buf_. 3983ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch unsigned int len_; 3993ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch // Only valid if len_ > 4. 4003ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch RelocInfo::Mode rmode_; 4013ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch 402a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block friend class Assembler; 4033ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch friend class MacroAssembler; 404a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block}; 405a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 406a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 407a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// ----------------------------------------------------------------------------- 408a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// A Displacement describes the 32bit immediate field of an instruction which 409a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// may be used together with a Label in order to refer to a yet unknown code 410a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// position. Displacements stored in the instruction stream are used to describe 411a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// the instruction and to chain a list of instructions using the same Label. 412a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// A Displacement contains 2 different fields: 413a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 414a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// next field: position of next displacement in the chain (0 = end of list) 415a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// type field: instruction type 416a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 417a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// A next value of null (0) indicates the end of a chain (note that there can 418a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// be no displacement at position zero, because there is always at least one 419a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// instruction byte before the displacement). 420a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 421a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// Displacement _data field layout 422a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// 423a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// |31.....2|1......0| 424a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// [ next | type | 425a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 426a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockclass Displacement BASE_EMBEDDED { 427a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block public: 428a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block enum Type { 429a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block UNCONDITIONAL_JUMP, 430a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block CODE_RELATIVE, 431a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block OTHER 432a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block }; 433a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 434a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int data() const { return data_; } 435a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Type type() const { return TypeField::decode(data_); } 436a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void next(Label* L) const { 437a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int n = NextField::decode(data_); 438a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block n > 0 ? L->link_to(n) : L->Unuse(); 439a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 440a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void link_to(Label* L) { init(L, type()); } 441a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 442a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block explicit Displacement(int data) { data_ = data; } 443a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 444a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Displacement(Label* L, Type type) { init(L, type); } 445a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 446a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void print() { 447a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block PrintF("%s (%x) ", (type() == UNCONDITIONAL_JUMP ? "jmp" : "[other]"), 448a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block NextField::decode(data_)); 449a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 450a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 451a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block private: 452a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int data_; 453a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 454a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block class TypeField: public BitField<Type, 0, 2> {}; 455a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block class NextField: public BitField<int, 2, 32-2> {}; 456a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 457a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void init(Label* L, Type type); 458a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block}; 459a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 460a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 46144f0eee88ff00398ff7f715fab053374d808c90dSteve Blockclass Assembler : public AssemblerBase { 462a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block private: 463a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // We check before assembling an instruction that there is sufficient 464a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // space to write an instruction and its relocation information. 465a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // The relocation writer's position must be kGap bytes above the end of 466a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // the generated instructions. This leaves enough space for the 467a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // longest possible ia32 instruction, 15 bytes, and the longest possible 468a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // relocation information encoding, RelocInfoWriter::kMaxLength == 16. 469a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // (There is a 15 byte limit on ia32 instruction length that rules out some 470a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // otherwise valid instructions.) 471a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // This allows for a single, fast space check per instruction. 472a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block static const int kGap = 32; 473a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 474a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block public: 475a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Create an assembler. Instructions and relocation information are emitted 476a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // into a buffer, with the instructions starting from the beginning and the 477a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // relocation information starting from the end of the buffer. See CodeDesc 478a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // for a detailed comment on the layout (globals.h). 479a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // 480a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // If the provided buffer is NULL, the assembler allocates and grows its own 481a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // buffer, and buffer_size determines the initial buffer size. The buffer is 482a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // owned by the assembler and deallocated upon destruction of the assembler. 483a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // 484a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // If the provided buffer is not NULL, the assembler uses the provided buffer 485a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // for code generation and assumes its size to be buffer_size. If the buffer 486a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // is too small, a fatal error occurs. No deallocation of the buffer is done 487a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // upon destruction of the assembler. 4888b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch // TODO(vitalyr): the assembler does not need an isolate. 4898b112d2025046f85ef7f6be087c6129c872ebad2Ben Murdoch Assembler(Isolate* isolate, void* buffer, int buffer_size); 490b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch virtual ~Assembler() { } 49144f0eee88ff00398ff7f715fab053374d808c90dSteve Block 492a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // GetCode emits any pending (non-emitted) code and fills the descriptor 493a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // desc. GetCode() is idempotent; it returns the same result if no other 494a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Assembler functions are invoked in between GetCode() calls. 495a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void GetCode(CodeDesc* desc); 496a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 497a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Read/Modify the code target in the branch/call instruction at pc. 498b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch inline static Address target_address_at(Address pc, 499b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ConstantPoolArray* constant_pool); 500b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch inline static void set_target_address_at(Address pc, 501b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ConstantPoolArray* constant_pool, 502b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Address target, 503b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ICacheFlushMode icache_flush_mode = 504b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch FLUSH_ICACHE_IF_NEEDED); 505b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline Address target_address_at(Address pc, Code* code) { 506b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ConstantPoolArray* constant_pool = code ? code->constant_pool() : NULL; 507b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return target_address_at(pc, constant_pool); 508b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 509b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline void set_target_address_at(Address pc, 510b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Code* code, 511b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Address target, 512b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ICacheFlushMode icache_flush_mode = 513b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch FLUSH_ICACHE_IF_NEEDED) { 514b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ConstantPoolArray* constant_pool = code ? code->constant_pool() : NULL; 515b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch set_target_address_at(pc, constant_pool, target); 516b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 517b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 518b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Return the code target address at a call site from the return address 519b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // of that call in the instruction stream. 520b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch inline static Address target_address_from_return_address(Address pc); 521b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 522b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Return the code target address of the patch debug break slot 523b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch inline static Address break_address_from_return_address(Address pc); 524a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 525d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block // This sets the branch destination (which is in the instruction on x86). 526d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block // This is for calls and branches within generated code. 5273ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch inline static void deserialization_set_special_target_at( 528b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Address instruction_payload, Code* code, Address target) { 529b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch set_target_address_at(instruction_payload, code, target); 530d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block } 531d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 5323ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch static const int kSpecialTargetSize = kPointerSize; 533d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block 534a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Distance between the address of the code target in the call instruction 535a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // and the return address 536a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block static const int kCallTargetAddressOffset = kPointerSize; 537a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Distance between start of patched return sequence and the emitted address 538a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // to jump to. 539a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block static const int kPatchReturnSequenceAddressOffset = 1; // JMP imm32. 540a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 5417f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // Distance between start of patched debug break slot and the emitted address 5427f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // to jump to. 5437f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch static const int kPatchDebugBreakSlotAddressOffset = 1; // JMP imm32. 5447f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 545d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block static const int kCallInstructionLength = 5; 546b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static const int kPatchDebugBreakSlotReturnOffset = kPointerSize; 547d0582a6c46733687d045e4188a1bcd0123c758a1Steve Block static const int kJSReturnSequenceLength = 6; 548a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 5497f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // The debug break slot must be able to contain a call instruction. 5507f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch static const int kDebugBreakSlotLength = kCallInstructionLength; 5517f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 552b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // One byte opcode for test al, 0xXX. 553b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch static const byte kTestAlByte = 0xA8; 554b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // One byte opcode for nop. 555b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch static const byte kNopByte = 0x90; 556b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 557b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // One byte opcode for a short unconditional jump. 558b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch static const byte kJmpShortOpcode = 0xEB; 559b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // One byte prefix for a short conditional jump. 560b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch static const byte kJccShortPrefix = 0x70; 561b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch static const byte kJncShortOpcode = kJccShortPrefix | not_carry; 562b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch static const byte kJcShortOpcode = kJccShortPrefix | carry; 563b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static const byte kJnzShortOpcode = kJccShortPrefix | not_zero; 564b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static const byte kJzShortOpcode = kJccShortPrefix | zero; 565b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 566b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch 567a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // --------------------------------------------------------------------------- 568a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Code generation 569a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // 570a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // - function names correspond one-to-one to ia32 instruction mnemonics 571a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // - unless specified otherwise, instructions operate on 32bit operands 572a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // - instructions on 8bit (byte) operands/registers have a trailing '_b' 573a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // - instructions on 16bit (word) operands/registers have a trailing '_w' 574a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // - naming conflicts with C++ keywords are resolved via a trailing '_' 575a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 576a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // NOTE ON INTERFACE: Currently, the interface is not very consistent 577a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // in the sense that some operations (e.g. mov()) can be called in more 578a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // the one way to generate the same instruction: The Register argument 579a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // can in some cases be replaced with an Operand(Register) argument. 580a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // This should be cleaned up and made more orthogonal. The questions 581a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // is: should we always use Operands instead of Registers where an 582a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Operand is possible, or should we have a Register (overloaded) form 583a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // instead? We must be careful to make sure that the selected instruction 584a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // is obvious from the parameters to avoid hard-to-find code generation 585a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // bugs. 586a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 587a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Insert the smallest number of nop instructions 588a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // possible to align the pc offset to a multiple 589a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // of m. m must be a power of 2. 590a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void Align(int m); 5913ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void Nop(int bytes = 1); 5929dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen // Aligns code to something that's optimal for a jump target for the platform. 5939dcf7e2f83591d471e88bf7d230651900b8e424bKristian Monsen void CodeTargetAlign(); 594a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 595a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Stack 596a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void pushad(); 597a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void popad(); 598a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 599a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void pushfd(); 600a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void popfd(); 601a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 602a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void push(const Immediate& x); 603b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch void push_imm32(int32_t imm32); 604a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void push(Register src); 605a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void push(const Operand& src); 606a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 607a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void pop(Register dst); 608a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void pop(const Operand& dst); 609a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 610a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void enter(const Immediate& size); 611a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void leave(); 612a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 613a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Moves 6143ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void mov_b(Register dst, Register src) { mov_b(dst, Operand(src)); } 615a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov_b(Register dst, const Operand& src); 6163ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void mov_b(Register dst, int8_t imm8) { mov_b(Operand(dst), imm8); } 617a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov_b(const Operand& dst, int8_t imm8); 618a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov_b(const Operand& dst, Register src); 619a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 620a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov_w(Register dst, const Operand& src); 621a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov_w(const Operand& dst, Register src); 622b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void mov_w(const Operand& dst, int16_t imm16); 623a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 624a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov(Register dst, int32_t imm32); 625a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov(Register dst, const Immediate& x); 626a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov(Register dst, Handle<Object> handle); 627a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov(Register dst, const Operand& src); 628a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov(Register dst, Register src); 629a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov(const Operand& dst, const Immediate& x); 630a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov(const Operand& dst, Handle<Object> handle); 631a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mov(const Operand& dst, Register src); 632a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 6333ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void movsx_b(Register dst, Register src) { movsx_b(dst, Operand(src)); } 634a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void movsx_b(Register dst, const Operand& src); 635a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 6363ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void movsx_w(Register dst, Register src) { movsx_w(dst, Operand(src)); } 637a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void movsx_w(Register dst, const Operand& src); 638a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 6393ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void movzx_b(Register dst, Register src) { movzx_b(dst, Operand(src)); } 640a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void movzx_b(Register dst, const Operand& src); 641a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 6423ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void movzx_w(Register dst, Register src) { movzx_w(dst, Operand(src)); } 643a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void movzx_w(Register dst, const Operand& src); 644a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 645a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Conditional moves 6463ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void cmov(Condition cc, Register dst, Register src) { 6473ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch cmov(cc, dst, Operand(src)); 6483ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch } 649a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cmov(Condition cc, Register dst, const Operand& src); 650a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 6516ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // Flag management. 6526ded16be15dd865a9b21ea304d5273c8be299c87Steve Block void cld(); 6536ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 654e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke // Repetitive string instructions. 655e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke void rep_movs(); 6566ded16be15dd865a9b21ea304d5273c8be299c87Steve Block void rep_stos(); 657f7060e27768c550ace7ec48ad8c093466db52dfaLeon Clarke void stos(); 658e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke 659b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Exchange 660a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void xchg(Register dst, Register src); 661b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void xchg(Register dst, const Operand& src); 662a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 663a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Arithmetics 664a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void adc(Register dst, int32_t imm32); 665a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void adc(Register dst, const Operand& src); 666a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 6673ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void add(Register dst, Register src) { add(dst, Operand(src)); } 668a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void add(Register dst, const Operand& src); 6693ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void add(const Operand& dst, Register src); 6703ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void add(Register dst, const Immediate& imm) { add(Operand(dst), imm); } 671a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void add(const Operand& dst, const Immediate& x); 672a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 673a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void and_(Register dst, int32_t imm32); 67459151504615d929945dc59db37bf1166937748c6Steve Block void and_(Register dst, const Immediate& x); 6753ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void and_(Register dst, Register src) { and_(dst, Operand(src)); } 676a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void and_(Register dst, const Operand& src); 6773ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void and_(const Operand& dst, Register src); 678a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void and_(const Operand& dst, const Immediate& x); 679a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 6803ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void cmpb(Register reg, int8_t imm8) { cmpb(Operand(reg), imm8); } 681a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cmpb(const Operand& op, int8_t imm8); 6823ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void cmpb(Register reg, const Operand& op); 6833ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void cmpb(const Operand& op, Register reg); 684a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cmpb_al(const Operand& op); 685a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cmpw_ax(const Operand& op); 686a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cmpw(const Operand& op, Immediate imm16); 687a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cmp(Register reg, int32_t imm32); 688a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cmp(Register reg, Handle<Object> handle); 6893ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void cmp(Register reg0, Register reg1) { cmp(reg0, Operand(reg1)); } 690a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cmp(Register reg, const Operand& op); 6913ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void cmp(Register reg, const Immediate& imm) { cmp(Operand(reg), imm); } 692a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cmp(const Operand& op, const Immediate& imm); 693a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cmp(const Operand& op, Handle<Object> handle); 694a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 695a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void dec_b(Register dst); 6960d5e116f6aee03185f237311a943491bb079a768Kristian Monsen void dec_b(const Operand& dst); 697a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 698a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void dec(Register dst); 699a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void dec(const Operand& dst); 700a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 701a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cdq(); 702a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 703b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void idiv(Register src) { idiv(Operand(src)); } 704b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void idiv(const Operand& src); 705b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void div(Register src) { div(Operand(src)); } 706b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void div(const Operand& src); 707a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 708a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Signed multiply instructions. 709a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void imul(Register src); // edx:eax = eax * src. 7103ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void imul(Register dst, Register src) { imul(dst, Operand(src)); } 711a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void imul(Register dst, const Operand& src); // dst = dst * src. 712a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void imul(Register dst, Register src, int32_t imm32); // dst = src * imm32. 713b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void imul(Register dst, const Operand& src, int32_t imm32); 714a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 715a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void inc(Register dst); 716a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void inc(const Operand& dst); 717a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 718a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void lea(Register dst, const Operand& src); 719a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 720a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Unsigned multiply instruction. 721a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mul(Register src); // edx:eax = eax * reg. 722a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 723a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void neg(Register dst); 724b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void neg(const Operand& dst); 725a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 726a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void not_(Register dst); 727b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void not_(const Operand& dst); 728a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 729a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void or_(Register dst, int32_t imm32); 7303ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void or_(Register dst, Register src) { or_(dst, Operand(src)); } 731a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void or_(Register dst, const Operand& src); 732a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void or_(const Operand& dst, Register src); 7333ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void or_(Register dst, const Immediate& imm) { or_(Operand(dst), imm); } 734a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void or_(const Operand& dst, const Immediate& x); 735a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 736a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void rcl(Register dst, uint8_t imm8); 737756813857a4c2a4d8ad2e805969d5768d3cf43a0Iain Merrick void rcr(Register dst, uint8_t imm8); 738b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void ror(Register dst, uint8_t imm8); 739b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void ror_cl(Register dst); 740a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 741b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void sar(Register dst, uint8_t imm8) { sar(Operand(dst), imm8); } 742b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void sar(const Operand& dst, uint8_t imm8); 743b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void sar_cl(Register dst) { sar_cl(Operand(dst)); } 744b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void sar_cl(const Operand& dst); 745a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 746a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void sbb(Register dst, const Operand& src); 747a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 7483ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void shld(Register dst, Register src) { shld(dst, Operand(src)); } 749a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void shld(Register dst, const Operand& src); 750a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 751b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void shl(Register dst, uint8_t imm8) { shl(Operand(dst), imm8); } 752b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void shl(const Operand& dst, uint8_t imm8); 753b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void shl_cl(Register dst) { shl_cl(Operand(dst)); } 754b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void shl_cl(const Operand& dst); 755a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 7563ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void shrd(Register dst, Register src) { shrd(dst, Operand(src)); } 757a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void shrd(Register dst, const Operand& src); 758a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 759b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void shr(Register dst, uint8_t imm8) { shr(Operand(dst), imm8); } 760b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void shr(const Operand& dst, uint8_t imm8); 761b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void shr_cl(Register dst) { shr_cl(Operand(dst)); } 762b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void shr_cl(const Operand& dst); 763a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 7643ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void sub(Register dst, const Immediate& imm) { sub(Operand(dst), imm); } 765a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void sub(const Operand& dst, const Immediate& x); 7663ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void sub(Register dst, Register src) { sub(dst, Operand(src)); } 767a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void sub(Register dst, const Operand& src); 768a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void sub(const Operand& dst, Register src); 769a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 770a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void test(Register reg, const Immediate& imm); 7713ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void test(Register reg0, Register reg1) { test(reg0, Operand(reg1)); } 772a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void test(Register reg, const Operand& op); 773e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke void test_b(Register reg, const Operand& op); 774a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void test(const Operand& op, const Immediate& imm); 775b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void test_b(Register reg, uint8_t imm8); 7767f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch void test_b(const Operand& op, uint8_t imm8); 777a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 778a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void xor_(Register dst, int32_t imm32); 7793ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void xor_(Register dst, Register src) { xor_(dst, Operand(src)); } 780a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void xor_(Register dst, const Operand& src); 7813ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void xor_(const Operand& dst, Register src); 7823ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void xor_(Register dst, const Immediate& imm) { xor_(Operand(dst), imm); } 783a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void xor_(const Operand& dst, const Immediate& x); 784a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 785a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Bit operations. 786a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void bt(const Operand& dst, Register src); 7873ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void bts(Register dst, Register src) { bts(Operand(dst), src); } 788a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void bts(const Operand& dst, Register src); 789b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void bsr(Register dst, Register src) { bsr(dst, Operand(src)); } 790b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void bsr(Register dst, const Operand& src); 791a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 792a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Miscellaneous 793a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void hlt(); 794a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void int3(); 795a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void nop(); 796a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void ret(int imm16); 797a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 798a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Label operations & relative jumps (PPUM Appendix D) 799a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // 800a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Takes a branch opcode (cc) and a label (L) and generates 801a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // either a backward branch or a forward branch and links it 802a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // to the label fixup chain. Usage: 803a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // 804a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Label L; // unbound label 805a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // j(cc, &L); // forward branch to unbound label 806a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // bind(&L); // bind label to the current pc 807a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // j(cc, &L); // backward branch to bound label 808a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // bind(&L); // illegal: a label may be bound only once 809a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // 810a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Note: The same Label can be used for forward and backward branches 811a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // but it may be bound only once. 812a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 813a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void bind(Label* L); // binds an unbound label L to the current code position 814a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 815a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Calls 816a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void call(Label* L); 817a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void call(byte* entry, RelocInfo::Mode rmode); 818257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int CallSize(const Operand& adr); 8193ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void call(Register reg) { call(Operand(reg)); } 820a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void call(const Operand& adr); 821257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch int CallSize(Handle<Code> code, RelocInfo::Mode mode); 822257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch void call(Handle<Code> code, 823b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch RelocInfo::Mode rmode, 824b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeFeedbackId id = TypeFeedbackId::None()); 825a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 826a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Jumps 827257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch // unconditional jump to L 828257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch void jmp(Label* L, Label::Distance distance = Label::kFar); 829a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void jmp(byte* entry, RelocInfo::Mode rmode); 8303ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void jmp(Register reg) { jmp(Operand(reg)); } 831a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void jmp(const Operand& adr); 832a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void jmp(Handle<Code> code, RelocInfo::Mode rmode); 833a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 834a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Conditional jumps 835257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch void j(Condition cc, 836257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Label* L, 837257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch Label::Distance distance = Label::kFar); 838257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch void j(Condition cc, byte* entry, RelocInfo::Mode rmode); 839257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch void j(Condition cc, Handle<Code> code); 8400d5e116f6aee03185f237311a943491bb079a768Kristian Monsen 841a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Floating-point operations 842a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fld(int i); 843402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu void fstp(int i); 844a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 845a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fld1(); 846a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fldz(); 847402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu void fldpi(); 848b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch void fldln2(); 849a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 850a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fld_s(const Operand& adr); 851a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fld_d(const Operand& adr); 852a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 853a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fstp_s(const Operand& adr); 854b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void fst_s(const Operand& adr); 855a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fstp_d(const Operand& adr); 856402d937239b0e2fd11bf2f4fe972ad78aa9fd481Andrei Popescu void fst_d(const Operand& adr); 857a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 858a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fild_s(const Operand& adr); 859a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fild_d(const Operand& adr); 860a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 861a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fist_s(const Operand& adr); 862a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 863a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fistp_s(const Operand& adr); 864a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fistp_d(const Operand& adr); 865a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 8666ded16be15dd865a9b21ea304d5273c8be299c87Steve Block // The fisttp instructions require SSE3. 867a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fisttp_s(const Operand& adr); 868e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke void fisttp_d(const Operand& adr); 869a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 870a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fabs(); 871a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fchs(); 872a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fcos(); 873a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fsin(); 8743ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void fptan(); 875b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch void fyl2x(); 8763ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void f2xm1(); 8773ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void fscale(); 8783ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void fninit(); 879a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 880a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fadd(int i); 881b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void fadd_i(int i); 882a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fsub(int i); 883b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void fsub_i(int i); 884a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fmul(int i); 885b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void fmul_i(int i); 886a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fdiv(int i); 887b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void fdiv_i(int i); 888a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 889a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fisub_s(const Operand& adr); 890a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 891a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void faddp(int i = 1); 892a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fsubp(int i = 1); 893a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fsubrp(int i = 1); 894a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fmulp(int i = 1); 895a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fdivp(int i = 1); 896a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fprem(); 897a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fprem1(); 898a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 899a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fxch(int i = 1); 900a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fincstp(); 901a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void ffree(int i = 0); 902a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 903a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void ftst(); 904a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fucomp(int i); 905a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fucompp(); 9063ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block void fucomi(int i); 9073ce2e2076e8e3e60cf1810eec160ea2d8557e9e7Steve Block void fucomip(); 908a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fcompp(); 909a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fnstsw_ax(); 910a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fwait(); 911a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void fnclex(); 912a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 913a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void frndint(); 914a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 915a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void sahf(); 916a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void setcc(Condition cc, Register reg); 917a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 918a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cpuid(); 919a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 920b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // SSE instructions 921b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void movaps(XMMRegister dst, XMMRegister src); 922b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void shufps(XMMRegister dst, XMMRegister src, byte imm8); 923b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 924b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void andps(XMMRegister dst, const Operand& src); 925b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void andps(XMMRegister dst, XMMRegister src) { andps(dst, Operand(src)); } 926b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void xorps(XMMRegister dst, const Operand& src); 927b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void xorps(XMMRegister dst, XMMRegister src) { xorps(dst, Operand(src)); } 928b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void orps(XMMRegister dst, const Operand& src); 929b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void orps(XMMRegister dst, XMMRegister src) { orps(dst, Operand(src)); } 930b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 931b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void addps(XMMRegister dst, const Operand& src); 932b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void addps(XMMRegister dst, XMMRegister src) { addps(dst, Operand(src)); } 933b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void subps(XMMRegister dst, const Operand& src); 934b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void subps(XMMRegister dst, XMMRegister src) { subps(dst, Operand(src)); } 935b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void mulps(XMMRegister dst, const Operand& src); 936b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void mulps(XMMRegister dst, XMMRegister src) { mulps(dst, Operand(src)); } 937b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void divps(XMMRegister dst, const Operand& src); 938b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void divps(XMMRegister dst, XMMRegister src) { divps(dst, Operand(src)); } 939b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 940a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // SSE2 instructions 941a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cvttss2si(Register dst, const Operand& src); 942b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void cvttss2si(Register dst, XMMRegister src) { 943b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch cvttss2si(dst, Operand(src)); 944b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 945a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cvttsd2si(Register dst, const Operand& src); 946b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void cvttsd2si(Register dst, XMMRegister src) { 947b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch cvttsd2si(dst, Operand(src)); 948b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 949b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void cvtsd2si(Register dst, XMMRegister src); 950a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 9513ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void cvtsi2sd(XMMRegister dst, Register src) { cvtsi2sd(dst, Operand(src)); } 952a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void cvtsi2sd(XMMRegister dst, const Operand& src); 9536ded16be15dd865a9b21ea304d5273c8be299c87Steve Block void cvtss2sd(XMMRegister dst, XMMRegister src); 95444f0eee88ff00398ff7f715fab053374d808c90dSteve Block void cvtsd2ss(XMMRegister dst, XMMRegister src); 955a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 956a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void addsd(XMMRegister dst, XMMRegister src); 957b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void addsd(XMMRegister dst, const Operand& src); 958a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void subsd(XMMRegister dst, XMMRegister src); 959b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void subsd(XMMRegister dst, const Operand& src); 960a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void mulsd(XMMRegister dst, XMMRegister src); 961b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void mulsd(XMMRegister dst, const Operand& src); 962a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void divsd(XMMRegister dst, XMMRegister src); 963e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke void xorpd(XMMRegister dst, XMMRegister src); 9646ded16be15dd865a9b21ea304d5273c8be299c87Steve Block void sqrtsd(XMMRegister dst, XMMRegister src); 965b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void sqrtsd(XMMRegister dst, const Operand& src); 966a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 9670d5e116f6aee03185f237311a943491bb079a768Kristian Monsen void andpd(XMMRegister dst, XMMRegister src); 968b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void orpd(XMMRegister dst, XMMRegister src); 9690d5e116f6aee03185f237311a943491bb079a768Kristian Monsen 970b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void ucomisd(XMMRegister dst, XMMRegister src) { ucomisd(dst, Operand(src)); } 9713ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void ucomisd(XMMRegister dst, const Operand& src); 97269a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch 97369a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch enum RoundingMode { 97469a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch kRoundToNearest = 0x0, 97569a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch kRoundDown = 0x1, 97669a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch kRoundUp = 0x2, 97769a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch kRoundToZero = 0x3 97869a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch }; 97969a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch 98069a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch void roundsd(XMMRegister dst, XMMRegister src, RoundingMode mode); 98169a99ed0b2b2ef69d393c371b03db3a98aaf880eBen Murdoch 9826ded16be15dd865a9b21ea304d5273c8be299c87Steve Block void movmskpd(Register dst, XMMRegister src); 983b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void movmskps(Register dst, XMMRegister src); 984a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 9850d5e116f6aee03185f237311a943491bb079a768Kristian Monsen void cmpltsd(XMMRegister dst, XMMRegister src); 986b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void pcmpeqd(XMMRegister dst, XMMRegister src); 9870d5e116f6aee03185f237311a943491bb079a768Kristian Monsen 988e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke void movdqa(XMMRegister dst, const Operand& src); 989e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke void movdqa(const Operand& dst, XMMRegister src); 990e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke void movdqu(XMMRegister dst, const Operand& src); 991e46be819fca9468a0cd4e74859ce0f778eb8ca60Leon Clarke void movdqu(const Operand& dst, XMMRegister src); 992b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void movdq(bool aligned, XMMRegister dst, const Operand& src) { 993b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch if (aligned) { 994b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch movdqa(dst, src); 995b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } else { 996b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch movdqu(dst, src); 997b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 998b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 999a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 10003ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void movd(XMMRegister dst, Register src) { movd(dst, Operand(src)); } 10016ded16be15dd865a9b21ea304d5273c8be299c87Steve Block void movd(XMMRegister dst, const Operand& src); 10023ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void movd(Register dst, XMMRegister src) { movd(Operand(dst), src); } 10033ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void movd(const Operand& dst, XMMRegister src); 1004b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void movsd(XMMRegister dst, XMMRegister src) { movsd(dst, Operand(src)); } 1005b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void movsd(XMMRegister dst, const Operand& src); 1006b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void movsd(const Operand& dst, XMMRegister src); 1007b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 10086ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 100944f0eee88ff00398ff7f715fab053374d808c90dSteve Block void movss(XMMRegister dst, const Operand& src); 10103ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void movss(const Operand& dst, XMMRegister src); 1011b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void movss(XMMRegister dst, XMMRegister src) { movss(dst, Operand(src)); } 10123ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void extractps(Register dst, XMMRegister src, byte imm8); 101344f0eee88ff00398ff7f715fab053374d808c90dSteve Block 1014b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch void pand(XMMRegister dst, XMMRegister src); 10156ded16be15dd865a9b21ea304d5273c8be299c87Steve Block void pxor(XMMRegister dst, XMMRegister src); 1016b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch void por(XMMRegister dst, XMMRegister src); 10176ded16be15dd865a9b21ea304d5273c8be299c87Steve Block void ptest(XMMRegister dst, XMMRegister src); 10186ded16be15dd865a9b21ea304d5273c8be299c87Steve Block 1019b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch void psllq(XMMRegister reg, int8_t shift); 1020b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch void psllq(XMMRegister dst, XMMRegister src); 1021b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch void psrlq(XMMRegister reg, int8_t shift); 1022b8e0da25ee8efac3bb05cd6b2730aafbd96119f4Ben Murdoch void psrlq(XMMRegister dst, XMMRegister src); 1023b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void pshufd(XMMRegister dst, XMMRegister src, uint8_t shuffle); 10243ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void pextrd(Register dst, XMMRegister src, int8_t offset) { 10253ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch pextrd(Operand(dst), src, offset); 10263ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch } 1027b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch void pextrd(const Operand& dst, XMMRegister src, int8_t offset); 10283ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void pinsrd(XMMRegister dst, Register src, int8_t offset) { 10293ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch pinsrd(dst, Operand(src), offset); 10303ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch } 10311e0659c275bb392c045087af4f6b0d7565cb3d77Steve Block void pinsrd(XMMRegister dst, const Operand& src, int8_t offset); 10320d5e116f6aee03185f237311a943491bb079a768Kristian Monsen 10337f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // Parallel XMM operations. 10343ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void movntdqa(XMMRegister dst, const Operand& src); 10357f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch void movntdq(const Operand& dst, XMMRegister src); 10367f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // Prefetch src position into cache level. 10377f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // Level 1, 2 or 3 specifies CPU cache level. Level 0 specifies a 10387f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // non-temporal 10397f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch void prefetch(const Operand& src, int level); 10407f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // TODO(lrn): Need SFENCE for movnt? 10417f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 1042a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Debugging 1043a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void Print(); 1044a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1045a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check the code size generated from label to here. 10463fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch int SizeOfCodeGeneratedSince(Label* label) { 10473fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch return pc_offset() - label->pos(); 10483fb3ca8c7ca439d408449a395897395c0faae8d1Ben Murdoch } 1049a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1050a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Mark address of the ExitJSFrame code. 1051a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void RecordJSReturn(); 1052a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 10537f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch // Mark address of a debug break slot. 10547f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch void RecordDebugBreakSlot(); 10557f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 1056a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Record a comment relocation entry that can be used by a disassembler. 1057e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // Use --code-comments to enable, or provide "force = true" flag to always 1058e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch // write a comment. 1059e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch void RecordComment(const char* msg, bool force = false); 1060a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1061b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // Writes a single byte or word of data in the code stream. Used for 1062b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch // inline tables, e.g., jump-tables. 1063b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch void db(uint8_t data); 1064b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch void dd(uint32_t data); 1065a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1066a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Check if there is less than kGap bytes available in the buffer. 1067a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // If this is the case, we need to grow the buffer before emitting 1068a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // an instruction or relocation information. 1069b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch inline bool buffer_overflow() const { 1070b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return pc_ >= reloc_info_writer.pos() - kGap; 1071b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 1072a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1073a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Get the number of bytes available in the buffer. 1074a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline int available_space() const { return reloc_info_writer.pos() - pc_; } 1075a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 10763ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch static bool IsNop(Address addr); 10777f4d5bd8c03935e2c0cd412e561b8fc5a6a880aeBen Murdoch 10783e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu PositionsRecorder* positions_recorder() { return &positions_recorder_; } 10793e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu 1080e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch int relocation_writer_size() { 1081e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch return (buffer_ + buffer_size_) - reloc_info_writer.pos(); 1082e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch } 1083e0cee9b3ed82e2391fd85d118aeaa4ea361c687dBen Murdoch 1084a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Avoid overflows for displacements etc. 1085a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block static const int kMaximalBufferSize = 512*MB; 1086a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1087b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch byte byte_at(int pos) { return buffer_[pos]; } 10883ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch void set_byte_at(int pos, byte value) { buffer_[pos] = value; } 10893ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch 1090b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Allocate a constant pool of the correct size for the generated code. 1091b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Handle<ConstantPoolArray> NewConstantPool(Isolate* isolate); 109244f0eee88ff00398ff7f715fab053374d808c90dSteve Block 1093b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Generate the constant pool for the generated code. 1094b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void PopulateConstantPool(ConstantPoolArray* constant_pool); 1095a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1096b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch protected: 1097a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void emit_sse_operand(XMMRegister reg, const Operand& adr); 1098a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void emit_sse_operand(XMMRegister dst, XMMRegister src); 10996ded16be15dd865a9b21ea304d5273c8be299c87Steve Block void emit_sse_operand(Register dst, XMMRegister src); 1100b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void emit_sse_operand(XMMRegister dst, Register src); 1101a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 110244f0eee88ff00398ff7f715fab053374d808c90dSteve Block byte* addr_at(int pos) { return buffer_ + pos; } 110344f0eee88ff00398ff7f715fab053374d808c90dSteve Block 11043ef787dbeca8a5fb1086949cda830dccee07bfbdBen Murdoch 1105b0fe1620dcb4135ac3ab2d66ff93072373911299Ben Murdoch private: 1106a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block uint32_t long_at(int pos) { 1107a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block return *reinterpret_cast<uint32_t*>(addr_at(pos)); 1108a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1109a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void long_at_put(int pos, uint32_t x) { 1110a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block *reinterpret_cast<uint32_t*>(addr_at(pos)) = x; 1111a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1112a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1113a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // code emission 1114a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void GrowBuffer(); 1115a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline void emit(uint32_t x); 1116a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline void emit(Handle<Object> handle); 1117257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch inline void emit(uint32_t x, 1118257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch RelocInfo::Mode rmode, 1119b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeFeedbackId id = TypeFeedbackId::None()); 1120b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch inline void emit(Handle<Code> code, 1121b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch RelocInfo::Mode rmode, 1122b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeFeedbackId id = TypeFeedbackId::None()); 1123a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline void emit(const Immediate& x); 1124a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline void emit_w(const Immediate& x); 1125a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1126a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Emit the code-object-relative offset of the label's position 1127a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline void emit_code_relative_offset(Label* label); 1128a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1129a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // instruction generation 1130a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void emit_arith_b(int op1, int op2, Register dst, int imm8); 1131a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1132a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // Emit a basic arithmetic instruction (i.e. first byte of the family is 0x81) 1133a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // with a given destination expression and an immediate operand. It attempts 1134a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // to use the shortest encoding possible. 1135a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // sel specifies the /n in the modrm byte (see the Intel PRM). 1136a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void emit_arith(int sel, Operand dst, const Immediate& x); 1137a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1138a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void emit_operand(Register reg, const Operand& adr); 1139a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1140a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void emit_farith(int b1, int b2, int i); 1141a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1142a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // labels 1143a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void print(Label* L); 1144a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void bind_to(Label* L, int pos); 1145a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1146a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // displacements 1147a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline Displacement disp_at(Label* L); 1148a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline void disp_at_put(Label* L, Displacement disp); 1149a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block inline void emit_disp(Label* L, Displacement::Type type); 1150257744e915dfc84d6d07a6b2accf8402d9ffc708Ben Murdoch inline void emit_near_disp(Label* L); 1151a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1152a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // record reloc info for current pc_ 1153a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block void RecordRelocInfo(RelocInfo::Mode rmode, intptr_t data = 0); 1154a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1155a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block friend class CodePatcher; 1156a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block friend class EnsureSpace; 1157a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1158a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block // code generation 1159a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block RelocInfoWriter reloc_info_writer; 1160a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 11613e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu PositionsRecorder positions_recorder_; 11623e5fa29ddb82551500b118e9bf37af3966277b70Teng-Hui Zhu friend class PositionsRecorder; 1163a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block}; 1164a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1165a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1166a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// Helper class that ensures that there is enough space for generating 1167a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// instructions and relocation information. The constructor makes 1168a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// sure that there is enough space and (in debug mode) the destructor 1169a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block// checks that we did not generate too much. 1170a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Blockclass EnsureSpace BASE_EMBEDDED { 1171a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block public: 1172a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block explicit EnsureSpace(Assembler* assembler) : assembler_(assembler) { 1173b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch if (assembler_->buffer_overflow()) assembler_->GrowBuffer(); 1174a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifdef DEBUG 1175a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block space_before_ = assembler_->available_space(); 1176a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 1177a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1178a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1179a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifdef DEBUG 1180a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block ~EnsureSpace() { 1181a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int bytes_generated = space_before_ - assembler_->available_space(); 1182b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(bytes_generated < assembler_->kGap); 1183a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block } 1184a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 1185a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1186a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block private: 1187a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block Assembler* assembler_; 1188a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#ifdef DEBUG 1189a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block int space_before_; 1190a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif 1191a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block}; 1192a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1193a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block} } // namespace v8::internal 1194a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block 1195a7e24c173cf37484693b9abb38e494fa7bd7baebSteve Block#endif // V8_IA32_ASSEMBLER_IA32_H_ 1196