js/src/jit/mips32/Lowering-mips32.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "jit/mips32/Lowering-mips32.h"
   8
   9 #include "jit/Lowering.h"
  10 #include "jit/mips32/Assembler-mips32.h"
  11 #include "jit/MIR.h"
  12
  13 #include "jit/shared/Lowering-shared-inl.h"
  14
  15 using namespace js;
  16 using namespace js::jit;
  17
  18 LBoxAllocation LIRGeneratorMIPS::useBoxFixed(MDefinition* mir, Register reg1,
  19                                              Register reg2, bool useAtStart) {
  20   MOZ_ASSERT(mir->type() == MIRType::Value);
  21   MOZ_ASSERT(reg1 != reg2);
  22
  23   ensureDefined(mir);
  24   return LBoxAllocation(LUse(reg1, mir->virtualRegister(), useAtStart),
  25                         LUse(reg2, VirtualRegisterOfPayload(mir), useAtStart));
  26 }
  27
  28 void LIRGenerator::visitBox(MBox* box) {
  29   MDefinition* inner = box->getOperand(0);
  30
  31   // If the box wrapped a double, it needs a new register.
  32   if (IsFloatingPointType(inner->type())) {
  33     defineBox(new (alloc()) LBoxFloatingPoint(
  34                   useRegisterAtStart(inner), tempCopy(inner, 0), inner->type()),
  35               box);
  36     return;
  37   }
  38
  39   if (box->canEmitAtUses()) {
  40     emitAtUses(box);
  41     return;
  42   }
  43
  44   if (inner->isConstant()) {
  45     defineBox(new (alloc()) LValue(inner->toConstant()->toJSValue()), box);
  46     return;
  47   }
  48
  49   LBox* lir = new (alloc()) LBox(use(inner), inner->type());
  50
  51   // Otherwise, we should not define a new register for the payload portion
  52   // of the output, so bypass defineBox().
  53   uint32_t vreg = getVirtualRegister();
  54
  55   // Note that because we're using BogusTemp(), we do not change the type of
  56   // the definition. We also do not define the first output as "TYPE",
  57   // because it has no corresponding payload at (vreg + 1). Also note that
  58   // although we copy the input's original type for the payload half of the
  59   // definition, this is only for clarity. BogusTemp() definitions are
  60   // ignored.
  61   lir->setDef(0, LDefinition(vreg, LDefinition::GENERAL));
  62   lir->setDef(1, LDefinition::BogusTemp());
  63   box->setVirtualRegister(vreg);
  64   add(lir);
  65 }
  66
  67 void LIRGenerator::visitUnbox(MUnbox* unbox) {
  68   MDefinition* inner = unbox->getOperand(0);
  69
  70   if (inner->type() == MIRType::ObjectOrNull) {
  71     LUnboxObjectOrNull* lir =
  72         new (alloc()) LUnboxObjectOrNull(useRegisterAtStart(inner));
  73     if (unbox->fallible()) {
  74       assignSnapshot(lir, unbox->bailoutKind());
  75     }
  76     defineReuseInput(lir, unbox, 0);
  77     return;
  78   }
  79
  80   // An unbox on mips reads in a type tag (either in memory or a register) and
  81   // a payload. Unlike most instructions consuming a box, we ask for the type
  82   // second, so that the result can re-use the first input.
  83   MOZ_ASSERT(inner->type() == MIRType::Value);
  84
  85   ensureDefined(inner);
  86
  87   if (IsFloatingPointType(unbox->type())) {
  88     LUnboxFloatingPoint* lir =
  89         new (alloc()) LUnboxFloatingPoint(useBox(inner), unbox->type());
  90     if (unbox->fallible()) {
  91       assignSnapshot(lir, unbox->bailoutKind());
  92     }
  93     define(lir, unbox);
  94     return;
  95   }
  96
  97   // Swap the order we use the box pieces so we can re-use the payload
  98   // register.
  99   LUnbox* lir = new (alloc()) LUnbox;
 100   lir->setOperand(0, usePayloadInRegisterAtStart(inner));
 101   lir->setOperand(1, useType(inner, LUse::REGISTER));
 102
 103   if (unbox->fallible()) {
 104     assignSnapshot(lir, unbox->bailoutKind());
 105   }
 106
 107   // Types and payloads form two separate intervals. If the type becomes dead
 108   // before the payload, it could be used as a Value without the type being
 109   // recoverable. Unbox's purpose is to eagerly kill the definition of a type
 110   // tag, so keeping both alive (for the purpose of gcmaps) is unappealing.
 111   // Instead, we create a new virtual register.
 112   defineReuseInput(lir, unbox, 0);
 113 }
 114
 115 void LIRGenerator::visitReturn(MReturn* ret) {
 116   MDefinition* opd = ret->getOperand(0);
 117   MOZ_ASSERT(opd->type() == MIRType::Value);
 118
 119   LReturn* ins = new (alloc()) LReturn;
 120   ins->setOperand(0, LUse(JSReturnReg_Type));
 121   ins->setOperand(1, LUse(JSReturnReg_Data));
 122   fillBoxUses(ins, 0, opd);
 123   add(ins);
 124 }
 125
 126 void LIRGeneratorMIPS::lowerUntypedPhiInput(MPhi* phi, uint32_t inputPosition,
 127                                             LBlock* block, size_t lirIndex) {
 128   MDefinition* operand = phi->getOperand(inputPosition);
 129   LPhi* type = block->getPhi(lirIndex + VREG_TYPE_OFFSET);
 130   LPhi* payload = block->getPhi(lirIndex + VREG_DATA_OFFSET);
 131   type->setOperand(
 132       inputPosition,
 133       LUse(operand->virtualRegister() + VREG_TYPE_OFFSET, LUse::ANY));
 134   payload->setOperand(inputPosition,
 135                       LUse(VirtualRegisterOfPayload(operand), LUse::ANY));
 136 }
 137
 138 void LIRGeneratorMIPS::defineInt64Phi(MPhi* phi, size_t lirIndex) {
 139   LPhi* low = current->getPhi(lirIndex + INT64LOW_INDEX);
 140   LPhi* high = current->getPhi(lirIndex + INT64HIGH_INDEX);
 141
 142   uint32_t lowVreg = getVirtualRegister();
 143
 144   phi->setVirtualRegister(lowVreg);
 145
 146   uint32_t highVreg = getVirtualRegister();
 147   MOZ_ASSERT(lowVreg + INT64HIGH_INDEX == highVreg + INT64LOW_INDEX);
 148
 149   low->setDef(0, LDefinition(lowVreg, LDefinition::INT32));
 150   high->setDef(0, LDefinition(highVreg, LDefinition::INT32));
 151   annotate(high);
 152   annotate(low);
 153 }
 154
 155 void LIRGeneratorMIPS::lowerInt64PhiInput(MPhi* phi, uint32_t inputPosition,
 156                                           LBlock* block, size_t lirIndex) {
 157   MDefinition* operand = phi->getOperand(inputPosition);
 158   LPhi* low = block->getPhi(lirIndex + INT64LOW_INDEX);
 159   LPhi* high = block->getPhi(lirIndex + INT64HIGH_INDEX);
 160   low->setOperand(inputPosition,
 161                   LUse(operand->virtualRegister() + INT64LOW_INDEX, LUse::ANY));
 162   high->setOperand(
 163       inputPosition,
 164       LUse(operand->virtualRegister() + INT64HIGH_INDEX, LUse::ANY));
 165 }
 166
 167 void LIRGeneratorMIPS::lowerTruncateDToInt32(MTruncateToInt32* ins) {
 168   MDefinition* opd = ins->input();
 169   MOZ_ASSERT(opd->type() == MIRType::Double);
 170
 171   define(new (alloc())
 172              LTruncateDToInt32(useRegister(opd), LDefinition::BogusTemp()),
 173          ins);
 174 }
 175
 176 void LIRGeneratorMIPS::lowerTruncateFToInt32(MTruncateToInt32* ins) {
 177   MDefinition* opd = ins->input();
 178   MOZ_ASSERT(opd->type() == MIRType::Float32);
 179
 180   define(new (alloc())
 181              LTruncateFToInt32(useRegister(opd), LDefinition::BogusTemp()),
 182          ins);
 183 }
 184
 185 void LIRGeneratorMIPS::lowerDivI64(MDiv* div) {
 186   if (div->isUnsigned()) {
 187     lowerUDivI64(div);
 188     return;
 189   }
 190
 191   LDivOrModI64* lir = new (alloc()) LDivOrModI64(
 192       useInt64RegisterAtStart(div->lhs()), useInt64RegisterAtStart(div->rhs()));
 193
 194   defineReturn(lir, div);
 195 }
 196
 197 void LIRGeneratorMIPS::lowerWasmBuiltinDivI64(MWasmBuiltinDivI64* div) {
 198   MOZ_CRASH("We don't use runtime div for this architecture");
 199 }
 200
 201 void LIRGeneratorMIPS::lowerModI64(MMod* mod) {
 202   if (mod->isUnsigned()) {
 203     lowerUModI64(mod);
 204     return;
 205   }
 206
 207   LDivOrModI64* lir = new (alloc()) LDivOrModI64(
 208       useInt64RegisterAtStart(mod->lhs()), useInt64RegisterAtStart(mod->rhs()));
 209
 210   defineReturn(lir, mod);
 211 }
 212
 213 void LIRGeneratorMIPS::lowerWasmBuiltinModI64(MWasmBuiltinModI64* mod) {
 214   MOZ_CRASH("We don't use runtime mod for this architecture");
 215 }
 216
 217 void LIRGeneratorMIPS::lowerUDivI64(MDiv* div) {
 218   LUDivOrModI64* lir = new (alloc()) LUDivOrModI64(
 219       useInt64RegisterAtStart(div->lhs()), useInt64RegisterAtStart(div->rhs()));
 220   defineReturn(lir, div);
 221 }
 222
 223 void LIRGeneratorMIPS::lowerUModI64(MMod* mod) {
 224   LUDivOrModI64* lir = new (alloc()) LUDivOrModI64(
 225       useInt64RegisterAtStart(mod->lhs()), useInt64RegisterAtStart(mod->rhs()));
 226   defineReturn(lir, mod);
 227 }
 228
 229 void LIRGenerator::visitWasmTruncateToInt64(MWasmTruncateToInt64* ins) {
 230   MDefinition* opd = ins->input();
 231   MOZ_ASSERT(opd->type() == MIRType::Double || opd->type() == MIRType::Float32);
 232
 233   defineReturn(new (alloc()) LWasmTruncateToInt64(useRegisterAtStart(opd)),
 234                ins);
 235 }
 236
 237 void LIRGenerator::visitInt64ToFloatingPoint(MInt64ToFloatingPoint* ins) {
 238   MDefinition* opd = ins->input();
 239   MOZ_ASSERT(opd->type() == MIRType::Int64);
 240   MOZ_ASSERT(IsFloatingPointType(ins->type()));
 241
 242   defineReturn(
 243       new (alloc()) LInt64ToFloatingPoint(useInt64RegisterAtStart(opd)), ins);
 244 }