contrib/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

   1 //=- WebAssemblyISelLowering.cpp - WebAssembly DAG Lowering Implementation -==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 ///
  10 /// \file
  11 /// This file implements the WebAssemblyTargetLowering class.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "WebAssemblyISelLowering.h"
  16 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
  17 #include "WebAssemblyMachineFunctionInfo.h"
  18 #include "WebAssemblySubtarget.h"
  19 #include "WebAssemblyTargetMachine.h"
  20 #include "llvm/CodeGen/Analysis.h"
  21 #include "llvm/CodeGen/CallingConvLower.h"
  22 #include "llvm/CodeGen/MachineInstrBuilder.h"
  23 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  24 #include "llvm/CodeGen/MachineRegisterInfo.h"
  25 #include "llvm/CodeGen/SelectionDAG.h"
  26 #include "llvm/IR/DiagnosticInfo.h"
  27 #include "llvm/IR/DiagnosticPrinter.h"
  28 #include "llvm/IR/Function.h"
  29 #include "llvm/IR/Intrinsics.h"
  30 #include "llvm/Support/Debug.h"
  31 #include "llvm/Support/ErrorHandling.h"
  32 #include "llvm/Support/raw_ostream.h"
  33 #include "llvm/Target/TargetOptions.h"
  34 using namespace llvm;
  35
  36 #define DEBUG_TYPE "wasm-lower"
  37
  38 WebAssemblyTargetLowering::WebAssemblyTargetLowering(
  39     const TargetMachine &TM, const WebAssemblySubtarget &STI)
  40     : TargetLowering(TM), Subtarget(&STI) {
  41   auto MVTPtr = Subtarget->hasAddr64() ? MVT::i64 : MVT::i32;
  42
  43   // Booleans always contain 0 or 1.
  44   setBooleanContents(ZeroOrOneBooleanContent);
  45   // WebAssembly does not produce floating-point exceptions on normal floating
  46   // point operations.
  47   setHasFloatingPointExceptions(false);
  48   // We don't know the microarchitecture here, so just reduce register pressure.
  49   setSchedulingPreference(Sched::RegPressure);
  50   // Tell ISel that we have a stack pointer.
  51   setStackPointerRegisterToSaveRestore(
  52       Subtarget->hasAddr64() ? WebAssembly::SP64 : WebAssembly::SP32);
  53   // Set up the register classes.
  54   addRegisterClass(MVT::i32, &WebAssembly::I32RegClass);
  55   addRegisterClass(MVT::i64, &WebAssembly::I64RegClass);
  56   addRegisterClass(MVT::f32, &WebAssembly::F32RegClass);
  57   addRegisterClass(MVT::f64, &WebAssembly::F64RegClass);
  58   if (Subtarget->hasSIMD128()) {
  59     addRegisterClass(MVT::v16i8, &WebAssembly::V128RegClass);
  60     addRegisterClass(MVT::v8i16, &WebAssembly::V128RegClass);
  61     addRegisterClass(MVT::v4i32, &WebAssembly::V128RegClass);
  62     addRegisterClass(MVT::v4f32, &WebAssembly::V128RegClass);
  63   }
  64   // Compute derived properties from the register classes.
  65   computeRegisterProperties(Subtarget->getRegisterInfo());
  66
  67   setOperationAction(ISD::GlobalAddress, MVTPtr, Custom);
  68   setOperationAction(ISD::ExternalSymbol, MVTPtr, Custom);
  69   setOperationAction(ISD::JumpTable, MVTPtr, Custom);
  70   setOperationAction(ISD::BlockAddress, MVTPtr, Custom);
  71   setOperationAction(ISD::BRIND, MVT::Other, Custom);
  72
  73   // Take the default expansion for va_arg, va_copy, and va_end. There is no
  74   // default action for va_start, so we do that custom.
  75   setOperationAction(ISD::VASTART, MVT::Other, Custom);
  76   setOperationAction(ISD::VAARG, MVT::Other, Expand);
  77   setOperationAction(ISD::VACOPY, MVT::Other, Expand);
  78   setOperationAction(ISD::VAEND, MVT::Other, Expand);
  79
  80   for (auto T : {MVT::f32, MVT::f64}) {
  81     // Don't expand the floating-point types to constant pools.
  82     setOperationAction(ISD::ConstantFP, T, Legal);
  83     // Expand floating-point comparisons.
  84     for (auto CC : {ISD::SETO, ISD::SETUO, ISD::SETUEQ, ISD::SETONE,
  85                     ISD::SETULT, ISD::SETULE, ISD::SETUGT, ISD::SETUGE})
  86       setCondCodeAction(CC, T, Expand);
  87     // Expand floating-point library function operators.
  88     for (auto Op : {ISD::FSIN, ISD::FCOS, ISD::FSINCOS, ISD::FPOW, ISD::FREM,
  89                     ISD::FMA})
  90       setOperationAction(Op, T, Expand);
  91     // Note supported floating-point library function operators that otherwise
  92     // default to expand.
  93     for (auto Op :
  94          {ISD::FCEIL, ISD::FFLOOR, ISD::FTRUNC, ISD::FNEARBYINT, ISD::FRINT})
  95       setOperationAction(Op, T, Legal);
  96     // Support minnan and maxnan, which otherwise default to expand.
  97     setOperationAction(ISD::FMINNAN, T, Legal);
  98     setOperationAction(ISD::FMAXNAN, T, Legal);
  99     // WebAssembly currently has no builtin f16 support.
 100     setOperationAction(ISD::FP16_TO_FP, T, Expand);
 101     setOperationAction(ISD::FP_TO_FP16, T, Expand);
 102     setLoadExtAction(ISD::EXTLOAD, T, MVT::f16, Expand);
 103     setTruncStoreAction(T, MVT::f16, Expand);
 104   }
 105
 106   for (auto T : {MVT::i32, MVT::i64}) {
 107     // Expand unavailable integer operations.
 108     for (auto Op :
 109          {ISD::BSWAP, ISD::SMUL_LOHI, ISD::UMUL_LOHI,
 110           ISD::MULHS, ISD::MULHU, ISD::SDIVREM, ISD::UDIVREM, ISD::SHL_PARTS,
 111           ISD::SRA_PARTS, ISD::SRL_PARTS, ISD::ADDC, ISD::ADDE, ISD::SUBC,
 112           ISD::SUBE}) {
 113       setOperationAction(Op, T, Expand);
 114     }
 115   }
 116
 117   // As a special case, these operators use the type to mean the type to
 118   // sign-extend from.
 119   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
 120   if (!Subtarget->hasSignExt()) {
 121     for (auto T : {MVT::i8, MVT::i16, MVT::i32})
 122       setOperationAction(ISD::SIGN_EXTEND_INREG, T, Expand);
 123   }
 124
 125   // Dynamic stack allocation: use the default expansion.
 126   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
 127   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
 128   setOperationAction(ISD::DYNAMIC_STACKALLOC, MVTPtr, Expand);
 129
 130   setOperationAction(ISD::FrameIndex, MVT::i32, Custom);
 131   setOperationAction(ISD::CopyToReg, MVT::Other, Custom);
 132
 133   // Expand these forms; we pattern-match the forms that we can handle in isel.
 134   for (auto T : {MVT::i32, MVT::i64, MVT::f32, MVT::f64})
 135     for (auto Op : {ISD::BR_CC, ISD::SELECT_CC})
 136       setOperationAction(Op, T, Expand);
 137
 138   // We have custom switch handling.
 139   setOperationAction(ISD::BR_JT, MVT::Other, Custom);
 140
 141   // WebAssembly doesn't have:
 142   //  - Floating-point extending loads.
 143   //  - Floating-point truncating stores.
 144   //  - i1 extending loads.
 145   setLoadExtAction(ISD::EXTLOAD, MVT::f64, MVT::f32, Expand);
 146   setTruncStoreAction(MVT::f64, MVT::f32, Expand);
 147   for (auto T : MVT::integer_valuetypes())
 148     for (auto Ext : {ISD::EXTLOAD, ISD::ZEXTLOAD, ISD::SEXTLOAD})
 149       setLoadExtAction(Ext, T, MVT::i1, Promote);
 150
 151   // Trap lowers to wasm unreachable
 152   setOperationAction(ISD::TRAP, MVT::Other, Legal);
 153
 154   // Exception handling intrinsics
 155   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
 156
 157   setMaxAtomicSizeInBitsSupported(64);
 158 }
 159
 160 FastISel *WebAssemblyTargetLowering::createFastISel(
 161     FunctionLoweringInfo &FuncInfo, const TargetLibraryInfo *LibInfo) const {
 162   return WebAssembly::createFastISel(FuncInfo, LibInfo);
 163 }
 164
 165 bool WebAssemblyTargetLowering::isOffsetFoldingLegal(
 166     const GlobalAddressSDNode * /*GA*/) const {
 167   // All offsets can be folded.
 168   return true;
 169 }
 170
 171 MVT WebAssemblyTargetLowering::getScalarShiftAmountTy(const DataLayout & /*DL*/,
 172                                                       EVT VT) const {
 173   unsigned BitWidth = NextPowerOf2(VT.getSizeInBits() - 1);
 174   if (BitWidth > 1 && BitWidth < 8) BitWidth = 8;
 175
 176   if (BitWidth > 64) {
 177     // The shift will be lowered to a libcall, and compiler-rt libcalls expect
 178     // the count to be an i32.
 179     BitWidth = 32;
 180     assert(BitWidth >= Log2_32_Ceil(VT.getSizeInBits()) &&
 181            "32-bit shift counts ought to be enough for anyone");
 182   }
 183
 184   MVT Result = MVT::getIntegerVT(BitWidth);
 185   assert(Result != MVT::INVALID_SIMPLE_VALUE_TYPE &&
 186          "Unable to represent scalar shift amount type");
 187   return Result;
 188 }
 189
 190 // Lower an fp-to-int conversion operator from the LLVM opcode, which has an
 191 // undefined result on invalid/overflow, to the WebAssembly opcode, which
 192 // traps on invalid/overflow.
 193 static MachineBasicBlock *
 194 LowerFPToInt(
 195     MachineInstr &MI,
 196     DebugLoc DL,
 197     MachineBasicBlock *BB,
 198     const TargetInstrInfo &TII,
 199     bool IsUnsigned,
 200     bool Int64,
 201     bool Float64,
 202     unsigned LoweredOpcode
 203 ) {
 204   MachineRegisterInfo &MRI = BB->getParent()->getRegInfo();
 205
 206   unsigned OutReg = MI.getOperand(0).getReg();
 207   unsigned InReg = MI.getOperand(1).getReg();
 208
 209   unsigned Abs = Float64 ? WebAssembly::ABS_F64 : WebAssembly::ABS_F32;
 210   unsigned FConst = Float64 ? WebAssembly::CONST_F64 : WebAssembly::CONST_F32;
 211   unsigned LT = Float64 ? WebAssembly::LT_F64 : WebAssembly::LT_F32;
 212   unsigned GE = Float64 ? WebAssembly::GE_F64 : WebAssembly::GE_F32;
 213   unsigned IConst = Int64 ? WebAssembly::CONST_I64 : WebAssembly::CONST_I32;
 214   unsigned Eqz = WebAssembly::EQZ_I32;
 215   unsigned And = WebAssembly::AND_I32;
 216   int64_t Limit = Int64 ? INT64_MIN : INT32_MIN;
 217   int64_t Substitute = IsUnsigned ? 0 : Limit;
 218   double CmpVal = IsUnsigned ? -(double)Limit * 2.0 : -(double)Limit;
 219   auto &Context = BB->getParent()->getFunction().getContext();
 220   Type *Ty = Float64 ? Type::getDoubleTy(Context) : Type::getFloatTy(Context);
 221
 222   const BasicBlock *LLVM_BB = BB->getBasicBlock();
 223   MachineFunction *F = BB->getParent();
 224   MachineBasicBlock *TrueMBB = F->CreateMachineBasicBlock(LLVM_BB);
 225   MachineBasicBlock *FalseMBB = F->CreateMachineBasicBlock(LLVM_BB);
 226   MachineBasicBlock *DoneMBB = F->CreateMachineBasicBlock(LLVM_BB);
 227
 228   MachineFunction::iterator It = ++BB->getIterator();
 229   F->insert(It, FalseMBB);
 230   F->insert(It, TrueMBB);
 231   F->insert(It, DoneMBB);
 232
 233   // Transfer the remainder of BB and its successor edges to DoneMBB.
 234   DoneMBB->splice(DoneMBB->begin(), BB,
 235                   std::next(MachineBasicBlock::iterator(MI)),
 236                   BB->end());
 237   DoneMBB->transferSuccessorsAndUpdatePHIs(BB);
 238
 239   BB->addSuccessor(TrueMBB);
 240   BB->addSuccessor(FalseMBB);
 241   TrueMBB->addSuccessor(DoneMBB);
 242   FalseMBB->addSuccessor(DoneMBB);
 243
 244   unsigned Tmp0, Tmp1, CmpReg, EqzReg, FalseReg, TrueReg;
 245   Tmp0 = MRI.createVirtualRegister(MRI.getRegClass(InReg));
 246   Tmp1 = MRI.createVirtualRegister(MRI.getRegClass(InReg));
 247   CmpReg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
 248   EqzReg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
 249   FalseReg = MRI.createVirtualRegister(MRI.getRegClass(OutReg));
 250   TrueReg = MRI.createVirtualRegister(MRI.getRegClass(OutReg));
 251
 252   MI.eraseFromParent();
 253   // For signed numbers, we can do a single comparison to determine whether
 254   // fabs(x) is within range.
 255   if (IsUnsigned) {
 256     Tmp0 = InReg;
 257   } else {
 258     BuildMI(BB, DL, TII.get(Abs), Tmp0)
 259         .addReg(InReg);
 260   }
 261   BuildMI(BB, DL, TII.get(FConst), Tmp1)
 262       .addFPImm(cast<ConstantFP>(ConstantFP::get(Ty, CmpVal)));
 263   BuildMI(BB, DL, TII.get(LT), CmpReg)
 264       .addReg(Tmp0)
 265       .addReg(Tmp1);
 266
 267   // For unsigned numbers, we have to do a separate comparison with zero.
 268   if (IsUnsigned) {
 269     Tmp1 = MRI.createVirtualRegister(MRI.getRegClass(InReg));
 270     unsigned SecondCmpReg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
 271     unsigned AndReg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
 272     BuildMI(BB, DL, TII.get(FConst), Tmp1)
 273         .addFPImm(cast<ConstantFP>(ConstantFP::get(Ty, 0.0)));
 274     BuildMI(BB, DL, TII.get(GE), SecondCmpReg)
 275         .addReg(Tmp0)
 276         .addReg(Tmp1);
 277     BuildMI(BB, DL, TII.get(And), AndReg)
 278         .addReg(CmpReg)
 279         .addReg(SecondCmpReg);
 280     CmpReg = AndReg;
 281   }
 282
 283   BuildMI(BB, DL, TII.get(Eqz), EqzReg)
 284       .addReg(CmpReg);
 285
 286   // Create the CFG diamond to select between doing the conversion or using
 287   // the substitute value.
 288   BuildMI(BB, DL, TII.get(WebAssembly::BR_IF))
 289       .addMBB(TrueMBB)
 290       .addReg(EqzReg);
 291   BuildMI(FalseMBB, DL, TII.get(LoweredOpcode), FalseReg)
 292       .addReg(InReg);
 293   BuildMI(FalseMBB, DL, TII.get(WebAssembly::BR))
 294       .addMBB(DoneMBB);
 295   BuildMI(TrueMBB, DL, TII.get(IConst), TrueReg)
 296       .addImm(Substitute);
 297   BuildMI(*DoneMBB, DoneMBB->begin(), DL, TII.get(TargetOpcode::PHI), OutReg)
 298       .addReg(FalseReg)
 299       .addMBB(FalseMBB)
 300       .addReg(TrueReg)
 301       .addMBB(TrueMBB);
 302
 303   return DoneMBB;
 304 }
 305
 306 MachineBasicBlock *
 307 WebAssemblyTargetLowering::EmitInstrWithCustomInserter(
 308     MachineInstr &MI,
 309     MachineBasicBlock *BB
 310 ) const {
 311   const TargetInstrInfo &TII = *Subtarget->getInstrInfo();
 312   DebugLoc DL = MI.getDebugLoc();
 313
 314   switch (MI.getOpcode()) {
 315   default: llvm_unreachable("Unexpected instr type to insert");
 316   case WebAssembly::FP_TO_SINT_I32_F32:
 317     return LowerFPToInt(MI, DL, BB, TII, false, false, false,
 318                         WebAssembly::I32_TRUNC_S_F32);
 319   case WebAssembly::FP_TO_UINT_I32_F32:
 320     return LowerFPToInt(MI, DL, BB, TII, true, false, false,
 321                         WebAssembly::I32_TRUNC_U_F32);
 322   case WebAssembly::FP_TO_SINT_I64_F32:
 323     return LowerFPToInt(MI, DL, BB, TII, false, true, false,
 324                         WebAssembly::I64_TRUNC_S_F32);
 325   case WebAssembly::FP_TO_UINT_I64_F32:
 326     return LowerFPToInt(MI, DL, BB, TII, true, true, false,
 327                         WebAssembly::I64_TRUNC_U_F32);
 328   case WebAssembly::FP_TO_SINT_I32_F64:
 329     return LowerFPToInt(MI, DL, BB, TII, false, false, true,
 330                         WebAssembly::I32_TRUNC_S_F64);
 331   case WebAssembly::FP_TO_UINT_I32_F64:
 332     return LowerFPToInt(MI, DL, BB, TII, true, false, true,
 333                         WebAssembly::I32_TRUNC_U_F64);
 334   case WebAssembly::FP_TO_SINT_I64_F64:
 335     return LowerFPToInt(MI, DL, BB, TII, false, true, true,
 336                         WebAssembly::I64_TRUNC_S_F64);
 337   case WebAssembly::FP_TO_UINT_I64_F64:
 338     return LowerFPToInt(MI, DL, BB, TII, true, true, true,
 339                         WebAssembly::I64_TRUNC_U_F64);
 340   llvm_unreachable("Unexpected instruction to emit with custom inserter");
 341   }
 342 }
 343
 344 const char *WebAssemblyTargetLowering::getTargetNodeName(
 345     unsigned Opcode) const {
 346   switch (static_cast<WebAssemblyISD::NodeType>(Opcode)) {
 347     case WebAssemblyISD::FIRST_NUMBER:
 348       break;
 349 #define HANDLE_NODETYPE(NODE) \
 350   case WebAssemblyISD::NODE:  \
 351     return "WebAssemblyISD::" #NODE;
 352 #include "WebAssemblyISD.def"
 353 #undef HANDLE_NODETYPE
 354   }
 355   return nullptr;
 356 }
 357
 358 std::pair<unsigned, const TargetRegisterClass *>
 359 WebAssemblyTargetLowering::getRegForInlineAsmConstraint(
 360     const TargetRegisterInfo *TRI, StringRef Constraint, MVT VT) const {
 361   // First, see if this is a constraint that directly corresponds to a
 362   // WebAssembly register class.
 363   if (Constraint.size() == 1) {
 364     switch (Constraint[0]) {
 365       case 'r':
 366         assert(VT != MVT::iPTR && "Pointer MVT not expected here");
 367         if (Subtarget->hasSIMD128() && VT.isVector()) {
 368           if (VT.getSizeInBits() == 128)
 369             return std::make_pair(0U, &WebAssembly::V128RegClass);
 370         }
 371         if (VT.isInteger() && !VT.isVector()) {
 372           if (VT.getSizeInBits() <= 32)
 373             return std::make_pair(0U, &WebAssembly::I32RegClass);
 374           if (VT.getSizeInBits() <= 64)
 375             return std::make_pair(0U, &WebAssembly::I64RegClass);
 376         }
 377         break;
 378       default:
 379         break;
 380     }
 381   }
 382
 383   return TargetLowering::getRegForInlineAsmConstraint(TRI, Constraint, VT);
 384 }
 385
 386 bool WebAssemblyTargetLowering::isCheapToSpeculateCttz() const {
 387   // Assume ctz is a relatively cheap operation.
 388   return true;
 389 }
 390
 391 bool WebAssemblyTargetLowering::isCheapToSpeculateCtlz() const {
 392   // Assume clz is a relatively cheap operation.
 393   return true;
 394 }
 395
 396 bool WebAssemblyTargetLowering::isLegalAddressingMode(const DataLayout &DL,
 397                                                       const AddrMode &AM,
 398                                                       Type *Ty,
 399                                                       unsigned AS,
 400                                                       Instruction *I) const {
 401   // WebAssembly offsets are added as unsigned without wrapping. The
 402   // isLegalAddressingMode gives us no way to determine if wrapping could be
 403   // happening, so we approximate this by accepting only non-negative offsets.
 404   if (AM.BaseOffs < 0) return false;
 405
 406   // WebAssembly has no scale register operands.
 407   if (AM.Scale != 0) return false;
 408
 409   // Everything else is legal.
 410   return true;
 411 }
 412
 413 bool WebAssemblyTargetLowering::allowsMisalignedMemoryAccesses(
 414     EVT /*VT*/, unsigned /*AddrSpace*/, unsigned /*Align*/, bool *Fast) const {
 415   // WebAssembly supports unaligned accesses, though it should be declared
 416   // with the p2align attribute on loads and stores which do so, and there
 417   // may be a performance impact. We tell LLVM they're "fast" because
 418   // for the kinds of things that LLVM uses this for (merging adjacent stores
 419   // of constants, etc.), WebAssembly implementations will either want the
 420   // unaligned access or they'll split anyway.
 421   if (Fast) *Fast = true;
 422   return true;
 423 }
 424
 425 bool WebAssemblyTargetLowering::isIntDivCheap(EVT VT,
 426                                               AttributeList Attr) const {
 427   // The current thinking is that wasm engines will perform this optimization,
 428   // so we can save on code size.
 429   return true;
 430 }
 431
 432 EVT WebAssemblyTargetLowering::getSetCCResultType(const DataLayout &DL,
 433                                                   LLVMContext &C,
 434                                                   EVT VT) const {
 435   if (VT.isVector())
 436     return VT.changeVectorElementTypeToInteger();
 437
 438   return TargetLowering::getSetCCResultType(DL, C, VT);
 439 }
 440
 441 //===----------------------------------------------------------------------===//
 442 // WebAssembly Lowering private implementation.
 443 //===----------------------------------------------------------------------===//
 444
 445 //===----------------------------------------------------------------------===//
 446 // Lowering Code
 447 //===----------------------------------------------------------------------===//
 448
 449 static void fail(const SDLoc &DL, SelectionDAG &DAG, const char *msg) {
 450   MachineFunction &MF = DAG.getMachineFunction();
 451   DAG.getContext()->diagnose(
 452       DiagnosticInfoUnsupported(MF.getFunction(), msg, DL.getDebugLoc()));
 453 }
 454
 455 // Test whether the given calling convention is supported.
 456 static bool CallingConvSupported(CallingConv::ID CallConv) {
 457   // We currently support the language-independent target-independent
 458   // conventions. We don't yet have a way to annotate calls with properties like
 459   // "cold", and we don't have any call-clobbered registers, so these are mostly
 460   // all handled the same.
 461   return CallConv == CallingConv::C || CallConv == CallingConv::Fast ||
 462          CallConv == CallingConv::Cold ||
 463          CallConv == CallingConv::PreserveMost ||
 464          CallConv == CallingConv::PreserveAll ||
 465          CallConv == CallingConv::CXX_FAST_TLS;
 466 }
 467
 468 SDValue WebAssemblyTargetLowering::LowerCall(
 469     CallLoweringInfo &CLI, SmallVectorImpl<SDValue> &InVals) const {
 470   SelectionDAG &DAG = CLI.DAG;
 471   SDLoc DL = CLI.DL;
 472   SDValue Chain = CLI.Chain;
 473   SDValue Callee = CLI.Callee;
 474   MachineFunction &MF = DAG.getMachineFunction();
 475   auto Layout = MF.getDataLayout();
 476
 477   CallingConv::ID CallConv = CLI.CallConv;
 478   if (!CallingConvSupported(CallConv))
 479     fail(DL, DAG,
 480          "WebAssembly doesn't support language-specific or target-specific "
 481          "calling conventions yet");
 482   if (CLI.IsPatchPoint)
 483     fail(DL, DAG, "WebAssembly doesn't support patch point yet");
 484
 485   // WebAssembly doesn't currently support explicit tail calls. If they are
 486   // required, fail. Otherwise, just disable them.
 487   if ((CallConv == CallingConv::Fast && CLI.IsTailCall &&
 488        MF.getTarget().Options.GuaranteedTailCallOpt) ||
 489       (CLI.CS && CLI.CS.isMustTailCall()))
 490     fail(DL, DAG, "WebAssembly doesn't support tail call yet");
 491   CLI.IsTailCall = false;
 492
 493   SmallVectorImpl<ISD::InputArg> &Ins = CLI.Ins;
 494   if (Ins.size() > 1)
 495     fail(DL, DAG, "WebAssembly doesn't support more than 1 returned value yet");
 496
 497   SmallVectorImpl<ISD::OutputArg> &Outs = CLI.Outs;
 498   SmallVectorImpl<SDValue> &OutVals = CLI.OutVals;
 499   unsigned NumFixedArgs = 0;
 500   for (unsigned i = 0; i < Outs.size(); ++i) {
 501     const ISD::OutputArg &Out = Outs[i];
 502     SDValue &OutVal = OutVals[i];
 503     if (Out.Flags.isNest())
 504       fail(DL, DAG, "WebAssembly hasn't implemented nest arguments");
 505     if (Out.Flags.isInAlloca())
 506       fail(DL, DAG, "WebAssembly hasn't implemented inalloca arguments");
 507     if (Out.Flags.isInConsecutiveRegs())
 508       fail(DL, DAG, "WebAssembly hasn't implemented cons regs arguments");
 509     if (Out.Flags.isInConsecutiveRegsLast())
 510       fail(DL, DAG, "WebAssembly hasn't implemented cons regs last arguments");
 511     if (Out.Flags.isByVal() && Out.Flags.getByValSize() != 0) {
 512       auto &MFI = MF.getFrameInfo();
 513       int FI = MFI.CreateStackObject(Out.Flags.getByValSize(),
 514                                      Out.Flags.getByValAlign(),
 515                                      /*isSS=*/false);
 516       SDValue SizeNode =
 517           DAG.getConstant(Out.Flags.getByValSize(), DL, MVT::i32);
 518       SDValue FINode = DAG.getFrameIndex(FI, getPointerTy(Layout));
 519       Chain = DAG.getMemcpy(
 520           Chain, DL, FINode, OutVal, SizeNode, Out.Flags.getByValAlign(),
 521           /*isVolatile*/ false, /*AlwaysInline=*/false,
 522           /*isTailCall*/ false, MachinePointerInfo(), MachinePointerInfo());
 523       OutVal = FINode;
 524     }
 525     // Count the number of fixed args *after* legalization.
 526     NumFixedArgs += Out.IsFixed;
 527   }
 528
 529   bool IsVarArg = CLI.IsVarArg;
 530   auto PtrVT = getPointerTy(Layout);
 531
 532   // Analyze operands of the call, assigning locations to each operand.
 533   SmallVector<CCValAssign, 16> ArgLocs;
 534   CCState CCInfo(CallConv, IsVarArg, MF, ArgLocs, *DAG.getContext());
 535
 536   if (IsVarArg) {
 537     // Outgoing non-fixed arguments are placed in a buffer. First
 538     // compute their offsets and the total amount of buffer space needed.
 539     for (SDValue Arg :
 540          make_range(OutVals.begin() + NumFixedArgs, OutVals.end())) {
 541       EVT VT = Arg.getValueType();
 542       assert(VT != MVT::iPTR && "Legalized args should be concrete");
 543       Type *Ty = VT.getTypeForEVT(*DAG.getContext());
 544       unsigned Offset = CCInfo.AllocateStack(Layout.getTypeAllocSize(Ty),
 545                                              Layout.getABITypeAlignment(Ty));
 546       CCInfo.addLoc(CCValAssign::getMem(ArgLocs.size(), VT.getSimpleVT(),
 547                                         Offset, VT.getSimpleVT(),
 548                                         CCValAssign::Full));
 549     }
 550   }
 551
 552   unsigned NumBytes = CCInfo.getAlignedCallFrameSize();
 553
 554   SDValue FINode;
 555   if (IsVarArg && NumBytes) {
 556     // For non-fixed arguments, next emit stores to store the argument values
 557     // to the stack buffer at the offsets computed above.
 558     int FI = MF.getFrameInfo().CreateStackObject(NumBytes,
 559                                                  Layout.getStackAlignment(),
 560                                                  /*isSS=*/false);
 561     unsigned ValNo = 0;
 562     SmallVector<SDValue, 8> Chains;
 563     for (SDValue Arg :
 564          make_range(OutVals.begin() + NumFixedArgs, OutVals.end())) {
 565       assert(ArgLocs[ValNo].getValNo() == ValNo &&
 566              "ArgLocs should remain in order and only hold varargs args");
 567       unsigned Offset = ArgLocs[ValNo++].getLocMemOffset();
 568       FINode = DAG.getFrameIndex(FI, getPointerTy(Layout));
 569       SDValue Add = DAG.getNode(ISD::ADD, DL, PtrVT, FINode,
 570                                 DAG.getConstant(Offset, DL, PtrVT));
 571       Chains.push_back(DAG.getStore(
 572           Chain, DL, Arg, Add,
 573           MachinePointerInfo::getFixedStack(MF, FI, Offset), 0));
 574     }
 575     if (!Chains.empty())
 576       Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
 577   } else if (IsVarArg) {
 578     FINode = DAG.getIntPtrConstant(0, DL);
 579   }
 580
 581   // Compute the operands for the CALLn node.
 582   SmallVector<SDValue, 16> Ops;
 583   Ops.push_back(Chain);
 584   Ops.push_back(Callee);
 585
 586   // Add all fixed arguments. Note that for non-varargs calls, NumFixedArgs
 587   // isn't reliable.
 588   Ops.append(OutVals.begin(),
 589              IsVarArg ? OutVals.begin() + NumFixedArgs : OutVals.end());
 590   // Add a pointer to the vararg buffer.
 591   if (IsVarArg) Ops.push_back(FINode);
 592
 593   SmallVector<EVT, 8> InTys;
 594   for (const auto &In : Ins) {
 595     assert(!In.Flags.isByVal() && "byval is not valid for return values");
 596     assert(!In.Flags.isNest() && "nest is not valid for return values");
 597     if (In.Flags.isInAlloca())
 598       fail(DL, DAG, "WebAssembly hasn't implemented inalloca return values");
 599     if (In.Flags.isInConsecutiveRegs())
 600       fail(DL, DAG, "WebAssembly hasn't implemented cons regs return values");
 601     if (In.Flags.isInConsecutiveRegsLast())
 602       fail(DL, DAG,
 603            "WebAssembly hasn't implemented cons regs last return values");
 604     // Ignore In.getOrigAlign() because all our arguments are passed in
 605     // registers.
 606     InTys.push_back(In.VT);
 607   }
 608   InTys.push_back(MVT::Other);
 609   SDVTList InTyList = DAG.getVTList(InTys);
 610   SDValue Res =
 611       DAG.getNode(Ins.empty() ? WebAssemblyISD::CALL0 : WebAssemblyISD::CALL1,
 612                   DL, InTyList, Ops);
 613   if (Ins.empty()) {
 614     Chain = Res;
 615   } else {
 616     InVals.push_back(Res);
 617     Chain = Res.getValue(1);
 618   }
 619
 620   return Chain;
 621 }
 622
 623 bool WebAssemblyTargetLowering::CanLowerReturn(
 624     CallingConv::ID /*CallConv*/, MachineFunction & /*MF*/, bool /*IsVarArg*/,
 625     const SmallVectorImpl<ISD::OutputArg> &Outs,
 626     LLVMContext & /*Context*/) const {
 627   // WebAssembly can't currently handle returning tuples.
 628   return Outs.size() <= 1;
 629 }
 630
 631 SDValue WebAssemblyTargetLowering::LowerReturn(
 632     SDValue Chain, CallingConv::ID CallConv, bool /*IsVarArg*/,
 633     const SmallVectorImpl<ISD::OutputArg> &Outs,
 634     const SmallVectorImpl<SDValue> &OutVals, const SDLoc &DL,
 635     SelectionDAG &DAG) const {
 636   assert(Outs.size() <= 1 && "WebAssembly can only return up to one value");
 637   if (!CallingConvSupported(CallConv))
 638     fail(DL, DAG, "WebAssembly doesn't support non-C calling conventions");
 639
 640   SmallVector<SDValue, 4> RetOps(1, Chain);
 641   RetOps.append(OutVals.begin(), OutVals.end());
 642   Chain = DAG.getNode(WebAssemblyISD::RETURN, DL, MVT::Other, RetOps);
 643
 644   // Record the number and types of the return values.
 645   for (const ISD::OutputArg &Out : Outs) {
 646     assert(!Out.Flags.isByVal() && "byval is not valid for return values");
 647     assert(!Out.Flags.isNest() && "nest is not valid for return values");
 648     assert(Out.IsFixed && "non-fixed return value is not valid");
 649     if (Out.Flags.isInAlloca())
 650       fail(DL, DAG, "WebAssembly hasn't implemented inalloca results");
 651     if (Out.Flags.isInConsecutiveRegs())
 652       fail(DL, DAG, "WebAssembly hasn't implemented cons regs results");
 653     if (Out.Flags.isInConsecutiveRegsLast())
 654       fail(DL, DAG, "WebAssembly hasn't implemented cons regs last results");
 655   }
 656
 657   return Chain;
 658 }
 659
 660 SDValue WebAssemblyTargetLowering::LowerFormalArguments(
 661     SDValue Chain, CallingConv::ID CallConv, bool IsVarArg,
 662     const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &DL,
 663     SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
 664   if (!CallingConvSupported(CallConv))
 665     fail(DL, DAG, "WebAssembly doesn't support non-C calling conventions");
 666
 667   MachineFunction &MF = DAG.getMachineFunction();
 668   auto *MFI = MF.getInfo<WebAssemblyFunctionInfo>();
 669
 670   // Set up the incoming ARGUMENTS value, which serves to represent the liveness
 671   // of the incoming values before they're represented by virtual registers.
 672   MF.getRegInfo().addLiveIn(WebAssembly::ARGUMENTS);
 673
 674   for (const ISD::InputArg &In : Ins) {
 675     if (In.Flags.isInAlloca())
 676       fail(DL, DAG, "WebAssembly hasn't implemented inalloca arguments");
 677     if (In.Flags.isNest())
 678       fail(DL, DAG, "WebAssembly hasn't implemented nest arguments");
 679     if (In.Flags.isInConsecutiveRegs())
 680       fail(DL, DAG, "WebAssembly hasn't implemented cons regs arguments");
 681     if (In.Flags.isInConsecutiveRegsLast())
 682       fail(DL, DAG, "WebAssembly hasn't implemented cons regs last arguments");
 683     // Ignore In.getOrigAlign() because all our arguments are passed in
 684     // registers.
 685     InVals.push_back(
 686         In.Used
 687             ? DAG.getNode(WebAssemblyISD::ARGUMENT, DL, In.VT,
 688                           DAG.getTargetConstant(InVals.size(), DL, MVT::i32))
 689             : DAG.getUNDEF(In.VT));
 690
 691     // Record the number and types of arguments.
 692     MFI->addParam(In.VT);
 693   }
 694
 695   // Varargs are copied into a buffer allocated by the caller, and a pointer to
 696   // the buffer is passed as an argument.
 697   if (IsVarArg) {
 698     MVT PtrVT = getPointerTy(MF.getDataLayout());
 699     unsigned VarargVreg =
 700         MF.getRegInfo().createVirtualRegister(getRegClassFor(PtrVT));
 701     MFI->setVarargBufferVreg(VarargVreg);
 702     Chain = DAG.getCopyToReg(
 703         Chain, DL, VarargVreg,
 704         DAG.getNode(WebAssemblyISD::ARGUMENT, DL, PtrVT,
 705                     DAG.getTargetConstant(Ins.size(), DL, MVT::i32)));
 706     MFI->addParam(PtrVT);
 707   }
 708
 709   // Record the number and types of results.
 710   SmallVector<MVT, 4> Params;
 711   SmallVector<MVT, 4> Results;
 712   ComputeSignatureVTs(MF.getFunction(), DAG.getTarget(), Params, Results);
 713   for (MVT VT : Results)
 714     MFI->addResult(VT);
 715
 716   return Chain;
 717 }
 718
 719 //===----------------------------------------------------------------------===//
 720 //  Custom lowering hooks.
 721 //===----------------------------------------------------------------------===//
 722
 723 SDValue WebAssemblyTargetLowering::LowerOperation(SDValue Op,
 724                                                   SelectionDAG &DAG) const {
 725   SDLoc DL(Op);
 726   switch (Op.getOpcode()) {
 727     default:
 728       llvm_unreachable("unimplemented operation lowering");
 729       return SDValue();
 730     case ISD::FrameIndex:
 731       return LowerFrameIndex(Op, DAG);
 732     case ISD::GlobalAddress:
 733       return LowerGlobalAddress(Op, DAG);
 734     case ISD::ExternalSymbol:
 735       return LowerExternalSymbol(Op, DAG);
 736     case ISD::JumpTable:
 737       return LowerJumpTable(Op, DAG);
 738     case ISD::BR_JT:
 739       return LowerBR_JT(Op, DAG);
 740     case ISD::VASTART:
 741       return LowerVASTART(Op, DAG);
 742     case ISD::BlockAddress:
 743     case ISD::BRIND:
 744       fail(DL, DAG, "WebAssembly hasn't implemented computed gotos");
 745       return SDValue();
 746     case ISD::RETURNADDR: // Probably nothing meaningful can be returned here.
 747       fail(DL, DAG, "WebAssembly hasn't implemented __builtin_return_address");
 748       return SDValue();
 749     case ISD::FRAMEADDR:
 750       return LowerFRAMEADDR(Op, DAG);
 751     case ISD::CopyToReg:
 752       return LowerCopyToReg(Op, DAG);
 753     case ISD::INTRINSIC_WO_CHAIN:
 754       return LowerINTRINSIC_WO_CHAIN(Op, DAG);
 755   }
 756 }
 757
 758 SDValue WebAssemblyTargetLowering::LowerCopyToReg(SDValue Op,
 759                                                   SelectionDAG &DAG) const {
 760   SDValue Src = Op.getOperand(2);
 761   if (isa<FrameIndexSDNode>(Src.getNode())) {
 762     // CopyToReg nodes don't support FrameIndex operands. Other targets select
 763     // the FI to some LEA-like instruction, but since we don't have that, we
 764     // need to insert some kind of instruction that can take an FI operand and
 765     // produces a value usable by CopyToReg (i.e. in a vreg). So insert a dummy
 766     // copy_local between Op and its FI operand.
 767     SDValue Chain = Op.getOperand(0);
 768     SDLoc DL(Op);
 769     unsigned Reg = cast<RegisterSDNode>(Op.getOperand(1))->getReg();
 770     EVT VT = Src.getValueType();
 771     SDValue Copy(
 772         DAG.getMachineNode(VT == MVT::i32 ? WebAssembly::COPY_I32
 773                                           : WebAssembly::COPY_I64,
 774                            DL, VT, Src),
 775         0);
 776     return Op.getNode()->getNumValues() == 1
 777                ? DAG.getCopyToReg(Chain, DL, Reg, Copy)
 778                : DAG.getCopyToReg(Chain, DL, Reg, Copy, Op.getNumOperands() == 4
 779                                                             ? Op.getOperand(3)
 780                                                             : SDValue());
 781   }
 782   return SDValue();
 783 }
 784
 785 SDValue WebAssemblyTargetLowering::LowerFrameIndex(SDValue Op,
 786                                                    SelectionDAG &DAG) const {
 787   int FI = cast<FrameIndexSDNode>(Op)->getIndex();
 788   return DAG.getTargetFrameIndex(FI, Op.getValueType());
 789 }
 790
 791 SDValue WebAssemblyTargetLowering::LowerFRAMEADDR(SDValue Op,
 792                                                   SelectionDAG &DAG) const {
 793   // Non-zero depths are not supported by WebAssembly currently. Use the
 794   // legalizer's default expansion, which is to return 0 (what this function is
 795   // documented to do).
 796   if (Op.getConstantOperandVal(0) > 0)
 797     return SDValue();
 798
 799   DAG.getMachineFunction().getFrameInfo().setFrameAddressIsTaken(true);
 800   EVT VT = Op.getValueType();
 801   unsigned FP =
 802       Subtarget->getRegisterInfo()->getFrameRegister(DAG.getMachineFunction());
 803   return DAG.getCopyFromReg(DAG.getEntryNode(), SDLoc(Op), FP, VT);
 804 }
 805
 806 SDValue WebAssemblyTargetLowering::LowerGlobalAddress(SDValue Op,
 807                                                       SelectionDAG &DAG) const {
 808   SDLoc DL(Op);
 809   const auto *GA = cast<GlobalAddressSDNode>(Op);
 810   EVT VT = Op.getValueType();
 811   assert(GA->getTargetFlags() == 0 &&
 812          "Unexpected target flags on generic GlobalAddressSDNode");
 813   if (GA->getAddressSpace() != 0)
 814     fail(DL, DAG, "WebAssembly only expects the 0 address space");
 815   return DAG.getNode(
 816       WebAssemblyISD::Wrapper, DL, VT,
 817       DAG.getTargetGlobalAddress(GA->getGlobal(), DL, VT, GA->getOffset()));
 818 }
 819
 820 SDValue WebAssemblyTargetLowering::LowerExternalSymbol(
 821     SDValue Op, SelectionDAG &DAG) const {
 822   SDLoc DL(Op);
 823   const auto *ES = cast<ExternalSymbolSDNode>(Op);
 824   EVT VT = Op.getValueType();
 825   assert(ES->getTargetFlags() == 0 &&
 826          "Unexpected target flags on generic ExternalSymbolSDNode");
 827   // Set the TargetFlags to 0x1 which indicates that this is a "function"
 828   // symbol rather than a data symbol. We do this unconditionally even though
 829   // we don't know anything about the symbol other than its name, because all
 830   // external symbols used in target-independent SelectionDAG code are for
 831   // functions.
 832   return DAG.getNode(WebAssemblyISD::Wrapper, DL, VT,
 833                      DAG.getTargetExternalSymbol(ES->getSymbol(), VT,
 834                                                  /*TargetFlags=*/0x1));
 835 }
 836
 837 SDValue WebAssemblyTargetLowering::LowerJumpTable(SDValue Op,
 838                                                   SelectionDAG &DAG) const {
 839   // There's no need for a Wrapper node because we always incorporate a jump
 840   // table operand into a BR_TABLE instruction, rather than ever
 841   // materializing it in a register.
 842   const JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
 843   return DAG.getTargetJumpTable(JT->getIndex(), Op.getValueType(),
 844                                 JT->getTargetFlags());
 845 }
 846
 847 SDValue WebAssemblyTargetLowering::LowerBR_JT(SDValue Op,
 848                                               SelectionDAG &DAG) const {
 849   SDLoc DL(Op);
 850   SDValue Chain = Op.getOperand(0);
 851   const auto *JT = cast<JumpTableSDNode>(Op.getOperand(1));
 852   SDValue Index = Op.getOperand(2);
 853   assert(JT->getTargetFlags() == 0 && "WebAssembly doesn't set target flags");
 854
 855   SmallVector<SDValue, 8> Ops;
 856   Ops.push_back(Chain);
 857   Ops.push_back(Index);
 858
 859   MachineJumpTableInfo *MJTI = DAG.getMachineFunction().getJumpTableInfo();
 860   const auto &MBBs = MJTI->getJumpTables()[JT->getIndex()].MBBs;
 861
 862   // Add an operand for each case.
 863   for (auto MBB : MBBs) Ops.push_back(DAG.getBasicBlock(MBB));
 864
 865   // TODO: For now, we just pick something arbitrary for a default case for now.
 866   // We really want to sniff out the guard and put in the real default case (and
 867   // delete the guard).
 868   Ops.push_back(DAG.getBasicBlock(MBBs[0]));
 869
 870   return DAG.getNode(WebAssemblyISD::BR_TABLE, DL, MVT::Other, Ops);
 871 }
 872
 873 SDValue WebAssemblyTargetLowering::LowerVASTART(SDValue Op,
 874                                                 SelectionDAG &DAG) const {
 875   SDLoc DL(Op);
 876   EVT PtrVT = getPointerTy(DAG.getMachineFunction().getDataLayout());
 877
 878   auto *MFI = DAG.getMachineFunction().getInfo<WebAssemblyFunctionInfo>();
 879   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
 880
 881   SDValue ArgN = DAG.getCopyFromReg(DAG.getEntryNode(), DL,
 882                                     MFI->getVarargBufferVreg(), PtrVT);
 883   return DAG.getStore(Op.getOperand(0), DL, ArgN, Op.getOperand(1),
 884                       MachinePointerInfo(SV), 0);
 885 }
 886
 887 SDValue
 888 WebAssemblyTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
 889                                                    SelectionDAG &DAG) const {
 890   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
 891   SDLoc DL(Op);
 892   switch (IntNo) {
 893   default:
 894     return {}; // Don't custom lower most intrinsics.
 895
 896   case Intrinsic::wasm_lsda:
 897     // TODO For now, just return 0 not to crash
 898     return DAG.getConstant(0, DL, Op.getValueType());
 899   }
 900 }
 901
 902 //===----------------------------------------------------------------------===//
 903 //                          WebAssembly Optimization Hooks
 904 //===----------------------------------------------------------------------===//