js/src/methodjit/PunboxAssembler.h

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  * vim: set ts=4 sw=4 et tw=99:
   3  *
   4  * ***** BEGIN LICENSE BLOCK *****
   5  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   6  *
   7  * The contents of this file are subject to the Mozilla Public License Version
   8  * 1.1 (the "License"); you may not use this file except in compliance with
   9  * the License. You may obtain a copy of the License at
  10  * http://www.mozilla.org/MPL/
  11  *
  12  * Software distributed under the License is distributed on an "AS IS" basis,
  13  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  14  * for the specific language governing rights and limitations under the
  15  * License.
  16  *
  17  * The Original Code is Mozilla SpiderMonkey JavaScript 1.9 code, released
  18  * May 28, 2008.
  19  *
  20  * The Initial Developer of the Original Code is
  21  *   Brendan Eich <brendan@mozilla.org>
  22  *
  23  * Contributor(s):
  24  *   Sean Stangl <sstangl@mozilla.com>
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 #if !defined jsjaeger_assembler64_h__ && defined JS_METHODJIT && defined JS_PUNBOX64
  41 #define jsjaeger_assembler64_h__
  42
  43 #include "assembler/assembler/MacroAssembler.h"
  44 #include "methodjit/MachineRegs.h"
  45 #include "methodjit/RematInfo.h"
  46
  47 namespace js {
  48 namespace mjit {
  49
  50 struct Imm64 : JSC::MacroAssembler::ImmPtr
  51 {
  52     Imm64(uint64 u)
  53       : ImmPtr((const void *)u)
  54     { }
  55 };
  56
  57 /* Tag stored in shifted format. */
  58 struct ImmTag : JSC::MacroAssembler::ImmPtr
  59 {
  60     ImmTag(JSValueShiftedTag shtag)
  61       : ImmPtr((const void *)shtag)
  62     { }
  63 };
  64
  65 struct ImmType : ImmTag
  66 {
  67     ImmType(JSValueType type)
  68       : ImmTag(JSValueShiftedTag(JSVAL_TYPE_TO_SHIFTED_TAG(type)))
  69     { }
  70 };
  71
  72 struct ImmPayload : Imm64
  73 {
  74     ImmPayload(uint64 payload)
  75       : Imm64(payload)
  76     { }
  77 };
  78
  79 class PunboxAssembler : public JSC::MacroAssembler
  80 {
  81     static const uint32 PAYLOAD_OFFSET = 0;
  82
  83   public:
  84     static const JSC::MacroAssembler::Scale JSVAL_SCALE = JSC::MacroAssembler::TimesEight;
  85
  86     template <typename T>
  87     T payloadOf(T address) {
  88         return address;
  89     }
  90
  91     template <typename T>
  92     T valueOf(T address) {
  93         return address;
  94     }
  95
  96     void loadInlineSlot(RegisterID objReg, uint32 slot,
  97                         RegisterID typeReg, RegisterID dataReg) {
  98         Address address(objReg, JSObject::getFixedSlotOffset(slot));
  99         loadValueAsComponents(address, typeReg, dataReg);
 100     }
 101
 102     template <typename T>
 103     void loadValue(T address, RegisterID dst) {
 104         loadPtr(address, dst);
 105     }
 106
 107     void convertValueToType(RegisterID val) {
 108         andPtr(Registers::TypeMaskReg, val);
 109     }
 110
 111     void convertValueToPayload(RegisterID val) {
 112         andPtr(Registers::PayloadMaskReg, val);
 113     }
 114
 115     // Returns a label after the one Value load.
 116     template <typename T>
 117     Label loadValueAsComponents(T address, RegisterID type, RegisterID payload) {
 118         loadValue(address, type);
 119         Label l = label();
 120
 121         move(Registers::PayloadMaskReg, payload);
 122         andPtr(type, payload);
 123         xorPtr(payload, type);
 124
 125         return l;
 126     }
 127
 128     void loadValueAsComponents(const Value &val, RegisterID type, RegisterID payload) {
 129         move(Imm64(val.asRawBits() & JSVAL_TAG_MASK), type);
 130         move(Imm64(val.asRawBits() & JSVAL_PAYLOAD_MASK), payload);
 131     }
 132
 133     template <typename T>
 134     void storeValueFromComponents(RegisterID type, RegisterID payload, T address) {
 135         move(type, Registers::ValueReg);
 136         orPtr(payload, Registers::ValueReg);
 137         storeValue(Registers::ValueReg, address);
 138     }
 139
 140     template <typename T>
 141     void storeValueFromComponents(ImmTag type, RegisterID payload, T address) {
 142         move(type, Registers::ValueReg);
 143         orPtr(payload, Registers::ValueReg);
 144         storeValue(Registers::ValueReg, address);
 145     }
 146
 147     template <typename T>
 148     void loadTypeTag(T address, RegisterID reg) {
 149         loadValue(address, reg);
 150         convertValueToType(reg);
 151     }
 152
 153     template <typename T>
 154     void storeTypeTag(ImmTag imm, T address) {
 155         loadPayload(address, Registers::ValueReg);
 156         orPtr(imm, Registers::ValueReg);
 157         storePtr(Registers::ValueReg, valueOf(address));
 158     }
 159
 160     template <typename T>
 161     void storeTypeTag(RegisterID reg, T address) {
 162         /* The type tag must be stored in shifted format. */
 163         loadPayload(address, Registers::ValueReg);
 164         orPtr(reg, Registers::ValueReg);
 165         storePtr(Registers::ValueReg, valueOf(address));
 166     }
 167
 168     template <typename T>
 169     void loadPayload(T address, RegisterID reg) {
 170         loadValue(address, reg);
 171         convertValueToPayload(reg);
 172     }
 173
 174     template <typename T>
 175     void storePayload(RegisterID reg, T address) {
 176         /* Not for doubles. */
 177         loadTypeTag(address, Registers::ValueReg);
 178         orPtr(reg, Registers::ValueReg);
 179         storePtr(Registers::ValueReg, valueOf(address));
 180     }
 181
 182     template <typename T>
 183     void storePayload(ImmPayload imm, T address) {
 184         /* Not for doubles. */
 185         storePtr(imm, valueOf(address));
 186     }
 187
 188     template <typename T>
 189     void storeValue(RegisterID reg, T address) {
 190         storePtr(reg, valueOf(address));
 191     }
 192
 193     template <typename T>
 194     void storeValue(const Value &v, T address) {
 195         jsval_layout jv;
 196         jv.asBits = JSVAL_BITS(Jsvalify(v));
 197
 198         storePtr(Imm64(jv.asBits), valueOf(address));
 199     }
 200
 201     template <typename T>
 202     void storeValue(const ValueRemat &vr, T address) {
 203         if (vr.isConstant())
 204             storeValue(vr.value(), address);
 205         else if (vr.isTypeKnown())
 206             storeValueFromComponents(ImmType(vr.knownType()), vr.dataReg(), address);
 207         else
 208             storeValueFromComponents(vr.typeReg(), vr.dataReg(), address);
 209     }
 210
 211     void loadPrivate(Address privAddr, RegisterID to) {
 212         loadPtr(privAddr, to);
 213         lshiftPtr(Imm32(1), to);
 214     }
 215
 216     void loadFunctionPrivate(RegisterID base, RegisterID to) {
 217         Address priv(base, offsetof(JSObject, privateData));
 218         loadPtr(priv, to);
 219     }
 220
 221     Jump testNull(Condition cond, RegisterID reg) {
 222         return branchPtr(cond, reg, ImmTag(JSVAL_SHIFTED_TAG_NULL));
 223     }
 224
 225     Jump testNull(Condition cond, Address address) {
 226         loadValue(address, Registers::ValueReg);
 227         return testNull(cond, Registers::ValueReg);
 228     }
 229
 230     Jump testUndefined(Condition cond, RegisterID reg) {
 231         return branchPtr(cond, reg, ImmTag(JSVAL_SHIFTED_TAG_UNDEFINED));
 232     }
 233
 234     Jump testUndefined(Condition cond, Address address) {
 235         loadValue(address, Registers::ValueReg);
 236         return testUndefined(cond, Registers::ValueReg);
 237     }
 238
 239     Jump testInt32(Condition cond, RegisterID reg) {
 240         return branchPtr(cond, reg, ImmTag(JSVAL_SHIFTED_TAG_INT32));
 241     }
 242
 243     Jump testInt32(Condition cond, Address address) {
 244         loadTypeTag(address, Registers::ValueReg);
 245         return testInt32(cond, Registers::ValueReg);
 246     }
 247
 248     Jump testNumber(Condition cond, RegisterID reg) {
 249         cond = (cond == Equal) ? Below : AboveOrEqual;
 250         return branchPtr(cond, reg,
 251                          ImmTag(JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET));
 252     }
 253
 254     Jump testNumber(Condition cond, Address address) {
 255         loadValue(address, Registers::ValueReg);
 256         return testNumber(cond, Registers::ValueReg);
 257     }
 258
 259     Jump testPrimitive(Condition cond, RegisterID reg) {
 260         cond = (cond == Equal) ? Below : AboveOrEqual;
 261         return branchPtr(cond, reg,
 262                          ImmTag(JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET));
 263     }
 264
 265     Jump testPrimitive(Condition cond, Address address) {
 266         loadValue(address, Registers::ValueReg);
 267         return testPrimitive(cond, Registers::ValueReg);
 268     }
 269
 270     Jump testObject(Condition cond, RegisterID reg) {
 271         cond = (cond == Equal) ? AboveOrEqual : Below;
 272         return branchPtr(cond, reg, ImmTag(JSVAL_SHIFTED_TAG_OBJECT));
 273     }
 274
 275     Jump testObject(Condition cond, Address address) {
 276         loadValue(address, Registers::ValueReg);
 277         return testObject(cond, Registers::ValueReg);
 278     }
 279
 280     Jump testDouble(Condition cond, RegisterID reg) {
 281         cond = (cond == Equal) ? BelowOrEqual : Above;
 282         return branchPtr(cond, reg, ImmTag(JSVAL_SHIFTED_TAG_MAX_DOUBLE));
 283     }
 284
 285     Jump testDouble(Condition cond, Address address) {
 286         loadValue(address, Registers::ValueReg);
 287         return testDouble(cond, Registers::ValueReg);
 288     }
 289
 290     Jump testBoolean(Condition cond, RegisterID reg) {
 291         return branchPtr(cond, reg, ImmTag(JSVAL_SHIFTED_TAG_BOOLEAN));
 292     }
 293
 294     Jump testBoolean(Condition cond, Address address) {
 295         loadTypeTag(address, Registers::ValueReg);
 296         return testBoolean(cond, Registers::ValueReg);
 297     }
 298
 299     Jump testString(Condition cond, RegisterID reg) {
 300         return branchPtr(cond, reg, ImmTag(JSVAL_SHIFTED_TAG_STRING));
 301     }
 302
 303     Jump testString(Condition cond, Address address) {
 304         loadTypeTag(address, Registers::ValueReg);
 305         return testString(cond, Registers::ValueReg);
 306     }
 307
 308     template <typename T>
 309     Jump fastArrayLoadSlot(T address, RegisterID typeReg, RegisterID dataReg) {
 310         loadValueAsComponents(address, typeReg, dataReg);
 311         return branchPtr(Equal, typeReg, ImmType(JSVAL_TYPE_MAGIC));
 312     }
 313 };
 314
 315 typedef PunboxAssembler ValueAssembler;
 316
 317 } /* namespace mjit */
 318 } /* namespace js */
 319
 320 #endif
 321