| File: | lib/CodeGen/GlobalISel/IRTranslator.cpp |
| Warning: | line 352, column 57 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | //===- llvm/CodeGen/GlobalISel/IRTranslator.cpp - IRTranslator ---*- C++ -*-==// | ||||||||
| 2 | // | ||||||||
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | ||||||||
| 4 | // See https://llvm.org/LICENSE.txt for license information. | ||||||||
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | ||||||||
| 6 | // | ||||||||
| 7 | //===----------------------------------------------------------------------===// | ||||||||
| 8 | /// \file | ||||||||
| 9 | /// This file implements the IRTranslator class. | ||||||||
| 10 | //===----------------------------------------------------------------------===// | ||||||||
| 11 | |||||||||
| 12 | #include "llvm/CodeGen/GlobalISel/IRTranslator.h" | ||||||||
| 13 | #include "llvm/ADT/PostOrderIterator.h" | ||||||||
| 14 | #include "llvm/ADT/STLExtras.h" | ||||||||
| 15 | #include "llvm/ADT/ScopeExit.h" | ||||||||
| 16 | #include "llvm/ADT/SmallSet.h" | ||||||||
| 17 | #include "llvm/ADT/SmallVector.h" | ||||||||
| 18 | #include "llvm/Analysis/BranchProbabilityInfo.h" | ||||||||
| 19 | #include "llvm/Analysis/OptimizationRemarkEmitter.h" | ||||||||
| 20 | #include "llvm/Analysis/ValueTracking.h" | ||||||||
| 21 | #include "llvm/CodeGen/Analysis.h" | ||||||||
| 22 | #include "llvm/CodeGen/FunctionLoweringInfo.h" | ||||||||
| 23 | #include "llvm/CodeGen/GlobalISel/CallLowering.h" | ||||||||
| 24 | #include "llvm/CodeGen/GlobalISel/GISelChangeObserver.h" | ||||||||
| 25 | #include "llvm/CodeGen/LowLevelType.h" | ||||||||
| 26 | #include "llvm/CodeGen/MachineBasicBlock.h" | ||||||||
| 27 | #include "llvm/CodeGen/MachineFrameInfo.h" | ||||||||
| 28 | #include "llvm/CodeGen/MachineFunction.h" | ||||||||
| 29 | #include "llvm/CodeGen/MachineInstrBuilder.h" | ||||||||
| 30 | #include "llvm/CodeGen/MachineMemOperand.h" | ||||||||
| 31 | #include "llvm/CodeGen/MachineOperand.h" | ||||||||
| 32 | #include "llvm/CodeGen/MachineRegisterInfo.h" | ||||||||
| 33 | #include "llvm/CodeGen/StackProtector.h" | ||||||||
| 34 | #include "llvm/CodeGen/TargetFrameLowering.h" | ||||||||
| 35 | #include "llvm/CodeGen/TargetInstrInfo.h" | ||||||||
| 36 | #include "llvm/CodeGen/TargetLowering.h" | ||||||||
| 37 | #include "llvm/CodeGen/TargetPassConfig.h" | ||||||||
| 38 | #include "llvm/CodeGen/TargetRegisterInfo.h" | ||||||||
| 39 | #include "llvm/CodeGen/TargetSubtargetInfo.h" | ||||||||
| 40 | #include "llvm/IR/BasicBlock.h" | ||||||||
| 41 | #include "llvm/IR/CFG.h" | ||||||||
| 42 | #include "llvm/IR/Constant.h" | ||||||||
| 43 | #include "llvm/IR/Constants.h" | ||||||||
| 44 | #include "llvm/IR/DataLayout.h" | ||||||||
| 45 | #include "llvm/IR/DebugInfo.h" | ||||||||
| 46 | #include "llvm/IR/DerivedTypes.h" | ||||||||
| 47 | #include "llvm/IR/Function.h" | ||||||||
| 48 | #include "llvm/IR/GetElementPtrTypeIterator.h" | ||||||||
| 49 | #include "llvm/IR/InlineAsm.h" | ||||||||
| 50 | #include "llvm/IR/InstrTypes.h" | ||||||||
| 51 | #include "llvm/IR/Instructions.h" | ||||||||
| 52 | #include "llvm/IR/IntrinsicInst.h" | ||||||||
| 53 | #include "llvm/IR/Intrinsics.h" | ||||||||
| 54 | #include "llvm/IR/LLVMContext.h" | ||||||||
| 55 | #include "llvm/IR/Metadata.h" | ||||||||
| 56 | #include "llvm/IR/Type.h" | ||||||||
| 57 | #include "llvm/IR/User.h" | ||||||||
| 58 | #include "llvm/IR/Value.h" | ||||||||
| 59 | #include "llvm/MC/MCContext.h" | ||||||||
| 60 | #include "llvm/Pass.h" | ||||||||
| 61 | #include "llvm/Support/Casting.h" | ||||||||
| 62 | #include "llvm/Support/CodeGen.h" | ||||||||
| 63 | #include "llvm/Support/Debug.h" | ||||||||
| 64 | #include "llvm/Support/ErrorHandling.h" | ||||||||
| 65 | #include "llvm/Support/LowLevelTypeImpl.h" | ||||||||
| 66 | #include "llvm/Support/MathExtras.h" | ||||||||
| 67 | #include "llvm/Support/raw_ostream.h" | ||||||||
| 68 | #include "llvm/Target/TargetIntrinsicInfo.h" | ||||||||
| 69 | #include "llvm/Target/TargetMachine.h" | ||||||||
| 70 | #include <algorithm> | ||||||||
| 71 | #include <cassert> | ||||||||
| 72 | #include <cstdint> | ||||||||
| 73 | #include <iterator> | ||||||||
| 74 | #include <string> | ||||||||
| 75 | #include <utility> | ||||||||
| 76 | #include <vector> | ||||||||
| 77 | |||||||||
| 78 | #define DEBUG_TYPE"irtranslator" "irtranslator" | ||||||||
| 79 | |||||||||
| 80 | using namespace llvm; | ||||||||
| 81 | |||||||||
| 82 | static cl::opt<bool> | ||||||||
| 83 | EnableCSEInIRTranslator("enable-cse-in-irtranslator", | ||||||||
| 84 | cl::desc("Should enable CSE in irtranslator"), | ||||||||
| 85 | cl::Optional, cl::init(false)); | ||||||||
| 86 | char IRTranslator::ID = 0; | ||||||||
| 87 | |||||||||
| 88 | INITIALIZE_PASS_BEGIN(IRTranslator, DEBUG_TYPE, "IRTranslator LLVM IR -> MI",static void *initializeIRTranslatorPassOnce(PassRegistry & Registry) { | ||||||||
| 89 | false, false)static void *initializeIRTranslatorPassOnce(PassRegistry & Registry) { | ||||||||
| 90 | INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)initializeTargetPassConfigPass(Registry); | ||||||||
| 91 | INITIALIZE_PASS_DEPENDENCY(GISelCSEAnalysisWrapperPass)initializeGISelCSEAnalysisWrapperPassPass(Registry); | ||||||||
| 92 | INITIALIZE_PASS_END(IRTranslator, DEBUG_TYPE, "IRTranslator LLVM IR -> MI",PassInfo *PI = new PassInfo( "IRTranslator LLVM IR -> MI", "irtranslator", &IRTranslator::ID, PassInfo::NormalCtor_t (callDefaultCtor<IRTranslator>), false, false); Registry .registerPass(*PI, true); return PI; } static llvm::once_flag InitializeIRTranslatorPassFlag; void llvm::initializeIRTranslatorPass (PassRegistry &Registry) { llvm::call_once(InitializeIRTranslatorPassFlag , initializeIRTranslatorPassOnce, std::ref(Registry)); } | ||||||||
| 93 | false, false)PassInfo *PI = new PassInfo( "IRTranslator LLVM IR -> MI", "irtranslator", &IRTranslator::ID, PassInfo::NormalCtor_t (callDefaultCtor<IRTranslator>), false, false); Registry .registerPass(*PI, true); return PI; } static llvm::once_flag InitializeIRTranslatorPassFlag; void llvm::initializeIRTranslatorPass (PassRegistry &Registry) { llvm::call_once(InitializeIRTranslatorPassFlag , initializeIRTranslatorPassOnce, std::ref(Registry)); } | ||||||||
| 94 | |||||||||
| 95 | static void reportTranslationError(MachineFunction &MF, | ||||||||
| 96 | const TargetPassConfig &TPC, | ||||||||
| 97 | OptimizationRemarkEmitter &ORE, | ||||||||
| 98 | OptimizationRemarkMissed &R) { | ||||||||
| 99 | MF.getProperties().set(MachineFunctionProperties::Property::FailedISel); | ||||||||
| 100 | |||||||||
| 101 | // Print the function name explicitly if we don't have a debug location (which | ||||||||
| 102 | // makes the diagnostic less useful) or if we're going to emit a raw error. | ||||||||
| 103 | if (!R.getLocation().isValid() || TPC.isGlobalISelAbortEnabled()) | ||||||||
| 104 | R << (" (in function: " + MF.getName() + ")").str(); | ||||||||
| 105 | |||||||||
| 106 | if (TPC.isGlobalISelAbortEnabled()) | ||||||||
| 107 | report_fatal_error(R.getMsg()); | ||||||||
| 108 | else | ||||||||
| 109 | ORE.emit(R); | ||||||||
| 110 | } | ||||||||
| 111 | |||||||||
| 112 | IRTranslator::IRTranslator() : MachineFunctionPass(ID) { } | ||||||||
| 113 | |||||||||
| 114 | #ifndef NDEBUG | ||||||||
| 115 | namespace { | ||||||||
| 116 | /// Verify that every instruction created has the same DILocation as the | ||||||||
| 117 | /// instruction being translated. | ||||||||
| 118 | class DILocationVerifier : public GISelChangeObserver { | ||||||||
| 119 | const Instruction *CurrInst = nullptr; | ||||||||
| 120 | |||||||||
| 121 | public: | ||||||||
| 122 | DILocationVerifier() = default; | ||||||||
| 123 | ~DILocationVerifier() = default; | ||||||||
| 124 | |||||||||
| 125 | const Instruction *getCurrentInst() const { return CurrInst; } | ||||||||
| 126 | void setCurrentInst(const Instruction *Inst) { CurrInst = Inst; } | ||||||||
| 127 | |||||||||
| 128 | void erasingInstr(MachineInstr &MI) override {} | ||||||||
| 129 | void changingInstr(MachineInstr &MI) override {} | ||||||||
| 130 | void changedInstr(MachineInstr &MI) override {} | ||||||||
| 131 | |||||||||
| 132 | void createdInstr(MachineInstr &MI) override { | ||||||||
| 133 | assert(getCurrentInst() && "Inserted instruction without a current MI")((getCurrentInst() && "Inserted instruction without a current MI" ) ? static_cast<void> (0) : __assert_fail ("getCurrentInst() && \"Inserted instruction without a current MI\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 133, __PRETTY_FUNCTION__)); | ||||||||
| 134 | |||||||||
| 135 | // Only print the check message if we're actually checking it. | ||||||||
| 136 | #ifndef NDEBUG | ||||||||
| 137 | LLVM_DEBUG(dbgs() << "Checking DILocation from " << *CurrInstdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { dbgs() << "Checking DILocation from " << *CurrInst << " was copied to " << MI; } } while (false) | ||||||||
| 138 | << " was copied to " << MI)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { dbgs() << "Checking DILocation from " << *CurrInst << " was copied to " << MI; } } while (false); | ||||||||
| 139 | #endif | ||||||||
| 140 | // We allow insts in the entry block to have a debug loc line of 0 because | ||||||||
| 141 | // they could have originated from constants, and we don't want a jumpy | ||||||||
| 142 | // debug experience. | ||||||||
| 143 | assert((CurrInst->getDebugLoc() == MI.getDebugLoc() ||(((CurrInst->getDebugLoc() == MI.getDebugLoc() || MI.getDebugLoc ().getLine() == 0) && "Line info was not transferred to all instructions" ) ? static_cast<void> (0) : __assert_fail ("(CurrInst->getDebugLoc() == MI.getDebugLoc() || MI.getDebugLoc().getLine() == 0) && \"Line info was not transferred to all instructions\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 145, __PRETTY_FUNCTION__)) | ||||||||
| 144 | MI.getDebugLoc().getLine() == 0) &&(((CurrInst->getDebugLoc() == MI.getDebugLoc() || MI.getDebugLoc ().getLine() == 0) && "Line info was not transferred to all instructions" ) ? static_cast<void> (0) : __assert_fail ("(CurrInst->getDebugLoc() == MI.getDebugLoc() || MI.getDebugLoc().getLine() == 0) && \"Line info was not transferred to all instructions\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 145, __PRETTY_FUNCTION__)) | ||||||||
| 145 | "Line info was not transferred to all instructions")(((CurrInst->getDebugLoc() == MI.getDebugLoc() || MI.getDebugLoc ().getLine() == 0) && "Line info was not transferred to all instructions" ) ? static_cast<void> (0) : __assert_fail ("(CurrInst->getDebugLoc() == MI.getDebugLoc() || MI.getDebugLoc().getLine() == 0) && \"Line info was not transferred to all instructions\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 145, __PRETTY_FUNCTION__)); | ||||||||
| 146 | } | ||||||||
| 147 | }; | ||||||||
| 148 | } // namespace | ||||||||
| 149 | #endif // ifndef NDEBUG | ||||||||
| 150 | |||||||||
| 151 | |||||||||
| 152 | void IRTranslator::getAnalysisUsage(AnalysisUsage &AU) const { | ||||||||
| 153 | AU.addRequired<StackProtector>(); | ||||||||
| 154 | AU.addRequired<TargetPassConfig>(); | ||||||||
| 155 | AU.addRequired<GISelCSEAnalysisWrapperPass>(); | ||||||||
| 156 | getSelectionDAGFallbackAnalysisUsage(AU); | ||||||||
| 157 | MachineFunctionPass::getAnalysisUsage(AU); | ||||||||
| 158 | } | ||||||||
| 159 | |||||||||
| 160 | IRTranslator::ValueToVRegInfo::VRegListT & | ||||||||
| 161 | IRTranslator::allocateVRegs(const Value &Val) { | ||||||||
| 162 | assert(!VMap.contains(Val) && "Value already allocated in VMap")((!VMap.contains(Val) && "Value already allocated in VMap" ) ? static_cast<void> (0) : __assert_fail ("!VMap.contains(Val) && \"Value already allocated in VMap\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 162, __PRETTY_FUNCTION__)); | ||||||||
| 163 | auto *Regs = VMap.getVRegs(Val); | ||||||||
| 164 | auto *Offsets = VMap.getOffsets(Val); | ||||||||
| 165 | SmallVector<LLT, 4> SplitTys; | ||||||||
| 166 | computeValueLLTs(*DL, *Val.getType(), SplitTys, | ||||||||
| 167 | Offsets->empty() ? Offsets : nullptr); | ||||||||
| 168 | for (unsigned i = 0; i < SplitTys.size(); ++i) | ||||||||
| 169 | Regs->push_back(0); | ||||||||
| 170 | return *Regs; | ||||||||
| 171 | } | ||||||||
| 172 | |||||||||
| 173 | ArrayRef<Register> IRTranslator::getOrCreateVRegs(const Value &Val) { | ||||||||
| 174 | auto VRegsIt = VMap.findVRegs(Val); | ||||||||
| 175 | if (VRegsIt != VMap.vregs_end()) | ||||||||
| 176 | return *VRegsIt->second; | ||||||||
| 177 | |||||||||
| 178 | if (Val.getType()->isVoidTy()) | ||||||||
| 179 | return *VMap.getVRegs(Val); | ||||||||
| 180 | |||||||||
| 181 | // Create entry for this type. | ||||||||
| 182 | auto *VRegs = VMap.getVRegs(Val); | ||||||||
| 183 | auto *Offsets = VMap.getOffsets(Val); | ||||||||
| 184 | |||||||||
| 185 | assert(Val.getType()->isSized() &&((Val.getType()->isSized() && "Don't know how to create an empty vreg" ) ? static_cast<void> (0) : __assert_fail ("Val.getType()->isSized() && \"Don't know how to create an empty vreg\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 186, __PRETTY_FUNCTION__)) | ||||||||
| 186 | "Don't know how to create an empty vreg")((Val.getType()->isSized() && "Don't know how to create an empty vreg" ) ? static_cast<void> (0) : __assert_fail ("Val.getType()->isSized() && \"Don't know how to create an empty vreg\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 186, __PRETTY_FUNCTION__)); | ||||||||
| 187 | |||||||||
| 188 | SmallVector<LLT, 4> SplitTys; | ||||||||
| 189 | computeValueLLTs(*DL, *Val.getType(), SplitTys, | ||||||||
| 190 | Offsets->empty() ? Offsets : nullptr); | ||||||||
| 191 | |||||||||
| 192 | if (!isa<Constant>(Val)) { | ||||||||
| 193 | for (auto Ty : SplitTys) | ||||||||
| 194 | VRegs->push_back(MRI->createGenericVirtualRegister(Ty)); | ||||||||
| 195 | return *VRegs; | ||||||||
| 196 | } | ||||||||
| 197 | |||||||||
| 198 | if (Val.getType()->isAggregateType()) { | ||||||||
| 199 | // UndefValue, ConstantAggregateZero | ||||||||
| 200 | auto &C = cast<Constant>(Val); | ||||||||
| 201 | unsigned Idx = 0; | ||||||||
| 202 | while (auto Elt = C.getAggregateElement(Idx++)) { | ||||||||
| 203 | auto EltRegs = getOrCreateVRegs(*Elt); | ||||||||
| 204 | llvm::copy(EltRegs, std::back_inserter(*VRegs)); | ||||||||
| 205 | } | ||||||||
| 206 | } else { | ||||||||
| 207 | assert(SplitTys.size() == 1 && "unexpectedly split LLT")((SplitTys.size() == 1 && "unexpectedly split LLT") ? static_cast<void> (0) : __assert_fail ("SplitTys.size() == 1 && \"unexpectedly split LLT\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 207, __PRETTY_FUNCTION__)); | ||||||||
| 208 | VRegs->push_back(MRI->createGenericVirtualRegister(SplitTys[0])); | ||||||||
| 209 | bool Success = translate(cast<Constant>(Val), VRegs->front()); | ||||||||
| 210 | if (!Success) { | ||||||||
| 211 | OptimizationRemarkMissed R("gisel-irtranslator", "GISelFailure", | ||||||||
| 212 | MF->getFunction().getSubprogram(), | ||||||||
| 213 | &MF->getFunction().getEntryBlock()); | ||||||||
| 214 | R << "unable to translate constant: " << ore::NV("Type", Val.getType()); | ||||||||
| 215 | reportTranslationError(*MF, *TPC, *ORE, R); | ||||||||
| 216 | return *VRegs; | ||||||||
| 217 | } | ||||||||
| 218 | } | ||||||||
| 219 | |||||||||
| 220 | return *VRegs; | ||||||||
| 221 | } | ||||||||
| 222 | |||||||||
| 223 | int IRTranslator::getOrCreateFrameIndex(const AllocaInst &AI) { | ||||||||
| 224 | if (FrameIndices.find(&AI) != FrameIndices.end()) | ||||||||
| 225 | return FrameIndices[&AI]; | ||||||||
| 226 | |||||||||
| 227 | unsigned ElementSize = DL->getTypeAllocSize(AI.getAllocatedType()); | ||||||||
| 228 | unsigned Size = | ||||||||
| 229 | ElementSize * cast<ConstantInt>(AI.getArraySize())->getZExtValue(); | ||||||||
| 230 | |||||||||
| 231 | // Always allocate at least one byte. | ||||||||
| 232 | Size = std::max(Size, 1u); | ||||||||
| 233 | |||||||||
| 234 | unsigned Alignment = AI.getAlignment(); | ||||||||
| 235 | if (!Alignment) | ||||||||
| 236 | Alignment = DL->getABITypeAlignment(AI.getAllocatedType()); | ||||||||
| 237 | |||||||||
| 238 | int &FI = FrameIndices[&AI]; | ||||||||
| 239 | FI = MF->getFrameInfo().CreateStackObject(Size, Alignment, false, &AI); | ||||||||
| 240 | return FI; | ||||||||
| 241 | } | ||||||||
| 242 | |||||||||
| 243 | unsigned IRTranslator::getMemOpAlignment(const Instruction &I) { | ||||||||
| 244 | unsigned Alignment = 0; | ||||||||
| 245 | Type *ValTy = nullptr; | ||||||||
| 246 | if (const StoreInst *SI = dyn_cast<StoreInst>(&I)) { | ||||||||
| 247 | Alignment = SI->getAlignment(); | ||||||||
| 248 | ValTy = SI->getValueOperand()->getType(); | ||||||||
| 249 | } else if (const LoadInst *LI = dyn_cast<LoadInst>(&I)) { | ||||||||
| 250 | Alignment = LI->getAlignment(); | ||||||||
| 251 | ValTy = LI->getType(); | ||||||||
| 252 | } else if (const AtomicCmpXchgInst *AI = dyn_cast<AtomicCmpXchgInst>(&I)) { | ||||||||
| 253 | // TODO(PR27168): This instruction has no alignment attribute, but unlike | ||||||||
| 254 | // the default alignment for load/store, the default here is to assume | ||||||||
| 255 | // it has NATURAL alignment, not DataLayout-specified alignment. | ||||||||
| 256 | const DataLayout &DL = AI->getModule()->getDataLayout(); | ||||||||
| 257 | Alignment = DL.getTypeStoreSize(AI->getCompareOperand()->getType()); | ||||||||
| 258 | ValTy = AI->getCompareOperand()->getType(); | ||||||||
| 259 | } else if (const AtomicRMWInst *AI = dyn_cast<AtomicRMWInst>(&I)) { | ||||||||
| 260 | // TODO(PR27168): This instruction has no alignment attribute, but unlike | ||||||||
| 261 | // the default alignment for load/store, the default here is to assume | ||||||||
| 262 | // it has NATURAL alignment, not DataLayout-specified alignment. | ||||||||
| 263 | const DataLayout &DL = AI->getModule()->getDataLayout(); | ||||||||
| 264 | Alignment = DL.getTypeStoreSize(AI->getValOperand()->getType()); | ||||||||
| 265 | ValTy = AI->getType(); | ||||||||
| 266 | } else { | ||||||||
| 267 | OptimizationRemarkMissed R("gisel-irtranslator", "", &I); | ||||||||
| 268 | R << "unable to translate memop: " << ore::NV("Opcode", &I); | ||||||||
| 269 | reportTranslationError(*MF, *TPC, *ORE, R); | ||||||||
| 270 | return 1; | ||||||||
| 271 | } | ||||||||
| 272 | |||||||||
| 273 | return Alignment ? Alignment : DL->getABITypeAlignment(ValTy); | ||||||||
| 274 | } | ||||||||
| 275 | |||||||||
| 276 | MachineBasicBlock &IRTranslator::getMBB(const BasicBlock &BB) { | ||||||||
| 277 | MachineBasicBlock *&MBB = BBToMBB[&BB]; | ||||||||
| 278 | assert(MBB && "BasicBlock was not encountered before")((MBB && "BasicBlock was not encountered before") ? static_cast <void> (0) : __assert_fail ("MBB && \"BasicBlock was not encountered before\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 278, __PRETTY_FUNCTION__)); | ||||||||
| 279 | return *MBB; | ||||||||
| 280 | } | ||||||||
| 281 | |||||||||
| 282 | void IRTranslator::addMachineCFGPred(CFGEdge Edge, MachineBasicBlock *NewPred) { | ||||||||
| 283 | assert(NewPred && "new predecessor must be a real MachineBasicBlock")((NewPred && "new predecessor must be a real MachineBasicBlock" ) ? static_cast<void> (0) : __assert_fail ("NewPred && \"new predecessor must be a real MachineBasicBlock\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 283, __PRETTY_FUNCTION__)); | ||||||||
| 284 | MachinePreds[Edge].push_back(NewPred); | ||||||||
| 285 | } | ||||||||
| 286 | |||||||||
| 287 | bool IRTranslator::translateBinaryOp(unsigned Opcode, const User &U, | ||||||||
| 288 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 289 | // Get or create a virtual register for each value. | ||||||||
| 290 | // Unless the value is a Constant => loadimm cst? | ||||||||
| 291 | // or inline constant each time? | ||||||||
| 292 | // Creation of a virtual register needs to have a size. | ||||||||
| 293 | Register Op0 = getOrCreateVReg(*U.getOperand(0)); | ||||||||
| 294 | Register Op1 = getOrCreateVReg(*U.getOperand(1)); | ||||||||
| 295 | Register Res = getOrCreateVReg(U); | ||||||||
| 296 | uint16_t Flags = 0; | ||||||||
| 297 | if (isa<Instruction>(U)) { | ||||||||
| 298 | const Instruction &I = cast<Instruction>(U); | ||||||||
| 299 | Flags = MachineInstr::copyFlagsFromInstruction(I); | ||||||||
| 300 | } | ||||||||
| 301 | |||||||||
| 302 | MIRBuilder.buildInstr(Opcode, {Res}, {Op0, Op1}, Flags); | ||||||||
| 303 | return true; | ||||||||
| 304 | } | ||||||||
| 305 | |||||||||
| 306 | bool IRTranslator::translateFSub(const User &U, MachineIRBuilder &MIRBuilder) { | ||||||||
| 307 | // -0.0 - X --> G_FNEG | ||||||||
| 308 | if (isa<Constant>(U.getOperand(0)) && | ||||||||
| 309 | U.getOperand(0) == ConstantFP::getZeroValueForNegation(U.getType())) { | ||||||||
| 310 | Register Op1 = getOrCreateVReg(*U.getOperand(1)); | ||||||||
| 311 | Register Res = getOrCreateVReg(U); | ||||||||
| 312 | uint16_t Flags = 0; | ||||||||
| 313 | if (isa<Instruction>(U)) { | ||||||||
| 314 | const Instruction &I = cast<Instruction>(U); | ||||||||
| 315 | Flags = MachineInstr::copyFlagsFromInstruction(I); | ||||||||
| 316 | } | ||||||||
| 317 | // Negate the last operand of the FSUB | ||||||||
| 318 | MIRBuilder.buildInstr(TargetOpcode::G_FNEG, {Res}, {Op1}, Flags); | ||||||||
| 319 | return true; | ||||||||
| 320 | } | ||||||||
| 321 | return translateBinaryOp(TargetOpcode::G_FSUB, U, MIRBuilder); | ||||||||
| 322 | } | ||||||||
| 323 | |||||||||
| 324 | bool IRTranslator::translateFNeg(const User &U, MachineIRBuilder &MIRBuilder) { | ||||||||
| 325 | Register Op0 = getOrCreateVReg(*U.getOperand(0)); | ||||||||
| 326 | Register Res = getOrCreateVReg(U); | ||||||||
| 327 | uint16_t Flags = 0; | ||||||||
| 328 | if (isa<Instruction>(U)) { | ||||||||
| 329 | const Instruction &I = cast<Instruction>(U); | ||||||||
| 330 | Flags = MachineInstr::copyFlagsFromInstruction(I); | ||||||||
| 331 | } | ||||||||
| 332 | MIRBuilder.buildInstr(TargetOpcode::G_FNEG, {Res}, {Op0}, Flags); | ||||||||
| 333 | return true; | ||||||||
| 334 | } | ||||||||
| 335 | |||||||||
| 336 | bool IRTranslator::translateCompare(const User &U, | ||||||||
| 337 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 338 | const CmpInst *CI = dyn_cast<CmpInst>(&U); | ||||||||
| 339 | Register Op0 = getOrCreateVReg(*U.getOperand(0)); | ||||||||
| 340 | Register Op1 = getOrCreateVReg(*U.getOperand(1)); | ||||||||
| 341 | Register Res = getOrCreateVReg(U); | ||||||||
| 342 | CmpInst::Predicate Pred = | ||||||||
| 343 | CI
| ||||||||
| 344 | cast<ConstantExpr>(U).getPredicate()); | ||||||||
| 345 | if (CmpInst::isIntPredicate(Pred)) | ||||||||
| 346 | MIRBuilder.buildICmp(Pred, Res, Op0, Op1); | ||||||||
| 347 | else if (Pred == CmpInst::FCMP_FALSE) | ||||||||
| 348 | MIRBuilder.buildCopy( | ||||||||
| 349 | Res, getOrCreateVReg(*Constant::getNullValue(CI->getType()))); | ||||||||
| 350 | else if (Pred == CmpInst::FCMP_TRUE) | ||||||||
| 351 | MIRBuilder.buildCopy( | ||||||||
| 352 | Res, getOrCreateVReg(*Constant::getAllOnesValue(CI->getType()))); | ||||||||
| |||||||||
| 353 | else { | ||||||||
| 354 | MIRBuilder.buildInstr(TargetOpcode::G_FCMP, {Res}, {Pred, Op0, Op1}, | ||||||||
| 355 | MachineInstr::copyFlagsFromInstruction(*CI)); | ||||||||
| 356 | } | ||||||||
| 357 | |||||||||
| 358 | return true; | ||||||||
| 359 | } | ||||||||
| 360 | |||||||||
| 361 | bool IRTranslator::translateRet(const User &U, MachineIRBuilder &MIRBuilder) { | ||||||||
| 362 | const ReturnInst &RI = cast<ReturnInst>(U); | ||||||||
| 363 | const Value *Ret = RI.getReturnValue(); | ||||||||
| 364 | if (Ret && DL->getTypeStoreSize(Ret->getType()) == 0) | ||||||||
| 365 | Ret = nullptr; | ||||||||
| 366 | |||||||||
| 367 | ArrayRef<Register> VRegs; | ||||||||
| 368 | if (Ret) | ||||||||
| 369 | VRegs = getOrCreateVRegs(*Ret); | ||||||||
| 370 | |||||||||
| 371 | Register SwiftErrorVReg = 0; | ||||||||
| 372 | if (CLI->supportSwiftError() && SwiftError.getFunctionArg()) { | ||||||||
| 373 | SwiftErrorVReg = SwiftError.getOrCreateVRegUseAt( | ||||||||
| 374 | &RI, &MIRBuilder.getMBB(), SwiftError.getFunctionArg()); | ||||||||
| 375 | } | ||||||||
| 376 | |||||||||
| 377 | // The target may mess up with the insertion point, but | ||||||||
| 378 | // this is not important as a return is the last instruction | ||||||||
| 379 | // of the block anyway. | ||||||||
| 380 | return CLI->lowerReturn(MIRBuilder, Ret, VRegs, SwiftErrorVReg); | ||||||||
| 381 | } | ||||||||
| 382 | |||||||||
| 383 | bool IRTranslator::translateBr(const User &U, MachineIRBuilder &MIRBuilder) { | ||||||||
| 384 | const BranchInst &BrInst = cast<BranchInst>(U); | ||||||||
| 385 | unsigned Succ = 0; | ||||||||
| 386 | if (!BrInst.isUnconditional()) { | ||||||||
| 387 | // We want a G_BRCOND to the true BB followed by an unconditional branch. | ||||||||
| 388 | Register Tst = getOrCreateVReg(*BrInst.getCondition()); | ||||||||
| 389 | const BasicBlock &TrueTgt = *cast<BasicBlock>(BrInst.getSuccessor(Succ++)); | ||||||||
| 390 | MachineBasicBlock &TrueBB = getMBB(TrueTgt); | ||||||||
| 391 | MIRBuilder.buildBrCond(Tst, TrueBB); | ||||||||
| 392 | } | ||||||||
| 393 | |||||||||
| 394 | const BasicBlock &BrTgt = *cast<BasicBlock>(BrInst.getSuccessor(Succ)); | ||||||||
| 395 | MachineBasicBlock &TgtBB = getMBB(BrTgt); | ||||||||
| 396 | MachineBasicBlock &CurBB = MIRBuilder.getMBB(); | ||||||||
| 397 | |||||||||
| 398 | // If the unconditional target is the layout successor, fallthrough. | ||||||||
| 399 | if (!CurBB.isLayoutSuccessor(&TgtBB)) | ||||||||
| 400 | MIRBuilder.buildBr(TgtBB); | ||||||||
| 401 | |||||||||
| 402 | // Link successors. | ||||||||
| 403 | for (const BasicBlock *Succ : successors(&BrInst)) | ||||||||
| 404 | CurBB.addSuccessor(&getMBB(*Succ)); | ||||||||
| 405 | return true; | ||||||||
| 406 | } | ||||||||
| 407 | |||||||||
| 408 | void IRTranslator::addSuccessorWithProb(MachineBasicBlock *Src, | ||||||||
| 409 | MachineBasicBlock *Dst, | ||||||||
| 410 | BranchProbability Prob) { | ||||||||
| 411 | if (!FuncInfo.BPI) { | ||||||||
| 412 | Src->addSuccessorWithoutProb(Dst); | ||||||||
| 413 | return; | ||||||||
| 414 | } | ||||||||
| 415 | if (Prob.isUnknown()) | ||||||||
| 416 | Prob = getEdgeProbability(Src, Dst); | ||||||||
| 417 | Src->addSuccessor(Dst, Prob); | ||||||||
| 418 | } | ||||||||
| 419 | |||||||||
| 420 | BranchProbability | ||||||||
| 421 | IRTranslator::getEdgeProbability(const MachineBasicBlock *Src, | ||||||||
| 422 | const MachineBasicBlock *Dst) const { | ||||||||
| 423 | const BasicBlock *SrcBB = Src->getBasicBlock(); | ||||||||
| 424 | const BasicBlock *DstBB = Dst->getBasicBlock(); | ||||||||
| 425 | if (!FuncInfo.BPI) { | ||||||||
| 426 | // If BPI is not available, set the default probability as 1 / N, where N is | ||||||||
| 427 | // the number of successors. | ||||||||
| 428 | auto SuccSize = std::max<uint32_t>(succ_size(SrcBB), 1); | ||||||||
| 429 | return BranchProbability(1, SuccSize); | ||||||||
| 430 | } | ||||||||
| 431 | return FuncInfo.BPI->getEdgeProbability(SrcBB, DstBB); | ||||||||
| 432 | } | ||||||||
| 433 | |||||||||
| 434 | bool IRTranslator::translateSwitch(const User &U, MachineIRBuilder &MIB) { | ||||||||
| 435 | using namespace SwitchCG; | ||||||||
| 436 | // Extract cases from the switch. | ||||||||
| 437 | const SwitchInst &SI = cast<SwitchInst>(U); | ||||||||
| 438 | BranchProbabilityInfo *BPI = FuncInfo.BPI; | ||||||||
| 439 | CaseClusterVector Clusters; | ||||||||
| 440 | Clusters.reserve(SI.getNumCases()); | ||||||||
| 441 | for (auto &I : SI.cases()) { | ||||||||
| 442 | MachineBasicBlock *Succ = &getMBB(*I.getCaseSuccessor()); | ||||||||
| 443 | assert(Succ && "Could not find successor mbb in mapping")((Succ && "Could not find successor mbb in mapping") ? static_cast<void> (0) : __assert_fail ("Succ && \"Could not find successor mbb in mapping\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 443, __PRETTY_FUNCTION__)); | ||||||||
| 444 | const ConstantInt *CaseVal = I.getCaseValue(); | ||||||||
| 445 | BranchProbability Prob = | ||||||||
| 446 | BPI ? BPI->getEdgeProbability(SI.getParent(), I.getSuccessorIndex()) | ||||||||
| 447 | : BranchProbability(1, SI.getNumCases() + 1); | ||||||||
| 448 | Clusters.push_back(CaseCluster::range(CaseVal, CaseVal, Succ, Prob)); | ||||||||
| 449 | } | ||||||||
| 450 | |||||||||
| 451 | MachineBasicBlock *DefaultMBB = &getMBB(*SI.getDefaultDest()); | ||||||||
| 452 | |||||||||
| 453 | // Cluster adjacent cases with the same destination. We do this at all | ||||||||
| 454 | // optimization levels because it's cheap to do and will make codegen faster | ||||||||
| 455 | // if there are many clusters. | ||||||||
| 456 | sortAndRangeify(Clusters); | ||||||||
| 457 | |||||||||
| 458 | MachineBasicBlock *SwitchMBB = &getMBB(*SI.getParent()); | ||||||||
| 459 | |||||||||
| 460 | // If there is only the default destination, jump there directly. | ||||||||
| 461 | if (Clusters.empty()) { | ||||||||
| 462 | SwitchMBB->addSuccessor(DefaultMBB); | ||||||||
| 463 | if (DefaultMBB != SwitchMBB->getNextNode()) | ||||||||
| 464 | MIB.buildBr(*DefaultMBB); | ||||||||
| 465 | return true; | ||||||||
| 466 | } | ||||||||
| 467 | |||||||||
| 468 | SL->findJumpTables(Clusters, &SI, DefaultMBB); | ||||||||
| 469 | |||||||||
| 470 | LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 471 | dbgs() << "Case clusters: ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 472 | for (const CaseCluster &C : Clusters) {do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 473 | if (C.Kind == CC_JumpTable)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 474 | dbgs() << "JT:";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 475 | if (C.Kind == CC_BitTests)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 476 | dbgs() << "BT:";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 477 | |||||||||
| 478 | C.Low->getValue().print(dbgs(), true);do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 479 | if (C.Low != C.High) {do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 480 | dbgs() << '-';do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 481 | C.High->getValue().print(dbgs(), true);do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 482 | }do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 483 | dbgs() << ' ';do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 484 | }do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 485 | dbgs() << '\n';do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false) | ||||||||
| 486 | })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { { dbgs() << "Case clusters: "; for ( const CaseCluster &C : Clusters) { if (C.Kind == CC_JumpTable ) dbgs() << "JT:"; if (C.Kind == CC_BitTests) dbgs() << "BT:"; C.Low->getValue().print(dbgs(), true); if (C.Low != C.High) { dbgs() << '-'; C.High->getValue().print(dbgs (), true); } dbgs() << ' '; } dbgs() << '\n'; }; } } while (false); | ||||||||
| 487 | |||||||||
| 488 | assert(!Clusters.empty())((!Clusters.empty()) ? static_cast<void> (0) : __assert_fail ("!Clusters.empty()", "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 488, __PRETTY_FUNCTION__)); | ||||||||
| 489 | SwitchWorkList WorkList; | ||||||||
| 490 | CaseClusterIt First = Clusters.begin(); | ||||||||
| 491 | CaseClusterIt Last = Clusters.end() - 1; | ||||||||
| 492 | auto DefaultProb = getEdgeProbability(SwitchMBB, DefaultMBB); | ||||||||
| 493 | WorkList.push_back({SwitchMBB, First, Last, nullptr, nullptr, DefaultProb}); | ||||||||
| 494 | |||||||||
| 495 | // FIXME: At the moment we don't do any splitting optimizations here like | ||||||||
| 496 | // SelectionDAG does, so this worklist only has one entry. | ||||||||
| 497 | while (!WorkList.empty()) { | ||||||||
| 498 | SwitchWorkListItem W = WorkList.back(); | ||||||||
| 499 | WorkList.pop_back(); | ||||||||
| 500 | if (!lowerSwitchWorkItem(W, SI.getCondition(), SwitchMBB, DefaultMBB, MIB)) | ||||||||
| 501 | return false; | ||||||||
| 502 | } | ||||||||
| 503 | return true; | ||||||||
| 504 | } | ||||||||
| 505 | |||||||||
| 506 | void IRTranslator::emitJumpTable(SwitchCG::JumpTable &JT, | ||||||||
| 507 | MachineBasicBlock *MBB) { | ||||||||
| 508 | // Emit the code for the jump table | ||||||||
| 509 | assert(JT.Reg != -1U && "Should lower JT Header first!")((JT.Reg != -1U && "Should lower JT Header first!") ? static_cast<void> (0) : __assert_fail ("JT.Reg != -1U && \"Should lower JT Header first!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 509, __PRETTY_FUNCTION__)); | ||||||||
| 510 | MachineIRBuilder MIB(*MBB->getParent()); | ||||||||
| 511 | MIB.setMBB(*MBB); | ||||||||
| 512 | MIB.setDebugLoc(CurBuilder->getDebugLoc()); | ||||||||
| 513 | |||||||||
| 514 | Type *PtrIRTy = Type::getInt8PtrTy(MF->getFunction().getContext()); | ||||||||
| 515 | const LLT PtrTy = getLLTForType(*PtrIRTy, *DL); | ||||||||
| 516 | |||||||||
| 517 | auto Table = MIB.buildJumpTable(PtrTy, JT.JTI); | ||||||||
| 518 | MIB.buildBrJT(Table.getReg(0), JT.JTI, JT.Reg); | ||||||||
| 519 | } | ||||||||
| 520 | |||||||||
| 521 | bool IRTranslator::emitJumpTableHeader(SwitchCG::JumpTable &JT, | ||||||||
| 522 | SwitchCG::JumpTableHeader &JTH, | ||||||||
| 523 | MachineBasicBlock *HeaderBB) { | ||||||||
| 524 | MachineIRBuilder MIB(*HeaderBB->getParent()); | ||||||||
| 525 | MIB.setMBB(*HeaderBB); | ||||||||
| 526 | MIB.setDebugLoc(CurBuilder->getDebugLoc()); | ||||||||
| 527 | |||||||||
| 528 | const Value &SValue = *JTH.SValue; | ||||||||
| 529 | // Subtract the lowest switch case value from the value being switched on. | ||||||||
| 530 | const LLT SwitchTy = getLLTForType(*SValue.getType(), *DL); | ||||||||
| 531 | Register SwitchOpReg = getOrCreateVReg(SValue); | ||||||||
| 532 | auto FirstCst = MIB.buildConstant(SwitchTy, JTH.First); | ||||||||
| 533 | auto Sub = MIB.buildSub({SwitchTy}, SwitchOpReg, FirstCst); | ||||||||
| 534 | |||||||||
| 535 | // This value may be smaller or larger than the target's pointer type, and | ||||||||
| 536 | // therefore require extension or truncating. | ||||||||
| 537 | Type *PtrIRTy = SValue.getType()->getPointerTo(); | ||||||||
| 538 | const LLT PtrScalarTy = LLT::scalar(DL->getTypeSizeInBits(PtrIRTy)); | ||||||||
| 539 | Sub = MIB.buildZExtOrTrunc(PtrScalarTy, Sub); | ||||||||
| 540 | |||||||||
| 541 | JT.Reg = Sub.getReg(0); | ||||||||
| 542 | |||||||||
| 543 | if (JTH.OmitRangeCheck) { | ||||||||
| 544 | if (JT.MBB != HeaderBB->getNextNode()) | ||||||||
| 545 | MIB.buildBr(*JT.MBB); | ||||||||
| 546 | return true; | ||||||||
| 547 | } | ||||||||
| 548 | |||||||||
| 549 | // Emit the range check for the jump table, and branch to the default block | ||||||||
| 550 | // for the switch statement if the value being switched on exceeds the | ||||||||
| 551 | // largest case in the switch. | ||||||||
| 552 | auto Cst = getOrCreateVReg( | ||||||||
| 553 | *ConstantInt::get(SValue.getType(), JTH.Last - JTH.First)); | ||||||||
| 554 | Cst = MIB.buildZExtOrTrunc(PtrScalarTy, Cst).getReg(0); | ||||||||
| 555 | auto Cmp = MIB.buildICmp(CmpInst::ICMP_UGT, LLT::scalar(1), Sub, Cst); | ||||||||
| 556 | |||||||||
| 557 | auto BrCond = MIB.buildBrCond(Cmp.getReg(0), *JT.Default); | ||||||||
| 558 | |||||||||
| 559 | // Avoid emitting unnecessary branches to the next block. | ||||||||
| 560 | if (JT.MBB != HeaderBB->getNextNode()) | ||||||||
| 561 | BrCond = MIB.buildBr(*JT.MBB); | ||||||||
| 562 | return true; | ||||||||
| 563 | } | ||||||||
| 564 | |||||||||
| 565 | void IRTranslator::emitSwitchCase(SwitchCG::CaseBlock &CB, | ||||||||
| 566 | MachineBasicBlock *SwitchBB, | ||||||||
| 567 | MachineIRBuilder &MIB) { | ||||||||
| 568 | Register CondLHS = getOrCreateVReg(*CB.CmpLHS); | ||||||||
| 569 | Register Cond; | ||||||||
| 570 | DebugLoc OldDbgLoc = MIB.getDebugLoc(); | ||||||||
| 571 | MIB.setDebugLoc(CB.DbgLoc); | ||||||||
| 572 | MIB.setMBB(*CB.ThisBB); | ||||||||
| 573 | |||||||||
| 574 | if (CB.PredInfo.NoCmp) { | ||||||||
| 575 | // Branch or fall through to TrueBB. | ||||||||
| 576 | addSuccessorWithProb(CB.ThisBB, CB.TrueBB, CB.TrueProb); | ||||||||
| 577 | addMachineCFGPred({SwitchBB->getBasicBlock(), CB.TrueBB->getBasicBlock()}, | ||||||||
| 578 | CB.ThisBB); | ||||||||
| 579 | CB.ThisBB->normalizeSuccProbs(); | ||||||||
| 580 | if (CB.TrueBB != CB.ThisBB->getNextNode()) | ||||||||
| 581 | MIB.buildBr(*CB.TrueBB); | ||||||||
| 582 | MIB.setDebugLoc(OldDbgLoc); | ||||||||
| 583 | return; | ||||||||
| 584 | } | ||||||||
| 585 | |||||||||
| 586 | const LLT i1Ty = LLT::scalar(1); | ||||||||
| 587 | // Build the compare. | ||||||||
| 588 | if (!CB.CmpMHS) { | ||||||||
| 589 | Register CondRHS = getOrCreateVReg(*CB.CmpRHS); | ||||||||
| 590 | Cond = MIB.buildICmp(CB.PredInfo.Pred, i1Ty, CondLHS, CondRHS).getReg(0); | ||||||||
| 591 | } else { | ||||||||
| 592 | assert(CB.PredInfo.Pred == CmpInst::ICMP_SLE &&((CB.PredInfo.Pred == CmpInst::ICMP_SLE && "Can only handle SLE ranges" ) ? static_cast<void> (0) : __assert_fail ("CB.PredInfo.Pred == CmpInst::ICMP_SLE && \"Can only handle SLE ranges\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 593, __PRETTY_FUNCTION__)) | ||||||||
| 593 | "Can only handle SLE ranges")((CB.PredInfo.Pred == CmpInst::ICMP_SLE && "Can only handle SLE ranges" ) ? static_cast<void> (0) : __assert_fail ("CB.PredInfo.Pred == CmpInst::ICMP_SLE && \"Can only handle SLE ranges\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 593, __PRETTY_FUNCTION__)); | ||||||||
| 594 | |||||||||
| 595 | const APInt& Low = cast<ConstantInt>(CB.CmpLHS)->getValue(); | ||||||||
| 596 | const APInt& High = cast<ConstantInt>(CB.CmpRHS)->getValue(); | ||||||||
| 597 | |||||||||
| 598 | Register CmpOpReg = getOrCreateVReg(*CB.CmpMHS); | ||||||||
| 599 | if (cast<ConstantInt>(CB.CmpLHS)->isMinValue(true)) { | ||||||||
| 600 | Register CondRHS = getOrCreateVReg(*CB.CmpRHS); | ||||||||
| 601 | Cond = | ||||||||
| 602 | MIB.buildICmp(CmpInst::ICMP_SLE, i1Ty, CmpOpReg, CondRHS).getReg(0); | ||||||||
| 603 | } else { | ||||||||
| 604 | const LLT &CmpTy = MRI->getType(CmpOpReg); | ||||||||
| 605 | auto Sub = MIB.buildSub({CmpTy}, CmpOpReg, CondLHS); | ||||||||
| 606 | auto Diff = MIB.buildConstant(CmpTy, High - Low); | ||||||||
| 607 | Cond = MIB.buildICmp(CmpInst::ICMP_ULE, i1Ty, Sub, Diff).getReg(0); | ||||||||
| 608 | } | ||||||||
| 609 | } | ||||||||
| 610 | |||||||||
| 611 | // Update successor info | ||||||||
| 612 | addSuccessorWithProb(CB.ThisBB, CB.TrueBB, CB.TrueProb); | ||||||||
| 613 | |||||||||
| 614 | addMachineCFGPred({SwitchBB->getBasicBlock(), CB.TrueBB->getBasicBlock()}, | ||||||||
| 615 | CB.ThisBB); | ||||||||
| 616 | |||||||||
| 617 | // TrueBB and FalseBB are always different unless the incoming IR is | ||||||||
| 618 | // degenerate. This only happens when running llc on weird IR. | ||||||||
| 619 | if (CB.TrueBB != CB.FalseBB) | ||||||||
| 620 | addSuccessorWithProb(CB.ThisBB, CB.FalseBB, CB.FalseProb); | ||||||||
| 621 | CB.ThisBB->normalizeSuccProbs(); | ||||||||
| 622 | |||||||||
| 623 | // if (SwitchBB->getBasicBlock() != CB.FalseBB->getBasicBlock()) | ||||||||
| 624 | addMachineCFGPred({SwitchBB->getBasicBlock(), CB.FalseBB->getBasicBlock()}, | ||||||||
| 625 | CB.ThisBB); | ||||||||
| 626 | |||||||||
| 627 | // If the lhs block is the next block, invert the condition so that we can | ||||||||
| 628 | // fall through to the lhs instead of the rhs block. | ||||||||
| 629 | if (CB.TrueBB == CB.ThisBB->getNextNode()) { | ||||||||
| 630 | std::swap(CB.TrueBB, CB.FalseBB); | ||||||||
| 631 | auto True = MIB.buildConstant(i1Ty, 1); | ||||||||
| 632 | Cond = MIB.buildInstr(TargetOpcode::G_XOR, {i1Ty}, {Cond, True}, None) | ||||||||
| 633 | .getReg(0); | ||||||||
| 634 | } | ||||||||
| 635 | |||||||||
| 636 | MIB.buildBrCond(Cond, *CB.TrueBB); | ||||||||
| 637 | MIB.buildBr(*CB.FalseBB); | ||||||||
| 638 | MIB.setDebugLoc(OldDbgLoc); | ||||||||
| 639 | } | ||||||||
| 640 | |||||||||
| 641 | bool IRTranslator::lowerJumpTableWorkItem(SwitchCG::SwitchWorkListItem W, | ||||||||
| 642 | MachineBasicBlock *SwitchMBB, | ||||||||
| 643 | MachineBasicBlock *CurMBB, | ||||||||
| 644 | MachineBasicBlock *DefaultMBB, | ||||||||
| 645 | MachineIRBuilder &MIB, | ||||||||
| 646 | MachineFunction::iterator BBI, | ||||||||
| 647 | BranchProbability UnhandledProbs, | ||||||||
| 648 | SwitchCG::CaseClusterIt I, | ||||||||
| 649 | MachineBasicBlock *Fallthrough, | ||||||||
| 650 | bool FallthroughUnreachable) { | ||||||||
| 651 | using namespace SwitchCG; | ||||||||
| 652 | MachineFunction *CurMF = SwitchMBB->getParent(); | ||||||||
| 653 | // FIXME: Optimize away range check based on pivot comparisons. | ||||||||
| 654 | JumpTableHeader *JTH = &SL->JTCases[I->JTCasesIndex].first; | ||||||||
| 655 | SwitchCG::JumpTable *JT = &SL->JTCases[I->JTCasesIndex].second; | ||||||||
| 656 | BranchProbability DefaultProb = W.DefaultProb; | ||||||||
| 657 | |||||||||
| 658 | // The jump block hasn't been inserted yet; insert it here. | ||||||||
| 659 | MachineBasicBlock *JumpMBB = JT->MBB; | ||||||||
| 660 | CurMF->insert(BBI, JumpMBB); | ||||||||
| 661 | |||||||||
| 662 | // Since the jump table block is separate from the switch block, we need | ||||||||
| 663 | // to keep track of it as a machine predecessor to the default block, | ||||||||
| 664 | // otherwise we lose the phi edges. | ||||||||
| 665 | addMachineCFGPred({SwitchMBB->getBasicBlock(), DefaultMBB->getBasicBlock()}, | ||||||||
| 666 | CurMBB); | ||||||||
| 667 | addMachineCFGPred({SwitchMBB->getBasicBlock(), DefaultMBB->getBasicBlock()}, | ||||||||
| 668 | JumpMBB); | ||||||||
| 669 | |||||||||
| 670 | auto JumpProb = I->Prob; | ||||||||
| 671 | auto FallthroughProb = UnhandledProbs; | ||||||||
| 672 | |||||||||
| 673 | // If the default statement is a target of the jump table, we evenly | ||||||||
| 674 | // distribute the default probability to successors of CurMBB. Also | ||||||||
| 675 | // update the probability on the edge from JumpMBB to Fallthrough. | ||||||||
| 676 | for (MachineBasicBlock::succ_iterator SI = JumpMBB->succ_begin(), | ||||||||
| 677 | SE = JumpMBB->succ_end(); | ||||||||
| 678 | SI != SE; ++SI) { | ||||||||
| 679 | if (*SI == DefaultMBB) { | ||||||||
| 680 | JumpProb += DefaultProb / 2; | ||||||||
| 681 | FallthroughProb -= DefaultProb / 2; | ||||||||
| 682 | JumpMBB->setSuccProbability(SI, DefaultProb / 2); | ||||||||
| 683 | JumpMBB->normalizeSuccProbs(); | ||||||||
| 684 | } else { | ||||||||
| 685 | // Also record edges from the jump table block to it's successors. | ||||||||
| 686 | addMachineCFGPred({SwitchMBB->getBasicBlock(), (*SI)->getBasicBlock()}, | ||||||||
| 687 | JumpMBB); | ||||||||
| 688 | } | ||||||||
| 689 | } | ||||||||
| 690 | |||||||||
| 691 | // Skip the range check if the fallthrough block is unreachable. | ||||||||
| 692 | if (FallthroughUnreachable) | ||||||||
| 693 | JTH->OmitRangeCheck = true; | ||||||||
| 694 | |||||||||
| 695 | if (!JTH->OmitRangeCheck) | ||||||||
| 696 | addSuccessorWithProb(CurMBB, Fallthrough, FallthroughProb); | ||||||||
| 697 | addSuccessorWithProb(CurMBB, JumpMBB, JumpProb); | ||||||||
| 698 | CurMBB->normalizeSuccProbs(); | ||||||||
| 699 | |||||||||
| 700 | // The jump table header will be inserted in our current block, do the | ||||||||
| 701 | // range check, and fall through to our fallthrough block. | ||||||||
| 702 | JTH->HeaderBB = CurMBB; | ||||||||
| 703 | JT->Default = Fallthrough; // FIXME: Move Default to JumpTableHeader. | ||||||||
| 704 | |||||||||
| 705 | // If we're in the right place, emit the jump table header right now. | ||||||||
| 706 | if (CurMBB == SwitchMBB) { | ||||||||
| 707 | if (!emitJumpTableHeader(*JT, *JTH, CurMBB)) | ||||||||
| 708 | return false; | ||||||||
| 709 | JTH->Emitted = true; | ||||||||
| 710 | } | ||||||||
| 711 | return true; | ||||||||
| 712 | } | ||||||||
| 713 | bool IRTranslator::lowerSwitchRangeWorkItem(SwitchCG::CaseClusterIt I, | ||||||||
| 714 | Value *Cond, | ||||||||
| 715 | MachineBasicBlock *Fallthrough, | ||||||||
| 716 | bool FallthroughUnreachable, | ||||||||
| 717 | BranchProbability UnhandledProbs, | ||||||||
| 718 | MachineBasicBlock *CurMBB, | ||||||||
| 719 | MachineIRBuilder &MIB, | ||||||||
| 720 | MachineBasicBlock *SwitchMBB) { | ||||||||
| 721 | using namespace SwitchCG; | ||||||||
| 722 | const Value *RHS, *LHS, *MHS; | ||||||||
| 723 | CmpInst::Predicate Pred; | ||||||||
| 724 | if (I->Low == I->High) { | ||||||||
| 725 | // Check Cond == I->Low. | ||||||||
| 726 | Pred = CmpInst::ICMP_EQ; | ||||||||
| 727 | LHS = Cond; | ||||||||
| 728 | RHS = I->Low; | ||||||||
| 729 | MHS = nullptr; | ||||||||
| 730 | } else { | ||||||||
| 731 | // Check I->Low <= Cond <= I->High. | ||||||||
| 732 | Pred = CmpInst::ICMP_SLE; | ||||||||
| 733 | LHS = I->Low; | ||||||||
| 734 | MHS = Cond; | ||||||||
| 735 | RHS = I->High; | ||||||||
| 736 | } | ||||||||
| 737 | |||||||||
| 738 | // If Fallthrough is unreachable, fold away the comparison. | ||||||||
| 739 | // The false probability is the sum of all unhandled cases. | ||||||||
| 740 | CaseBlock CB(Pred, FallthroughUnreachable, LHS, RHS, MHS, I->MBB, Fallthrough, | ||||||||
| 741 | CurMBB, MIB.getDebugLoc(), I->Prob, UnhandledProbs); | ||||||||
| 742 | |||||||||
| 743 | emitSwitchCase(CB, SwitchMBB, MIB); | ||||||||
| 744 | return true; | ||||||||
| 745 | } | ||||||||
| 746 | |||||||||
| 747 | bool IRTranslator::lowerSwitchWorkItem(SwitchCG::SwitchWorkListItem W, | ||||||||
| 748 | Value *Cond, | ||||||||
| 749 | MachineBasicBlock *SwitchMBB, | ||||||||
| 750 | MachineBasicBlock *DefaultMBB, | ||||||||
| 751 | MachineIRBuilder &MIB) { | ||||||||
| 752 | using namespace SwitchCG; | ||||||||
| 753 | MachineFunction *CurMF = FuncInfo.MF; | ||||||||
| 754 | MachineBasicBlock *NextMBB = nullptr; | ||||||||
| 755 | MachineFunction::iterator BBI(W.MBB); | ||||||||
| 756 | if (++BBI != FuncInfo.MF->end()) | ||||||||
| 757 | NextMBB = &*BBI; | ||||||||
| 758 | |||||||||
| 759 | if (EnableOpts) { | ||||||||
| 760 | // Here, we order cases by probability so the most likely case will be | ||||||||
| 761 | // checked first. However, two clusters can have the same probability in | ||||||||
| 762 | // which case their relative ordering is non-deterministic. So we use Low | ||||||||
| 763 | // as a tie-breaker as clusters are guaranteed to never overlap. | ||||||||
| 764 | llvm::sort(W.FirstCluster, W.LastCluster + 1, | ||||||||
| 765 | [](const CaseCluster &a, const CaseCluster &b) { | ||||||||
| 766 | return a.Prob != b.Prob | ||||||||
| 767 | ? a.Prob > b.Prob | ||||||||
| 768 | : a.Low->getValue().slt(b.Low->getValue()); | ||||||||
| 769 | }); | ||||||||
| 770 | |||||||||
| 771 | // Rearrange the case blocks so that the last one falls through if possible | ||||||||
| 772 | // without changing the order of probabilities. | ||||||||
| 773 | for (CaseClusterIt I = W.LastCluster; I > W.FirstCluster;) { | ||||||||
| 774 | --I; | ||||||||
| 775 | if (I->Prob > W.LastCluster->Prob) | ||||||||
| 776 | break; | ||||||||
| 777 | if (I->Kind == CC_Range && I->MBB == NextMBB) { | ||||||||
| 778 | std::swap(*I, *W.LastCluster); | ||||||||
| 779 | break; | ||||||||
| 780 | } | ||||||||
| 781 | } | ||||||||
| 782 | } | ||||||||
| 783 | |||||||||
| 784 | // Compute total probability. | ||||||||
| 785 | BranchProbability DefaultProb = W.DefaultProb; | ||||||||
| 786 | BranchProbability UnhandledProbs = DefaultProb; | ||||||||
| 787 | for (CaseClusterIt I = W.FirstCluster; I <= W.LastCluster; ++I) | ||||||||
| 788 | UnhandledProbs += I->Prob; | ||||||||
| 789 | |||||||||
| 790 | MachineBasicBlock *CurMBB = W.MBB; | ||||||||
| 791 | for (CaseClusterIt I = W.FirstCluster, E = W.LastCluster; I <= E; ++I) { | ||||||||
| 792 | bool FallthroughUnreachable = false; | ||||||||
| 793 | MachineBasicBlock *Fallthrough; | ||||||||
| 794 | if (I == W.LastCluster) { | ||||||||
| 795 | // For the last cluster, fall through to the default destination. | ||||||||
| 796 | Fallthrough = DefaultMBB; | ||||||||
| 797 | FallthroughUnreachable = isa<UnreachableInst>( | ||||||||
| 798 | DefaultMBB->getBasicBlock()->getFirstNonPHIOrDbg()); | ||||||||
| 799 | } else { | ||||||||
| 800 | Fallthrough = CurMF->CreateMachineBasicBlock(CurMBB->getBasicBlock()); | ||||||||
| 801 | CurMF->insert(BBI, Fallthrough); | ||||||||
| 802 | } | ||||||||
| 803 | UnhandledProbs -= I->Prob; | ||||||||
| 804 | |||||||||
| 805 | switch (I->Kind) { | ||||||||
| 806 | case CC_BitTests: { | ||||||||
| 807 | LLVM_DEBUG(dbgs() << "Switch to bit test optimization unimplemented")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { dbgs() << "Switch to bit test optimization unimplemented" ; } } while (false); | ||||||||
| 808 | return false; // Bit tests currently unimplemented. | ||||||||
| 809 | } | ||||||||
| 810 | case CC_JumpTable: { | ||||||||
| 811 | if (!lowerJumpTableWorkItem(W, SwitchMBB, CurMBB, DefaultMBB, MIB, BBI, | ||||||||
| 812 | UnhandledProbs, I, Fallthrough, | ||||||||
| 813 | FallthroughUnreachable)) { | ||||||||
| 814 | LLVM_DEBUG(dbgs() << "Failed to lower jump table")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { dbgs() << "Failed to lower jump table" ; } } while (false); | ||||||||
| 815 | return false; | ||||||||
| 816 | } | ||||||||
| 817 | break; | ||||||||
| 818 | } | ||||||||
| 819 | case CC_Range: { | ||||||||
| 820 | if (!lowerSwitchRangeWorkItem(I, Cond, Fallthrough, | ||||||||
| 821 | FallthroughUnreachable, UnhandledProbs, | ||||||||
| 822 | CurMBB, MIB, SwitchMBB)) { | ||||||||
| 823 | LLVM_DEBUG(dbgs() << "Failed to lower switch range")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { dbgs() << "Failed to lower switch range" ; } } while (false); | ||||||||
| 824 | return false; | ||||||||
| 825 | } | ||||||||
| 826 | break; | ||||||||
| 827 | } | ||||||||
| 828 | } | ||||||||
| 829 | CurMBB = Fallthrough; | ||||||||
| 830 | } | ||||||||
| 831 | |||||||||
| 832 | return true; | ||||||||
| 833 | } | ||||||||
| 834 | |||||||||
| 835 | bool IRTranslator::translateIndirectBr(const User &U, | ||||||||
| 836 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 837 | const IndirectBrInst &BrInst = cast<IndirectBrInst>(U); | ||||||||
| 838 | |||||||||
| 839 | const Register Tgt = getOrCreateVReg(*BrInst.getAddress()); | ||||||||
| 840 | MIRBuilder.buildBrIndirect(Tgt); | ||||||||
| 841 | |||||||||
| 842 | // Link successors. | ||||||||
| 843 | MachineBasicBlock &CurBB = MIRBuilder.getMBB(); | ||||||||
| 844 | for (const BasicBlock *Succ : successors(&BrInst)) | ||||||||
| 845 | CurBB.addSuccessor(&getMBB(*Succ)); | ||||||||
| 846 | |||||||||
| 847 | return true; | ||||||||
| 848 | } | ||||||||
| 849 | |||||||||
| 850 | static bool isSwiftError(const Value *V) { | ||||||||
| 851 | if (auto Arg = dyn_cast<Argument>(V)) | ||||||||
| 852 | return Arg->hasSwiftErrorAttr(); | ||||||||
| 853 | if (auto AI = dyn_cast<AllocaInst>(V)) | ||||||||
| 854 | return AI->isSwiftError(); | ||||||||
| 855 | return false; | ||||||||
| 856 | } | ||||||||
| 857 | |||||||||
| 858 | bool IRTranslator::translateLoad(const User &U, MachineIRBuilder &MIRBuilder) { | ||||||||
| 859 | const LoadInst &LI = cast<LoadInst>(U); | ||||||||
| 860 | |||||||||
| 861 | auto Flags = LI.isVolatile() ? MachineMemOperand::MOVolatile | ||||||||
| 862 | : MachineMemOperand::MONone; | ||||||||
| 863 | Flags |= MachineMemOperand::MOLoad; | ||||||||
| 864 | |||||||||
| 865 | if (DL->getTypeStoreSize(LI.getType()) == 0) | ||||||||
| 866 | return true; | ||||||||
| 867 | |||||||||
| 868 | ArrayRef<Register> Regs = getOrCreateVRegs(LI); | ||||||||
| 869 | ArrayRef<uint64_t> Offsets = *VMap.getOffsets(LI); | ||||||||
| 870 | Register Base = getOrCreateVReg(*LI.getPointerOperand()); | ||||||||
| 871 | |||||||||
| 872 | Type *OffsetIRTy = DL->getIntPtrType(LI.getPointerOperandType()); | ||||||||
| 873 | LLT OffsetTy = getLLTForType(*OffsetIRTy, *DL); | ||||||||
| 874 | |||||||||
| 875 | if (CLI->supportSwiftError() && isSwiftError(LI.getPointerOperand())) { | ||||||||
| 876 | assert(Regs.size() == 1 && "swifterror should be single pointer")((Regs.size() == 1 && "swifterror should be single pointer" ) ? static_cast<void> (0) : __assert_fail ("Regs.size() == 1 && \"swifterror should be single pointer\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 876, __PRETTY_FUNCTION__)); | ||||||||
| 877 | Register VReg = SwiftError.getOrCreateVRegUseAt(&LI, &MIRBuilder.getMBB(), | ||||||||
| 878 | LI.getPointerOperand()); | ||||||||
| 879 | MIRBuilder.buildCopy(Regs[0], VReg); | ||||||||
| 880 | return true; | ||||||||
| 881 | } | ||||||||
| 882 | |||||||||
| 883 | const MDNode *Ranges = | ||||||||
| 884 | Regs.size() == 1 ? LI.getMetadata(LLVMContext::MD_range) : nullptr; | ||||||||
| 885 | for (unsigned i = 0; i < Regs.size(); ++i) { | ||||||||
| 886 | Register Addr; | ||||||||
| 887 | MIRBuilder.materializeGEP(Addr, Base, OffsetTy, Offsets[i] / 8); | ||||||||
| 888 | |||||||||
| 889 | MachinePointerInfo Ptr(LI.getPointerOperand(), Offsets[i] / 8); | ||||||||
| 890 | unsigned BaseAlign = getMemOpAlignment(LI); | ||||||||
| 891 | auto MMO = MF->getMachineMemOperand( | ||||||||
| 892 | Ptr, Flags, (MRI->getType(Regs[i]).getSizeInBits() + 7) / 8, | ||||||||
| 893 | MinAlign(BaseAlign, Offsets[i] / 8), AAMDNodes(), Ranges, | ||||||||
| 894 | LI.getSyncScopeID(), LI.getOrdering()); | ||||||||
| 895 | MIRBuilder.buildLoad(Regs[i], Addr, *MMO); | ||||||||
| 896 | } | ||||||||
| 897 | |||||||||
| 898 | return true; | ||||||||
| 899 | } | ||||||||
| 900 | |||||||||
| 901 | bool IRTranslator::translateStore(const User &U, MachineIRBuilder &MIRBuilder) { | ||||||||
| 902 | const StoreInst &SI = cast<StoreInst>(U); | ||||||||
| 903 | auto Flags = SI.isVolatile() ? MachineMemOperand::MOVolatile | ||||||||
| 904 | : MachineMemOperand::MONone; | ||||||||
| 905 | Flags |= MachineMemOperand::MOStore; | ||||||||
| 906 | |||||||||
| 907 | if (DL->getTypeStoreSize(SI.getValueOperand()->getType()) == 0) | ||||||||
| 908 | return true; | ||||||||
| 909 | |||||||||
| 910 | ArrayRef<Register> Vals = getOrCreateVRegs(*SI.getValueOperand()); | ||||||||
| 911 | ArrayRef<uint64_t> Offsets = *VMap.getOffsets(*SI.getValueOperand()); | ||||||||
| 912 | Register Base = getOrCreateVReg(*SI.getPointerOperand()); | ||||||||
| 913 | |||||||||
| 914 | Type *OffsetIRTy = DL->getIntPtrType(SI.getPointerOperandType()); | ||||||||
| 915 | LLT OffsetTy = getLLTForType(*OffsetIRTy, *DL); | ||||||||
| 916 | |||||||||
| 917 | if (CLI->supportSwiftError() && isSwiftError(SI.getPointerOperand())) { | ||||||||
| 918 | assert(Vals.size() == 1 && "swifterror should be single pointer")((Vals.size() == 1 && "swifterror should be single pointer" ) ? static_cast<void> (0) : __assert_fail ("Vals.size() == 1 && \"swifterror should be single pointer\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 918, __PRETTY_FUNCTION__)); | ||||||||
| 919 | |||||||||
| 920 | Register VReg = SwiftError.getOrCreateVRegDefAt(&SI, &MIRBuilder.getMBB(), | ||||||||
| 921 | SI.getPointerOperand()); | ||||||||
| 922 | MIRBuilder.buildCopy(VReg, Vals[0]); | ||||||||
| 923 | return true; | ||||||||
| 924 | } | ||||||||
| 925 | |||||||||
| 926 | for (unsigned i = 0; i < Vals.size(); ++i) { | ||||||||
| 927 | Register Addr; | ||||||||
| 928 | MIRBuilder.materializeGEP(Addr, Base, OffsetTy, Offsets[i] / 8); | ||||||||
| 929 | |||||||||
| 930 | MachinePointerInfo Ptr(SI.getPointerOperand(), Offsets[i] / 8); | ||||||||
| 931 | unsigned BaseAlign = getMemOpAlignment(SI); | ||||||||
| 932 | auto MMO = MF->getMachineMemOperand( | ||||||||
| 933 | Ptr, Flags, (MRI->getType(Vals[i]).getSizeInBits() + 7) / 8, | ||||||||
| 934 | MinAlign(BaseAlign, Offsets[i] / 8), AAMDNodes(), nullptr, | ||||||||
| 935 | SI.getSyncScopeID(), SI.getOrdering()); | ||||||||
| 936 | MIRBuilder.buildStore(Vals[i], Addr, *MMO); | ||||||||
| 937 | } | ||||||||
| 938 | return true; | ||||||||
| 939 | } | ||||||||
| 940 | |||||||||
| 941 | static uint64_t getOffsetFromIndices(const User &U, const DataLayout &DL) { | ||||||||
| 942 | const Value *Src = U.getOperand(0); | ||||||||
| 943 | Type *Int32Ty = Type::getInt32Ty(U.getContext()); | ||||||||
| 944 | |||||||||
| 945 | // getIndexedOffsetInType is designed for GEPs, so the first index is the | ||||||||
| 946 | // usual array element rather than looking into the actual aggregate. | ||||||||
| 947 | SmallVector<Value *, 1> Indices; | ||||||||
| 948 | Indices.push_back(ConstantInt::get(Int32Ty, 0)); | ||||||||
| 949 | |||||||||
| 950 | if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&U)) { | ||||||||
| 951 | for (auto Idx : EVI->indices()) | ||||||||
| 952 | Indices.push_back(ConstantInt::get(Int32Ty, Idx)); | ||||||||
| 953 | } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&U)) { | ||||||||
| 954 | for (auto Idx : IVI->indices()) | ||||||||
| 955 | Indices.push_back(ConstantInt::get(Int32Ty, Idx)); | ||||||||
| 956 | } else { | ||||||||
| 957 | for (unsigned i = 1; i < U.getNumOperands(); ++i) | ||||||||
| 958 | Indices.push_back(U.getOperand(i)); | ||||||||
| 959 | } | ||||||||
| 960 | |||||||||
| 961 | return 8 * static_cast<uint64_t>( | ||||||||
| 962 | DL.getIndexedOffsetInType(Src->getType(), Indices)); | ||||||||
| 963 | } | ||||||||
| 964 | |||||||||
| 965 | bool IRTranslator::translateExtractValue(const User &U, | ||||||||
| 966 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 967 | const Value *Src = U.getOperand(0); | ||||||||
| 968 | uint64_t Offset = getOffsetFromIndices(U, *DL); | ||||||||
| 969 | ArrayRef<Register> SrcRegs = getOrCreateVRegs(*Src); | ||||||||
| 970 | ArrayRef<uint64_t> Offsets = *VMap.getOffsets(*Src); | ||||||||
| 971 | unsigned Idx = llvm::lower_bound(Offsets, Offset) - Offsets.begin(); | ||||||||
| 972 | auto &DstRegs = allocateVRegs(U); | ||||||||
| 973 | |||||||||
| 974 | for (unsigned i = 0; i < DstRegs.size(); ++i) | ||||||||
| 975 | DstRegs[i] = SrcRegs[Idx++]; | ||||||||
| 976 | |||||||||
| 977 | return true; | ||||||||
| 978 | } | ||||||||
| 979 | |||||||||
| 980 | bool IRTranslator::translateInsertValue(const User &U, | ||||||||
| 981 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 982 | const Value *Src = U.getOperand(0); | ||||||||
| 983 | uint64_t Offset = getOffsetFromIndices(U, *DL); | ||||||||
| 984 | auto &DstRegs = allocateVRegs(U); | ||||||||
| 985 | ArrayRef<uint64_t> DstOffsets = *VMap.getOffsets(U); | ||||||||
| 986 | ArrayRef<Register> SrcRegs = getOrCreateVRegs(*Src); | ||||||||
| 987 | ArrayRef<Register> InsertedRegs = getOrCreateVRegs(*U.getOperand(1)); | ||||||||
| 988 | auto InsertedIt = InsertedRegs.begin(); | ||||||||
| 989 | |||||||||
| 990 | for (unsigned i = 0; i < DstRegs.size(); ++i) { | ||||||||
| 991 | if (DstOffsets[i] >= Offset && InsertedIt != InsertedRegs.end()) | ||||||||
| 992 | DstRegs[i] = *InsertedIt++; | ||||||||
| 993 | else | ||||||||
| 994 | DstRegs[i] = SrcRegs[i]; | ||||||||
| 995 | } | ||||||||
| 996 | |||||||||
| 997 | return true; | ||||||||
| 998 | } | ||||||||
| 999 | |||||||||
| 1000 | bool IRTranslator::translateSelect(const User &U, | ||||||||
| 1001 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1002 | Register Tst = getOrCreateVReg(*U.getOperand(0)); | ||||||||
| 1003 | ArrayRef<Register> ResRegs = getOrCreateVRegs(U); | ||||||||
| 1004 | ArrayRef<Register> Op0Regs = getOrCreateVRegs(*U.getOperand(1)); | ||||||||
| 1005 | ArrayRef<Register> Op1Regs = getOrCreateVRegs(*U.getOperand(2)); | ||||||||
| 1006 | |||||||||
| 1007 | const SelectInst &SI = cast<SelectInst>(U); | ||||||||
| 1008 | uint16_t Flags = 0; | ||||||||
| 1009 | if (const CmpInst *Cmp = dyn_cast<CmpInst>(SI.getCondition())) | ||||||||
| 1010 | Flags = MachineInstr::copyFlagsFromInstruction(*Cmp); | ||||||||
| 1011 | |||||||||
| 1012 | for (unsigned i = 0; i < ResRegs.size(); ++i) { | ||||||||
| 1013 | MIRBuilder.buildInstr(TargetOpcode::G_SELECT, {ResRegs[i]}, | ||||||||
| 1014 | {Tst, Op0Regs[i], Op1Regs[i]}, Flags); | ||||||||
| 1015 | } | ||||||||
| 1016 | |||||||||
| 1017 | return true; | ||||||||
| 1018 | } | ||||||||
| 1019 | |||||||||
| 1020 | bool IRTranslator::translateBitCast(const User &U, | ||||||||
| 1021 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1022 | // If we're bitcasting to the source type, we can reuse the source vreg. | ||||||||
| 1023 | if (getLLTForType(*U.getOperand(0)->getType(), *DL) == | ||||||||
| 1024 | getLLTForType(*U.getType(), *DL)) { | ||||||||
| 1025 | Register SrcReg = getOrCreateVReg(*U.getOperand(0)); | ||||||||
| 1026 | auto &Regs = *VMap.getVRegs(U); | ||||||||
| 1027 | // If we already assigned a vreg for this bitcast, we can't change that. | ||||||||
| 1028 | // Emit a copy to satisfy the users we already emitted. | ||||||||
| 1029 | if (!Regs.empty()) | ||||||||
| 1030 | MIRBuilder.buildCopy(Regs[0], SrcReg); | ||||||||
| 1031 | else { | ||||||||
| 1032 | Regs.push_back(SrcReg); | ||||||||
| 1033 | VMap.getOffsets(U)->push_back(0); | ||||||||
| 1034 | } | ||||||||
| 1035 | return true; | ||||||||
| 1036 | } | ||||||||
| 1037 | return translateCast(TargetOpcode::G_BITCAST, U, MIRBuilder); | ||||||||
| 1038 | } | ||||||||
| 1039 | |||||||||
| 1040 | bool IRTranslator::translateCast(unsigned Opcode, const User &U, | ||||||||
| 1041 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1042 | Register Op = getOrCreateVReg(*U.getOperand(0)); | ||||||||
| 1043 | Register Res = getOrCreateVReg(U); | ||||||||
| 1044 | MIRBuilder.buildInstr(Opcode, {Res}, {Op}); | ||||||||
| 1045 | return true; | ||||||||
| 1046 | } | ||||||||
| 1047 | |||||||||
| 1048 | bool IRTranslator::translateGetElementPtr(const User &U, | ||||||||
| 1049 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1050 | // FIXME: support vector GEPs. | ||||||||
| 1051 | if (U.getType()->isVectorTy()) | ||||||||
| 1052 | return false; | ||||||||
| 1053 | |||||||||
| 1054 | Value &Op0 = *U.getOperand(0); | ||||||||
| 1055 | Register BaseReg = getOrCreateVReg(Op0); | ||||||||
| 1056 | Type *PtrIRTy = Op0.getType(); | ||||||||
| 1057 | LLT PtrTy = getLLTForType(*PtrIRTy, *DL); | ||||||||
| 1058 | Type *OffsetIRTy = DL->getIntPtrType(PtrIRTy); | ||||||||
| 1059 | LLT OffsetTy = getLLTForType(*OffsetIRTy, *DL); | ||||||||
| 1060 | |||||||||
| 1061 | int64_t Offset = 0; | ||||||||
| 1062 | for (gep_type_iterator GTI = gep_type_begin(&U), E = gep_type_end(&U); | ||||||||
| 1063 | GTI != E; ++GTI) { | ||||||||
| 1064 | const Value *Idx = GTI.getOperand(); | ||||||||
| 1065 | if (StructType *StTy = GTI.getStructTypeOrNull()) { | ||||||||
| 1066 | unsigned Field = cast<Constant>(Idx)->getUniqueInteger().getZExtValue(); | ||||||||
| 1067 | Offset += DL->getStructLayout(StTy)->getElementOffset(Field); | ||||||||
| 1068 | continue; | ||||||||
| 1069 | } else { | ||||||||
| 1070 | uint64_t ElementSize = DL->getTypeAllocSize(GTI.getIndexedType()); | ||||||||
| 1071 | |||||||||
| 1072 | // If this is a scalar constant or a splat vector of constants, | ||||||||
| 1073 | // handle it quickly. | ||||||||
| 1074 | if (const auto *CI = dyn_cast<ConstantInt>(Idx)) { | ||||||||
| 1075 | Offset += ElementSize * CI->getSExtValue(); | ||||||||
| 1076 | continue; | ||||||||
| 1077 | } | ||||||||
| 1078 | |||||||||
| 1079 | if (Offset != 0) { | ||||||||
| 1080 | LLT OffsetTy = getLLTForType(*OffsetIRTy, *DL); | ||||||||
| 1081 | auto OffsetMIB = MIRBuilder.buildConstant({OffsetTy}, Offset); | ||||||||
| 1082 | BaseReg = | ||||||||
| 1083 | MIRBuilder.buildGEP(PtrTy, BaseReg, OffsetMIB.getReg(0)).getReg(0); | ||||||||
| 1084 | Offset = 0; | ||||||||
| 1085 | } | ||||||||
| 1086 | |||||||||
| 1087 | Register IdxReg = getOrCreateVReg(*Idx); | ||||||||
| 1088 | if (MRI->getType(IdxReg) != OffsetTy) | ||||||||
| 1089 | IdxReg = MIRBuilder.buildSExtOrTrunc(OffsetTy, IdxReg).getReg(0); | ||||||||
| 1090 | |||||||||
| 1091 | // N = N + Idx * ElementSize; | ||||||||
| 1092 | // Avoid doing it for ElementSize of 1. | ||||||||
| 1093 | Register GepOffsetReg; | ||||||||
| 1094 | if (ElementSize != 1) { | ||||||||
| 1095 | auto ElementSizeMIB = MIRBuilder.buildConstant( | ||||||||
| 1096 | getLLTForType(*OffsetIRTy, *DL), ElementSize); | ||||||||
| 1097 | GepOffsetReg = | ||||||||
| 1098 | MIRBuilder.buildMul(OffsetTy, ElementSizeMIB, IdxReg).getReg(0); | ||||||||
| 1099 | } else | ||||||||
| 1100 | GepOffsetReg = IdxReg; | ||||||||
| 1101 | |||||||||
| 1102 | BaseReg = MIRBuilder.buildGEP(PtrTy, BaseReg, GepOffsetReg).getReg(0); | ||||||||
| 1103 | } | ||||||||
| 1104 | } | ||||||||
| 1105 | |||||||||
| 1106 | if (Offset != 0) { | ||||||||
| 1107 | auto OffsetMIB = | ||||||||
| 1108 | MIRBuilder.buildConstant(getLLTForType(*OffsetIRTy, *DL), Offset); | ||||||||
| 1109 | MIRBuilder.buildGEP(getOrCreateVReg(U), BaseReg, OffsetMIB.getReg(0)); | ||||||||
| 1110 | return true; | ||||||||
| 1111 | } | ||||||||
| 1112 | |||||||||
| 1113 | MIRBuilder.buildCopy(getOrCreateVReg(U), BaseReg); | ||||||||
| 1114 | return true; | ||||||||
| 1115 | } | ||||||||
| 1116 | |||||||||
| 1117 | bool IRTranslator::translateMemFunc(const CallInst &CI, | ||||||||
| 1118 | MachineIRBuilder &MIRBuilder, | ||||||||
| 1119 | Intrinsic::ID ID) { | ||||||||
| 1120 | |||||||||
| 1121 | // If the source is undef, then just emit a nop. | ||||||||
| 1122 | if (isa<UndefValue>(CI.getArgOperand(1))) | ||||||||
| 1123 | return true; | ||||||||
| 1124 | |||||||||
| 1125 | ArrayRef<Register> Res; | ||||||||
| 1126 | auto ICall = MIRBuilder.buildIntrinsic(ID, Res, true); | ||||||||
| 1127 | for (auto AI = CI.arg_begin(), AE = CI.arg_end(); std::next(AI) != AE; ++AI) | ||||||||
| 1128 | ICall.addUse(getOrCreateVReg(**AI)); | ||||||||
| 1129 | |||||||||
| 1130 | unsigned DstAlign = 0, SrcAlign = 0; | ||||||||
| 1131 | unsigned IsVol = | ||||||||
| 1132 | cast<ConstantInt>(CI.getArgOperand(CI.getNumArgOperands() - 1)) | ||||||||
| 1133 | ->getZExtValue(); | ||||||||
| 1134 | |||||||||
| 1135 | if (auto *MCI = dyn_cast<MemCpyInst>(&CI)) { | ||||||||
| 1136 | DstAlign = std::max<unsigned>(MCI->getDestAlignment(), 1); | ||||||||
| 1137 | SrcAlign = std::max<unsigned>(MCI->getSourceAlignment(), 1); | ||||||||
| 1138 | } else if (auto *MMI = dyn_cast<MemMoveInst>(&CI)) { | ||||||||
| 1139 | DstAlign = std::max<unsigned>(MMI->getDestAlignment(), 1); | ||||||||
| 1140 | SrcAlign = std::max<unsigned>(MMI->getSourceAlignment(), 1); | ||||||||
| 1141 | } else { | ||||||||
| 1142 | auto *MSI = cast<MemSetInst>(&CI); | ||||||||
| 1143 | DstAlign = std::max<unsigned>(MSI->getDestAlignment(), 1); | ||||||||
| 1144 | } | ||||||||
| 1145 | |||||||||
| 1146 | // We need to propagate the tail call flag from the IR inst as an argument. | ||||||||
| 1147 | // Otherwise, we have to pessimize and assume later that we cannot tail call | ||||||||
| 1148 | // any memory intrinsics. | ||||||||
| 1149 | ICall.addImm(CI.isTailCall() ? 1 : 0); | ||||||||
| 1150 | |||||||||
| 1151 | // Create mem operands to store the alignment and volatile info. | ||||||||
| 1152 | auto VolFlag = IsVol ? MachineMemOperand::MOVolatile : MachineMemOperand::MONone; | ||||||||
| 1153 | ICall.addMemOperand(MF->getMachineMemOperand( | ||||||||
| 1154 | MachinePointerInfo(CI.getArgOperand(0)), | ||||||||
| 1155 | MachineMemOperand::MOStore | VolFlag, 1, DstAlign)); | ||||||||
| 1156 | if (ID != Intrinsic::memset) | ||||||||
| 1157 | ICall.addMemOperand(MF->getMachineMemOperand( | ||||||||
| 1158 | MachinePointerInfo(CI.getArgOperand(1)), | ||||||||
| 1159 | MachineMemOperand::MOLoad | VolFlag, 1, SrcAlign)); | ||||||||
| 1160 | |||||||||
| 1161 | return true; | ||||||||
| 1162 | } | ||||||||
| 1163 | |||||||||
| 1164 | void IRTranslator::getStackGuard(Register DstReg, | ||||||||
| 1165 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1166 | const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo(); | ||||||||
| 1167 | MRI->setRegClass(DstReg, TRI->getPointerRegClass(*MF)); | ||||||||
| 1168 | auto MIB = MIRBuilder.buildInstr(TargetOpcode::LOAD_STACK_GUARD); | ||||||||
| 1169 | MIB.addDef(DstReg); | ||||||||
| 1170 | |||||||||
| 1171 | auto &TLI = *MF->getSubtarget().getTargetLowering(); | ||||||||
| 1172 | Value *Global = TLI.getSDagStackGuard(*MF->getFunction().getParent()); | ||||||||
| 1173 | if (!Global) | ||||||||
| 1174 | return; | ||||||||
| 1175 | |||||||||
| 1176 | MachinePointerInfo MPInfo(Global); | ||||||||
| 1177 | auto Flags = MachineMemOperand::MOLoad | MachineMemOperand::MOInvariant | | ||||||||
| 1178 | MachineMemOperand::MODereferenceable; | ||||||||
| 1179 | MachineMemOperand *MemRef = | ||||||||
| 1180 | MF->getMachineMemOperand(MPInfo, Flags, DL->getPointerSizeInBits() / 8, | ||||||||
| 1181 | DL->getPointerABIAlignment(0).value()); | ||||||||
| 1182 | MIB.setMemRefs({MemRef}); | ||||||||
| 1183 | } | ||||||||
| 1184 | |||||||||
| 1185 | bool IRTranslator::translateOverflowIntrinsic(const CallInst &CI, unsigned Op, | ||||||||
| 1186 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1187 | ArrayRef<Register> ResRegs = getOrCreateVRegs(CI); | ||||||||
| 1188 | MIRBuilder.buildInstr(Op) | ||||||||
| 1189 | .addDef(ResRegs[0]) | ||||||||
| 1190 | .addDef(ResRegs[1]) | ||||||||
| 1191 | .addUse(getOrCreateVReg(*CI.getOperand(0))) | ||||||||
| 1192 | .addUse(getOrCreateVReg(*CI.getOperand(1))); | ||||||||
| 1193 | |||||||||
| 1194 | return true; | ||||||||
| 1195 | } | ||||||||
| 1196 | |||||||||
| 1197 | unsigned IRTranslator::getSimpleIntrinsicOpcode(Intrinsic::ID ID) { | ||||||||
| 1198 | switch (ID) { | ||||||||
| 1199 | default: | ||||||||
| 1200 | break; | ||||||||
| 1201 | case Intrinsic::bswap: | ||||||||
| 1202 | return TargetOpcode::G_BSWAP; | ||||||||
| 1203 | case Intrinsic::bitreverse: | ||||||||
| 1204 | return TargetOpcode::G_BITREVERSE; | ||||||||
| 1205 | case Intrinsic::ceil: | ||||||||
| 1206 | return TargetOpcode::G_FCEIL; | ||||||||
| 1207 | case Intrinsic::cos: | ||||||||
| 1208 | return TargetOpcode::G_FCOS; | ||||||||
| 1209 | case Intrinsic::ctpop: | ||||||||
| 1210 | return TargetOpcode::G_CTPOP; | ||||||||
| 1211 | case Intrinsic::exp: | ||||||||
| 1212 | return TargetOpcode::G_FEXP; | ||||||||
| 1213 | case Intrinsic::exp2: | ||||||||
| 1214 | return TargetOpcode::G_FEXP2; | ||||||||
| 1215 | case Intrinsic::fabs: | ||||||||
| 1216 | return TargetOpcode::G_FABS; | ||||||||
| 1217 | case Intrinsic::copysign: | ||||||||
| 1218 | return TargetOpcode::G_FCOPYSIGN; | ||||||||
| 1219 | case Intrinsic::minnum: | ||||||||
| 1220 | return TargetOpcode::G_FMINNUM; | ||||||||
| 1221 | case Intrinsic::maxnum: | ||||||||
| 1222 | return TargetOpcode::G_FMAXNUM; | ||||||||
| 1223 | case Intrinsic::minimum: | ||||||||
| 1224 | return TargetOpcode::G_FMINIMUM; | ||||||||
| 1225 | case Intrinsic::maximum: | ||||||||
| 1226 | return TargetOpcode::G_FMAXIMUM; | ||||||||
| 1227 | case Intrinsic::canonicalize: | ||||||||
| 1228 | return TargetOpcode::G_FCANONICALIZE; | ||||||||
| 1229 | case Intrinsic::floor: | ||||||||
| 1230 | return TargetOpcode::G_FFLOOR; | ||||||||
| 1231 | case Intrinsic::fma: | ||||||||
| 1232 | return TargetOpcode::G_FMA; | ||||||||
| 1233 | case Intrinsic::log: | ||||||||
| 1234 | return TargetOpcode::G_FLOG; | ||||||||
| 1235 | case Intrinsic::log2: | ||||||||
| 1236 | return TargetOpcode::G_FLOG2; | ||||||||
| 1237 | case Intrinsic::log10: | ||||||||
| 1238 | return TargetOpcode::G_FLOG10; | ||||||||
| 1239 | case Intrinsic::nearbyint: | ||||||||
| 1240 | return TargetOpcode::G_FNEARBYINT; | ||||||||
| 1241 | case Intrinsic::pow: | ||||||||
| 1242 | return TargetOpcode::G_FPOW; | ||||||||
| 1243 | case Intrinsic::rint: | ||||||||
| 1244 | return TargetOpcode::G_FRINT; | ||||||||
| 1245 | case Intrinsic::round: | ||||||||
| 1246 | return TargetOpcode::G_INTRINSIC_ROUND; | ||||||||
| 1247 | case Intrinsic::sin: | ||||||||
| 1248 | return TargetOpcode::G_FSIN; | ||||||||
| 1249 | case Intrinsic::sqrt: | ||||||||
| 1250 | return TargetOpcode::G_FSQRT; | ||||||||
| 1251 | case Intrinsic::trunc: | ||||||||
| 1252 | return TargetOpcode::G_INTRINSIC_TRUNC; | ||||||||
| 1253 | } | ||||||||
| 1254 | return Intrinsic::not_intrinsic; | ||||||||
| 1255 | } | ||||||||
| 1256 | |||||||||
| 1257 | bool IRTranslator::translateSimpleIntrinsic(const CallInst &CI, | ||||||||
| 1258 | Intrinsic::ID ID, | ||||||||
| 1259 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1260 | |||||||||
| 1261 | unsigned Op = getSimpleIntrinsicOpcode(ID); | ||||||||
| 1262 | |||||||||
| 1263 | // Is this a simple intrinsic? | ||||||||
| 1264 | if (Op == Intrinsic::not_intrinsic) | ||||||||
| 1265 | return false; | ||||||||
| 1266 | |||||||||
| 1267 | // Yes. Let's translate it. | ||||||||
| 1268 | SmallVector<llvm::SrcOp, 4> VRegs; | ||||||||
| 1269 | for (auto &Arg : CI.arg_operands()) | ||||||||
| 1270 | VRegs.push_back(getOrCreateVReg(*Arg)); | ||||||||
| 1271 | |||||||||
| 1272 | MIRBuilder.buildInstr(Op, {getOrCreateVReg(CI)}, VRegs, | ||||||||
| 1273 | MachineInstr::copyFlagsFromInstruction(CI)); | ||||||||
| 1274 | return true; | ||||||||
| 1275 | } | ||||||||
| 1276 | |||||||||
| 1277 | bool IRTranslator::translateKnownIntrinsic(const CallInst &CI, Intrinsic::ID ID, | ||||||||
| 1278 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1279 | |||||||||
| 1280 | // If this is a simple intrinsic (that is, we just need to add a def of | ||||||||
| 1281 | // a vreg, and uses for each arg operand, then translate it. | ||||||||
| 1282 | if (translateSimpleIntrinsic(CI, ID, MIRBuilder)) | ||||||||
| 1283 | return true; | ||||||||
| 1284 | |||||||||
| 1285 | switch (ID) { | ||||||||
| 1286 | default: | ||||||||
| 1287 | break; | ||||||||
| 1288 | case Intrinsic::lifetime_start: | ||||||||
| 1289 | case Intrinsic::lifetime_end: { | ||||||||
| 1290 | // No stack colouring in O0, discard region information. | ||||||||
| 1291 | if (MF->getTarget().getOptLevel() == CodeGenOpt::None) | ||||||||
| 1292 | return true; | ||||||||
| 1293 | |||||||||
| 1294 | unsigned Op = ID == Intrinsic::lifetime_start ? TargetOpcode::LIFETIME_START | ||||||||
| 1295 | : TargetOpcode::LIFETIME_END; | ||||||||
| 1296 | |||||||||
| 1297 | // Get the underlying objects for the location passed on the lifetime | ||||||||
| 1298 | // marker. | ||||||||
| 1299 | SmallVector<const Value *, 4> Allocas; | ||||||||
| 1300 | GetUnderlyingObjects(CI.getArgOperand(1), Allocas, *DL); | ||||||||
| 1301 | |||||||||
| 1302 | // Iterate over each underlying object, creating lifetime markers for each | ||||||||
| 1303 | // static alloca. Quit if we find a non-static alloca. | ||||||||
| 1304 | for (const Value *V : Allocas) { | ||||||||
| 1305 | const AllocaInst *AI = dyn_cast<AllocaInst>(V); | ||||||||
| 1306 | if (!AI) | ||||||||
| 1307 | continue; | ||||||||
| 1308 | |||||||||
| 1309 | if (!AI->isStaticAlloca()) | ||||||||
| 1310 | return true; | ||||||||
| 1311 | |||||||||
| 1312 | MIRBuilder.buildInstr(Op).addFrameIndex(getOrCreateFrameIndex(*AI)); | ||||||||
| 1313 | } | ||||||||
| 1314 | return true; | ||||||||
| 1315 | } | ||||||||
| 1316 | case Intrinsic::dbg_declare: { | ||||||||
| 1317 | const DbgDeclareInst &DI = cast<DbgDeclareInst>(CI); | ||||||||
| 1318 | assert(DI.getVariable() && "Missing variable")((DI.getVariable() && "Missing variable") ? static_cast <void> (0) : __assert_fail ("DI.getVariable() && \"Missing variable\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1318, __PRETTY_FUNCTION__)); | ||||||||
| 1319 | |||||||||
| 1320 | const Value *Address = DI.getAddress(); | ||||||||
| 1321 | if (!Address || isa<UndefValue>(Address)) { | ||||||||
| 1322 | LLVM_DEBUG(dbgs() << "Dropping debug info for " << DI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("irtranslator")) { dbgs() << "Dropping debug info for " << DI << "\n"; } } while (false); | ||||||||
| 1323 | return true; | ||||||||
| 1324 | } | ||||||||
| 1325 | |||||||||
| 1326 | assert(DI.getVariable()->isValidLocationForIntrinsic(((DI.getVariable()->isValidLocationForIntrinsic( MIRBuilder .getDebugLoc()) && "Expected inlined-at fields to agree" ) ? static_cast<void> (0) : __assert_fail ("DI.getVariable()->isValidLocationForIntrinsic( MIRBuilder.getDebugLoc()) && \"Expected inlined-at fields to agree\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1328, __PRETTY_FUNCTION__)) | ||||||||
| 1327 | MIRBuilder.getDebugLoc()) &&((DI.getVariable()->isValidLocationForIntrinsic( MIRBuilder .getDebugLoc()) && "Expected inlined-at fields to agree" ) ? static_cast<void> (0) : __assert_fail ("DI.getVariable()->isValidLocationForIntrinsic( MIRBuilder.getDebugLoc()) && \"Expected inlined-at fields to agree\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1328, __PRETTY_FUNCTION__)) | ||||||||
| 1328 | "Expected inlined-at fields to agree")((DI.getVariable()->isValidLocationForIntrinsic( MIRBuilder .getDebugLoc()) && "Expected inlined-at fields to agree" ) ? static_cast<void> (0) : __assert_fail ("DI.getVariable()->isValidLocationForIntrinsic( MIRBuilder.getDebugLoc()) && \"Expected inlined-at fields to agree\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1328, __PRETTY_FUNCTION__)); | ||||||||
| 1329 | auto AI = dyn_cast<AllocaInst>(Address); | ||||||||
| 1330 | if (AI && AI->isStaticAlloca()) { | ||||||||
| 1331 | // Static allocas are tracked at the MF level, no need for DBG_VALUE | ||||||||
| 1332 | // instructions (in fact, they get ignored if they *do* exist). | ||||||||
| 1333 | MF->setVariableDbgInfo(DI.getVariable(), DI.getExpression(), | ||||||||
| 1334 | getOrCreateFrameIndex(*AI), DI.getDebugLoc()); | ||||||||
| 1335 | } else { | ||||||||
| 1336 | // A dbg.declare describes the address of a source variable, so lower it | ||||||||
| 1337 | // into an indirect DBG_VALUE. | ||||||||
| 1338 | MIRBuilder.buildIndirectDbgValue(getOrCreateVReg(*Address), | ||||||||
| 1339 | DI.getVariable(), DI.getExpression()); | ||||||||
| 1340 | } | ||||||||
| 1341 | return true; | ||||||||
| 1342 | } | ||||||||
| 1343 | case Intrinsic::dbg_label: { | ||||||||
| 1344 | const DbgLabelInst &DI = cast<DbgLabelInst>(CI); | ||||||||
| 1345 | assert(DI.getLabel() && "Missing label")((DI.getLabel() && "Missing label") ? static_cast< void> (0) : __assert_fail ("DI.getLabel() && \"Missing label\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1345, __PRETTY_FUNCTION__)); | ||||||||
| 1346 | |||||||||
| 1347 | assert(DI.getLabel()->isValidLocationForIntrinsic(((DI.getLabel()->isValidLocationForIntrinsic( MIRBuilder.getDebugLoc ()) && "Expected inlined-at fields to agree") ? static_cast <void> (0) : __assert_fail ("DI.getLabel()->isValidLocationForIntrinsic( MIRBuilder.getDebugLoc()) && \"Expected inlined-at fields to agree\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1349, __PRETTY_FUNCTION__)) | ||||||||
| 1348 | MIRBuilder.getDebugLoc()) &&((DI.getLabel()->isValidLocationForIntrinsic( MIRBuilder.getDebugLoc ()) && "Expected inlined-at fields to agree") ? static_cast <void> (0) : __assert_fail ("DI.getLabel()->isValidLocationForIntrinsic( MIRBuilder.getDebugLoc()) && \"Expected inlined-at fields to agree\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1349, __PRETTY_FUNCTION__)) | ||||||||
| 1349 | "Expected inlined-at fields to agree")((DI.getLabel()->isValidLocationForIntrinsic( MIRBuilder.getDebugLoc ()) && "Expected inlined-at fields to agree") ? static_cast <void> (0) : __assert_fail ("DI.getLabel()->isValidLocationForIntrinsic( MIRBuilder.getDebugLoc()) && \"Expected inlined-at fields to agree\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1349, __PRETTY_FUNCTION__)); | ||||||||
| 1350 | |||||||||
| 1351 | MIRBuilder.buildDbgLabel(DI.getLabel()); | ||||||||
| 1352 | return true; | ||||||||
| 1353 | } | ||||||||
| 1354 | case Intrinsic::vaend: | ||||||||
| 1355 | // No target I know of cares about va_end. Certainly no in-tree target | ||||||||
| 1356 | // does. Simplest intrinsic ever! | ||||||||
| 1357 | return true; | ||||||||
| 1358 | case Intrinsic::vastart: { | ||||||||
| 1359 | auto &TLI = *MF->getSubtarget().getTargetLowering(); | ||||||||
| 1360 | Value *Ptr = CI.getArgOperand(0); | ||||||||
| 1361 | unsigned ListSize = TLI.getVaListSizeInBits(*DL) / 8; | ||||||||
| 1362 | |||||||||
| 1363 | // FIXME: Get alignment | ||||||||
| 1364 | MIRBuilder.buildInstr(TargetOpcode::G_VASTART) | ||||||||
| 1365 | .addUse(getOrCreateVReg(*Ptr)) | ||||||||
| 1366 | .addMemOperand(MF->getMachineMemOperand( | ||||||||
| 1367 | MachinePointerInfo(Ptr), MachineMemOperand::MOStore, ListSize, 1)); | ||||||||
| 1368 | return true; | ||||||||
| 1369 | } | ||||||||
| 1370 | case Intrinsic::dbg_value: { | ||||||||
| 1371 | // This form of DBG_VALUE is target-independent. | ||||||||
| 1372 | const DbgValueInst &DI = cast<DbgValueInst>(CI); | ||||||||
| 1373 | const Value *V = DI.getValue(); | ||||||||
| 1374 | assert(DI.getVariable()->isValidLocationForIntrinsic(((DI.getVariable()->isValidLocationForIntrinsic( MIRBuilder .getDebugLoc()) && "Expected inlined-at fields to agree" ) ? static_cast<void> (0) : __assert_fail ("DI.getVariable()->isValidLocationForIntrinsic( MIRBuilder.getDebugLoc()) && \"Expected inlined-at fields to agree\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1376, __PRETTY_FUNCTION__)) | ||||||||
| 1375 | MIRBuilder.getDebugLoc()) &&((DI.getVariable()->isValidLocationForIntrinsic( MIRBuilder .getDebugLoc()) && "Expected inlined-at fields to agree" ) ? static_cast<void> (0) : __assert_fail ("DI.getVariable()->isValidLocationForIntrinsic( MIRBuilder.getDebugLoc()) && \"Expected inlined-at fields to agree\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1376, __PRETTY_FUNCTION__)) | ||||||||
| 1376 | "Expected inlined-at fields to agree")((DI.getVariable()->isValidLocationForIntrinsic( MIRBuilder .getDebugLoc()) && "Expected inlined-at fields to agree" ) ? static_cast<void> (0) : __assert_fail ("DI.getVariable()->isValidLocationForIntrinsic( MIRBuilder.getDebugLoc()) && \"Expected inlined-at fields to agree\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1376, __PRETTY_FUNCTION__)); | ||||||||
| 1377 | if (!V) { | ||||||||
| 1378 | // Currently the optimizer can produce this; insert an undef to | ||||||||
| 1379 | // help debugging. Probably the optimizer should not do this. | ||||||||
| 1380 | MIRBuilder.buildIndirectDbgValue(0, DI.getVariable(), DI.getExpression()); | ||||||||
| 1381 | } else if (const auto *CI = dyn_cast<Constant>(V)) { | ||||||||
| 1382 | MIRBuilder.buildConstDbgValue(*CI, DI.getVariable(), DI.getExpression()); | ||||||||
| 1383 | } else { | ||||||||
| 1384 | for (Register Reg : getOrCreateVRegs(*V)) { | ||||||||
| 1385 | // FIXME: This does not handle register-indirect values at offset 0. The | ||||||||
| 1386 | // direct/indirect thing shouldn't really be handled by something as | ||||||||
| 1387 | // implicit as reg+noreg vs reg+imm in the first place, but it seems | ||||||||
| 1388 | // pretty baked in right now. | ||||||||
| 1389 | MIRBuilder.buildDirectDbgValue(Reg, DI.getVariable(), DI.getExpression()); | ||||||||
| 1390 | } | ||||||||
| 1391 | } | ||||||||
| 1392 | return true; | ||||||||
| 1393 | } | ||||||||
| 1394 | case Intrinsic::uadd_with_overflow: | ||||||||
| 1395 | return translateOverflowIntrinsic(CI, TargetOpcode::G_UADDO, MIRBuilder); | ||||||||
| 1396 | case Intrinsic::sadd_with_overflow: | ||||||||
| 1397 | return translateOverflowIntrinsic(CI, TargetOpcode::G_SADDO, MIRBuilder); | ||||||||
| 1398 | case Intrinsic::usub_with_overflow: | ||||||||
| 1399 | return translateOverflowIntrinsic(CI, TargetOpcode::G_USUBO, MIRBuilder); | ||||||||
| 1400 | case Intrinsic::ssub_with_overflow: | ||||||||
| 1401 | return translateOverflowIntrinsic(CI, TargetOpcode::G_SSUBO, MIRBuilder); | ||||||||
| 1402 | case Intrinsic::umul_with_overflow: | ||||||||
| 1403 | return translateOverflowIntrinsic(CI, TargetOpcode::G_UMULO, MIRBuilder); | ||||||||
| 1404 | case Intrinsic::smul_with_overflow: | ||||||||
| 1405 | return translateOverflowIntrinsic(CI, TargetOpcode::G_SMULO, MIRBuilder); | ||||||||
| 1406 | case Intrinsic::fmuladd: { | ||||||||
| 1407 | const TargetMachine &TM = MF->getTarget(); | ||||||||
| 1408 | const TargetLowering &TLI = *MF->getSubtarget().getTargetLowering(); | ||||||||
| 1409 | Register Dst = getOrCreateVReg(CI); | ||||||||
| 1410 | Register Op0 = getOrCreateVReg(*CI.getArgOperand(0)); | ||||||||
| 1411 | Register Op1 = getOrCreateVReg(*CI.getArgOperand(1)); | ||||||||
| 1412 | Register Op2 = getOrCreateVReg(*CI.getArgOperand(2)); | ||||||||
| 1413 | if (TM.Options.AllowFPOpFusion != FPOpFusion::Strict && | ||||||||
| 1414 | TLI.isFMAFasterThanFMulAndFAdd(TLI.getValueType(*DL, CI.getType()))) { | ||||||||
| 1415 | // TODO: Revisit this to see if we should move this part of the | ||||||||
| 1416 | // lowering to the combiner. | ||||||||
| 1417 | MIRBuilder.buildInstr(TargetOpcode::G_FMA, {Dst}, {Op0, Op1, Op2}, | ||||||||
| 1418 | MachineInstr::copyFlagsFromInstruction(CI)); | ||||||||
| 1419 | } else { | ||||||||
| 1420 | LLT Ty = getLLTForType(*CI.getType(), *DL); | ||||||||
| 1421 | auto FMul = MIRBuilder.buildInstr(TargetOpcode::G_FMUL, {Ty}, {Op0, Op1}, | ||||||||
| 1422 | MachineInstr::copyFlagsFromInstruction(CI)); | ||||||||
| 1423 | MIRBuilder.buildInstr(TargetOpcode::G_FADD, {Dst}, {FMul, Op2}, | ||||||||
| 1424 | MachineInstr::copyFlagsFromInstruction(CI)); | ||||||||
| 1425 | } | ||||||||
| 1426 | return true; | ||||||||
| 1427 | } | ||||||||
| 1428 | case Intrinsic::memcpy: | ||||||||
| 1429 | case Intrinsic::memmove: | ||||||||
| 1430 | case Intrinsic::memset: | ||||||||
| 1431 | return translateMemFunc(CI, MIRBuilder, ID); | ||||||||
| 1432 | case Intrinsic::eh_typeid_for: { | ||||||||
| 1433 | GlobalValue *GV = ExtractTypeInfo(CI.getArgOperand(0)); | ||||||||
| 1434 | Register Reg = getOrCreateVReg(CI); | ||||||||
| 1435 | unsigned TypeID = MF->getTypeIDFor(GV); | ||||||||
| 1436 | MIRBuilder.buildConstant(Reg, TypeID); | ||||||||
| 1437 | return true; | ||||||||
| 1438 | } | ||||||||
| 1439 | case Intrinsic::objectsize: { | ||||||||
| 1440 | // If we don't know by now, we're never going to know. | ||||||||
| 1441 | const ConstantInt *Min = cast<ConstantInt>(CI.getArgOperand(1)); | ||||||||
| 1442 | |||||||||
| 1443 | MIRBuilder.buildConstant(getOrCreateVReg(CI), Min->isZero() ? -1ULL : 0); | ||||||||
| 1444 | return true; | ||||||||
| 1445 | } | ||||||||
| 1446 | case Intrinsic::is_constant: | ||||||||
| 1447 | // If this wasn't constant-folded away by now, then it's not a | ||||||||
| 1448 | // constant. | ||||||||
| 1449 | MIRBuilder.buildConstant(getOrCreateVReg(CI), 0); | ||||||||
| 1450 | return true; | ||||||||
| 1451 | case Intrinsic::stackguard: | ||||||||
| 1452 | getStackGuard(getOrCreateVReg(CI), MIRBuilder); | ||||||||
| 1453 | return true; | ||||||||
| 1454 | case Intrinsic::stackprotector: { | ||||||||
| 1455 | LLT PtrTy = getLLTForType(*CI.getArgOperand(0)->getType(), *DL); | ||||||||
| 1456 | Register GuardVal = MRI->createGenericVirtualRegister(PtrTy); | ||||||||
| 1457 | getStackGuard(GuardVal, MIRBuilder); | ||||||||
| 1458 | |||||||||
| 1459 | AllocaInst *Slot = cast<AllocaInst>(CI.getArgOperand(1)); | ||||||||
| 1460 | int FI = getOrCreateFrameIndex(*Slot); | ||||||||
| 1461 | MF->getFrameInfo().setStackProtectorIndex(FI); | ||||||||
| 1462 | |||||||||
| 1463 | MIRBuilder.buildStore( | ||||||||
| 1464 | GuardVal, getOrCreateVReg(*Slot), | ||||||||
| 1465 | *MF->getMachineMemOperand(MachinePointerInfo::getFixedStack(*MF, FI), | ||||||||
| 1466 | MachineMemOperand::MOStore | | ||||||||
| 1467 | MachineMemOperand::MOVolatile, | ||||||||
| 1468 | PtrTy.getSizeInBits() / 8, 8)); | ||||||||
| 1469 | return true; | ||||||||
| 1470 | } | ||||||||
| 1471 | case Intrinsic::stacksave: { | ||||||||
| 1472 | // Save the stack pointer to the location provided by the intrinsic. | ||||||||
| 1473 | Register Reg = getOrCreateVReg(CI); | ||||||||
| 1474 | Register StackPtr = MF->getSubtarget() | ||||||||
| 1475 | .getTargetLowering() | ||||||||
| 1476 | ->getStackPointerRegisterToSaveRestore(); | ||||||||
| 1477 | |||||||||
| 1478 | // If the target doesn't specify a stack pointer, then fall back. | ||||||||
| 1479 | if (!StackPtr) | ||||||||
| 1480 | return false; | ||||||||
| 1481 | |||||||||
| 1482 | MIRBuilder.buildCopy(Reg, StackPtr); | ||||||||
| 1483 | return true; | ||||||||
| 1484 | } | ||||||||
| 1485 | case Intrinsic::stackrestore: { | ||||||||
| 1486 | // Restore the stack pointer from the location provided by the intrinsic. | ||||||||
| 1487 | Register Reg = getOrCreateVReg(*CI.getArgOperand(0)); | ||||||||
| 1488 | Register StackPtr = MF->getSubtarget() | ||||||||
| 1489 | .getTargetLowering() | ||||||||
| 1490 | ->getStackPointerRegisterToSaveRestore(); | ||||||||
| 1491 | |||||||||
| 1492 | // If the target doesn't specify a stack pointer, then fall back. | ||||||||
| 1493 | if (!StackPtr) | ||||||||
| 1494 | return false; | ||||||||
| 1495 | |||||||||
| 1496 | MIRBuilder.buildCopy(StackPtr, Reg); | ||||||||
| 1497 | return true; | ||||||||
| 1498 | } | ||||||||
| 1499 | case Intrinsic::cttz: | ||||||||
| 1500 | case Intrinsic::ctlz: { | ||||||||
| 1501 | ConstantInt *Cst = cast<ConstantInt>(CI.getArgOperand(1)); | ||||||||
| 1502 | bool isTrailing = ID == Intrinsic::cttz; | ||||||||
| 1503 | unsigned Opcode = isTrailing | ||||||||
| 1504 | ? Cst->isZero() ? TargetOpcode::G_CTTZ | ||||||||
| 1505 | : TargetOpcode::G_CTTZ_ZERO_UNDEF | ||||||||
| 1506 | : Cst->isZero() ? TargetOpcode::G_CTLZ | ||||||||
| 1507 | : TargetOpcode::G_CTLZ_ZERO_UNDEF; | ||||||||
| 1508 | MIRBuilder.buildInstr(Opcode) | ||||||||
| 1509 | .addDef(getOrCreateVReg(CI)) | ||||||||
| 1510 | .addUse(getOrCreateVReg(*CI.getArgOperand(0))); | ||||||||
| 1511 | return true; | ||||||||
| 1512 | } | ||||||||
| 1513 | case Intrinsic::invariant_start: { | ||||||||
| 1514 | LLT PtrTy = getLLTForType(*CI.getArgOperand(0)->getType(), *DL); | ||||||||
| 1515 | Register Undef = MRI->createGenericVirtualRegister(PtrTy); | ||||||||
| 1516 | MIRBuilder.buildUndef(Undef); | ||||||||
| 1517 | return true; | ||||||||
| 1518 | } | ||||||||
| 1519 | case Intrinsic::invariant_end: | ||||||||
| 1520 | return true; | ||||||||
| 1521 | case Intrinsic::assume: | ||||||||
| 1522 | case Intrinsic::var_annotation: | ||||||||
| 1523 | case Intrinsic::sideeffect: | ||||||||
| 1524 | // Discard annotate attributes, assumptions, and artificial side-effects. | ||||||||
| 1525 | return true; | ||||||||
| 1526 | } | ||||||||
| 1527 | return false; | ||||||||
| 1528 | } | ||||||||
| 1529 | |||||||||
| 1530 | bool IRTranslator::translateInlineAsm(const CallInst &CI, | ||||||||
| 1531 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1532 | const InlineAsm &IA = cast<InlineAsm>(*CI.getCalledValue()); | ||||||||
| 1533 | if (!IA.getConstraintString().empty()) | ||||||||
| 1534 | return false; | ||||||||
| 1535 | |||||||||
| 1536 | unsigned ExtraInfo = 0; | ||||||||
| 1537 | if (IA.hasSideEffects()) | ||||||||
| 1538 | ExtraInfo |= InlineAsm::Extra_HasSideEffects; | ||||||||
| 1539 | if (IA.getDialect() == InlineAsm::AD_Intel) | ||||||||
| 1540 | ExtraInfo |= InlineAsm::Extra_AsmDialect; | ||||||||
| 1541 | |||||||||
| 1542 | MIRBuilder.buildInstr(TargetOpcode::INLINEASM) | ||||||||
| 1543 | .addExternalSymbol(IA.getAsmString().c_str()) | ||||||||
| 1544 | .addImm(ExtraInfo); | ||||||||
| 1545 | |||||||||
| 1546 | return true; | ||||||||
| 1547 | } | ||||||||
| 1548 | |||||||||
| 1549 | bool IRTranslator::translateCallSite(const ImmutableCallSite &CS, | ||||||||
| 1550 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1551 | const Instruction &I = *CS.getInstruction(); | ||||||||
| 1552 | ArrayRef<Register> Res = getOrCreateVRegs(I); | ||||||||
| 1553 | |||||||||
| 1554 | SmallVector<ArrayRef<Register>, 8> Args; | ||||||||
| 1555 | Register SwiftInVReg = 0; | ||||||||
| 1556 | Register SwiftErrorVReg = 0; | ||||||||
| 1557 | for (auto &Arg : CS.args()) { | ||||||||
| 1558 | if (CLI->supportSwiftError() && isSwiftError(Arg)) { | ||||||||
| 1559 | assert(SwiftInVReg == 0 && "Expected only one swift error argument")((SwiftInVReg == 0 && "Expected only one swift error argument" ) ? static_cast<void> (0) : __assert_fail ("SwiftInVReg == 0 && \"Expected only one swift error argument\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1559, __PRETTY_FUNCTION__)); | ||||||||
| 1560 | LLT Ty = getLLTForType(*Arg->getType(), *DL); | ||||||||
| 1561 | SwiftInVReg = MRI->createGenericVirtualRegister(Ty); | ||||||||
| 1562 | MIRBuilder.buildCopy(SwiftInVReg, SwiftError.getOrCreateVRegUseAt( | ||||||||
| 1563 | &I, &MIRBuilder.getMBB(), Arg)); | ||||||||
| 1564 | Args.emplace_back(makeArrayRef(SwiftInVReg)); | ||||||||
| 1565 | SwiftErrorVReg = | ||||||||
| 1566 | SwiftError.getOrCreateVRegDefAt(&I, &MIRBuilder.getMBB(), Arg); | ||||||||
| 1567 | continue; | ||||||||
| 1568 | } | ||||||||
| 1569 | Args.push_back(getOrCreateVRegs(*Arg)); | ||||||||
| 1570 | } | ||||||||
| 1571 | |||||||||
| 1572 | // We don't set HasCalls on MFI here yet because call lowering may decide to | ||||||||
| 1573 | // optimize into tail calls. Instead, we defer that to selection where a final | ||||||||
| 1574 | // scan is done to check if any instructions are calls. | ||||||||
| 1575 | bool Success = | ||||||||
| 1576 | CLI->lowerCall(MIRBuilder, CS, Res, Args, SwiftErrorVReg, | ||||||||
| 1577 | [&]() { return getOrCreateVReg(*CS.getCalledValue()); }); | ||||||||
| 1578 | |||||||||
| 1579 | // Check if we just inserted a tail call. | ||||||||
| 1580 | if (Success) { | ||||||||
| 1581 | assert(!HasTailCall && "Can't tail call return twice from block?")((!HasTailCall && "Can't tail call return twice from block?" ) ? static_cast<void> (0) : __assert_fail ("!HasTailCall && \"Can't tail call return twice from block?\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1581, __PRETTY_FUNCTION__)); | ||||||||
| 1582 | const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo(); | ||||||||
| 1583 | HasTailCall = TII->isTailCall(*std::prev(MIRBuilder.getInsertPt())); | ||||||||
| 1584 | } | ||||||||
| 1585 | |||||||||
| 1586 | return Success; | ||||||||
| 1587 | } | ||||||||
| 1588 | |||||||||
| 1589 | bool IRTranslator::translateCall(const User &U, MachineIRBuilder &MIRBuilder) { | ||||||||
| 1590 | const CallInst &CI = cast<CallInst>(U); | ||||||||
| 1591 | auto TII = MF->getTarget().getIntrinsicInfo(); | ||||||||
| 1592 | const Function *F = CI.getCalledFunction(); | ||||||||
| 1593 | |||||||||
| 1594 | // FIXME: support Windows dllimport function calls. | ||||||||
| 1595 | if (F && F->hasDLLImportStorageClass()) | ||||||||
| 1596 | return false; | ||||||||
| 1597 | |||||||||
| 1598 | if (CI.isInlineAsm()) | ||||||||
| 1599 | return translateInlineAsm(CI, MIRBuilder); | ||||||||
| 1600 | |||||||||
| 1601 | Intrinsic::ID ID = Intrinsic::not_intrinsic; | ||||||||
| 1602 | if (F && F->isIntrinsic()) { | ||||||||
| 1603 | ID = F->getIntrinsicID(); | ||||||||
| 1604 | if (TII && ID == Intrinsic::not_intrinsic) | ||||||||
| 1605 | ID = static_cast<Intrinsic::ID>(TII->getIntrinsicID(F)); | ||||||||
| 1606 | } | ||||||||
| 1607 | |||||||||
| 1608 | if (!F || !F->isIntrinsic() || ID == Intrinsic::not_intrinsic) | ||||||||
| 1609 | return translateCallSite(&CI, MIRBuilder); | ||||||||
| 1610 | |||||||||
| 1611 | assert(ID != Intrinsic::not_intrinsic && "unknown intrinsic")((ID != Intrinsic::not_intrinsic && "unknown intrinsic" ) ? static_cast<void> (0) : __assert_fail ("ID != Intrinsic::not_intrinsic && \"unknown intrinsic\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1611, __PRETTY_FUNCTION__)); | ||||||||
| 1612 | |||||||||
| 1613 | if (translateKnownIntrinsic(CI, ID, MIRBuilder)) | ||||||||
| 1614 | return true; | ||||||||
| 1615 | |||||||||
| 1616 | ArrayRef<Register> ResultRegs; | ||||||||
| 1617 | if (!CI.getType()->isVoidTy()) | ||||||||
| 1618 | ResultRegs = getOrCreateVRegs(CI); | ||||||||
| 1619 | |||||||||
| 1620 | // Ignore the callsite attributes. Backend code is most likely not expecting | ||||||||
| 1621 | // an intrinsic to sometimes have side effects and sometimes not. | ||||||||
| 1622 | MachineInstrBuilder MIB = | ||||||||
| 1623 | MIRBuilder.buildIntrinsic(ID, ResultRegs, !F->doesNotAccessMemory()); | ||||||||
| 1624 | if (isa<FPMathOperator>(CI)) | ||||||||
| 1625 | MIB->copyIRFlags(CI); | ||||||||
| 1626 | |||||||||
| 1627 | for (auto &Arg : enumerate(CI.arg_operands())) { | ||||||||
| 1628 | // Some intrinsics take metadata parameters. Reject them. | ||||||||
| 1629 | if (isa<MetadataAsValue>(Arg.value())) | ||||||||
| 1630 | return false; | ||||||||
| 1631 | |||||||||
| 1632 | // If this is required to be an immediate, don't materialize it in a | ||||||||
| 1633 | // register. | ||||||||
| 1634 | if (CI.paramHasAttr(Arg.index(), Attribute::ImmArg)) { | ||||||||
| 1635 | if (ConstantInt *CI = dyn_cast<ConstantInt>(Arg.value())) { | ||||||||
| 1636 | // imm arguments are more convenient than cimm (and realistically | ||||||||
| 1637 | // probably sufficient), so use them. | ||||||||
| 1638 | assert(CI->getBitWidth() <= 64 &&((CI->getBitWidth() <= 64 && "large intrinsic immediates not handled" ) ? static_cast<void> (0) : __assert_fail ("CI->getBitWidth() <= 64 && \"large intrinsic immediates not handled\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1639, __PRETTY_FUNCTION__)) | ||||||||
| 1639 | "large intrinsic immediates not handled")((CI->getBitWidth() <= 64 && "large intrinsic immediates not handled" ) ? static_cast<void> (0) : __assert_fail ("CI->getBitWidth() <= 64 && \"large intrinsic immediates not handled\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1639, __PRETTY_FUNCTION__)); | ||||||||
| 1640 | MIB.addImm(CI->getSExtValue()); | ||||||||
| 1641 | } else { | ||||||||
| 1642 | MIB.addFPImm(cast<ConstantFP>(Arg.value())); | ||||||||
| 1643 | } | ||||||||
| 1644 | } else { | ||||||||
| 1645 | ArrayRef<Register> VRegs = getOrCreateVRegs(*Arg.value()); | ||||||||
| 1646 | if (VRegs.size() > 1) | ||||||||
| 1647 | return false; | ||||||||
| 1648 | MIB.addUse(VRegs[0]); | ||||||||
| 1649 | } | ||||||||
| 1650 | } | ||||||||
| 1651 | |||||||||
| 1652 | // Add a MachineMemOperand if it is a target mem intrinsic. | ||||||||
| 1653 | const TargetLowering &TLI = *MF->getSubtarget().getTargetLowering(); | ||||||||
| 1654 | TargetLowering::IntrinsicInfo Info; | ||||||||
| 1655 | // TODO: Add a GlobalISel version of getTgtMemIntrinsic. | ||||||||
| 1656 | if (TLI.getTgtMemIntrinsic(Info, CI, *MF, ID)) { | ||||||||
| 1657 | MaybeAlign Align = Info.align; | ||||||||
| 1658 | if (!Align) | ||||||||
| 1659 | Align = MaybeAlign( | ||||||||
| 1660 | DL->getABITypeAlignment(Info.memVT.getTypeForEVT(F->getContext()))); | ||||||||
| 1661 | |||||||||
| 1662 | uint64_t Size = Info.memVT.getStoreSize(); | ||||||||
| 1663 | MIB.addMemOperand(MF->getMachineMemOperand( | ||||||||
| 1664 | MachinePointerInfo(Info.ptrVal), Info.flags, Size, Align->value())); | ||||||||
| 1665 | } | ||||||||
| 1666 | |||||||||
| 1667 | return true; | ||||||||
| 1668 | } | ||||||||
| 1669 | |||||||||
| 1670 | bool IRTranslator::translateInvoke(const User &U, | ||||||||
| 1671 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1672 | const InvokeInst &I = cast<InvokeInst>(U); | ||||||||
| 1673 | MCContext &Context = MF->getContext(); | ||||||||
| 1674 | |||||||||
| 1675 | const BasicBlock *ReturnBB = I.getSuccessor(0); | ||||||||
| 1676 | const BasicBlock *EHPadBB = I.getSuccessor(1); | ||||||||
| 1677 | |||||||||
| 1678 | const Value *Callee = I.getCalledValue(); | ||||||||
| 1679 | const Function *Fn = dyn_cast<Function>(Callee); | ||||||||
| 1680 | if (isa<InlineAsm>(Callee)) | ||||||||
| 1681 | return false; | ||||||||
| 1682 | |||||||||
| 1683 | // FIXME: support invoking patchpoint and statepoint intrinsics. | ||||||||
| 1684 | if (Fn && Fn->isIntrinsic()) | ||||||||
| 1685 | return false; | ||||||||
| 1686 | |||||||||
| 1687 | // FIXME: support whatever these are. | ||||||||
| 1688 | if (I.countOperandBundlesOfType(LLVMContext::OB_deopt)) | ||||||||
| 1689 | return false; | ||||||||
| 1690 | |||||||||
| 1691 | // FIXME: support Windows exception handling. | ||||||||
| 1692 | if (!isa<LandingPadInst>(EHPadBB->front())) | ||||||||
| 1693 | return false; | ||||||||
| 1694 | |||||||||
| 1695 | // Emit the actual call, bracketed by EH_LABELs so that the MF knows about | ||||||||
| 1696 | // the region covered by the try. | ||||||||
| 1697 | MCSymbol *BeginSymbol = Context.createTempSymbol(); | ||||||||
| 1698 | MIRBuilder.buildInstr(TargetOpcode::EH_LABEL).addSym(BeginSymbol); | ||||||||
| 1699 | |||||||||
| 1700 | if (!translateCallSite(&I, MIRBuilder)) | ||||||||
| 1701 | return false; | ||||||||
| 1702 | |||||||||
| 1703 | MCSymbol *EndSymbol = Context.createTempSymbol(); | ||||||||
| 1704 | MIRBuilder.buildInstr(TargetOpcode::EH_LABEL).addSym(EndSymbol); | ||||||||
| 1705 | |||||||||
| 1706 | // FIXME: track probabilities. | ||||||||
| 1707 | MachineBasicBlock &EHPadMBB = getMBB(*EHPadBB), | ||||||||
| 1708 | &ReturnMBB = getMBB(*ReturnBB); | ||||||||
| 1709 | MF->addInvoke(&EHPadMBB, BeginSymbol, EndSymbol); | ||||||||
| 1710 | MIRBuilder.getMBB().addSuccessor(&ReturnMBB); | ||||||||
| 1711 | MIRBuilder.getMBB().addSuccessor(&EHPadMBB); | ||||||||
| 1712 | MIRBuilder.buildBr(ReturnMBB); | ||||||||
| 1713 | |||||||||
| 1714 | return true; | ||||||||
| 1715 | } | ||||||||
| 1716 | |||||||||
| 1717 | bool IRTranslator::translateCallBr(const User &U, | ||||||||
| 1718 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1719 | // FIXME: Implement this. | ||||||||
| 1720 | return false; | ||||||||
| 1721 | } | ||||||||
| 1722 | |||||||||
| 1723 | bool IRTranslator::translateLandingPad(const User &U, | ||||||||
| 1724 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1725 | const LandingPadInst &LP = cast<LandingPadInst>(U); | ||||||||
| 1726 | |||||||||
| 1727 | MachineBasicBlock &MBB = MIRBuilder.getMBB(); | ||||||||
| 1728 | |||||||||
| 1729 | MBB.setIsEHPad(); | ||||||||
| 1730 | |||||||||
| 1731 | // If there aren't registers to copy the values into (e.g., during SjLj | ||||||||
| 1732 | // exceptions), then don't bother. | ||||||||
| 1733 | auto &TLI = *MF->getSubtarget().getTargetLowering(); | ||||||||
| 1734 | const Constant *PersonalityFn = MF->getFunction().getPersonalityFn(); | ||||||||
| 1735 | if (TLI.getExceptionPointerRegister(PersonalityFn) == 0 && | ||||||||
| 1736 | TLI.getExceptionSelectorRegister(PersonalityFn) == 0) | ||||||||
| 1737 | return true; | ||||||||
| 1738 | |||||||||
| 1739 | // If landingpad's return type is token type, we don't create DAG nodes | ||||||||
| 1740 | // for its exception pointer and selector value. The extraction of exception | ||||||||
| 1741 | // pointer or selector value from token type landingpads is not currently | ||||||||
| 1742 | // supported. | ||||||||
| 1743 | if (LP.getType()->isTokenTy()) | ||||||||
| 1744 | return true; | ||||||||
| 1745 | |||||||||
| 1746 | // Add a label to mark the beginning of the landing pad. Deletion of the | ||||||||
| 1747 | // landing pad can thus be detected via the MachineModuleInfo. | ||||||||
| 1748 | MIRBuilder.buildInstr(TargetOpcode::EH_LABEL) | ||||||||
| 1749 | .addSym(MF->addLandingPad(&MBB)); | ||||||||
| 1750 | |||||||||
| 1751 | LLT Ty = getLLTForType(*LP.getType(), *DL); | ||||||||
| 1752 | Register Undef = MRI->createGenericVirtualRegister(Ty); | ||||||||
| 1753 | MIRBuilder.buildUndef(Undef); | ||||||||
| 1754 | |||||||||
| 1755 | SmallVector<LLT, 2> Tys; | ||||||||
| 1756 | for (Type *Ty : cast<StructType>(LP.getType())->elements()) | ||||||||
| 1757 | Tys.push_back(getLLTForType(*Ty, *DL)); | ||||||||
| 1758 | assert(Tys.size() == 2 && "Only two-valued landingpads are supported")((Tys.size() == 2 && "Only two-valued landingpads are supported" ) ? static_cast<void> (0) : __assert_fail ("Tys.size() == 2 && \"Only two-valued landingpads are supported\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1758, __PRETTY_FUNCTION__)); | ||||||||
| 1759 | |||||||||
| 1760 | // Mark exception register as live in. | ||||||||
| 1761 | Register ExceptionReg = TLI.getExceptionPointerRegister(PersonalityFn); | ||||||||
| 1762 | if (!ExceptionReg) | ||||||||
| 1763 | return false; | ||||||||
| 1764 | |||||||||
| 1765 | MBB.addLiveIn(ExceptionReg); | ||||||||
| 1766 | ArrayRef<Register> ResRegs = getOrCreateVRegs(LP); | ||||||||
| 1767 | MIRBuilder.buildCopy(ResRegs[0], ExceptionReg); | ||||||||
| 1768 | |||||||||
| 1769 | Register SelectorReg = TLI.getExceptionSelectorRegister(PersonalityFn); | ||||||||
| 1770 | if (!SelectorReg) | ||||||||
| 1771 | return false; | ||||||||
| 1772 | |||||||||
| 1773 | MBB.addLiveIn(SelectorReg); | ||||||||
| 1774 | Register PtrVReg = MRI->createGenericVirtualRegister(Tys[0]); | ||||||||
| 1775 | MIRBuilder.buildCopy(PtrVReg, SelectorReg); | ||||||||
| 1776 | MIRBuilder.buildCast(ResRegs[1], PtrVReg); | ||||||||
| 1777 | |||||||||
| 1778 | return true; | ||||||||
| 1779 | } | ||||||||
| 1780 | |||||||||
| 1781 | bool IRTranslator::translateAlloca(const User &U, | ||||||||
| 1782 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1783 | auto &AI = cast<AllocaInst>(U); | ||||||||
| 1784 | |||||||||
| 1785 | if (AI.isSwiftError()) | ||||||||
| 1786 | return true; | ||||||||
| 1787 | |||||||||
| 1788 | if (AI.isStaticAlloca()) { | ||||||||
| 1789 | Register Res = getOrCreateVReg(AI); | ||||||||
| 1790 | int FI = getOrCreateFrameIndex(AI); | ||||||||
| 1791 | MIRBuilder.buildFrameIndex(Res, FI); | ||||||||
| 1792 | return true; | ||||||||
| 1793 | } | ||||||||
| 1794 | |||||||||
| 1795 | // FIXME: support stack probing for Windows. | ||||||||
| 1796 | if (MF->getTarget().getTargetTriple().isOSWindows()) | ||||||||
| 1797 | return false; | ||||||||
| 1798 | |||||||||
| 1799 | // Now we're in the harder dynamic case. | ||||||||
| 1800 | Type *Ty = AI.getAllocatedType(); | ||||||||
| 1801 | unsigned Align = | ||||||||
| 1802 | std::max((unsigned)DL->getPrefTypeAlignment(Ty), AI.getAlignment()); | ||||||||
| 1803 | |||||||||
| 1804 | Register NumElts = getOrCreateVReg(*AI.getArraySize()); | ||||||||
| 1805 | |||||||||
| 1806 | Type *IntPtrIRTy = DL->getIntPtrType(AI.getType()); | ||||||||
| 1807 | LLT IntPtrTy = getLLTForType(*IntPtrIRTy, *DL); | ||||||||
| 1808 | if (MRI->getType(NumElts) != IntPtrTy) { | ||||||||
| 1809 | Register ExtElts = MRI->createGenericVirtualRegister(IntPtrTy); | ||||||||
| 1810 | MIRBuilder.buildZExtOrTrunc(ExtElts, NumElts); | ||||||||
| 1811 | NumElts = ExtElts; | ||||||||
| 1812 | } | ||||||||
| 1813 | |||||||||
| 1814 | Register AllocSize = MRI->createGenericVirtualRegister(IntPtrTy); | ||||||||
| 1815 | Register TySize = | ||||||||
| 1816 | getOrCreateVReg(*ConstantInt::get(IntPtrIRTy, DL->getTypeAllocSize(Ty))); | ||||||||
| 1817 | MIRBuilder.buildMul(AllocSize, NumElts, TySize); | ||||||||
| 1818 | |||||||||
| 1819 | unsigned StackAlign = | ||||||||
| 1820 | MF->getSubtarget().getFrameLowering()->getStackAlignment(); | ||||||||
| 1821 | if (Align <= StackAlign) | ||||||||
| 1822 | Align = 0; | ||||||||
| 1823 | |||||||||
| 1824 | // Round the size of the allocation up to the stack alignment size | ||||||||
| 1825 | // by add SA-1 to the size. This doesn't overflow because we're computing | ||||||||
| 1826 | // an address inside an alloca. | ||||||||
| 1827 | auto SAMinusOne = MIRBuilder.buildConstant(IntPtrTy, StackAlign - 1); | ||||||||
| 1828 | auto AllocAdd = MIRBuilder.buildAdd(IntPtrTy, AllocSize, SAMinusOne, | ||||||||
| 1829 | MachineInstr::NoUWrap); | ||||||||
| 1830 | auto AlignCst = | ||||||||
| 1831 | MIRBuilder.buildConstant(IntPtrTy, ~(uint64_t)(StackAlign - 1)); | ||||||||
| 1832 | auto AlignedAlloc = MIRBuilder.buildAnd(IntPtrTy, AllocAdd, AlignCst); | ||||||||
| 1833 | |||||||||
| 1834 | MIRBuilder.buildDynStackAlloc(getOrCreateVReg(AI), AlignedAlloc, Align); | ||||||||
| 1835 | |||||||||
| 1836 | MF->getFrameInfo().CreateVariableSizedObject(Align ? Align : 1, &AI); | ||||||||
| 1837 | assert(MF->getFrameInfo().hasVarSizedObjects())((MF->getFrameInfo().hasVarSizedObjects()) ? static_cast< void> (0) : __assert_fail ("MF->getFrameInfo().hasVarSizedObjects()" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 1837, __PRETTY_FUNCTION__)); | ||||||||
| 1838 | return true; | ||||||||
| 1839 | } | ||||||||
| 1840 | |||||||||
| 1841 | bool IRTranslator::translateVAArg(const User &U, MachineIRBuilder &MIRBuilder) { | ||||||||
| 1842 | // FIXME: We may need more info about the type. Because of how LLT works, | ||||||||
| 1843 | // we're completely discarding the i64/double distinction here (amongst | ||||||||
| 1844 | // others). Fortunately the ABIs I know of where that matters don't use va_arg | ||||||||
| 1845 | // anyway but that's not guaranteed. | ||||||||
| 1846 | MIRBuilder.buildInstr(TargetOpcode::G_VAARG) | ||||||||
| 1847 | .addDef(getOrCreateVReg(U)) | ||||||||
| 1848 | .addUse(getOrCreateVReg(*U.getOperand(0))) | ||||||||
| 1849 | .addImm(DL->getABITypeAlignment(U.getType())); | ||||||||
| 1850 | return true; | ||||||||
| 1851 | } | ||||||||
| 1852 | |||||||||
| 1853 | bool IRTranslator::translateInsertElement(const User &U, | ||||||||
| 1854 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1855 | // If it is a <1 x Ty> vector, use the scalar as it is | ||||||||
| 1856 | // not a legal vector type in LLT. | ||||||||
| 1857 | if (U.getType()->getVectorNumElements() == 1) { | ||||||||
| 1858 | Register Elt = getOrCreateVReg(*U.getOperand(1)); | ||||||||
| 1859 | auto &Regs = *VMap.getVRegs(U); | ||||||||
| 1860 | if (Regs.empty()) { | ||||||||
| 1861 | Regs.push_back(Elt); | ||||||||
| 1862 | VMap.getOffsets(U)->push_back(0); | ||||||||
| 1863 | } else { | ||||||||
| 1864 | MIRBuilder.buildCopy(Regs[0], Elt); | ||||||||
| 1865 | } | ||||||||
| 1866 | return true; | ||||||||
| 1867 | } | ||||||||
| 1868 | |||||||||
| 1869 | Register Res = getOrCreateVReg(U); | ||||||||
| 1870 | Register Val = getOrCreateVReg(*U.getOperand(0)); | ||||||||
| 1871 | Register Elt = getOrCreateVReg(*U.getOperand(1)); | ||||||||
| 1872 | Register Idx = getOrCreateVReg(*U.getOperand(2)); | ||||||||
| 1873 | MIRBuilder.buildInsertVectorElement(Res, Val, Elt, Idx); | ||||||||
| 1874 | return true; | ||||||||
| 1875 | } | ||||||||
| 1876 | |||||||||
| 1877 | bool IRTranslator::translateExtractElement(const User &U, | ||||||||
| 1878 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1879 | // If it is a <1 x Ty> vector, use the scalar as it is | ||||||||
| 1880 | // not a legal vector type in LLT. | ||||||||
| 1881 | if (U.getOperand(0)->getType()->getVectorNumElements() == 1) { | ||||||||
| 1882 | Register Elt = getOrCreateVReg(*U.getOperand(0)); | ||||||||
| 1883 | auto &Regs = *VMap.getVRegs(U); | ||||||||
| 1884 | if (Regs.empty()) { | ||||||||
| 1885 | Regs.push_back(Elt); | ||||||||
| 1886 | VMap.getOffsets(U)->push_back(0); | ||||||||
| 1887 | } else { | ||||||||
| 1888 | MIRBuilder.buildCopy(Regs[0], Elt); | ||||||||
| 1889 | } | ||||||||
| 1890 | return true; | ||||||||
| 1891 | } | ||||||||
| 1892 | Register Res = getOrCreateVReg(U); | ||||||||
| 1893 | Register Val = getOrCreateVReg(*U.getOperand(0)); | ||||||||
| 1894 | const auto &TLI = *MF->getSubtarget().getTargetLowering(); | ||||||||
| 1895 | unsigned PreferredVecIdxWidth = TLI.getVectorIdxTy(*DL).getSizeInBits(); | ||||||||
| 1896 | Register Idx; | ||||||||
| 1897 | if (auto *CI = dyn_cast<ConstantInt>(U.getOperand(1))) { | ||||||||
| 1898 | if (CI->getBitWidth() != PreferredVecIdxWidth) { | ||||||||
| 1899 | APInt NewIdx = CI->getValue().sextOrTrunc(PreferredVecIdxWidth); | ||||||||
| 1900 | auto *NewIdxCI = ConstantInt::get(CI->getContext(), NewIdx); | ||||||||
| 1901 | Idx = getOrCreateVReg(*NewIdxCI); | ||||||||
| 1902 | } | ||||||||
| 1903 | } | ||||||||
| 1904 | if (!Idx) | ||||||||
| 1905 | Idx = getOrCreateVReg(*U.getOperand(1)); | ||||||||
| 1906 | if (MRI->getType(Idx).getSizeInBits() != PreferredVecIdxWidth) { | ||||||||
| 1907 | const LLT &VecIdxTy = LLT::scalar(PreferredVecIdxWidth); | ||||||||
| 1908 | Idx = MIRBuilder.buildSExtOrTrunc(VecIdxTy, Idx)->getOperand(0).getReg(); | ||||||||
| 1909 | } | ||||||||
| 1910 | MIRBuilder.buildExtractVectorElement(Res, Val, Idx); | ||||||||
| 1911 | return true; | ||||||||
| 1912 | } | ||||||||
| 1913 | |||||||||
| 1914 | bool IRTranslator::translateShuffleVector(const User &U, | ||||||||
| 1915 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1916 | MIRBuilder.buildInstr(TargetOpcode::G_SHUFFLE_VECTOR) | ||||||||
| 1917 | .addDef(getOrCreateVReg(U)) | ||||||||
| 1918 | .addUse(getOrCreateVReg(*U.getOperand(0))) | ||||||||
| 1919 | .addUse(getOrCreateVReg(*U.getOperand(1))) | ||||||||
| 1920 | .addShuffleMask(cast<Constant>(U.getOperand(2))); | ||||||||
| 1921 | return true; | ||||||||
| 1922 | } | ||||||||
| 1923 | |||||||||
| 1924 | bool IRTranslator::translatePHI(const User &U, MachineIRBuilder &MIRBuilder) { | ||||||||
| 1925 | const PHINode &PI = cast<PHINode>(U); | ||||||||
| 1926 | |||||||||
| 1927 | SmallVector<MachineInstr *, 4> Insts; | ||||||||
| 1928 | for (auto Reg : getOrCreateVRegs(PI)) { | ||||||||
| 1929 | auto MIB = MIRBuilder.buildInstr(TargetOpcode::G_PHI, {Reg}, {}); | ||||||||
| 1930 | Insts.push_back(MIB.getInstr()); | ||||||||
| 1931 | } | ||||||||
| 1932 | |||||||||
| 1933 | PendingPHIs.emplace_back(&PI, std::move(Insts)); | ||||||||
| 1934 | return true; | ||||||||
| 1935 | } | ||||||||
| 1936 | |||||||||
| 1937 | bool IRTranslator::translateAtomicCmpXchg(const User &U, | ||||||||
| 1938 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1939 | const AtomicCmpXchgInst &I = cast<AtomicCmpXchgInst>(U); | ||||||||
| 1940 | |||||||||
| 1941 | if (I.isWeak()) | ||||||||
| 1942 | return false; | ||||||||
| 1943 | |||||||||
| 1944 | auto Flags = I.isVolatile() ? MachineMemOperand::MOVolatile | ||||||||
| 1945 | : MachineMemOperand::MONone; | ||||||||
| 1946 | Flags |= MachineMemOperand::MOLoad | MachineMemOperand::MOStore; | ||||||||
| 1947 | |||||||||
| 1948 | Type *ResType = I.getType(); | ||||||||
| 1949 | Type *ValType = ResType->Type::getStructElementType(0); | ||||||||
| 1950 | |||||||||
| 1951 | auto Res = getOrCreateVRegs(I); | ||||||||
| 1952 | Register OldValRes = Res[0]; | ||||||||
| 1953 | Register SuccessRes = Res[1]; | ||||||||
| 1954 | Register Addr = getOrCreateVReg(*I.getPointerOperand()); | ||||||||
| 1955 | Register Cmp = getOrCreateVReg(*I.getCompareOperand()); | ||||||||
| 1956 | Register NewVal = getOrCreateVReg(*I.getNewValOperand()); | ||||||||
| 1957 | |||||||||
| 1958 | MIRBuilder.buildAtomicCmpXchgWithSuccess( | ||||||||
| 1959 | OldValRes, SuccessRes, Addr, Cmp, NewVal, | ||||||||
| 1960 | *MF->getMachineMemOperand(MachinePointerInfo(I.getPointerOperand()), | ||||||||
| 1961 | Flags, DL->getTypeStoreSize(ValType), | ||||||||
| 1962 | getMemOpAlignment(I), AAMDNodes(), nullptr, | ||||||||
| 1963 | I.getSyncScopeID(), I.getSuccessOrdering(), | ||||||||
| 1964 | I.getFailureOrdering())); | ||||||||
| 1965 | return true; | ||||||||
| 1966 | } | ||||||||
| 1967 | |||||||||
| 1968 | bool IRTranslator::translateAtomicRMW(const User &U, | ||||||||
| 1969 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 1970 | const AtomicRMWInst &I = cast<AtomicRMWInst>(U); | ||||||||
| 1971 | |||||||||
| 1972 | auto Flags = I.isVolatile() ? MachineMemOperand::MOVolatile | ||||||||
| 1973 | : MachineMemOperand::MONone; | ||||||||
| 1974 | Flags |= MachineMemOperand::MOLoad | MachineMemOperand::MOStore; | ||||||||
| 1975 | |||||||||
| 1976 | Type *ResType = I.getType(); | ||||||||
| 1977 | |||||||||
| 1978 | Register Res = getOrCreateVReg(I); | ||||||||
| 1979 | Register Addr = getOrCreateVReg(*I.getPointerOperand()); | ||||||||
| 1980 | Register Val = getOrCreateVReg(*I.getValOperand()); | ||||||||
| 1981 | |||||||||
| 1982 | unsigned Opcode = 0; | ||||||||
| 1983 | switch (I.getOperation()) { | ||||||||
| 1984 | default: | ||||||||
| 1985 | return false; | ||||||||
| 1986 | case AtomicRMWInst::Xchg: | ||||||||
| 1987 | Opcode = TargetOpcode::G_ATOMICRMW_XCHG; | ||||||||
| 1988 | break; | ||||||||
| 1989 | case AtomicRMWInst::Add: | ||||||||
| 1990 | Opcode = TargetOpcode::G_ATOMICRMW_ADD; | ||||||||
| 1991 | break; | ||||||||
| 1992 | case AtomicRMWInst::Sub: | ||||||||
| 1993 | Opcode = TargetOpcode::G_ATOMICRMW_SUB; | ||||||||
| 1994 | break; | ||||||||
| 1995 | case AtomicRMWInst::And: | ||||||||
| 1996 | Opcode = TargetOpcode::G_ATOMICRMW_AND; | ||||||||
| 1997 | break; | ||||||||
| 1998 | case AtomicRMWInst::Nand: | ||||||||
| 1999 | Opcode = TargetOpcode::G_ATOMICRMW_NAND; | ||||||||
| 2000 | break; | ||||||||
| 2001 | case AtomicRMWInst::Or: | ||||||||
| 2002 | Opcode = TargetOpcode::G_ATOMICRMW_OR; | ||||||||
| 2003 | break; | ||||||||
| 2004 | case AtomicRMWInst::Xor: | ||||||||
| 2005 | Opcode = TargetOpcode::G_ATOMICRMW_XOR; | ||||||||
| 2006 | break; | ||||||||
| 2007 | case AtomicRMWInst::Max: | ||||||||
| 2008 | Opcode = TargetOpcode::G_ATOMICRMW_MAX; | ||||||||
| 2009 | break; | ||||||||
| 2010 | case AtomicRMWInst::Min: | ||||||||
| 2011 | Opcode = TargetOpcode::G_ATOMICRMW_MIN; | ||||||||
| 2012 | break; | ||||||||
| 2013 | case AtomicRMWInst::UMax: | ||||||||
| 2014 | Opcode = TargetOpcode::G_ATOMICRMW_UMAX; | ||||||||
| 2015 | break; | ||||||||
| 2016 | case AtomicRMWInst::UMin: | ||||||||
| 2017 | Opcode = TargetOpcode::G_ATOMICRMW_UMIN; | ||||||||
| 2018 | break; | ||||||||
| 2019 | case AtomicRMWInst::FAdd: | ||||||||
| 2020 | Opcode = TargetOpcode::G_ATOMICRMW_FADD; | ||||||||
| 2021 | break; | ||||||||
| 2022 | case AtomicRMWInst::FSub: | ||||||||
| 2023 | Opcode = TargetOpcode::G_ATOMICRMW_FSUB; | ||||||||
| 2024 | break; | ||||||||
| 2025 | } | ||||||||
| 2026 | |||||||||
| 2027 | MIRBuilder.buildAtomicRMW( | ||||||||
| 2028 | Opcode, Res, Addr, Val, | ||||||||
| 2029 | *MF->getMachineMemOperand(MachinePointerInfo(I.getPointerOperand()), | ||||||||
| 2030 | Flags, DL->getTypeStoreSize(ResType), | ||||||||
| 2031 | getMemOpAlignment(I), AAMDNodes(), nullptr, | ||||||||
| 2032 | I.getSyncScopeID(), I.getOrdering())); | ||||||||
| 2033 | return true; | ||||||||
| 2034 | } | ||||||||
| 2035 | |||||||||
| 2036 | bool IRTranslator::translateFence(const User &U, | ||||||||
| 2037 | MachineIRBuilder &MIRBuilder) { | ||||||||
| 2038 | const FenceInst &Fence = cast<FenceInst>(U); | ||||||||
| 2039 | MIRBuilder.buildFence(static_cast<unsigned>(Fence.getOrdering()), | ||||||||
| 2040 | Fence.getSyncScopeID()); | ||||||||
| 2041 | return true; | ||||||||
| 2042 | } | ||||||||
| 2043 | |||||||||
| 2044 | void IRTranslator::finishPendingPhis() { | ||||||||
| 2045 | #ifndef NDEBUG | ||||||||
| 2046 | DILocationVerifier Verifier; | ||||||||
| 2047 | GISelObserverWrapper WrapperObserver(&Verifier); | ||||||||
| 2048 | RAIIDelegateInstaller DelInstall(*MF, &WrapperObserver); | ||||||||
| 2049 | #endif // ifndef NDEBUG | ||||||||
| 2050 | for (auto &Phi : PendingPHIs) { | ||||||||
| 2051 | const PHINode *PI = Phi.first; | ||||||||
| 2052 | ArrayRef<MachineInstr *> ComponentPHIs = Phi.second; | ||||||||
| 2053 | MachineBasicBlock *PhiMBB = ComponentPHIs[0]->getParent(); | ||||||||
| 2054 | EntryBuilder->setDebugLoc(PI->getDebugLoc()); | ||||||||
| 2055 | #ifndef NDEBUG | ||||||||
| 2056 | Verifier.setCurrentInst(PI); | ||||||||
| 2057 | #endif // ifndef NDEBUG | ||||||||
| 2058 | |||||||||
| 2059 | SmallSet<const MachineBasicBlock *, 16> SeenPreds; | ||||||||
| 2060 | for (unsigned i = 0; i < PI->getNumIncomingValues(); ++i) { | ||||||||
| 2061 | auto IRPred = PI->getIncomingBlock(i); | ||||||||
| 2062 | ArrayRef<Register> ValRegs = getOrCreateVRegs(*PI->getIncomingValue(i)); | ||||||||
| 2063 | for (auto Pred : getMachinePredBBs({IRPred, PI->getParent()})) { | ||||||||
| 2064 | if (SeenPreds.count(Pred) || !PhiMBB->isPredecessor(Pred)) | ||||||||
| 2065 | continue; | ||||||||
| 2066 | SeenPreds.insert(Pred); | ||||||||
| 2067 | for (unsigned j = 0; j < ValRegs.size(); ++j) { | ||||||||
| 2068 | MachineInstrBuilder MIB(*MF, ComponentPHIs[j]); | ||||||||
| 2069 | MIB.addUse(ValRegs[j]); | ||||||||
| 2070 | MIB.addMBB(Pred); | ||||||||
| 2071 | } | ||||||||
| 2072 | } | ||||||||
| 2073 | } | ||||||||
| 2074 | } | ||||||||
| 2075 | } | ||||||||
| 2076 | |||||||||
| 2077 | bool IRTranslator::valueIsSplit(const Value &V, | ||||||||
| 2078 | SmallVectorImpl<uint64_t> *Offsets) { | ||||||||
| 2079 | SmallVector<LLT, 4> SplitTys; | ||||||||
| 2080 | if (Offsets && !Offsets->empty()) | ||||||||
| 2081 | Offsets->clear(); | ||||||||
| 2082 | computeValueLLTs(*DL, *V.getType(), SplitTys, Offsets); | ||||||||
| 2083 | return SplitTys.size() > 1; | ||||||||
| 2084 | } | ||||||||
| 2085 | |||||||||
| 2086 | bool IRTranslator::translate(const Instruction &Inst) { | ||||||||
| 2087 | CurBuilder->setDebugLoc(Inst.getDebugLoc()); | ||||||||
| 2088 | // We only emit constants into the entry block from here. To prevent jumpy | ||||||||
| 2089 | // debug behaviour set the line to 0. | ||||||||
| 2090 | if (const DebugLoc &DL = Inst.getDebugLoc()) | ||||||||
| 2091 | EntryBuilder->setDebugLoc( | ||||||||
| 2092 | DebugLoc::get(0, 0, DL.getScope(), DL.getInlinedAt())); | ||||||||
| 2093 | else | ||||||||
| 2094 | EntryBuilder->setDebugLoc(DebugLoc()); | ||||||||
| 2095 | |||||||||
| 2096 | switch (Inst.getOpcode()) { | ||||||||
| 2097 | #define HANDLE_INST(NUM, OPCODE, CLASS) \ | ||||||||
| 2098 | case Instruction::OPCODE: \ | ||||||||
| 2099 | return translate##OPCODE(Inst, *CurBuilder.get()); | ||||||||
| 2100 | #include "llvm/IR/Instruction.def" | ||||||||
| 2101 | default: | ||||||||
| 2102 | return false; | ||||||||
| 2103 | } | ||||||||
| 2104 | } | ||||||||
| 2105 | |||||||||
| 2106 | bool IRTranslator::translate(const Constant &C, Register Reg) { | ||||||||
| 2107 | if (auto CI = dyn_cast<ConstantInt>(&C)) | ||||||||
| 2108 | EntryBuilder->buildConstant(Reg, *CI); | ||||||||
| 2109 | else if (auto CF = dyn_cast<ConstantFP>(&C)) | ||||||||
| 2110 | EntryBuilder->buildFConstant(Reg, *CF); | ||||||||
| 2111 | else if (isa<UndefValue>(C)) | ||||||||
| 2112 | EntryBuilder->buildUndef(Reg); | ||||||||
| 2113 | else if (isa<ConstantPointerNull>(C)) { | ||||||||
| 2114 | // As we are trying to build a constant val of 0 into a pointer, | ||||||||
| 2115 | // insert a cast to make them correct with respect to types. | ||||||||
| 2116 | unsigned NullSize = DL->getTypeSizeInBits(C.getType()); | ||||||||
| 2117 | auto *ZeroTy = Type::getIntNTy(C.getContext(), NullSize); | ||||||||
| 2118 | auto *ZeroVal = ConstantInt::get(ZeroTy, 0); | ||||||||
| 2119 | Register ZeroReg = getOrCreateVReg(*ZeroVal); | ||||||||
| 2120 | EntryBuilder->buildCast(Reg, ZeroReg); | ||||||||
| 2121 | } else if (auto GV = dyn_cast<GlobalValue>(&C)) | ||||||||
| 2122 | EntryBuilder->buildGlobalValue(Reg, GV); | ||||||||
| 2123 | else if (auto CAZ = dyn_cast<ConstantAggregateZero>(&C)) { | ||||||||
| 2124 | if (!CAZ->getType()->isVectorTy()) | ||||||||
| 2125 | return false; | ||||||||
| 2126 | // Return the scalar if it is a <1 x Ty> vector. | ||||||||
| 2127 | if (CAZ->getNumElements() == 1) | ||||||||
| 2128 | return translate(*CAZ->getElementValue(0u), Reg); | ||||||||
| 2129 | SmallVector<Register, 4> Ops; | ||||||||
| 2130 | for (unsigned i = 0; i < CAZ->getNumElements(); ++i) { | ||||||||
| 2131 | Constant &Elt = *CAZ->getElementValue(i); | ||||||||
| 2132 | Ops.push_back(getOrCreateVReg(Elt)); | ||||||||
| 2133 | } | ||||||||
| 2134 | EntryBuilder->buildBuildVector(Reg, Ops); | ||||||||
| 2135 | } else if (auto CV = dyn_cast<ConstantDataVector>(&C)) { | ||||||||
| 2136 | // Return the scalar if it is a <1 x Ty> vector. | ||||||||
| 2137 | if (CV->getNumElements() == 1) | ||||||||
| 2138 | return translate(*CV->getElementAsConstant(0), Reg); | ||||||||
| 2139 | SmallVector<Register, 4> Ops; | ||||||||
| 2140 | for (unsigned i = 0; i < CV->getNumElements(); ++i) { | ||||||||
| 2141 | Constant &Elt = *CV->getElementAsConstant(i); | ||||||||
| 2142 | Ops.push_back(getOrCreateVReg(Elt)); | ||||||||
| 2143 | } | ||||||||
| 2144 | EntryBuilder->buildBuildVector(Reg, Ops); | ||||||||
| 2145 | } else if (auto CE = dyn_cast<ConstantExpr>(&C)) { | ||||||||
| 2146 | switch(CE->getOpcode()) { | ||||||||
| 2147 | #define HANDLE_INST(NUM, OPCODE, CLASS) \ | ||||||||
| 2148 | case Instruction::OPCODE: \ | ||||||||
| 2149 | return translate##OPCODE(*CE, *EntryBuilder.get()); | ||||||||
| 2150 | #include "llvm/IR/Instruction.def" | ||||||||
| 2151 | default: | ||||||||
| 2152 | return false; | ||||||||
| 2153 | } | ||||||||
| 2154 | } else if (auto CV = dyn_cast<ConstantVector>(&C)) { | ||||||||
| 2155 | if (CV->getNumOperands() == 1) | ||||||||
| 2156 | return translate(*CV->getOperand(0), Reg); | ||||||||
| 2157 | SmallVector<Register, 4> Ops; | ||||||||
| 2158 | for (unsigned i = 0; i < CV->getNumOperands(); ++i) { | ||||||||
| 2159 | Ops.push_back(getOrCreateVReg(*CV->getOperand(i))); | ||||||||
| 2160 | } | ||||||||
| 2161 | EntryBuilder->buildBuildVector(Reg, Ops); | ||||||||
| 2162 | } else if (auto *BA = dyn_cast<BlockAddress>(&C)) { | ||||||||
| 2163 | EntryBuilder->buildBlockAddress(Reg, BA); | ||||||||
| 2164 | } else | ||||||||
| 2165 | return false; | ||||||||
| 2166 | |||||||||
| 2167 | return true; | ||||||||
| 2168 | } | ||||||||
| 2169 | |||||||||
| 2170 | void IRTranslator::finalizeBasicBlock() { | ||||||||
| 2171 | for (auto &JTCase : SL->JTCases) { | ||||||||
| 2172 | // Emit header first, if it wasn't already emitted. | ||||||||
| 2173 | if (!JTCase.first.Emitted) | ||||||||
| 2174 | emitJumpTableHeader(JTCase.second, JTCase.first, JTCase.first.HeaderBB); | ||||||||
| 2175 | |||||||||
| 2176 | emitJumpTable(JTCase.second, JTCase.second.MBB); | ||||||||
| 2177 | } | ||||||||
| 2178 | SL->JTCases.clear(); | ||||||||
| 2179 | } | ||||||||
| 2180 | |||||||||
| 2181 | void IRTranslator::finalizeFunction() { | ||||||||
| 2182 | // Release the memory used by the different maps we | ||||||||
| 2183 | // needed during the translation. | ||||||||
| 2184 | PendingPHIs.clear(); | ||||||||
| 2185 | VMap.reset(); | ||||||||
| 2186 | FrameIndices.clear(); | ||||||||
| 2187 | MachinePreds.clear(); | ||||||||
| 2188 | // MachineIRBuilder::DebugLoc can outlive the DILocation it holds. Clear it | ||||||||
| 2189 | // to avoid accessing free’d memory (in runOnMachineFunction) and to avoid | ||||||||
| 2190 | // destroying it twice (in ~IRTranslator() and ~LLVMContext()) | ||||||||
| 2191 | EntryBuilder.reset(); | ||||||||
| 2192 | CurBuilder.reset(); | ||||||||
| 2193 | FuncInfo.clear(); | ||||||||
| 2194 | } | ||||||||
| 2195 | |||||||||
| 2196 | /// Returns true if a BasicBlock \p BB within a variadic function contains a | ||||||||
| 2197 | /// variadic musttail call. | ||||||||
| 2198 | static bool checkForMustTailInVarArgFn(bool IsVarArg, const BasicBlock &BB) { | ||||||||
| 2199 | if (!IsVarArg) | ||||||||
| 2200 | return false; | ||||||||
| 2201 | |||||||||
| 2202 | // Walk the block backwards, because tail calls usually only appear at the end | ||||||||
| 2203 | // of a block. | ||||||||
| 2204 | return std::any_of(BB.rbegin(), BB.rend(), [](const Instruction &I) { | ||||||||
| 2205 | const auto *CI = dyn_cast<CallInst>(&I); | ||||||||
| 2206 | return CI && CI->isMustTailCall(); | ||||||||
| 2207 | }); | ||||||||
| 2208 | } | ||||||||
| 2209 | |||||||||
| 2210 | bool IRTranslator::runOnMachineFunction(MachineFunction &CurMF) { | ||||||||
| 2211 | MF = &CurMF; | ||||||||
| 2212 | const Function &F = MF->getFunction(); | ||||||||
| 2213 | if (F.empty()) | ||||||||
| |||||||||
| 2214 | return false; | ||||||||
| 2215 | GISelCSEAnalysisWrapper &Wrapper = | ||||||||
| 2216 | getAnalysis<GISelCSEAnalysisWrapperPass>().getCSEWrapper(); | ||||||||
| 2217 | // Set the CSEConfig and run the analysis. | ||||||||
| 2218 | GISelCSEInfo *CSEInfo = nullptr; | ||||||||
| 2219 | TPC = &getAnalysis<TargetPassConfig>(); | ||||||||
| 2220 | bool EnableCSE = EnableCSEInIRTranslator.getNumOccurrences() | ||||||||
| 2221 | ? EnableCSEInIRTranslator | ||||||||
| 2222 | : TPC->isGISelCSEEnabled(); | ||||||||
| 2223 | |||||||||
| 2224 | if (EnableCSE) { | ||||||||
| 2225 | EntryBuilder = std::make_unique<CSEMIRBuilder>(CurMF); | ||||||||
| 2226 | CSEInfo = &Wrapper.get(TPC->getCSEConfig()); | ||||||||
| 2227 | EntryBuilder->setCSEInfo(CSEInfo); | ||||||||
| 2228 | CurBuilder = std::make_unique<CSEMIRBuilder>(CurMF); | ||||||||
| 2229 | CurBuilder->setCSEInfo(CSEInfo); | ||||||||
| 2230 | } else { | ||||||||
| 2231 | EntryBuilder = std::make_unique<MachineIRBuilder>(); | ||||||||
| 2232 | CurBuilder = std::make_unique<MachineIRBuilder>(); | ||||||||
| 2233 | } | ||||||||
| 2234 | CLI = MF->getSubtarget().getCallLowering(); | ||||||||
| 2235 | CurBuilder->setMF(*MF); | ||||||||
| 2236 | EntryBuilder->setMF(*MF); | ||||||||
| 2237 | MRI = &MF->getRegInfo(); | ||||||||
| 2238 | DL = &F.getParent()->getDataLayout(); | ||||||||
| 2239 | ORE = std::make_unique<OptimizationRemarkEmitter>(&F); | ||||||||
| 2240 | FuncInfo.MF = MF; | ||||||||
| 2241 | FuncInfo.BPI = nullptr; | ||||||||
| 2242 | const auto &TLI = *MF->getSubtarget().getTargetLowering(); | ||||||||
| 2243 | const TargetMachine &TM = MF->getTarget(); | ||||||||
| 2244 | SL = std::make_unique<GISelSwitchLowering>(this, FuncInfo); | ||||||||
| 2245 | SL->init(TLI, TM, *DL); | ||||||||
| 2246 | |||||||||
| 2247 | EnableOpts = TM.getOptLevel() != CodeGenOpt::None && !skipFunction(F); | ||||||||
| 2248 | |||||||||
| 2249 | assert(PendingPHIs.empty() && "stale PHIs")((PendingPHIs.empty() && "stale PHIs") ? static_cast< void> (0) : __assert_fail ("PendingPHIs.empty() && \"stale PHIs\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 2249, __PRETTY_FUNCTION__)); | ||||||||
| 2250 | |||||||||
| 2251 | if (!DL->isLittleEndian()) { | ||||||||
| 2252 | // Currently we don't properly handle big endian code. | ||||||||
| 2253 | OptimizationRemarkMissed R("gisel-irtranslator", "GISelFailure", | ||||||||
| 2254 | F.getSubprogram(), &F.getEntryBlock()); | ||||||||
| 2255 | R << "unable to translate in big endian mode"; | ||||||||
| 2256 | reportTranslationError(*MF, *TPC, *ORE, R); | ||||||||
| 2257 | } | ||||||||
| 2258 | |||||||||
| 2259 | // Release the per-function state when we return, whether we succeeded or not. | ||||||||
| 2260 | auto FinalizeOnReturn = make_scope_exit([this]() { finalizeFunction(); }); | ||||||||
| 2261 | |||||||||
| 2262 | // Setup a separate basic-block for the arguments and constants | ||||||||
| 2263 | MachineBasicBlock *EntryBB = MF->CreateMachineBasicBlock(); | ||||||||
| 2264 | MF->push_back(EntryBB); | ||||||||
| 2265 | EntryBuilder->setMBB(*EntryBB); | ||||||||
| 2266 | |||||||||
| 2267 | DebugLoc DbgLoc = F.getEntryBlock().getFirstNonPHI()->getDebugLoc(); | ||||||||
| 2268 | SwiftError.setFunction(CurMF); | ||||||||
| 2269 | SwiftError.createEntriesInEntryBlock(DbgLoc); | ||||||||
| 2270 | |||||||||
| 2271 | bool IsVarArg = F.isVarArg(); | ||||||||
| 2272 | bool HasMustTailInVarArgFn = false; | ||||||||
| 2273 | |||||||||
| 2274 | // Create all blocks, in IR order, to preserve the layout. | ||||||||
| 2275 | for (const BasicBlock &BB: F) { | ||||||||
| 2276 | auto *&MBB = BBToMBB[&BB]; | ||||||||
| 2277 | |||||||||
| 2278 | MBB = MF->CreateMachineBasicBlock(&BB); | ||||||||
| 2279 | MF->push_back(MBB); | ||||||||
| 2280 | |||||||||
| 2281 | if (BB.hasAddressTaken()) | ||||||||
| 2282 | MBB->setHasAddressTaken(); | ||||||||
| 2283 | |||||||||
| 2284 | if (!HasMustTailInVarArgFn) | ||||||||
| 2285 | HasMustTailInVarArgFn = checkForMustTailInVarArgFn(IsVarArg, BB); | ||||||||
| 2286 | } | ||||||||
| 2287 | |||||||||
| 2288 | MF->getFrameInfo().setHasMustTailInVarArgFunc(HasMustTailInVarArgFn); | ||||||||
| 2289 | |||||||||
| 2290 | // Make our arguments/constants entry block fallthrough to the IR entry block. | ||||||||
| 2291 | EntryBB->addSuccessor(&getMBB(F.front())); | ||||||||
| 2292 | |||||||||
| 2293 | // Lower the actual args into this basic block. | ||||||||
| 2294 | SmallVector<ArrayRef<Register>, 8> VRegArgs; | ||||||||
| 2295 | for (const Argument &Arg: F.args()) { | ||||||||
| 2296 | if (DL->getTypeStoreSize(Arg.getType()) == 0) | ||||||||
| 2297 | continue; // Don't handle zero sized types. | ||||||||
| 2298 | ArrayRef<Register> VRegs = getOrCreateVRegs(Arg); | ||||||||
| 2299 | VRegArgs.push_back(VRegs); | ||||||||
| 2300 | |||||||||
| 2301 | if (Arg.hasSwiftErrorAttr()) { | ||||||||
| 2302 | assert(VRegs.size() == 1 && "Too many vregs for Swift error")((VRegs.size() == 1 && "Too many vregs for Swift error" ) ? static_cast<void> (0) : __assert_fail ("VRegs.size() == 1 && \"Too many vregs for Swift error\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 2302, __PRETTY_FUNCTION__)); | ||||||||
| 2303 | SwiftError.setCurrentVReg(EntryBB, SwiftError.getFunctionArg(), VRegs[0]); | ||||||||
| 2304 | } | ||||||||
| 2305 | } | ||||||||
| 2306 | |||||||||
| 2307 | if (!CLI->lowerFormalArguments(*EntryBuilder.get(), F, VRegArgs)) { | ||||||||
| 2308 | OptimizationRemarkMissed R("gisel-irtranslator", "GISelFailure", | ||||||||
| 2309 | F.getSubprogram(), &F.getEntryBlock()); | ||||||||
| 2310 | R << "unable to lower arguments: " << ore::NV("Prototype", F.getType()); | ||||||||
| 2311 | reportTranslationError(*MF, *TPC, *ORE, R); | ||||||||
| 2312 | return false; | ||||||||
| 2313 | } | ||||||||
| 2314 | |||||||||
| 2315 | // Need to visit defs before uses when translating instructions. | ||||||||
| 2316 | GISelObserverWrapper WrapperObserver; | ||||||||
| 2317 | if (EnableCSE
| ||||||||
| 2318 | WrapperObserver.addObserver(CSEInfo); | ||||||||
| 2319 | { | ||||||||
| 2320 | ReversePostOrderTraversal<const Function *> RPOT(&F); | ||||||||
| 2321 | #ifndef NDEBUG | ||||||||
| 2322 | DILocationVerifier Verifier; | ||||||||
| 2323 | WrapperObserver.addObserver(&Verifier); | ||||||||
| 2324 | #endif // ifndef NDEBUG | ||||||||
| 2325 | RAIIDelegateInstaller DelInstall(*MF, &WrapperObserver); | ||||||||
| 2326 | for (const BasicBlock *BB : RPOT) { | ||||||||
| 2327 | MachineBasicBlock &MBB = getMBB(*BB); | ||||||||
| 2328 | // Set the insertion point of all the following translations to | ||||||||
| 2329 | // the end of this basic block. | ||||||||
| 2330 | CurBuilder->setMBB(MBB); | ||||||||
| 2331 | HasTailCall = false; | ||||||||
| 2332 | for (const Instruction &Inst : *BB) { | ||||||||
| 2333 | // If we translated a tail call in the last step, then we know | ||||||||
| 2334 | // everything after the call is either a return, or something that is | ||||||||
| 2335 | // handled by the call itself. (E.g. a lifetime marker or assume | ||||||||
| 2336 | // intrinsic.) In this case, we should stop translating the block and | ||||||||
| 2337 | // move on. | ||||||||
| 2338 | if (HasTailCall
| ||||||||
| 2339 | break; | ||||||||
| 2340 | #ifndef NDEBUG | ||||||||
| 2341 | Verifier.setCurrentInst(&Inst); | ||||||||
| 2342 | #endif // ifndef NDEBUG | ||||||||
| 2343 | if (translate(Inst)) | ||||||||
| 2344 | continue; | ||||||||
| 2345 | |||||||||
| 2346 | OptimizationRemarkMissed R("gisel-irtranslator", "GISelFailure", | ||||||||
| 2347 | Inst.getDebugLoc(), BB); | ||||||||
| 2348 | R << "unable to translate instruction: " << ore::NV("Opcode", &Inst); | ||||||||
| 2349 | |||||||||
| 2350 | if (ORE->allowExtraAnalysis("gisel-irtranslator")) { | ||||||||
| 2351 | std::string InstStrStorage; | ||||||||
| 2352 | raw_string_ostream InstStr(InstStrStorage); | ||||||||
| 2353 | InstStr << Inst; | ||||||||
| 2354 | |||||||||
| 2355 | R << ": '" << InstStr.str() << "'"; | ||||||||
| 2356 | } | ||||||||
| 2357 | |||||||||
| 2358 | reportTranslationError(*MF, *TPC, *ORE, R); | ||||||||
| 2359 | return false; | ||||||||
| 2360 | } | ||||||||
| 2361 | |||||||||
| 2362 | finalizeBasicBlock(); | ||||||||
| 2363 | } | ||||||||
| 2364 | #ifndef NDEBUG | ||||||||
| 2365 | WrapperObserver.removeObserver(&Verifier); | ||||||||
| 2366 | #endif | ||||||||
| 2367 | } | ||||||||
| 2368 | |||||||||
| 2369 | finishPendingPhis(); | ||||||||
| 2370 | |||||||||
| 2371 | SwiftError.propagateVRegs(); | ||||||||
| 2372 | |||||||||
| 2373 | // Merge the argument lowering and constants block with its single | ||||||||
| 2374 | // successor, the LLVM-IR entry block. We want the basic block to | ||||||||
| 2375 | // be maximal. | ||||||||
| 2376 | assert(EntryBB->succ_size() == 1 &&((EntryBB->succ_size() == 1 && "Custom BB used for lowering should have only one successor" ) ? static_cast<void> (0) : __assert_fail ("EntryBB->succ_size() == 1 && \"Custom BB used for lowering should have only one successor\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 2377, __PRETTY_FUNCTION__)) | ||||||||
| 2377 | "Custom BB used for lowering should have only one successor")((EntryBB->succ_size() == 1 && "Custom BB used for lowering should have only one successor" ) ? static_cast<void> (0) : __assert_fail ("EntryBB->succ_size() == 1 && \"Custom BB used for lowering should have only one successor\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 2377, __PRETTY_FUNCTION__)); | ||||||||
| 2378 | // Get the successor of the current entry block. | ||||||||
| 2379 | MachineBasicBlock &NewEntryBB = **EntryBB->succ_begin(); | ||||||||
| 2380 | assert(NewEntryBB.pred_size() == 1 &&((NewEntryBB.pred_size() == 1 && "LLVM-IR entry block has a predecessor!?" ) ? static_cast<void> (0) : __assert_fail ("NewEntryBB.pred_size() == 1 && \"LLVM-IR entry block has a predecessor!?\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 2381, __PRETTY_FUNCTION__)) | ||||||||
| 2381 | "LLVM-IR entry block has a predecessor!?")((NewEntryBB.pred_size() == 1 && "LLVM-IR entry block has a predecessor!?" ) ? static_cast<void> (0) : __assert_fail ("NewEntryBB.pred_size() == 1 && \"LLVM-IR entry block has a predecessor!?\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 2381, __PRETTY_FUNCTION__)); | ||||||||
| 2382 | // Move all the instruction from the current entry block to the | ||||||||
| 2383 | // new entry block. | ||||||||
| 2384 | NewEntryBB.splice(NewEntryBB.begin(), EntryBB, EntryBB->begin(), | ||||||||
| 2385 | EntryBB->end()); | ||||||||
| 2386 | |||||||||
| 2387 | // Update the live-in information for the new entry block. | ||||||||
| 2388 | for (const MachineBasicBlock::RegisterMaskPair &LiveIn : EntryBB->liveins()) | ||||||||
| 2389 | NewEntryBB.addLiveIn(LiveIn); | ||||||||
| 2390 | NewEntryBB.sortUniqueLiveIns(); | ||||||||
| 2391 | |||||||||
| 2392 | // Get rid of the now empty basic block. | ||||||||
| 2393 | EntryBB->removeSuccessor(&NewEntryBB); | ||||||||
| 2394 | MF->remove(EntryBB); | ||||||||
| 2395 | MF->DeleteMachineBasicBlock(EntryBB); | ||||||||
| 2396 | |||||||||
| 2397 | assert(&MF->front() == &NewEntryBB &&((&MF->front() == &NewEntryBB && "New entry wasn't next in the list of basic block!" ) ? static_cast<void> (0) : __assert_fail ("&MF->front() == &NewEntryBB && \"New entry wasn't next in the list of basic block!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 2398, __PRETTY_FUNCTION__)) | ||||||||
| 2398 | "New entry wasn't next in the list of basic block!")((&MF->front() == &NewEntryBB && "New entry wasn't next in the list of basic block!" ) ? static_cast<void> (0) : __assert_fail ("&MF->front() == &NewEntryBB && \"New entry wasn't next in the list of basic block!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/lib/CodeGen/GlobalISel/IRTranslator.cpp" , 2398, __PRETTY_FUNCTION__)); | ||||||||
| 2399 | |||||||||
| 2400 | // Initialize stack protector information. | ||||||||
| 2401 | StackProtector &SP = getAnalysis<StackProtector>(); | ||||||||
| 2402 | SP.copyToMachineFrameInfo(MF->getFrameInfo()); | ||||||||
| 2403 | |||||||||
| 2404 | return false; | ||||||||
| 2405 | } |
| 1 | //===-- llvm/Instruction.def - File that describes Instructions -*- C++ -*-===// |
| 2 | // |
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | // |
| 9 | // This file contains descriptions of the various LLVM instructions. This is |
| 10 | // used as a central place for enumerating the different instructions and |
| 11 | // should eventually be the place to put comments about the instructions. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | // NOTE: NO INCLUDE GUARD DESIRED! |
| 16 | |
| 17 | // Provide definitions of macros so that users of this file do not have to |
| 18 | // define everything to use it... |
| 19 | // |
| 20 | #ifndef FIRST_TERM_INST |
| 21 | #define FIRST_TERM_INST(num) |
| 22 | #endif |
| 23 | #ifndef HANDLE_TERM_INST |
| 24 | #ifndef HANDLE_INST |
| 25 | #define HANDLE_TERM_INST(num, opcode, Class) |
| 26 | #else |
| 27 | #define HANDLE_TERM_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class) |
| 28 | #endif |
| 29 | #endif |
| 30 | #ifndef LAST_TERM_INST |
| 31 | #define LAST_TERM_INST(num) |
| 32 | #endif |
| 33 | |
| 34 | #ifndef FIRST_UNARY_INST |
| 35 | #define FIRST_UNARY_INST(num) |
| 36 | #endif |
| 37 | #ifndef HANDLE_UNARY_INST |
| 38 | #ifndef HANDLE_INST |
| 39 | #define HANDLE_UNARY_INST(num, opcode, instclass) |
| 40 | #else |
| 41 | #define HANDLE_UNARY_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class) |
| 42 | #endif |
| 43 | #endif |
| 44 | #ifndef LAST_UNARY_INST |
| 45 | #define LAST_UNARY_INST(num) |
| 46 | #endif |
| 47 | |
| 48 | #ifndef FIRST_BINARY_INST |
| 49 | #define FIRST_BINARY_INST(num) |
| 50 | #endif |
| 51 | #ifndef HANDLE_BINARY_INST |
| 52 | #ifndef HANDLE_INST |
| 53 | #define HANDLE_BINARY_INST(num, opcode, instclass) |
| 54 | #else |
| 55 | #define HANDLE_BINARY_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class) |
| 56 | #endif |
| 57 | #endif |
| 58 | #ifndef LAST_BINARY_INST |
| 59 | #define LAST_BINARY_INST(num) |
| 60 | #endif |
| 61 | |
| 62 | #ifndef FIRST_MEMORY_INST |
| 63 | #define FIRST_MEMORY_INST(num) |
| 64 | #endif |
| 65 | #ifndef HANDLE_MEMORY_INST |
| 66 | #ifndef HANDLE_INST |
| 67 | #define HANDLE_MEMORY_INST(num, opcode, Class) |
| 68 | #else |
| 69 | #define HANDLE_MEMORY_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class) |
| 70 | #endif |
| 71 | #endif |
| 72 | #ifndef LAST_MEMORY_INST |
| 73 | #define LAST_MEMORY_INST(num) |
| 74 | #endif |
| 75 | |
| 76 | #ifndef FIRST_CAST_INST |
| 77 | #define FIRST_CAST_INST(num) |
| 78 | #endif |
| 79 | #ifndef HANDLE_CAST_INST |
| 80 | #ifndef HANDLE_INST |
| 81 | #define HANDLE_CAST_INST(num, opcode, Class) |
| 82 | #else |
| 83 | #define HANDLE_CAST_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class) |
| 84 | #endif |
| 85 | #endif |
| 86 | #ifndef LAST_CAST_INST |
| 87 | #define LAST_CAST_INST(num) |
| 88 | #endif |
| 89 | |
| 90 | #ifndef FIRST_FUNCLETPAD_INST |
| 91 | #define FIRST_FUNCLETPAD_INST(num) |
| 92 | #endif |
| 93 | #ifndef HANDLE_FUNCLETPAD_INST |
| 94 | #ifndef HANDLE_INST |
| 95 | #define HANDLE_FUNCLETPAD_INST(num, opcode, Class) |
| 96 | #else |
| 97 | #define HANDLE_FUNCLETPAD_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class) |
| 98 | #endif |
| 99 | #endif |
| 100 | #ifndef LAST_FUNCLETPAD_INST |
| 101 | #define LAST_FUNCLETPAD_INST(num) |
| 102 | #endif |
| 103 | |
| 104 | #ifndef FIRST_OTHER_INST |
| 105 | #define FIRST_OTHER_INST(num) |
| 106 | #endif |
| 107 | #ifndef HANDLE_OTHER_INST |
| 108 | #ifndef HANDLE_INST |
| 109 | #define HANDLE_OTHER_INST(num, opcode, Class) |
| 110 | #else |
| 111 | #define HANDLE_OTHER_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class) |
| 112 | #endif |
| 113 | #endif |
| 114 | #ifndef LAST_OTHER_INST |
| 115 | #define LAST_OTHER_INST(num) |
| 116 | #endif |
| 117 | |
| 118 | #ifndef HANDLE_USER_INST |
| 119 | #define HANDLE_USER_INST(num, opc, Class) HANDLE_OTHER_INST(num, opc, Class) |
| 120 | #endif |
| 121 | |
| 122 | // Terminator Instructions - These instructions are used to terminate a basic |
| 123 | // block of the program. Every basic block must end with one of these |
| 124 | // instructions for it to be a well formed basic block. |
| 125 | // |
| 126 | FIRST_TERM_INST ( 1) |
| 127 | HANDLE_TERM_INST ( 1, Ret , ReturnInst) |
| 128 | HANDLE_TERM_INST ( 2, Br , BranchInst) |
| 129 | HANDLE_TERM_INST ( 3, Switch , SwitchInst) |
| 130 | HANDLE_TERM_INST ( 4, IndirectBr , IndirectBrInst) |
| 131 | HANDLE_TERM_INST ( 5, Invoke , InvokeInst) |
| 132 | HANDLE_TERM_INST ( 6, Resume , ResumeInst) |
| 133 | HANDLE_TERM_INST ( 7, Unreachable , UnreachableInst) |
| 134 | HANDLE_TERM_INST ( 8, CleanupRet , CleanupReturnInst) |
| 135 | HANDLE_TERM_INST ( 9, CatchRet , CatchReturnInst) |
| 136 | HANDLE_TERM_INST (10, CatchSwitch , CatchSwitchInst) |
| 137 | HANDLE_TERM_INST (11, CallBr , CallBrInst) // A call-site terminator |
| 138 | LAST_TERM_INST (11) |
| 139 | |
| 140 | // Standard unary operators... |
| 141 | FIRST_UNARY_INST(12) |
| 142 | HANDLE_UNARY_INST(12, FNeg , UnaryOperator) |
| 143 | LAST_UNARY_INST(12) |
| 144 | |
| 145 | // Standard binary operators... |
| 146 | FIRST_BINARY_INST(13) |
| 147 | HANDLE_BINARY_INST(13, Add , BinaryOperator) |
| 148 | HANDLE_BINARY_INST(14, FAdd , BinaryOperator) |
| 149 | HANDLE_BINARY_INST(15, Sub , BinaryOperator) |
| 150 | HANDLE_BINARY_INST(16, FSub , BinaryOperator) |
| 151 | HANDLE_BINARY_INST(17, Mul , BinaryOperator) |
| 152 | HANDLE_BINARY_INST(18, FMul , BinaryOperator) |
| 153 | HANDLE_BINARY_INST(19, UDiv , BinaryOperator) |
| 154 | HANDLE_BINARY_INST(20, SDiv , BinaryOperator) |
| 155 | HANDLE_BINARY_INST(21, FDiv , BinaryOperator) |
| 156 | HANDLE_BINARY_INST(22, URem , BinaryOperator) |
| 157 | HANDLE_BINARY_INST(23, SRem , BinaryOperator) |
| 158 | HANDLE_BINARY_INST(24, FRem , BinaryOperator) |
| 159 | |
| 160 | // Logical operators (integer operands) |
| 161 | HANDLE_BINARY_INST(25, Shl , BinaryOperator) // Shift left (logical) |
| 162 | HANDLE_BINARY_INST(26, LShr , BinaryOperator) // Shift right (logical) |
| 163 | HANDLE_BINARY_INST(27, AShr , BinaryOperator) // Shift right (arithmetic) |
| 164 | HANDLE_BINARY_INST(28, And , BinaryOperator) |
| 165 | HANDLE_BINARY_INST(29, Or , BinaryOperator) |
| 166 | HANDLE_BINARY_INST(30, Xor , BinaryOperator) |
| 167 | LAST_BINARY_INST(30) |
| 168 | |
| 169 | // Memory operators... |
| 170 | FIRST_MEMORY_INST(31) |
| 171 | HANDLE_MEMORY_INST(31, Alloca, AllocaInst) // Stack management |
| 172 | HANDLE_MEMORY_INST(32, Load , LoadInst ) // Memory manipulation instrs |
| 173 | HANDLE_MEMORY_INST(33, Store , StoreInst ) |
| 174 | HANDLE_MEMORY_INST(34, GetElementPtr, GetElementPtrInst) |
| 175 | HANDLE_MEMORY_INST(35, Fence , FenceInst ) |
| 176 | HANDLE_MEMORY_INST(36, AtomicCmpXchg , AtomicCmpXchgInst ) |
| 177 | HANDLE_MEMORY_INST(37, AtomicRMW , AtomicRMWInst ) |
| 178 | LAST_MEMORY_INST(37) |
| 179 | |
| 180 | // Cast operators ... |
| 181 | // NOTE: The order matters here because CastInst::isEliminableCastPair |
| 182 | // NOTE: (see Instructions.cpp) encodes a table based on this ordering. |
| 183 | FIRST_CAST_INST(38) |
| 184 | HANDLE_CAST_INST(38, Trunc , TruncInst ) // Truncate integers |
| 185 | HANDLE_CAST_INST(39, ZExt , ZExtInst ) // Zero extend integers |
| 186 | HANDLE_CAST_INST(40, SExt , SExtInst ) // Sign extend integers |
| 187 | HANDLE_CAST_INST(41, FPToUI , FPToUIInst ) // floating point -> UInt |
| 188 | HANDLE_CAST_INST(42, FPToSI , FPToSIInst ) // floating point -> SInt |
| 189 | HANDLE_CAST_INST(43, UIToFP , UIToFPInst ) // UInt -> floating point |
| 190 | HANDLE_CAST_INST(44, SIToFP , SIToFPInst ) // SInt -> floating point |
| 191 | HANDLE_CAST_INST(45, FPTrunc , FPTruncInst ) // Truncate floating point |
| 192 | HANDLE_CAST_INST(46, FPExt , FPExtInst ) // Extend floating point |
| 193 | HANDLE_CAST_INST(47, PtrToInt, PtrToIntInst) // Pointer -> Integer |
| 194 | HANDLE_CAST_INST(48, IntToPtr, IntToPtrInst) // Integer -> Pointer |
| 195 | HANDLE_CAST_INST(49, BitCast , BitCastInst ) // Type cast |
| 196 | HANDLE_CAST_INST(50, AddrSpaceCast, AddrSpaceCastInst) // addrspace cast |
| 197 | LAST_CAST_INST(50) |
| 198 | |
| 199 | FIRST_FUNCLETPAD_INST(51) |
| 200 | HANDLE_FUNCLETPAD_INST(51, CleanupPad, CleanupPadInst) |
| 201 | HANDLE_FUNCLETPAD_INST(52, CatchPad , CatchPadInst) |
| 202 | LAST_FUNCLETPAD_INST(52) |
| 203 | |
| 204 | // Other operators... |
| 205 | FIRST_OTHER_INST(53) |
| 206 | HANDLE_OTHER_INST(53, ICmp , ICmpInst ) // Integer comparison instruction |
| 207 | HANDLE_OTHER_INST(54, FCmp , FCmpInst ) // Floating point comparison instr. |
| 208 | HANDLE_OTHER_INST(55, PHI , PHINode ) // PHI node instruction |
| 209 | HANDLE_OTHER_INST(56, Call , CallInst ) // Call a function |
| 210 | HANDLE_OTHER_INST(57, Select , SelectInst ) // select instruction |
| 211 | HANDLE_USER_INST (58, UserOp1, Instruction) // May be used internally in a pass |
| 212 | HANDLE_USER_INST (59, UserOp2, Instruction) // Internal to passes only |
| 213 | HANDLE_OTHER_INST(60, VAArg , VAArgInst ) // vaarg instruction |
| 214 | HANDLE_OTHER_INST(61, ExtractElement, ExtractElementInst)// extract from vector |
| 215 | HANDLE_OTHER_INST(62, InsertElement, InsertElementInst) // insert into vector |
| 216 | HANDLE_OTHER_INST(63, ShuffleVector, ShuffleVectorInst) // shuffle two vectors. |
| 217 | HANDLE_OTHER_INST(64, ExtractValue, ExtractValueInst)// extract from aggregate |
| 218 | HANDLE_OTHER_INST(65, InsertValue, InsertValueInst) // insert into aggregate |
| 219 | HANDLE_OTHER_INST(66, LandingPad, LandingPadInst) // Landing pad instruction. |
| 220 | LAST_OTHER_INST(66) |
| 221 | |
| 222 | #undef FIRST_TERM_INST |
| 223 | #undef HANDLE_TERM_INST |
| 224 | #undef LAST_TERM_INST |
| 225 | |
| 226 | #undef FIRST_UNARY_INST |
| 227 | #undef HANDLE_UNARY_INST |
| 228 | #undef LAST_UNARY_INST |
| 229 | |
| 230 | #undef FIRST_BINARY_INST |
| 231 | #undef HANDLE_BINARY_INST |
| 232 | #undef LAST_BINARY_INST |
| 233 | |
| 234 | #undef FIRST_MEMORY_INST |
| 235 | #undef HANDLE_MEMORY_INST |
| 236 | #undef LAST_MEMORY_INST |
| 237 | |
| 238 | #undef FIRST_CAST_INST |
| 239 | #undef HANDLE_CAST_INST |
| 240 | #undef LAST_CAST_INST |
| 241 | |
| 242 | #undef FIRST_FUNCLETPAD_INST |
| 243 | #undef HANDLE_FUNCLETPAD_INST |
| 244 | #undef LAST_FUNCLETPAD_INST |
| 245 | |
| 246 | #undef FIRST_OTHER_INST |
| 247 | #undef HANDLE_OTHER_INST |
| 248 | #undef LAST_OTHER_INST |
| 249 | |
| 250 | #undef HANDLE_USER_INST |
| 251 | |
| 252 | #ifdef HANDLE_INST |
| 253 | #undef HANDLE_INST |
| 254 | #endif |
| 1 | //===- llvm/CodeGen/GlobalISel/IRTranslator.h - IRTranslator ----*- C++ -*-===// |
| 2 | // |
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | /// \file |
| 9 | /// This file declares the IRTranslator pass. |
| 10 | /// This pass is responsible for translating LLVM IR into MachineInstr. |
| 11 | /// It uses target hooks to lower the ABI but aside from that, the pass |
| 12 | /// generated code is generic. This is the default translator used for |
| 13 | /// GlobalISel. |
| 14 | /// |
| 15 | /// \todo Replace the comments with actual doxygen comments. |
| 16 | //===----------------------------------------------------------------------===// |
| 17 | |
| 18 | #ifndef LLVM_CODEGEN_GLOBALISEL_IRTRANSLATOR_H |
| 19 | #define LLVM_CODEGEN_GLOBALISEL_IRTRANSLATOR_H |
| 20 | |
| 21 | #include "llvm/ADT/DenseMap.h" |
| 22 | #include "llvm/ADT/SmallVector.h" |
| 23 | #include "llvm/CodeGen/GlobalISel/CSEMIRBuilder.h" |
| 24 | #include "llvm/CodeGen/GlobalISel/Types.h" |
| 25 | #include "llvm/CodeGen/SwiftErrorValueTracking.h" |
| 26 | #include "llvm/CodeGen/MachineFunctionPass.h" |
| 27 | #include "llvm/CodeGen/SwitchLoweringUtils.h" |
| 28 | #include "llvm/IR/Intrinsics.h" |
| 29 | #include "llvm/Support/Allocator.h" |
| 30 | #include <memory> |
| 31 | #include <utility> |
| 32 | |
| 33 | namespace llvm { |
| 34 | |
| 35 | class AllocaInst; |
| 36 | class BasicBlock; |
| 37 | class CallInst; |
| 38 | class CallLowering; |
| 39 | class Constant; |
| 40 | class DataLayout; |
| 41 | class FunctionLoweringInfo; |
| 42 | class Instruction; |
| 43 | class MachineBasicBlock; |
| 44 | class MachineFunction; |
| 45 | class MachineInstr; |
| 46 | class MachineRegisterInfo; |
| 47 | class OptimizationRemarkEmitter; |
| 48 | class PHINode; |
| 49 | class TargetPassConfig; |
| 50 | class User; |
| 51 | class Value; |
| 52 | |
| 53 | // Technically the pass should run on an hypothetical MachineModule, |
| 54 | // since it should translate Global into some sort of MachineGlobal. |
| 55 | // The MachineGlobal should ultimately just be a transfer of ownership of |
| 56 | // the interesting bits that are relevant to represent a global value. |
| 57 | // That being said, we could investigate what would it cost to just duplicate |
| 58 | // the information from the LLVM IR. |
| 59 | // The idea is that ultimately we would be able to free up the memory used |
| 60 | // by the LLVM IR as soon as the translation is over. |
| 61 | class IRTranslator : public MachineFunctionPass { |
| 62 | public: |
| 63 | static char ID; |
| 64 | |
| 65 | private: |
| 66 | /// Interface used to lower the everything related to calls. |
| 67 | const CallLowering *CLI; |
| 68 | |
| 69 | /// This class contains the mapping between the Values to vreg related data. |
| 70 | class ValueToVRegInfo { |
| 71 | public: |
| 72 | ValueToVRegInfo() = default; |
| 73 | |
| 74 | using VRegListT = SmallVector<Register, 1>; |
| 75 | using OffsetListT = SmallVector<uint64_t, 1>; |
| 76 | |
| 77 | using const_vreg_iterator = |
| 78 | DenseMap<const Value *, VRegListT *>::const_iterator; |
| 79 | using const_offset_iterator = |
| 80 | DenseMap<const Value *, OffsetListT *>::const_iterator; |
| 81 | |
| 82 | inline const_vreg_iterator vregs_end() const { return ValToVRegs.end(); } |
| 83 | |
| 84 | VRegListT *getVRegs(const Value &V) { |
| 85 | auto It = ValToVRegs.find(&V); |
| 86 | if (It != ValToVRegs.end()) |
| 87 | return It->second; |
| 88 | |
| 89 | return insertVRegs(V); |
| 90 | } |
| 91 | |
| 92 | OffsetListT *getOffsets(const Value &V) { |
| 93 | auto It = TypeToOffsets.find(V.getType()); |
| 94 | if (It != TypeToOffsets.end()) |
| 95 | return It->second; |
| 96 | |
| 97 | return insertOffsets(V); |
| 98 | } |
| 99 | |
| 100 | const_vreg_iterator findVRegs(const Value &V) const { |
| 101 | return ValToVRegs.find(&V); |
| 102 | } |
| 103 | |
| 104 | bool contains(const Value &V) const { |
| 105 | return ValToVRegs.find(&V) != ValToVRegs.end(); |
| 106 | } |
| 107 | |
| 108 | void reset() { |
| 109 | ValToVRegs.clear(); |
| 110 | TypeToOffsets.clear(); |
| 111 | VRegAlloc.DestroyAll(); |
| 112 | OffsetAlloc.DestroyAll(); |
| 113 | } |
| 114 | |
| 115 | private: |
| 116 | VRegListT *insertVRegs(const Value &V) { |
| 117 | assert(ValToVRegs.find(&V) == ValToVRegs.end() && "Value already exists")((ValToVRegs.find(&V) == ValToVRegs.end() && "Value already exists" ) ? static_cast<void> (0) : __assert_fail ("ValToVRegs.find(&V) == ValToVRegs.end() && \"Value already exists\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/CodeGen/GlobalISel/IRTranslator.h" , 117, __PRETTY_FUNCTION__)); |
| 118 | |
| 119 | // We placement new using our fast allocator since we never try to free |
| 120 | // the vectors until translation is finished. |
| 121 | auto *VRegList = new (VRegAlloc.Allocate()) VRegListT(); |
| 122 | ValToVRegs[&V] = VRegList; |
| 123 | return VRegList; |
| 124 | } |
| 125 | |
| 126 | OffsetListT *insertOffsets(const Value &V) { |
| 127 | assert(TypeToOffsets.find(V.getType()) == TypeToOffsets.end() &&((TypeToOffsets.find(V.getType()) == TypeToOffsets.end() && "Type already exists") ? static_cast<void> (0) : __assert_fail ("TypeToOffsets.find(V.getType()) == TypeToOffsets.end() && \"Type already exists\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/CodeGen/GlobalISel/IRTranslator.h" , 128, __PRETTY_FUNCTION__)) |
| 128 | "Type already exists")((TypeToOffsets.find(V.getType()) == TypeToOffsets.end() && "Type already exists") ? static_cast<void> (0) : __assert_fail ("TypeToOffsets.find(V.getType()) == TypeToOffsets.end() && \"Type already exists\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/CodeGen/GlobalISel/IRTranslator.h" , 128, __PRETTY_FUNCTION__)); |
| 129 | |
| 130 | auto *OffsetList = new (OffsetAlloc.Allocate()) OffsetListT(); |
| 131 | TypeToOffsets[V.getType()] = OffsetList; |
| 132 | return OffsetList; |
| 133 | } |
| 134 | SpecificBumpPtrAllocator<VRegListT> VRegAlloc; |
| 135 | SpecificBumpPtrAllocator<OffsetListT> OffsetAlloc; |
| 136 | |
| 137 | // We store pointers to vectors here since references may be invalidated |
| 138 | // while we hold them if we stored the vectors directly. |
| 139 | DenseMap<const Value *, VRegListT*> ValToVRegs; |
| 140 | DenseMap<const Type *, OffsetListT*> TypeToOffsets; |
| 141 | }; |
| 142 | |
| 143 | /// Mapping of the values of the current LLVM IR function to the related |
| 144 | /// virtual registers and offsets. |
| 145 | ValueToVRegInfo VMap; |
| 146 | |
| 147 | // N.b. it's not completely obvious that this will be sufficient for every |
| 148 | // LLVM IR construct (with "invoke" being the obvious candidate to mess up our |
| 149 | // lives. |
| 150 | DenseMap<const BasicBlock *, MachineBasicBlock *> BBToMBB; |
| 151 | |
| 152 | // One BasicBlock can be translated to multiple MachineBasicBlocks. For such |
| 153 | // BasicBlocks translated to multiple MachineBasicBlocks, MachinePreds retains |
| 154 | // a mapping between the edges arriving at the BasicBlock to the corresponding |
| 155 | // created MachineBasicBlocks. Some BasicBlocks that get translated to a |
| 156 | // single MachineBasicBlock may also end up in this Map. |
| 157 | using CFGEdge = std::pair<const BasicBlock *, const BasicBlock *>; |
| 158 | DenseMap<CFGEdge, SmallVector<MachineBasicBlock *, 1>> MachinePreds; |
| 159 | |
| 160 | // List of stubbed PHI instructions, for values and basic blocks to be filled |
| 161 | // in once all MachineBasicBlocks have been created. |
| 162 | SmallVector<std::pair<const PHINode *, SmallVector<MachineInstr *, 1>>, 4> |
| 163 | PendingPHIs; |
| 164 | |
| 165 | /// Record of what frame index has been allocated to specified allocas for |
| 166 | /// this function. |
| 167 | DenseMap<const AllocaInst *, int> FrameIndices; |
| 168 | |
| 169 | SwiftErrorValueTracking SwiftError; |
| 170 | |
| 171 | /// \name Methods for translating form LLVM IR to MachineInstr. |
| 172 | /// \see ::translate for general information on the translate methods. |
| 173 | /// @{ |
| 174 | |
| 175 | /// Translate \p Inst into its corresponding MachineInstr instruction(s). |
| 176 | /// Insert the newly translated instruction(s) right where the CurBuilder |
| 177 | /// is set. |
| 178 | /// |
| 179 | /// The general algorithm is: |
| 180 | /// 1. Look for a virtual register for each operand or |
| 181 | /// create one. |
| 182 | /// 2 Update the VMap accordingly. |
| 183 | /// 2.alt. For constant arguments, if they are compile time constants, |
| 184 | /// produce an immediate in the right operand and do not touch |
| 185 | /// ValToReg. Actually we will go with a virtual register for each |
| 186 | /// constants because it may be expensive to actually materialize the |
| 187 | /// constant. Moreover, if the constant spans on several instructions, |
| 188 | /// CSE may not catch them. |
| 189 | /// => Update ValToVReg and remember that we saw a constant in Constants. |
| 190 | /// We will materialize all the constants in finalize. |
| 191 | /// Note: we would need to do something so that we can recognize such operand |
| 192 | /// as constants. |
| 193 | /// 3. Create the generic instruction. |
| 194 | /// |
| 195 | /// \return true if the translation succeeded. |
| 196 | bool translate(const Instruction &Inst); |
| 197 | |
| 198 | /// Materialize \p C into virtual-register \p Reg. The generic instructions |
| 199 | /// performing this materialization will be inserted into the entry block of |
| 200 | /// the function. |
| 201 | /// |
| 202 | /// \return true if the materialization succeeded. |
| 203 | bool translate(const Constant &C, Register Reg); |
| 204 | |
| 205 | /// Translate an LLVM bitcast into generic IR. Either a COPY or a G_BITCAST is |
| 206 | /// emitted. |
| 207 | bool translateBitCast(const User &U, MachineIRBuilder &MIRBuilder); |
| 208 | |
| 209 | /// Translate an LLVM load instruction into generic IR. |
| 210 | bool translateLoad(const User &U, MachineIRBuilder &MIRBuilder); |
| 211 | |
| 212 | /// Translate an LLVM store instruction into generic IR. |
| 213 | bool translateStore(const User &U, MachineIRBuilder &MIRBuilder); |
| 214 | |
| 215 | /// Translate an LLVM string intrinsic (memcpy, memset, ...). |
| 216 | bool translateMemFunc(const CallInst &CI, MachineIRBuilder &MIRBuilder, |
| 217 | Intrinsic::ID ID); |
| 218 | |
| 219 | void getStackGuard(Register DstReg, MachineIRBuilder &MIRBuilder); |
| 220 | |
| 221 | bool translateOverflowIntrinsic(const CallInst &CI, unsigned Op, |
| 222 | MachineIRBuilder &MIRBuilder); |
| 223 | |
| 224 | /// Helper function for translateSimpleIntrinsic. |
| 225 | /// \return The generic opcode for \p IntrinsicID if \p IntrinsicID is a |
| 226 | /// simple intrinsic (ceil, fabs, etc.). Otherwise, returns |
| 227 | /// Intrinsic::not_intrinsic. |
| 228 | unsigned getSimpleIntrinsicOpcode(Intrinsic::ID ID); |
| 229 | |
| 230 | /// Translates the intrinsics defined in getSimpleIntrinsicOpcode. |
| 231 | /// \return true if the translation succeeded. |
| 232 | bool translateSimpleIntrinsic(const CallInst &CI, Intrinsic::ID ID, |
| 233 | MachineIRBuilder &MIRBuilder); |
| 234 | |
| 235 | bool translateKnownIntrinsic(const CallInst &CI, Intrinsic::ID ID, |
| 236 | MachineIRBuilder &MIRBuilder); |
| 237 | |
| 238 | bool translateInlineAsm(const CallInst &CI, MachineIRBuilder &MIRBuilder); |
| 239 | |
| 240 | /// Returns true if the value should be split into multiple LLTs. |
| 241 | /// If \p Offsets is given then the split type's offsets will be stored in it. |
| 242 | /// If \p Offsets is not empty it will be cleared first. |
| 243 | bool valueIsSplit(const Value &V, |
| 244 | SmallVectorImpl<uint64_t> *Offsets = nullptr); |
| 245 | |
| 246 | /// Common code for translating normal calls or invokes. |
| 247 | bool translateCallSite(const ImmutableCallSite &CS, |
| 248 | MachineIRBuilder &MIRBuilder); |
| 249 | |
| 250 | /// Translate call instruction. |
| 251 | /// \pre \p U is a call instruction. |
| 252 | bool translateCall(const User &U, MachineIRBuilder &MIRBuilder); |
| 253 | |
| 254 | bool translateInvoke(const User &U, MachineIRBuilder &MIRBuilder); |
| 255 | |
| 256 | bool translateCallBr(const User &U, MachineIRBuilder &MIRBuilder); |
| 257 | |
| 258 | bool translateLandingPad(const User &U, MachineIRBuilder &MIRBuilder); |
| 259 | |
| 260 | /// Translate one of LLVM's cast instructions into MachineInstrs, with the |
| 261 | /// given generic Opcode. |
| 262 | bool translateCast(unsigned Opcode, const User &U, |
| 263 | MachineIRBuilder &MIRBuilder); |
| 264 | |
| 265 | /// Translate a phi instruction. |
| 266 | bool translatePHI(const User &U, MachineIRBuilder &MIRBuilder); |
| 267 | |
| 268 | /// Translate a comparison (icmp or fcmp) instruction or constant. |
| 269 | bool translateCompare(const User &U, MachineIRBuilder &MIRBuilder); |
| 270 | |
| 271 | /// Translate an integer compare instruction (or constant). |
| 272 | bool translateICmp(const User &U, MachineIRBuilder &MIRBuilder) { |
| 273 | return translateCompare(U, MIRBuilder); |
| 274 | } |
| 275 | |
| 276 | /// Translate a floating-point compare instruction (or constant). |
| 277 | bool translateFCmp(const User &U, MachineIRBuilder &MIRBuilder) { |
| 278 | return translateCompare(U, MIRBuilder); |
| 279 | } |
| 280 | |
| 281 | /// Add remaining operands onto phis we've translated. Executed after all |
| 282 | /// MachineBasicBlocks for the function have been created. |
| 283 | void finishPendingPhis(); |
| 284 | |
| 285 | /// Translate \p Inst into a binary operation \p Opcode. |
| 286 | /// \pre \p U is a binary operation. |
| 287 | bool translateBinaryOp(unsigned Opcode, const User &U, |
| 288 | MachineIRBuilder &MIRBuilder); |
| 289 | |
| 290 | /// Translate branch (br) instruction. |
| 291 | /// \pre \p U is a branch instruction. |
| 292 | bool translateBr(const User &U, MachineIRBuilder &MIRBuilder); |
| 293 | |
| 294 | // Begin switch lowering functions. |
| 295 | bool emitJumpTableHeader(SwitchCG::JumpTable &JT, |
| 296 | SwitchCG::JumpTableHeader &JTH, |
| 297 | MachineBasicBlock *HeaderBB); |
| 298 | void emitJumpTable(SwitchCG::JumpTable &JT, MachineBasicBlock *MBB); |
| 299 | |
| 300 | void emitSwitchCase(SwitchCG::CaseBlock &CB, MachineBasicBlock *SwitchBB, |
| 301 | MachineIRBuilder &MIB); |
| 302 | |
| 303 | bool lowerJumpTableWorkItem(SwitchCG::SwitchWorkListItem W, |
| 304 | MachineBasicBlock *SwitchMBB, |
| 305 | MachineBasicBlock *CurMBB, |
| 306 | MachineBasicBlock *DefaultMBB, |
| 307 | MachineIRBuilder &MIB, |
| 308 | MachineFunction::iterator BBI, |
| 309 | BranchProbability UnhandledProbs, |
| 310 | SwitchCG::CaseClusterIt I, |
| 311 | MachineBasicBlock *Fallthrough, |
| 312 | bool FallthroughUnreachable); |
| 313 | |
| 314 | bool lowerSwitchRangeWorkItem(SwitchCG::CaseClusterIt I, |
| 315 | Value *Cond, |
| 316 | MachineBasicBlock *Fallthrough, |
| 317 | bool FallthroughUnreachable, |
| 318 | BranchProbability UnhandledProbs, |
| 319 | MachineBasicBlock *CurMBB, |
| 320 | MachineIRBuilder &MIB, |
| 321 | MachineBasicBlock *SwitchMBB); |
| 322 | |
| 323 | bool lowerSwitchWorkItem(SwitchCG::SwitchWorkListItem W, Value *Cond, |
| 324 | MachineBasicBlock *SwitchMBB, |
| 325 | MachineBasicBlock *DefaultMBB, |
| 326 | MachineIRBuilder &MIB); |
| 327 | |
| 328 | bool translateSwitch(const User &U, MachineIRBuilder &MIRBuilder); |
| 329 | // End switch lowering section. |
| 330 | |
| 331 | bool translateIndirectBr(const User &U, MachineIRBuilder &MIRBuilder); |
| 332 | |
| 333 | bool translateExtractValue(const User &U, MachineIRBuilder &MIRBuilder); |
| 334 | |
| 335 | bool translateInsertValue(const User &U, MachineIRBuilder &MIRBuilder); |
| 336 | |
| 337 | bool translateSelect(const User &U, MachineIRBuilder &MIRBuilder); |
| 338 | |
| 339 | bool translateGetElementPtr(const User &U, MachineIRBuilder &MIRBuilder); |
| 340 | |
| 341 | bool translateAlloca(const User &U, MachineIRBuilder &MIRBuilder); |
| 342 | |
| 343 | /// Translate return (ret) instruction. |
| 344 | /// The target needs to implement CallLowering::lowerReturn for |
| 345 | /// this to succeed. |
| 346 | /// \pre \p U is a return instruction. |
| 347 | bool translateRet(const User &U, MachineIRBuilder &MIRBuilder); |
| 348 | |
| 349 | bool translateFSub(const User &U, MachineIRBuilder &MIRBuilder); |
| 350 | |
| 351 | bool translateFNeg(const User &U, MachineIRBuilder &MIRBuilder); |
| 352 | |
| 353 | bool translateAdd(const User &U, MachineIRBuilder &MIRBuilder) { |
| 354 | return translateBinaryOp(TargetOpcode::G_ADD, U, MIRBuilder); |
| 355 | } |
| 356 | bool translateSub(const User &U, MachineIRBuilder &MIRBuilder) { |
| 357 | return translateBinaryOp(TargetOpcode::G_SUB, U, MIRBuilder); |
| 358 | } |
| 359 | bool translateAnd(const User &U, MachineIRBuilder &MIRBuilder) { |
| 360 | return translateBinaryOp(TargetOpcode::G_AND, U, MIRBuilder); |
| 361 | } |
| 362 | bool translateMul(const User &U, MachineIRBuilder &MIRBuilder) { |
| 363 | return translateBinaryOp(TargetOpcode::G_MUL, U, MIRBuilder); |
| 364 | } |
| 365 | bool translateOr(const User &U, MachineIRBuilder &MIRBuilder) { |
| 366 | return translateBinaryOp(TargetOpcode::G_OR, U, MIRBuilder); |
| 367 | } |
| 368 | bool translateXor(const User &U, MachineIRBuilder &MIRBuilder) { |
| 369 | return translateBinaryOp(TargetOpcode::G_XOR, U, MIRBuilder); |
| 370 | } |
| 371 | |
| 372 | bool translateUDiv(const User &U, MachineIRBuilder &MIRBuilder) { |
| 373 | return translateBinaryOp(TargetOpcode::G_UDIV, U, MIRBuilder); |
| 374 | } |
| 375 | bool translateSDiv(const User &U, MachineIRBuilder &MIRBuilder) { |
| 376 | return translateBinaryOp(TargetOpcode::G_SDIV, U, MIRBuilder); |
| 377 | } |
| 378 | bool translateURem(const User &U, MachineIRBuilder &MIRBuilder) { |
| 379 | return translateBinaryOp(TargetOpcode::G_UREM, U, MIRBuilder); |
| 380 | } |
| 381 | bool translateSRem(const User &U, MachineIRBuilder &MIRBuilder) { |
| 382 | return translateBinaryOp(TargetOpcode::G_SREM, U, MIRBuilder); |
| 383 | } |
| 384 | bool translateIntToPtr(const User &U, MachineIRBuilder &MIRBuilder) { |
| 385 | return translateCast(TargetOpcode::G_INTTOPTR, U, MIRBuilder); |
| 386 | } |
| 387 | bool translatePtrToInt(const User &U, MachineIRBuilder &MIRBuilder) { |
| 388 | return translateCast(TargetOpcode::G_PTRTOINT, U, MIRBuilder); |
| 389 | } |
| 390 | bool translateTrunc(const User &U, MachineIRBuilder &MIRBuilder) { |
| 391 | return translateCast(TargetOpcode::G_TRUNC, U, MIRBuilder); |
| 392 | } |
| 393 | bool translateFPTrunc(const User &U, MachineIRBuilder &MIRBuilder) { |
| 394 | return translateCast(TargetOpcode::G_FPTRUNC, U, MIRBuilder); |
| 395 | } |
| 396 | bool translateFPExt(const User &U, MachineIRBuilder &MIRBuilder) { |
| 397 | return translateCast(TargetOpcode::G_FPEXT, U, MIRBuilder); |
| 398 | } |
| 399 | bool translateFPToUI(const User &U, MachineIRBuilder &MIRBuilder) { |
| 400 | return translateCast(TargetOpcode::G_FPTOUI, U, MIRBuilder); |
| 401 | } |
| 402 | bool translateFPToSI(const User &U, MachineIRBuilder &MIRBuilder) { |
| 403 | return translateCast(TargetOpcode::G_FPTOSI, U, MIRBuilder); |
| 404 | } |
| 405 | bool translateUIToFP(const User &U, MachineIRBuilder &MIRBuilder) { |
| 406 | return translateCast(TargetOpcode::G_UITOFP, U, MIRBuilder); |
| 407 | } |
| 408 | bool translateSIToFP(const User &U, MachineIRBuilder &MIRBuilder) { |
| 409 | return translateCast(TargetOpcode::G_SITOFP, U, MIRBuilder); |
| 410 | } |
| 411 | bool translateUnreachable(const User &U, MachineIRBuilder &MIRBuilder) { |
| 412 | return true; |
| 413 | } |
| 414 | bool translateSExt(const User &U, MachineIRBuilder &MIRBuilder) { |
| 415 | return translateCast(TargetOpcode::G_SEXT, U, MIRBuilder); |
| 416 | } |
| 417 | |
| 418 | bool translateZExt(const User &U, MachineIRBuilder &MIRBuilder) { |
| 419 | return translateCast(TargetOpcode::G_ZEXT, U, MIRBuilder); |
| 420 | } |
| 421 | |
| 422 | bool translateShl(const User &U, MachineIRBuilder &MIRBuilder) { |
| 423 | return translateBinaryOp(TargetOpcode::G_SHL, U, MIRBuilder); |
| 424 | } |
| 425 | bool translateLShr(const User &U, MachineIRBuilder &MIRBuilder) { |
| 426 | return translateBinaryOp(TargetOpcode::G_LSHR, U, MIRBuilder); |
| 427 | } |
| 428 | bool translateAShr(const User &U, MachineIRBuilder &MIRBuilder) { |
| 429 | return translateBinaryOp(TargetOpcode::G_ASHR, U, MIRBuilder); |
| 430 | } |
| 431 | |
| 432 | bool translateFAdd(const User &U, MachineIRBuilder &MIRBuilder) { |
| 433 | return translateBinaryOp(TargetOpcode::G_FADD, U, MIRBuilder); |
| 434 | } |
| 435 | bool translateFMul(const User &U, MachineIRBuilder &MIRBuilder) { |
| 436 | return translateBinaryOp(TargetOpcode::G_FMUL, U, MIRBuilder); |
| 437 | } |
| 438 | bool translateFDiv(const User &U, MachineIRBuilder &MIRBuilder) { |
| 439 | return translateBinaryOp(TargetOpcode::G_FDIV, U, MIRBuilder); |
| 440 | } |
| 441 | bool translateFRem(const User &U, MachineIRBuilder &MIRBuilder) { |
| 442 | return translateBinaryOp(TargetOpcode::G_FREM, U, MIRBuilder); |
| 443 | } |
| 444 | |
| 445 | bool translateVAArg(const User &U, MachineIRBuilder &MIRBuilder); |
| 446 | |
| 447 | bool translateInsertElement(const User &U, MachineIRBuilder &MIRBuilder); |
| 448 | |
| 449 | bool translateExtractElement(const User &U, MachineIRBuilder &MIRBuilder); |
| 450 | |
| 451 | bool translateShuffleVector(const User &U, MachineIRBuilder &MIRBuilder); |
| 452 | |
| 453 | bool translateAtomicCmpXchg(const User &U, MachineIRBuilder &MIRBuilder); |
| 454 | bool translateAtomicRMW(const User &U, MachineIRBuilder &MIRBuilder); |
| 455 | bool translateFence(const User &U, MachineIRBuilder &MIRBuilder); |
| 456 | |
| 457 | // Stubs to keep the compiler happy while we implement the rest of the |
| 458 | // translation. |
| 459 | bool translateResume(const User &U, MachineIRBuilder &MIRBuilder) { |
| 460 | return false; |
| 461 | } |
| 462 | bool translateCleanupRet(const User &U, MachineIRBuilder &MIRBuilder) { |
| 463 | return false; |
| 464 | } |
| 465 | bool translateCatchRet(const User &U, MachineIRBuilder &MIRBuilder) { |
| 466 | return false; |
| 467 | } |
| 468 | bool translateCatchSwitch(const User &U, MachineIRBuilder &MIRBuilder) { |
| 469 | return false; |
| 470 | } |
| 471 | bool translateAddrSpaceCast(const User &U, MachineIRBuilder &MIRBuilder) { |
| 472 | return translateCast(TargetOpcode::G_ADDRSPACE_CAST, U, MIRBuilder); |
| 473 | } |
| 474 | bool translateCleanupPad(const User &U, MachineIRBuilder &MIRBuilder) { |
| 475 | return false; |
| 476 | } |
| 477 | bool translateCatchPad(const User &U, MachineIRBuilder &MIRBuilder) { |
| 478 | return false; |
| 479 | } |
| 480 | bool translateUserOp1(const User &U, MachineIRBuilder &MIRBuilder) { |
| 481 | return false; |
| 482 | } |
| 483 | bool translateUserOp2(const User &U, MachineIRBuilder &MIRBuilder) { |
| 484 | return false; |
| 485 | } |
| 486 | |
| 487 | /// @} |
| 488 | |
| 489 | // Builder for machine instruction a la IRBuilder. |
| 490 | // I.e., compared to regular MIBuilder, this one also inserts the instruction |
| 491 | // in the current block, it can creates block, etc., basically a kind of |
| 492 | // IRBuilder, but for Machine IR. |
| 493 | // CSEMIRBuilder CurBuilder; |
| 494 | std::unique_ptr<MachineIRBuilder> CurBuilder; |
| 495 | |
| 496 | // Builder set to the entry block (just after ABI lowering instructions). Used |
| 497 | // as a convenient location for Constants. |
| 498 | // CSEMIRBuilder EntryBuilder; |
| 499 | std::unique_ptr<MachineIRBuilder> EntryBuilder; |
| 500 | |
| 501 | // The MachineFunction currently being translated. |
| 502 | MachineFunction *MF; |
| 503 | |
| 504 | /// MachineRegisterInfo used to create virtual registers. |
| 505 | MachineRegisterInfo *MRI = nullptr; |
| 506 | |
| 507 | const DataLayout *DL; |
| 508 | |
| 509 | /// Current target configuration. Controls how the pass handles errors. |
| 510 | const TargetPassConfig *TPC; |
| 511 | |
| 512 | /// Current optimization remark emitter. Used to report failures. |
| 513 | std::unique_ptr<OptimizationRemarkEmitter> ORE; |
| 514 | |
| 515 | FunctionLoweringInfo FuncInfo; |
| 516 | |
| 517 | // True when either the Target Machine specifies no optimizations or the |
| 518 | // function has the optnone attribute. |
| 519 | bool EnableOpts = false; |
| 520 | |
| 521 | /// True when the block contains a tail call. This allows the IRTranslator to |
| 522 | /// stop translating such blocks early. |
| 523 | bool HasTailCall = false; |
| 524 | |
| 525 | /// Switch analysis and optimization. |
| 526 | class GISelSwitchLowering : public SwitchCG::SwitchLowering { |
| 527 | public: |
| 528 | GISelSwitchLowering(IRTranslator *irt, FunctionLoweringInfo &funcinfo) |
| 529 | : SwitchLowering(funcinfo), IRT(irt) { |
| 530 | assert(irt && "irt is null!")((irt && "irt is null!") ? static_cast<void> (0 ) : __assert_fail ("irt && \"irt is null!\"", "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/CodeGen/GlobalISel/IRTranslator.h" , 530, __PRETTY_FUNCTION__)); |
| 531 | } |
| 532 | |
| 533 | virtual void addSuccessorWithProb( |
| 534 | MachineBasicBlock *Src, MachineBasicBlock *Dst, |
| 535 | BranchProbability Prob = BranchProbability::getUnknown()) override { |
| 536 | IRT->addSuccessorWithProb(Src, Dst, Prob); |
| 537 | } |
| 538 | |
| 539 | virtual ~GISelSwitchLowering() = default; |
| 540 | |
| 541 | private: |
| 542 | IRTranslator *IRT; |
| 543 | }; |
| 544 | |
| 545 | std::unique_ptr<GISelSwitchLowering> SL; |
| 546 | |
| 547 | // * Insert all the code needed to materialize the constants |
| 548 | // at the proper place. E.g., Entry block or dominator block |
| 549 | // of each constant depending on how fancy we want to be. |
| 550 | // * Clear the different maps. |
| 551 | void finalizeFunction(); |
| 552 | |
| 553 | // Handle emitting jump tables for each basic block. |
| 554 | void finalizeBasicBlock(); |
| 555 | |
| 556 | /// Get the VRegs that represent \p Val. |
| 557 | /// Non-aggregate types have just one corresponding VReg and the list can be |
| 558 | /// used as a single "unsigned". Aggregates get flattened. If such VRegs do |
| 559 | /// not exist, they are created. |
| 560 | ArrayRef<Register> getOrCreateVRegs(const Value &Val); |
| 561 | |
| 562 | Register getOrCreateVReg(const Value &Val) { |
| 563 | auto Regs = getOrCreateVRegs(Val); |
| 564 | if (Regs.empty()) |
| 565 | return 0; |
| 566 | assert(Regs.size() == 1 &&((Regs.size() == 1 && "attempt to get single VReg for aggregate or void" ) ? static_cast<void> (0) : __assert_fail ("Regs.size() == 1 && \"attempt to get single VReg for aggregate or void\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/CodeGen/GlobalISel/IRTranslator.h" , 567, __PRETTY_FUNCTION__)) |
| 567 | "attempt to get single VReg for aggregate or void")((Regs.size() == 1 && "attempt to get single VReg for aggregate or void" ) ? static_cast<void> (0) : __assert_fail ("Regs.size() == 1 && \"attempt to get single VReg for aggregate or void\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/CodeGen/GlobalISel/IRTranslator.h" , 567, __PRETTY_FUNCTION__)); |
| 568 | return Regs[0]; |
| 569 | } |
| 570 | |
| 571 | /// Allocate some vregs and offsets in the VMap. Then populate just the |
| 572 | /// offsets while leaving the vregs empty. |
| 573 | ValueToVRegInfo::VRegListT &allocateVRegs(const Value &Val); |
| 574 | |
| 575 | /// Get the frame index that represents \p Val. |
| 576 | /// If such VReg does not exist, it is created. |
| 577 | int getOrCreateFrameIndex(const AllocaInst &AI); |
| 578 | |
| 579 | /// Get the alignment of the given memory operation instruction. This will |
| 580 | /// either be the explicitly specified value or the ABI-required alignment for |
| 581 | /// the type being accessed (according to the Module's DataLayout). |
| 582 | unsigned getMemOpAlignment(const Instruction &I); |
| 583 | |
| 584 | /// Get the MachineBasicBlock that represents \p BB. Specifically, the block |
| 585 | /// returned will be the head of the translated block (suitable for branch |
| 586 | /// destinations). |
| 587 | MachineBasicBlock &getMBB(const BasicBlock &BB); |
| 588 | |
| 589 | /// Record \p NewPred as a Machine predecessor to `Edge.second`, corresponding |
| 590 | /// to `Edge.first` at the IR level. This is used when IRTranslation creates |
| 591 | /// multiple MachineBasicBlocks for a given IR block and the CFG is no longer |
| 592 | /// represented simply by the IR-level CFG. |
| 593 | void addMachineCFGPred(CFGEdge Edge, MachineBasicBlock *NewPred); |
| 594 | |
| 595 | /// Returns the Machine IR predecessors for the given IR CFG edge. Usually |
| 596 | /// this is just the single MachineBasicBlock corresponding to the predecessor |
| 597 | /// in the IR. More complex lowering can result in multiple MachineBasicBlocks |
| 598 | /// preceding the original though (e.g. switch instructions). |
| 599 | SmallVector<MachineBasicBlock *, 1> getMachinePredBBs(CFGEdge Edge) { |
| 600 | auto RemappedEdge = MachinePreds.find(Edge); |
| 601 | if (RemappedEdge != MachinePreds.end()) |
| 602 | return RemappedEdge->second; |
| 603 | return SmallVector<MachineBasicBlock *, 4>(1, &getMBB(*Edge.first)); |
| 604 | } |
| 605 | |
| 606 | /// Return branch probability calculated by BranchProbabilityInfo for IR |
| 607 | /// blocks. |
| 608 | BranchProbability getEdgeProbability(const MachineBasicBlock *Src, |
| 609 | const MachineBasicBlock *Dst) const; |
| 610 | |
| 611 | void addSuccessorWithProb(MachineBasicBlock *Src, MachineBasicBlock *Dst, |
| 612 | BranchProbability Prob); |
| 613 | |
| 614 | public: |
| 615 | // Ctor, nothing fancy. |
| 616 | IRTranslator(); |
| 617 | |
| 618 | StringRef getPassName() const override { return "IRTranslator"; } |
| 619 | |
| 620 | void getAnalysisUsage(AnalysisUsage &AU) const override; |
| 621 | |
| 622 | // Algo: |
| 623 | // CallLowering = MF.subtarget.getCallLowering() |
| 624 | // F = MF.getParent() |
| 625 | // MIRBuilder.reset(MF) |
| 626 | // getMBB(F.getEntryBB()) |
| 627 | // CallLowering->translateArguments(MIRBuilder, F, ValToVReg) |
| 628 | // for each bb in F |
| 629 | // getMBB(bb) |
| 630 | // for each inst in bb |
| 631 | // if (!translate(MIRBuilder, inst, ValToVReg, ConstantToSequence)) |
| 632 | // report_fatal_error("Don't know how to translate input"); |
| 633 | // finalize() |
| 634 | bool runOnMachineFunction(MachineFunction &MF) override; |
| 635 | }; |
| 636 | |
| 637 | } // end namespace llvm |
| 638 | |
| 639 | #endif // LLVM_CODEGEN_GLOBALISEL_IRTRANSLATOR_H |
| 1 | //===- llvm/InstrTypes.h - Important Instruction subclasses -----*- C++ -*-===// |
| 2 | // |
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | // |
| 9 | // This file defines various meta classes of instructions that exist in the VM |
| 10 | // representation. Specific concrete subclasses of these may be found in the |
| 11 | // i*.h files... |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #ifndef LLVM_IR_INSTRTYPES_H |
| 16 | #define LLVM_IR_INSTRTYPES_H |
| 17 | |
| 18 | #include "llvm/ADT/ArrayRef.h" |
| 19 | #include "llvm/ADT/None.h" |
| 20 | #include "llvm/ADT/Optional.h" |
| 21 | #include "llvm/ADT/STLExtras.h" |
| 22 | #include "llvm/ADT/StringMap.h" |
| 23 | #include "llvm/ADT/StringRef.h" |
| 24 | #include "llvm/ADT/Twine.h" |
| 25 | #include "llvm/ADT/iterator_range.h" |
| 26 | #include "llvm/IR/Attributes.h" |
| 27 | #include "llvm/IR/CallingConv.h" |
| 28 | #include "llvm/IR/Constants.h" |
| 29 | #include "llvm/IR/DerivedTypes.h" |
| 30 | #include "llvm/IR/Function.h" |
| 31 | #include "llvm/IR/Instruction.h" |
| 32 | #include "llvm/IR/LLVMContext.h" |
| 33 | #include "llvm/IR/OperandTraits.h" |
| 34 | #include "llvm/IR/Type.h" |
| 35 | #include "llvm/IR/User.h" |
| 36 | #include "llvm/IR/Value.h" |
| 37 | #include "llvm/Support/Casting.h" |
| 38 | #include "llvm/Support/ErrorHandling.h" |
| 39 | #include <algorithm> |
| 40 | #include <cassert> |
| 41 | #include <cstddef> |
| 42 | #include <cstdint> |
| 43 | #include <iterator> |
| 44 | #include <string> |
| 45 | #include <vector> |
| 46 | |
| 47 | namespace llvm { |
| 48 | |
| 49 | namespace Intrinsic { |
| 50 | enum ID : unsigned; |
| 51 | } |
| 52 | |
| 53 | //===----------------------------------------------------------------------===// |
| 54 | // UnaryInstruction Class |
| 55 | //===----------------------------------------------------------------------===// |
| 56 | |
| 57 | class UnaryInstruction : public Instruction { |
| 58 | protected: |
| 59 | UnaryInstruction(Type *Ty, unsigned iType, Value *V, |
| 60 | Instruction *IB = nullptr) |
| 61 | : Instruction(Ty, iType, &Op<0>(), 1, IB) { |
| 62 | Op<0>() = V; |
| 63 | } |
| 64 | UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE) |
| 65 | : Instruction(Ty, iType, &Op<0>(), 1, IAE) { |
| 66 | Op<0>() = V; |
| 67 | } |
| 68 | |
| 69 | public: |
| 70 | // allocate space for exactly one operand |
| 71 | void *operator new(size_t s) { |
| 72 | return User::operator new(s, 1); |
| 73 | } |
| 74 | |
| 75 | /// Transparently provide more efficient getOperand methods. |
| 76 | DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void setOperand(unsigned, Value*); inline op_iterator op_begin(); inline const_op_iterator op_begin() const; inline op_iterator op_end(); inline const_op_iterator op_end() const; protected : template <int> inline Use &Op(); template <int > inline const Use &Op() const; public: inline unsigned getNumOperands() const; |
| 77 | |
| 78 | // Methods for support type inquiry through isa, cast, and dyn_cast: |
| 79 | static bool classof(const Instruction *I) { |
| 80 | return I->isUnaryOp() || |
| 81 | I->getOpcode() == Instruction::Alloca || |
| 82 | I->getOpcode() == Instruction::Load || |
| 83 | I->getOpcode() == Instruction::VAArg || |
| 84 | I->getOpcode() == Instruction::ExtractValue || |
| 85 | (I->getOpcode() >= CastOpsBegin && I->getOpcode() < CastOpsEnd); |
| 86 | } |
| 87 | static bool classof(const Value *V) { |
| 88 | return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| 89 | } |
| 90 | }; |
| 91 | |
| 92 | template <> |
| 93 | struct OperandTraits<UnaryInstruction> : |
| 94 | public FixedNumOperandTraits<UnaryInstruction, 1> { |
| 95 | }; |
| 96 | |
| 97 | DEFINE_TRANSPARENT_OPERAND_ACCESSORS(UnaryInstruction, Value)UnaryInstruction::op_iterator UnaryInstruction::op_begin() { return OperandTraits<UnaryInstruction>::op_begin(this); } UnaryInstruction ::const_op_iterator UnaryInstruction::op_begin() const { return OperandTraits<UnaryInstruction>::op_begin(const_cast< UnaryInstruction*>(this)); } UnaryInstruction::op_iterator UnaryInstruction::op_end() { return OperandTraits<UnaryInstruction >::op_end(this); } UnaryInstruction::const_op_iterator UnaryInstruction ::op_end() const { return OperandTraits<UnaryInstruction> ::op_end(const_cast<UnaryInstruction*>(this)); } Value * UnaryInstruction::getOperand(unsigned i_nocapture) const { (( i_nocapture < OperandTraits<UnaryInstruction>::operands (this) && "getOperand() out of range!") ? static_cast <void> (0) : __assert_fail ("i_nocapture < OperandTraits<UnaryInstruction>::operands(this) && \"getOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 97, __PRETTY_FUNCTION__)); return cast_or_null<Value> ( OperandTraits<UnaryInstruction>::op_begin(const_cast< UnaryInstruction*>(this))[i_nocapture].get()); } void UnaryInstruction ::setOperand(unsigned i_nocapture, Value *Val_nocapture) { (( i_nocapture < OperandTraits<UnaryInstruction>::operands (this) && "setOperand() out of range!") ? static_cast <void> (0) : __assert_fail ("i_nocapture < OperandTraits<UnaryInstruction>::operands(this) && \"setOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 97, __PRETTY_FUNCTION__)); OperandTraits<UnaryInstruction >::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned UnaryInstruction::getNumOperands() const { return OperandTraits <UnaryInstruction>::operands(this); } template <int Idx_nocapture > Use &UnaryInstruction::Op() { return this->OpFrom <Idx_nocapture>(this); } template <int Idx_nocapture > const Use &UnaryInstruction::Op() const { return this ->OpFrom<Idx_nocapture>(this); } |
| 98 | |
| 99 | //===----------------------------------------------------------------------===// |
| 100 | // UnaryOperator Class |
| 101 | //===----------------------------------------------------------------------===// |
| 102 | |
| 103 | class UnaryOperator : public UnaryInstruction { |
| 104 | void AssertOK(); |
| 105 | |
| 106 | protected: |
| 107 | UnaryOperator(UnaryOps iType, Value *S, Type *Ty, |
| 108 | const Twine &Name, Instruction *InsertBefore); |
| 109 | UnaryOperator(UnaryOps iType, Value *S, Type *Ty, |
| 110 | const Twine &Name, BasicBlock *InsertAtEnd); |
| 111 | |
| 112 | // Note: Instruction needs to be a friend here to call cloneImpl. |
| 113 | friend class Instruction; |
| 114 | |
| 115 | UnaryOperator *cloneImpl() const; |
| 116 | |
| 117 | public: |
| 118 | |
| 119 | /// Construct a unary instruction, given the opcode and an operand. |
| 120 | /// Optionally (if InstBefore is specified) insert the instruction |
| 121 | /// into a BasicBlock right before the specified instruction. The specified |
| 122 | /// Instruction is allowed to be a dereferenced end iterator. |
| 123 | /// |
| 124 | static UnaryOperator *Create(UnaryOps Op, Value *S, |
| 125 | const Twine &Name = Twine(), |
| 126 | Instruction *InsertBefore = nullptr); |
| 127 | |
| 128 | /// Construct a unary instruction, given the opcode and an operand. |
| 129 | /// Also automatically insert this instruction to the end of the |
| 130 | /// BasicBlock specified. |
| 131 | /// |
| 132 | static UnaryOperator *Create(UnaryOps Op, Value *S, |
| 133 | const Twine &Name, |
| 134 | BasicBlock *InsertAtEnd); |
| 135 | |
| 136 | /// These methods just forward to Create, and are useful when you |
| 137 | /// statically know what type of instruction you're going to create. These |
| 138 | /// helpers just save some typing. |
| 139 | #define HANDLE_UNARY_INST(N, OPC, CLASS) \ |
| 140 | static UnaryOperator *Create##OPC(Value *V, const Twine &Name = "") {\ |
| 141 | return Create(Instruction::OPC, V, Name);\ |
| 142 | } |
| 143 | #include "llvm/IR/Instruction.def" |
| 144 | #define HANDLE_UNARY_INST(N, OPC, CLASS) \ |
| 145 | static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \ |
| 146 | BasicBlock *BB) {\ |
| 147 | return Create(Instruction::OPC, V, Name, BB);\ |
| 148 | } |
| 149 | #include "llvm/IR/Instruction.def" |
| 150 | #define HANDLE_UNARY_INST(N, OPC, CLASS) \ |
| 151 | static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \ |
| 152 | Instruction *I) {\ |
| 153 | return Create(Instruction::OPC, V, Name, I);\ |
| 154 | } |
| 155 | #include "llvm/IR/Instruction.def" |
| 156 | |
| 157 | static UnaryOperator *CreateWithCopiedFlags(UnaryOps Opc, |
| 158 | Value *V, |
| 159 | Instruction *CopyO, |
| 160 | const Twine &Name = "") { |
| 161 | UnaryOperator *UO = Create(Opc, V, Name); |
| 162 | UO->copyIRFlags(CopyO); |
| 163 | return UO; |
| 164 | } |
| 165 | |
| 166 | static UnaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource, |
| 167 | const Twine &Name = "") { |
| 168 | return CreateWithCopiedFlags(Instruction::FNeg, Op, FMFSource, Name); |
| 169 | } |
| 170 | |
| 171 | UnaryOps getOpcode() const { |
| 172 | return static_cast<UnaryOps>(Instruction::getOpcode()); |
| 173 | } |
| 174 | |
| 175 | // Methods for support type inquiry through isa, cast, and dyn_cast: |
| 176 | static bool classof(const Instruction *I) { |
| 177 | return I->isUnaryOp(); |
| 178 | } |
| 179 | static bool classof(const Value *V) { |
| 180 | return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| 181 | } |
| 182 | }; |
| 183 | |
| 184 | //===----------------------------------------------------------------------===// |
| 185 | // BinaryOperator Class |
| 186 | //===----------------------------------------------------------------------===// |
| 187 | |
| 188 | class BinaryOperator : public Instruction { |
| 189 | void AssertOK(); |
| 190 | |
| 191 | protected: |
| 192 | BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty, |
| 193 | const Twine &Name, Instruction *InsertBefore); |
| 194 | BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty, |
| 195 | const Twine &Name, BasicBlock *InsertAtEnd); |
| 196 | |
| 197 | // Note: Instruction needs to be a friend here to call cloneImpl. |
| 198 | friend class Instruction; |
| 199 | |
| 200 | BinaryOperator *cloneImpl() const; |
| 201 | |
| 202 | public: |
| 203 | // allocate space for exactly two operands |
| 204 | void *operator new(size_t s) { |
| 205 | return User::operator new(s, 2); |
| 206 | } |
| 207 | |
| 208 | /// Transparently provide more efficient getOperand methods. |
| 209 | DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void setOperand(unsigned, Value*); inline op_iterator op_begin(); inline const_op_iterator op_begin() const; inline op_iterator op_end(); inline const_op_iterator op_end() const; protected : template <int> inline Use &Op(); template <int > inline const Use &Op() const; public: inline unsigned getNumOperands() const; |
| 210 | |
| 211 | /// Construct a binary instruction, given the opcode and the two |
| 212 | /// operands. Optionally (if InstBefore is specified) insert the instruction |
| 213 | /// into a BasicBlock right before the specified instruction. The specified |
| 214 | /// Instruction is allowed to be a dereferenced end iterator. |
| 215 | /// |
| 216 | static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2, |
| 217 | const Twine &Name = Twine(), |
| 218 | Instruction *InsertBefore = nullptr); |
| 219 | |
| 220 | /// Construct a binary instruction, given the opcode and the two |
| 221 | /// operands. Also automatically insert this instruction to the end of the |
| 222 | /// BasicBlock specified. |
| 223 | /// |
| 224 | static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2, |
| 225 | const Twine &Name, BasicBlock *InsertAtEnd); |
| 226 | |
| 227 | /// These methods just forward to Create, and are useful when you |
| 228 | /// statically know what type of instruction you're going to create. These |
| 229 | /// helpers just save some typing. |
| 230 | #define HANDLE_BINARY_INST(N, OPC, CLASS) \ |
| 231 | static BinaryOperator *Create##OPC(Value *V1, Value *V2, \ |
| 232 | const Twine &Name = "") {\ |
| 233 | return Create(Instruction::OPC, V1, V2, Name);\ |
| 234 | } |
| 235 | #include "llvm/IR/Instruction.def" |
| 236 | #define HANDLE_BINARY_INST(N, OPC, CLASS) \ |
| 237 | static BinaryOperator *Create##OPC(Value *V1, Value *V2, \ |
| 238 | const Twine &Name, BasicBlock *BB) {\ |
| 239 | return Create(Instruction::OPC, V1, V2, Name, BB);\ |
| 240 | } |
| 241 | #include "llvm/IR/Instruction.def" |
| 242 | #define HANDLE_BINARY_INST(N, OPC, CLASS) \ |
| 243 | static BinaryOperator *Create##OPC(Value *V1, Value *V2, \ |
| 244 | const Twine &Name, Instruction *I) {\ |
| 245 | return Create(Instruction::OPC, V1, V2, Name, I);\ |
| 246 | } |
| 247 | #include "llvm/IR/Instruction.def" |
| 248 | |
| 249 | static BinaryOperator *CreateWithCopiedFlags(BinaryOps Opc, |
| 250 | Value *V1, Value *V2, |
| 251 | Instruction *CopyO, |
| 252 | const Twine &Name = "") { |
| 253 | BinaryOperator *BO = Create(Opc, V1, V2, Name); |
| 254 | BO->copyIRFlags(CopyO); |
| 255 | return BO; |
| 256 | } |
| 257 | |
| 258 | static BinaryOperator *CreateFAddFMF(Value *V1, Value *V2, |
| 259 | Instruction *FMFSource, |
| 260 | const Twine &Name = "") { |
| 261 | return CreateWithCopiedFlags(Instruction::FAdd, V1, V2, FMFSource, Name); |
| 262 | } |
| 263 | static BinaryOperator *CreateFSubFMF(Value *V1, Value *V2, |
| 264 | Instruction *FMFSource, |
| 265 | const Twine &Name = "") { |
| 266 | return CreateWithCopiedFlags(Instruction::FSub, V1, V2, FMFSource, Name); |
| 267 | } |
| 268 | static BinaryOperator *CreateFMulFMF(Value *V1, Value *V2, |
| 269 | Instruction *FMFSource, |
| 270 | const Twine &Name = "") { |
| 271 | return CreateWithCopiedFlags(Instruction::FMul, V1, V2, FMFSource, Name); |
| 272 | } |
| 273 | static BinaryOperator *CreateFDivFMF(Value *V1, Value *V2, |
| 274 | Instruction *FMFSource, |
| 275 | const Twine &Name = "") { |
| 276 | return CreateWithCopiedFlags(Instruction::FDiv, V1, V2, FMFSource, Name); |
| 277 | } |
| 278 | static BinaryOperator *CreateFRemFMF(Value *V1, Value *V2, |
| 279 | Instruction *FMFSource, |
| 280 | const Twine &Name = "") { |
| 281 | return CreateWithCopiedFlags(Instruction::FRem, V1, V2, FMFSource, Name); |
| 282 | } |
| 283 | static BinaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource, |
| 284 | const Twine &Name = "") { |
| 285 | Value *Zero = ConstantFP::getNegativeZero(Op->getType()); |
| 286 | return CreateWithCopiedFlags(Instruction::FSub, Zero, Op, FMFSource, Name); |
| 287 | } |
| 288 | |
| 289 | static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2, |
| 290 | const Twine &Name = "") { |
| 291 | BinaryOperator *BO = Create(Opc, V1, V2, Name); |
| 292 | BO->setHasNoSignedWrap(true); |
| 293 | return BO; |
| 294 | } |
| 295 | static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2, |
| 296 | const Twine &Name, BasicBlock *BB) { |
| 297 | BinaryOperator *BO = Create(Opc, V1, V2, Name, BB); |
| 298 | BO->setHasNoSignedWrap(true); |
| 299 | return BO; |
| 300 | } |
| 301 | static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2, |
| 302 | const Twine &Name, Instruction *I) { |
| 303 | BinaryOperator *BO = Create(Opc, V1, V2, Name, I); |
| 304 | BO->setHasNoSignedWrap(true); |
| 305 | return BO; |
| 306 | } |
| 307 | |
| 308 | static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2, |
| 309 | const Twine &Name = "") { |
| 310 | BinaryOperator *BO = Create(Opc, V1, V2, Name); |
| 311 | BO->setHasNoUnsignedWrap(true); |
| 312 | return BO; |
| 313 | } |
| 314 | static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2, |
| 315 | const Twine &Name, BasicBlock *BB) { |
| 316 | BinaryOperator *BO = Create(Opc, V1, V2, Name, BB); |
| 317 | BO->setHasNoUnsignedWrap(true); |
| 318 | return BO; |
| 319 | } |
| 320 | static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2, |
| 321 | const Twine &Name, Instruction *I) { |
| 322 | BinaryOperator *BO = Create(Opc, V1, V2, Name, I); |
| 323 | BO->setHasNoUnsignedWrap(true); |
| 324 | return BO; |
| 325 | } |
| 326 | |
| 327 | static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2, |
| 328 | const Twine &Name = "") { |
| 329 | BinaryOperator *BO = Create(Opc, V1, V2, Name); |
| 330 | BO->setIsExact(true); |
| 331 | return BO; |
| 332 | } |
| 333 | static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2, |
| 334 | const Twine &Name, BasicBlock *BB) { |
| 335 | BinaryOperator *BO = Create(Opc, V1, V2, Name, BB); |
| 336 | BO->setIsExact(true); |
| 337 | return BO; |
| 338 | } |
| 339 | static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2, |
| 340 | const Twine &Name, Instruction *I) { |
| 341 | BinaryOperator *BO = Create(Opc, V1, V2, Name, I); |
| 342 | BO->setIsExact(true); |
| 343 | return BO; |
| 344 | } |
| 345 | |
| 346 | #define DEFINE_HELPERS(OPC, NUWNSWEXACT) \ |
| 347 | static BinaryOperator *Create##NUWNSWEXACT##OPC(Value *V1, Value *V2, \ |
| 348 | const Twine &Name = "") { \ |
| 349 | return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name); \ |
| 350 | } \ |
| 351 | static BinaryOperator *Create##NUWNSWEXACT##OPC( \ |
| 352 | Value *V1, Value *V2, const Twine &Name, BasicBlock *BB) { \ |
| 353 | return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, BB); \ |
| 354 | } \ |
| 355 | static BinaryOperator *Create##NUWNSWEXACT##OPC( \ |
| 356 | Value *V1, Value *V2, const Twine &Name, Instruction *I) { \ |
| 357 | return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, I); \ |
| 358 | } |
| 359 | |
| 360 | DEFINE_HELPERS(Add, NSW) // CreateNSWAdd |
| 361 | DEFINE_HELPERS(Add, NUW) // CreateNUWAdd |
| 362 | DEFINE_HELPERS(Sub, NSW) // CreateNSWSub |
| 363 | DEFINE_HELPERS(Sub, NUW) // CreateNUWSub |
| 364 | DEFINE_HELPERS(Mul, NSW) // CreateNSWMul |
| 365 | DEFINE_HELPERS(Mul, NUW) // CreateNUWMul |
| 366 | DEFINE_HELPERS(Shl, NSW) // CreateNSWShl |
| 367 | DEFINE_HELPERS(Shl, NUW) // CreateNUWShl |
| 368 | |
| 369 | DEFINE_HELPERS(SDiv, Exact) // CreateExactSDiv |
| 370 | DEFINE_HELPERS(UDiv, Exact) // CreateExactUDiv |
| 371 | DEFINE_HELPERS(AShr, Exact) // CreateExactAShr |
| 372 | DEFINE_HELPERS(LShr, Exact) // CreateExactLShr |
| 373 | |
| 374 | #undef DEFINE_HELPERS |
| 375 | |
| 376 | /// Helper functions to construct and inspect unary operations (NEG and NOT) |
| 377 | /// via binary operators SUB and XOR: |
| 378 | /// |
| 379 | /// Create the NEG and NOT instructions out of SUB and XOR instructions. |
| 380 | /// |
| 381 | static BinaryOperator *CreateNeg(Value *Op, const Twine &Name = "", |
| 382 | Instruction *InsertBefore = nullptr); |
| 383 | static BinaryOperator *CreateNeg(Value *Op, const Twine &Name, |
| 384 | BasicBlock *InsertAtEnd); |
| 385 | static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name = "", |
| 386 | Instruction *InsertBefore = nullptr); |
| 387 | static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name, |
| 388 | BasicBlock *InsertAtEnd); |
| 389 | static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name = "", |
| 390 | Instruction *InsertBefore = nullptr); |
| 391 | static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name, |
| 392 | BasicBlock *InsertAtEnd); |
| 393 | static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name = "", |
| 394 | Instruction *InsertBefore = nullptr); |
| 395 | static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name, |
| 396 | BasicBlock *InsertAtEnd); |
| 397 | static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "", |
| 398 | Instruction *InsertBefore = nullptr); |
| 399 | static BinaryOperator *CreateNot(Value *Op, const Twine &Name, |
| 400 | BasicBlock *InsertAtEnd); |
| 401 | |
| 402 | BinaryOps getOpcode() const { |
| 403 | return static_cast<BinaryOps>(Instruction::getOpcode()); |
| 404 | } |
| 405 | |
| 406 | /// Exchange the two operands to this instruction. |
| 407 | /// This instruction is safe to use on any binary instruction and |
| 408 | /// does not modify the semantics of the instruction. If the instruction |
| 409 | /// cannot be reversed (ie, it's a Div), then return true. |
| 410 | /// |
| 411 | bool swapOperands(); |
| 412 | |
| 413 | // Methods for support type inquiry through isa, cast, and dyn_cast: |
| 414 | static bool classof(const Instruction *I) { |
| 415 | return I->isBinaryOp(); |
| 416 | } |
| 417 | static bool classof(const Value *V) { |
| 418 | return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| 419 | } |
| 420 | }; |
| 421 | |
| 422 | template <> |
| 423 | struct OperandTraits<BinaryOperator> : |
| 424 | public FixedNumOperandTraits<BinaryOperator, 2> { |
| 425 | }; |
| 426 | |
| 427 | DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BinaryOperator, Value)BinaryOperator::op_iterator BinaryOperator::op_begin() { return OperandTraits<BinaryOperator>::op_begin(this); } BinaryOperator ::const_op_iterator BinaryOperator::op_begin() const { return OperandTraits<BinaryOperator>::op_begin(const_cast< BinaryOperator*>(this)); } BinaryOperator::op_iterator BinaryOperator ::op_end() { return OperandTraits<BinaryOperator>::op_end (this); } BinaryOperator::const_op_iterator BinaryOperator::op_end () const { return OperandTraits<BinaryOperator>::op_end (const_cast<BinaryOperator*>(this)); } Value *BinaryOperator ::getOperand(unsigned i_nocapture) const { ((i_nocapture < OperandTraits<BinaryOperator>::operands(this) && "getOperand() out of range!") ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<BinaryOperator>::operands(this) && \"getOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 427, __PRETTY_FUNCTION__)); return cast_or_null<Value> ( OperandTraits<BinaryOperator>::op_begin(const_cast< BinaryOperator*>(this))[i_nocapture].get()); } void BinaryOperator ::setOperand(unsigned i_nocapture, Value *Val_nocapture) { (( i_nocapture < OperandTraits<BinaryOperator>::operands (this) && "setOperand() out of range!") ? static_cast <void> (0) : __assert_fail ("i_nocapture < OperandTraits<BinaryOperator>::operands(this) && \"setOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 427, __PRETTY_FUNCTION__)); OperandTraits<BinaryOperator >::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned BinaryOperator::getNumOperands() const { return OperandTraits <BinaryOperator>::operands(this); } template <int Idx_nocapture > Use &BinaryOperator::Op() { return this->OpFrom< Idx_nocapture>(this); } template <int Idx_nocapture> const Use &BinaryOperator::Op() const { return this-> OpFrom<Idx_nocapture>(this); } |
| 428 | |
| 429 | //===----------------------------------------------------------------------===// |
| 430 | // CastInst Class |
| 431 | //===----------------------------------------------------------------------===// |
| 432 | |
| 433 | /// This is the base class for all instructions that perform data |
| 434 | /// casts. It is simply provided so that instruction category testing |
| 435 | /// can be performed with code like: |
| 436 | /// |
| 437 | /// if (isa<CastInst>(Instr)) { ... } |
| 438 | /// Base class of casting instructions. |
| 439 | class CastInst : public UnaryInstruction { |
| 440 | protected: |
| 441 | /// Constructor with insert-before-instruction semantics for subclasses |
| 442 | CastInst(Type *Ty, unsigned iType, Value *S, |
| 443 | const Twine &NameStr = "", Instruction *InsertBefore = nullptr) |
| 444 | : UnaryInstruction(Ty, iType, S, InsertBefore) { |
| 445 | setName(NameStr); |
| 446 | } |
| 447 | /// Constructor with insert-at-end-of-block semantics for subclasses |
| 448 | CastInst(Type *Ty, unsigned iType, Value *S, |
| 449 | const Twine &NameStr, BasicBlock *InsertAtEnd) |
| 450 | : UnaryInstruction(Ty, iType, S, InsertAtEnd) { |
| 451 | setName(NameStr); |
| 452 | } |
| 453 | |
| 454 | public: |
| 455 | /// Provides a way to construct any of the CastInst subclasses using an |
| 456 | /// opcode instead of the subclass's constructor. The opcode must be in the |
| 457 | /// CastOps category (Instruction::isCast(opcode) returns true). This |
| 458 | /// constructor has insert-before-instruction semantics to automatically |
| 459 | /// insert the new CastInst before InsertBefore (if it is non-null). |
| 460 | /// Construct any of the CastInst subclasses |
| 461 | static CastInst *Create( |
| 462 | Instruction::CastOps, ///< The opcode of the cast instruction |
| 463 | Value *S, ///< The value to be casted (operand 0) |
| 464 | Type *Ty, ///< The type to which cast should be made |
| 465 | const Twine &Name = "", ///< Name for the instruction |
| 466 | Instruction *InsertBefore = nullptr ///< Place to insert the instruction |
| 467 | ); |
| 468 | /// Provides a way to construct any of the CastInst subclasses using an |
| 469 | /// opcode instead of the subclass's constructor. The opcode must be in the |
| 470 | /// CastOps category. This constructor has insert-at-end-of-block semantics |
| 471 | /// to automatically insert the new CastInst at the end of InsertAtEnd (if |
| 472 | /// its non-null). |
| 473 | /// Construct any of the CastInst subclasses |
| 474 | static CastInst *Create( |
| 475 | Instruction::CastOps, ///< The opcode for the cast instruction |
| 476 | Value *S, ///< The value to be casted (operand 0) |
| 477 | Type *Ty, ///< The type to which operand is casted |
| 478 | const Twine &Name, ///< The name for the instruction |
| 479 | BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| 480 | ); |
| 481 | |
| 482 | /// Create a ZExt or BitCast cast instruction |
| 483 | static CastInst *CreateZExtOrBitCast( |
| 484 | Value *S, ///< The value to be casted (operand 0) |
| 485 | Type *Ty, ///< The type to which cast should be made |
| 486 | const Twine &Name = "", ///< Name for the instruction |
| 487 | Instruction *InsertBefore = nullptr ///< Place to insert the instruction |
| 488 | ); |
| 489 | |
| 490 | /// Create a ZExt or BitCast cast instruction |
| 491 | static CastInst *CreateZExtOrBitCast( |
| 492 | Value *S, ///< The value to be casted (operand 0) |
| 493 | Type *Ty, ///< The type to which operand is casted |
| 494 | const Twine &Name, ///< The name for the instruction |
| 495 | BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| 496 | ); |
| 497 | |
| 498 | /// Create a SExt or BitCast cast instruction |
| 499 | static CastInst *CreateSExtOrBitCast( |
| 500 | Value *S, ///< The value to be casted (operand 0) |
| 501 | Type *Ty, ///< The type to which cast should be made |
| 502 | const Twine &Name = "", ///< Name for the instruction |
| 503 | Instruction *InsertBefore = nullptr ///< Place to insert the instruction |
| 504 | ); |
| 505 | |
| 506 | /// Create a SExt or BitCast cast instruction |
| 507 | static CastInst *CreateSExtOrBitCast( |
| 508 | Value *S, ///< The value to be casted (operand 0) |
| 509 | Type *Ty, ///< The type to which operand is casted |
| 510 | const Twine &Name, ///< The name for the instruction |
| 511 | BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| 512 | ); |
| 513 | |
| 514 | /// Create a BitCast AddrSpaceCast, or a PtrToInt cast instruction. |
| 515 | static CastInst *CreatePointerCast( |
| 516 | Value *S, ///< The pointer value to be casted (operand 0) |
| 517 | Type *Ty, ///< The type to which operand is casted |
| 518 | const Twine &Name, ///< The name for the instruction |
| 519 | BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| 520 | ); |
| 521 | |
| 522 | /// Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction. |
| 523 | static CastInst *CreatePointerCast( |
| 524 | Value *S, ///< The pointer value to be casted (operand 0) |
| 525 | Type *Ty, ///< The type to which cast should be made |
| 526 | const Twine &Name = "", ///< Name for the instruction |
| 527 | Instruction *InsertBefore = nullptr ///< Place to insert the instruction |
| 528 | ); |
| 529 | |
| 530 | /// Create a BitCast or an AddrSpaceCast cast instruction. |
| 531 | static CastInst *CreatePointerBitCastOrAddrSpaceCast( |
| 532 | Value *S, ///< The pointer value to be casted (operand 0) |
| 533 | Type *Ty, ///< The type to which operand is casted |
| 534 | const Twine &Name, ///< The name for the instruction |
| 535 | BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| 536 | ); |
| 537 | |
| 538 | /// Create a BitCast or an AddrSpaceCast cast instruction. |
| 539 | static CastInst *CreatePointerBitCastOrAddrSpaceCast( |
| 540 | Value *S, ///< The pointer value to be casted (operand 0) |
| 541 | Type *Ty, ///< The type to which cast should be made |
| 542 | const Twine &Name = "", ///< Name for the instruction |
| 543 | Instruction *InsertBefore = nullptr ///< Place to insert the instruction |
| 544 | ); |
| 545 | |
| 546 | /// Create a BitCast, a PtrToInt, or an IntToPTr cast instruction. |
| 547 | /// |
| 548 | /// If the value is a pointer type and the destination an integer type, |
| 549 | /// creates a PtrToInt cast. If the value is an integer type and the |
| 550 | /// destination a pointer type, creates an IntToPtr cast. Otherwise, creates |
| 551 | /// a bitcast. |
| 552 | static CastInst *CreateBitOrPointerCast( |
| 553 | Value *S, ///< The pointer value to be casted (operand 0) |
| 554 | Type *Ty, ///< The type to which cast should be made |
| 555 | const Twine &Name = "", ///< Name for the instruction |
| 556 | Instruction *InsertBefore = nullptr ///< Place to insert the instruction |
| 557 | ); |
| 558 | |
| 559 | /// Create a ZExt, BitCast, or Trunc for int -> int casts. |
| 560 | static CastInst *CreateIntegerCast( |
| 561 | Value *S, ///< The pointer value to be casted (operand 0) |
| 562 | Type *Ty, ///< The type to which cast should be made |
| 563 | bool isSigned, ///< Whether to regard S as signed or not |
| 564 | const Twine &Name = "", ///< Name for the instruction |
| 565 | Instruction *InsertBefore = nullptr ///< Place to insert the instruction |
| 566 | ); |
| 567 | |
| 568 | /// Create a ZExt, BitCast, or Trunc for int -> int casts. |
| 569 | static CastInst *CreateIntegerCast( |
| 570 | Value *S, ///< The integer value to be casted (operand 0) |
| 571 | Type *Ty, ///< The integer type to which operand is casted |
| 572 | bool isSigned, ///< Whether to regard S as signed or not |
| 573 | const Twine &Name, ///< The name for the instruction |
| 574 | BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| 575 | ); |
| 576 | |
| 577 | /// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts |
| 578 | static CastInst *CreateFPCast( |
| 579 | Value *S, ///< The floating point value to be casted |
| 580 | Type *Ty, ///< The floating point type to cast to |
| 581 | const Twine &Name = "", ///< Name for the instruction |
| 582 | Instruction *InsertBefore = nullptr ///< Place to insert the instruction |
| 583 | ); |
| 584 | |
| 585 | /// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts |
| 586 | static CastInst *CreateFPCast( |
| 587 | Value *S, ///< The floating point value to be casted |
| 588 | Type *Ty, ///< The floating point type to cast to |
| 589 | const Twine &Name, ///< The name for the instruction |
| 590 | BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| 591 | ); |
| 592 | |
| 593 | /// Create a Trunc or BitCast cast instruction |
| 594 | static CastInst *CreateTruncOrBitCast( |
| 595 | Value *S, ///< The value to be casted (operand 0) |
| 596 | Type *Ty, ///< The type to which cast should be made |
| 597 | const Twine &Name = "", ///< Name for the instruction |
| 598 | Instruction *InsertBefore = nullptr ///< Place to insert the instruction |
| 599 | ); |
| 600 | |
| 601 | /// Create a Trunc or BitCast cast instruction |
| 602 | static CastInst *CreateTruncOrBitCast( |
| 603 | Value *S, ///< The value to be casted (operand 0) |
| 604 | Type *Ty, ///< The type to which operand is casted |
| 605 | const Twine &Name, ///< The name for the instruction |
| 606 | BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| 607 | ); |
| 608 | |
| 609 | /// Check whether it is valid to call getCastOpcode for these types. |
| 610 | static bool isCastable( |
| 611 | Type *SrcTy, ///< The Type from which the value should be cast. |
| 612 | Type *DestTy ///< The Type to which the value should be cast. |
| 613 | ); |
| 614 | |
| 615 | /// Check whether a bitcast between these types is valid |
| 616 | static bool isBitCastable( |
| 617 | Type *SrcTy, ///< The Type from which the value should be cast. |
| 618 | Type *DestTy ///< The Type to which the value should be cast. |
| 619 | ); |
| 620 | |
| 621 | /// Check whether a bitcast, inttoptr, or ptrtoint cast between these |
| 622 | /// types is valid and a no-op. |
| 623 | /// |
| 624 | /// This ensures that any pointer<->integer cast has enough bits in the |
| 625 | /// integer and any other cast is a bitcast. |
| 626 | static bool isBitOrNoopPointerCastable( |
| 627 | Type *SrcTy, ///< The Type from which the value should be cast. |
| 628 | Type *DestTy, ///< The Type to which the value should be cast. |
| 629 | const DataLayout &DL); |
| 630 | |
| 631 | /// Returns the opcode necessary to cast Val into Ty using usual casting |
| 632 | /// rules. |
| 633 | /// Infer the opcode for cast operand and type |
| 634 | static Instruction::CastOps getCastOpcode( |
| 635 | const Value *Val, ///< The value to cast |
| 636 | bool SrcIsSigned, ///< Whether to treat the source as signed |
| 637 | Type *Ty, ///< The Type to which the value should be casted |
| 638 | bool DstIsSigned ///< Whether to treate the dest. as signed |
| 639 | ); |
| 640 | |
| 641 | /// There are several places where we need to know if a cast instruction |
| 642 | /// only deals with integer source and destination types. To simplify that |
| 643 | /// logic, this method is provided. |
| 644 | /// @returns true iff the cast has only integral typed operand and dest type. |
| 645 | /// Determine if this is an integer-only cast. |
| 646 | bool isIntegerCast() const; |
| 647 | |
| 648 | /// A lossless cast is one that does not alter the basic value. It implies |
| 649 | /// a no-op cast but is more stringent, preventing things like int->float, |
| 650 | /// long->double, or int->ptr. |
| 651 | /// @returns true iff the cast is lossless. |
| 652 | /// Determine if this is a lossless cast. |
| 653 | bool isLosslessCast() const; |
| 654 | |
| 655 | /// A no-op cast is one that can be effected without changing any bits. |
| 656 | /// It implies that the source and destination types are the same size. The |
| 657 | /// DataLayout argument is to determine the pointer size when examining casts |
| 658 | /// involving Integer and Pointer types. They are no-op casts if the integer |
| 659 | /// is the same size as the pointer. However, pointer size varies with |
| 660 | /// platform. |
| 661 | /// Determine if the described cast is a no-op cast. |
| 662 | static bool isNoopCast( |
| 663 | Instruction::CastOps Opcode, ///< Opcode of cast |
| 664 | Type *SrcTy, ///< SrcTy of cast |
| 665 | Type *DstTy, ///< DstTy of cast |
| 666 | const DataLayout &DL ///< DataLayout to get the Int Ptr type from. |
| 667 | ); |
| 668 | |
| 669 | /// Determine if this cast is a no-op cast. |
| 670 | /// |
| 671 | /// \param DL is the DataLayout to determine pointer size. |
| 672 | bool isNoopCast(const DataLayout &DL) const; |
| 673 | |
| 674 | /// Determine how a pair of casts can be eliminated, if they can be at all. |
| 675 | /// This is a helper function for both CastInst and ConstantExpr. |
| 676 | /// @returns 0 if the CastInst pair can't be eliminated, otherwise |
| 677 | /// returns Instruction::CastOps value for a cast that can replace |
| 678 | /// the pair, casting SrcTy to DstTy. |
| 679 | /// Determine if a cast pair is eliminable |
| 680 | static unsigned isEliminableCastPair( |
| 681 | Instruction::CastOps firstOpcode, ///< Opcode of first cast |
| 682 | Instruction::CastOps secondOpcode, ///< Opcode of second cast |
| 683 | Type *SrcTy, ///< SrcTy of 1st cast |
| 684 | Type *MidTy, ///< DstTy of 1st cast & SrcTy of 2nd cast |
| 685 | Type *DstTy, ///< DstTy of 2nd cast |
| 686 | Type *SrcIntPtrTy, ///< Integer type corresponding to Ptr SrcTy, or null |
| 687 | Type *MidIntPtrTy, ///< Integer type corresponding to Ptr MidTy, or null |
| 688 | Type *DstIntPtrTy ///< Integer type corresponding to Ptr DstTy, or null |
| 689 | ); |
| 690 | |
| 691 | /// Return the opcode of this CastInst |
| 692 | Instruction::CastOps getOpcode() const { |
| 693 | return Instruction::CastOps(Instruction::getOpcode()); |
| 694 | } |
| 695 | |
| 696 | /// Return the source type, as a convenience |
| 697 | Type* getSrcTy() const { return getOperand(0)->getType(); } |
| 698 | /// Return the destination type, as a convenience |
| 699 | Type* getDestTy() const { return getType(); } |
| 700 | |
| 701 | /// This method can be used to determine if a cast from S to DstTy using |
| 702 | /// Opcode op is valid or not. |
| 703 | /// @returns true iff the proposed cast is valid. |
| 704 | /// Determine if a cast is valid without creating one. |
| 705 | static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy); |
| 706 | |
| 707 | /// Methods for support type inquiry through isa, cast, and dyn_cast: |
| 708 | static bool classof(const Instruction *I) { |
| 709 | return I->isCast(); |
| 710 | } |
| 711 | static bool classof(const Value *V) { |
| 712 | return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| 713 | } |
| 714 | }; |
| 715 | |
| 716 | //===----------------------------------------------------------------------===// |
| 717 | // CmpInst Class |
| 718 | //===----------------------------------------------------------------------===// |
| 719 | |
| 720 | /// This class is the base class for the comparison instructions. |
| 721 | /// Abstract base class of comparison instructions. |
| 722 | class CmpInst : public Instruction { |
| 723 | public: |
| 724 | /// This enumeration lists the possible predicates for CmpInst subclasses. |
| 725 | /// Values in the range 0-31 are reserved for FCmpInst, while values in the |
| 726 | /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the |
| 727 | /// predicate values are not overlapping between the classes. |
| 728 | /// |
| 729 | /// Some passes (e.g. InstCombine) depend on the bit-wise characteristics of |
| 730 | /// FCMP_* values. Changing the bit patterns requires a potential change to |
| 731 | /// those passes. |
| 732 | enum Predicate { |
| 733 | // Opcode U L G E Intuitive operation |
| 734 | FCMP_FALSE = 0, ///< 0 0 0 0 Always false (always folded) |
| 735 | FCMP_OEQ = 1, ///< 0 0 0 1 True if ordered and equal |
| 736 | FCMP_OGT = 2, ///< 0 0 1 0 True if ordered and greater than |
| 737 | FCMP_OGE = 3, ///< 0 0 1 1 True if ordered and greater than or equal |
| 738 | FCMP_OLT = 4, ///< 0 1 0 0 True if ordered and less than |
| 739 | FCMP_OLE = 5, ///< 0 1 0 1 True if ordered and less than or equal |
| 740 | FCMP_ONE = 6, ///< 0 1 1 0 True if ordered and operands are unequal |
| 741 | FCMP_ORD = 7, ///< 0 1 1 1 True if ordered (no nans) |
| 742 | FCMP_UNO = 8, ///< 1 0 0 0 True if unordered: isnan(X) | isnan(Y) |
| 743 | FCMP_UEQ = 9, ///< 1 0 0 1 True if unordered or equal |
| 744 | FCMP_UGT = 10, ///< 1 0 1 0 True if unordered or greater than |
| 745 | FCMP_UGE = 11, ///< 1 0 1 1 True if unordered, greater than, or equal |
| 746 | FCMP_ULT = 12, ///< 1 1 0 0 True if unordered or less than |
| 747 | FCMP_ULE = 13, ///< 1 1 0 1 True if unordered, less than, or equal |
| 748 | FCMP_UNE = 14, ///< 1 1 1 0 True if unordered or not equal |
| 749 | FCMP_TRUE = 15, ///< 1 1 1 1 Always true (always folded) |
| 750 | FIRST_FCMP_PREDICATE = FCMP_FALSE, |
| 751 | LAST_FCMP_PREDICATE = FCMP_TRUE, |
| 752 | BAD_FCMP_PREDICATE = FCMP_TRUE + 1, |
| 753 | ICMP_EQ = 32, ///< equal |
| 754 | ICMP_NE = 33, ///< not equal |
| 755 | ICMP_UGT = 34, ///< unsigned greater than |
| 756 | ICMP_UGE = 35, ///< unsigned greater or equal |
| 757 | ICMP_ULT = 36, ///< unsigned less than |
| 758 | ICMP_ULE = 37, ///< unsigned less or equal |
| 759 | ICMP_SGT = 38, ///< signed greater than |
| 760 | ICMP_SGE = 39, ///< signed greater or equal |
| 761 | ICMP_SLT = 40, ///< signed less than |
| 762 | ICMP_SLE = 41, ///< signed less or equal |
| 763 | FIRST_ICMP_PREDICATE = ICMP_EQ, |
| 764 | LAST_ICMP_PREDICATE = ICMP_SLE, |
| 765 | BAD_ICMP_PREDICATE = ICMP_SLE + 1 |
| 766 | }; |
| 767 | |
| 768 | protected: |
| 769 | CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred, |
| 770 | Value *LHS, Value *RHS, const Twine &Name = "", |
| 771 | Instruction *InsertBefore = nullptr, |
| 772 | Instruction *FlagsSource = nullptr); |
| 773 | |
| 774 | CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred, |
| 775 | Value *LHS, Value *RHS, const Twine &Name, |
| 776 | BasicBlock *InsertAtEnd); |
| 777 | |
| 778 | public: |
| 779 | // allocate space for exactly two operands |
| 780 | void *operator new(size_t s) { |
| 781 | return User::operator new(s, 2); |
| 782 | } |
| 783 | |
| 784 | /// Construct a compare instruction, given the opcode, the predicate and |
| 785 | /// the two operands. Optionally (if InstBefore is specified) insert the |
| 786 | /// instruction into a BasicBlock right before the specified instruction. |
| 787 | /// The specified Instruction is allowed to be a dereferenced end iterator. |
| 788 | /// Create a CmpInst |
| 789 | static CmpInst *Create(OtherOps Op, |
| 790 | Predicate predicate, Value *S1, |
| 791 | Value *S2, const Twine &Name = "", |
| 792 | Instruction *InsertBefore = nullptr); |
| 793 | |
| 794 | /// Construct a compare instruction, given the opcode, the predicate and the |
| 795 | /// two operands. Also automatically insert this instruction to the end of |
| 796 | /// the BasicBlock specified. |
| 797 | /// Create a CmpInst |
| 798 | static CmpInst *Create(OtherOps Op, Predicate predicate, Value *S1, |
| 799 | Value *S2, const Twine &Name, BasicBlock *InsertAtEnd); |
| 800 | |
| 801 | /// Get the opcode casted to the right type |
| 802 | OtherOps getOpcode() const { |
| 803 | return static_cast<OtherOps>(Instruction::getOpcode()); |
| 804 | } |
| 805 | |
| 806 | /// Return the predicate for this instruction. |
| 807 | Predicate getPredicate() const { |
| 808 | return Predicate(getSubclassDataFromInstruction()); |
| 809 | } |
| 810 | |
| 811 | /// Set the predicate for this instruction to the specified value. |
| 812 | void setPredicate(Predicate P) { setInstructionSubclassData(P); } |
| 813 | |
| 814 | static bool isFPPredicate(Predicate P) { |
| 815 | return P >= FIRST_FCMP_PREDICATE && P <= LAST_FCMP_PREDICATE; |
| 816 | } |
| 817 | |
| 818 | static bool isIntPredicate(Predicate P) { |
| 819 | return P >= FIRST_ICMP_PREDICATE && P <= LAST_ICMP_PREDICATE; |
| 820 | } |
| 821 | |
| 822 | static StringRef getPredicateName(Predicate P); |
| 823 | |
| 824 | bool isFPPredicate() const { return isFPPredicate(getPredicate()); } |
| 825 | bool isIntPredicate() const { return isIntPredicate(getPredicate()); } |
| 826 | |
| 827 | /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE, |
| 828 | /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc. |
| 829 | /// @returns the inverse predicate for the instruction's current predicate. |
| 830 | /// Return the inverse of the instruction's predicate. |
| 831 | Predicate getInversePredicate() const { |
| 832 | return getInversePredicate(getPredicate()); |
| 833 | } |
| 834 | |
| 835 | /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE, |
| 836 | /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc. |
| 837 | /// @returns the inverse predicate for predicate provided in \p pred. |
| 838 | /// Return the inverse of a given predicate |
| 839 | static Predicate getInversePredicate(Predicate pred); |
| 840 | |
| 841 | /// For example, EQ->EQ, SLE->SGE, ULT->UGT, |
| 842 | /// OEQ->OEQ, ULE->UGE, OLT->OGT, etc. |
| 843 | /// @returns the predicate that would be the result of exchanging the two |
| 844 | /// operands of the CmpInst instruction without changing the result |
| 845 | /// produced. |
| 846 | /// Return the predicate as if the operands were swapped |
| 847 | Predicate getSwappedPredicate() const { |
| 848 | return getSwappedPredicate(getPredicate()); |
| 849 | } |
| 850 | |
| 851 | /// This is a static version that you can use without an instruction |
| 852 | /// available. |
| 853 | /// Return the predicate as if the operands were swapped. |
| 854 | static Predicate getSwappedPredicate(Predicate pred); |
| 855 | |
| 856 | /// For predicate of kind "is X or equal to 0" returns the predicate "is X". |
| 857 | /// For predicate of kind "is X" returns the predicate "is X or equal to 0". |
| 858 | /// does not support other kind of predicates. |
| 859 | /// @returns the predicate that does not contains is equal to zero if |
| 860 | /// it had and vice versa. |
| 861 | /// Return the flipped strictness of predicate |
| 862 | Predicate getFlippedStrictnessPredicate() const { |
| 863 | return getFlippedStrictnessPredicate(getPredicate()); |
| 864 | } |
| 865 | |
| 866 | /// This is a static version that you can use without an instruction |
| 867 | /// available. |
| 868 | /// Return the flipped strictness of predicate |
| 869 | static Predicate getFlippedStrictnessPredicate(Predicate pred); |
| 870 | |
| 871 | /// For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE. |
| 872 | /// Returns the non-strict version of strict comparisons. |
| 873 | Predicate getNonStrictPredicate() const { |
| 874 | return getNonStrictPredicate(getPredicate()); |
| 875 | } |
| 876 | |
| 877 | /// This is a static version that you can use without an instruction |
| 878 | /// available. |
| 879 | /// @returns the non-strict version of comparison provided in \p pred. |
| 880 | /// If \p pred is not a strict comparison predicate, returns \p pred. |
| 881 | /// Returns the non-strict version of strict comparisons. |
| 882 | static Predicate getNonStrictPredicate(Predicate pred); |
| 883 | |
| 884 | /// Provide more efficient getOperand methods. |
| 885 | DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void setOperand(unsigned, Value*); inline op_iterator op_begin(); inline const_op_iterator op_begin() const; inline op_iterator op_end(); inline const_op_iterator op_end() const; protected : template <int> inline Use &Op(); template <int > inline const Use &Op() const; public: inline unsigned getNumOperands() const; |
| 886 | |
| 887 | /// This is just a convenience that dispatches to the subclasses. |
| 888 | /// Swap the operands and adjust predicate accordingly to retain |
| 889 | /// the same comparison. |
| 890 | void swapOperands(); |
| 891 | |
| 892 | /// This is just a convenience that dispatches to the subclasses. |
| 893 | /// Determine if this CmpInst is commutative. |
| 894 | bool isCommutative() const; |
| 895 | |
| 896 | /// This is just a convenience that dispatches to the subclasses. |
| 897 | /// Determine if this is an equals/not equals predicate. |
| 898 | bool isEquality() const; |
| 899 | |
| 900 | /// @returns true if the comparison is signed, false otherwise. |
| 901 | /// Determine if this instruction is using a signed comparison. |
| 902 | bool isSigned() const { |
| 903 | return isSigned(getPredicate()); |
| 904 | } |
| 905 | |
| 906 | /// @returns true if the comparison is unsigned, false otherwise. |
| 907 | /// Determine if this instruction is using an unsigned comparison. |
| 908 | bool isUnsigned() const { |
| 909 | return isUnsigned(getPredicate()); |
| 910 | } |
| 911 | |
| 912 | /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert |
| 913 | /// @returns the signed version of the unsigned predicate pred. |
| 914 | /// return the signed version of a predicate |
| 915 | static Predicate getSignedPredicate(Predicate pred); |
| 916 | |
| 917 | /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert |
| 918 | /// @returns the signed version of the predicate for this instruction (which |
| 919 | /// has to be an unsigned predicate). |
| 920 | /// return the signed version of a predicate |
| 921 | Predicate getSignedPredicate() { |
| 922 | return getSignedPredicate(getPredicate()); |
| 923 | } |
| 924 | |
| 925 | /// This is just a convenience. |
| 926 | /// Determine if this is true when both operands are the same. |
| 927 | bool isTrueWhenEqual() const { |
| 928 | return isTrueWhenEqual(getPredicate()); |
| 929 | } |
| 930 | |
| 931 | /// This is just a convenience. |
| 932 | /// Determine if this is false when both operands are the same. |
| 933 | bool isFalseWhenEqual() const { |
| 934 | return isFalseWhenEqual(getPredicate()); |
| 935 | } |
| 936 | |
| 937 | /// @returns true if the predicate is unsigned, false otherwise. |
| 938 | /// Determine if the predicate is an unsigned operation. |
| 939 | static bool isUnsigned(Predicate predicate); |
| 940 | |
| 941 | /// @returns true if the predicate is signed, false otherwise. |
| 942 | /// Determine if the predicate is an signed operation. |
| 943 | static bool isSigned(Predicate predicate); |
| 944 | |
| 945 | /// Determine if the predicate is an ordered operation. |
| 946 | static bool isOrdered(Predicate predicate); |
| 947 | |
| 948 | /// Determine if the predicate is an unordered operation. |
| 949 | static bool isUnordered(Predicate predicate); |
| 950 | |
| 951 | /// Determine if the predicate is true when comparing a value with itself. |
| 952 | static bool isTrueWhenEqual(Predicate predicate); |
| 953 | |
| 954 | /// Determine if the predicate is false when comparing a value with itself. |
| 955 | static bool isFalseWhenEqual(Predicate predicate); |
| 956 | |
| 957 | /// Determine if Pred1 implies Pred2 is true when two compares have matching |
| 958 | /// operands. |
| 959 | static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2); |
| 960 | |
| 961 | /// Determine if Pred1 implies Pred2 is false when two compares have matching |
| 962 | /// operands. |
| 963 | static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2); |
| 964 | |
| 965 | /// Methods for support type inquiry through isa, cast, and dyn_cast: |
| 966 | static bool classof(const Instruction *I) { |
| 967 | return I->getOpcode() == Instruction::ICmp || |
| 968 | I->getOpcode() == Instruction::FCmp; |
| 969 | } |
| 970 | static bool classof(const Value *V) { |
| 971 | return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| 972 | } |
| 973 | |
| 974 | /// Create a result type for fcmp/icmp |
| 975 | static Type* makeCmpResultType(Type* opnd_type) { |
| 976 | if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) { |
| 977 | return VectorType::get(Type::getInt1Ty(opnd_type->getContext()), |
| 978 | vt->getElementCount()); |
| 979 | } |
| 980 | return Type::getInt1Ty(opnd_type->getContext()); |
| 981 | } |
| 982 | |
| 983 | private: |
| 984 | // Shadow Value::setValueSubclassData with a private forwarding method so that |
| 985 | // subclasses cannot accidentally use it. |
| 986 | void setValueSubclassData(unsigned short D) { |
| 987 | Value::setValueSubclassData(D); |
| 988 | } |
| 989 | }; |
| 990 | |
| 991 | // FIXME: these are redundant if CmpInst < BinaryOperator |
| 992 | template <> |
| 993 | struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> { |
| 994 | }; |
| 995 | |
| 996 | DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CmpInst, Value)CmpInst::op_iterator CmpInst::op_begin() { return OperandTraits <CmpInst>::op_begin(this); } CmpInst::const_op_iterator CmpInst::op_begin() const { return OperandTraits<CmpInst> ::op_begin(const_cast<CmpInst*>(this)); } CmpInst::op_iterator CmpInst::op_end() { return OperandTraits<CmpInst>::op_end (this); } CmpInst::const_op_iterator CmpInst::op_end() const { return OperandTraits<CmpInst>::op_end(const_cast<CmpInst *>(this)); } Value *CmpInst::getOperand(unsigned i_nocapture ) const { ((i_nocapture < OperandTraits<CmpInst>::operands (this) && "getOperand() out of range!") ? static_cast <void> (0) : __assert_fail ("i_nocapture < OperandTraits<CmpInst>::operands(this) && \"getOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 996, __PRETTY_FUNCTION__)); return cast_or_null<Value> ( OperandTraits<CmpInst>::op_begin(const_cast<CmpInst *>(this))[i_nocapture].get()); } void CmpInst::setOperand( unsigned i_nocapture, Value *Val_nocapture) { ((i_nocapture < OperandTraits<CmpInst>::operands(this) && "setOperand() out of range!" ) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<CmpInst>::operands(this) && \"setOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 996, __PRETTY_FUNCTION__)); OperandTraits<CmpInst>::op_begin (this)[i_nocapture] = Val_nocapture; } unsigned CmpInst::getNumOperands () const { return OperandTraits<CmpInst>::operands(this ); } template <int Idx_nocapture> Use &CmpInst::Op( ) { return this->OpFrom<Idx_nocapture>(this); } template <int Idx_nocapture> const Use &CmpInst::Op() const { return this->OpFrom<Idx_nocapture>(this); } |
| 997 | |
| 998 | /// A lightweight accessor for an operand bundle meant to be passed |
| 999 | /// around by value. |
| 1000 | struct OperandBundleUse { |
| 1001 | ArrayRef<Use> Inputs; |
| 1002 | |
| 1003 | OperandBundleUse() = default; |
| 1004 | explicit OperandBundleUse(StringMapEntry<uint32_t> *Tag, ArrayRef<Use> Inputs) |
| 1005 | : Inputs(Inputs), Tag(Tag) {} |
| 1006 | |
| 1007 | /// Return true if the operand at index \p Idx in this operand bundle |
| 1008 | /// has the attribute A. |
| 1009 | bool operandHasAttr(unsigned Idx, Attribute::AttrKind A) const { |
| 1010 | if (isDeoptOperandBundle()) |
| 1011 | if (A == Attribute::ReadOnly || A == Attribute::NoCapture) |
| 1012 | return Inputs[Idx]->getType()->isPointerTy(); |
| 1013 | |
| 1014 | // Conservative answer: no operands have any attributes. |
| 1015 | return false; |
| 1016 | } |
| 1017 | |
| 1018 | /// Return the tag of this operand bundle as a string. |
| 1019 | StringRef getTagName() const { |
| 1020 | return Tag->getKey(); |
| 1021 | } |
| 1022 | |
| 1023 | /// Return the tag of this operand bundle as an integer. |
| 1024 | /// |
| 1025 | /// Operand bundle tags are interned by LLVMContextImpl::getOrInsertBundleTag, |
| 1026 | /// and this function returns the unique integer getOrInsertBundleTag |
| 1027 | /// associated the tag of this operand bundle to. |
| 1028 | uint32_t getTagID() const { |
| 1029 | return Tag->getValue(); |
| 1030 | } |
| 1031 | |
| 1032 | /// Return true if this is a "deopt" operand bundle. |
| 1033 | bool isDeoptOperandBundle() const { |
| 1034 | return getTagID() == LLVMContext::OB_deopt; |
| 1035 | } |
| 1036 | |
| 1037 | /// Return true if this is a "funclet" operand bundle. |
| 1038 | bool isFuncletOperandBundle() const { |
| 1039 | return getTagID() == LLVMContext::OB_funclet; |
| 1040 | } |
| 1041 | |
| 1042 | private: |
| 1043 | /// Pointer to an entry in LLVMContextImpl::getOrInsertBundleTag. |
| 1044 | StringMapEntry<uint32_t> *Tag; |
| 1045 | }; |
| 1046 | |
| 1047 | /// A container for an operand bundle being viewed as a set of values |
| 1048 | /// rather than a set of uses. |
| 1049 | /// |
| 1050 | /// Unlike OperandBundleUse, OperandBundleDefT owns the memory it carries, and |
| 1051 | /// so it is possible to create and pass around "self-contained" instances of |
| 1052 | /// OperandBundleDef and ConstOperandBundleDef. |
| 1053 | template <typename InputTy> class OperandBundleDefT { |
| 1054 | std::string Tag; |
| 1055 | std::vector<InputTy> Inputs; |
| 1056 | |
| 1057 | public: |
| 1058 | explicit OperandBundleDefT(std::string Tag, std::vector<InputTy> Inputs) |
| 1059 | : Tag(std::move(Tag)), Inputs(std::move(Inputs)) {} |
| 1060 | explicit OperandBundleDefT(std::string Tag, ArrayRef<InputTy> Inputs) |
| 1061 | : Tag(std::move(Tag)), Inputs(Inputs) {} |
| 1062 | |
| 1063 | explicit OperandBundleDefT(const OperandBundleUse &OBU) { |
| 1064 | Tag = OBU.getTagName(); |
| 1065 | Inputs.insert(Inputs.end(), OBU.Inputs.begin(), OBU.Inputs.end()); |
| 1066 | } |
| 1067 | |
| 1068 | ArrayRef<InputTy> inputs() const { return Inputs; } |
| 1069 | |
| 1070 | using input_iterator = typename std::vector<InputTy>::const_iterator; |
| 1071 | |
| 1072 | size_t input_size() const { return Inputs.size(); } |
| 1073 | input_iterator input_begin() const { return Inputs.begin(); } |
| 1074 | input_iterator input_end() const { return Inputs.end(); } |
| 1075 | |
| 1076 | StringRef getTag() const { return Tag; } |
| 1077 | }; |
| 1078 | |
| 1079 | using OperandBundleDef = OperandBundleDefT<Value *>; |
| 1080 | using ConstOperandBundleDef = OperandBundleDefT<const Value *>; |
| 1081 | |
| 1082 | //===----------------------------------------------------------------------===// |
| 1083 | // CallBase Class |
| 1084 | //===----------------------------------------------------------------------===// |
| 1085 | |
| 1086 | /// Base class for all callable instructions (InvokeInst and CallInst) |
| 1087 | /// Holds everything related to calling a function. |
| 1088 | /// |
| 1089 | /// All call-like instructions are required to use a common operand layout: |
| 1090 | /// - Zero or more arguments to the call, |
| 1091 | /// - Zero or more operand bundles with zero or more operand inputs each |
| 1092 | /// bundle, |
| 1093 | /// - Zero or more subclass controlled operands |
| 1094 | /// - The called function. |
| 1095 | /// |
| 1096 | /// This allows this base class to easily access the called function and the |
| 1097 | /// start of the arguments without knowing how many other operands a particular |
| 1098 | /// subclass requires. Note that accessing the end of the argument list isn't |
| 1099 | /// as cheap as most other operations on the base class. |
| 1100 | class CallBase : public Instruction { |
| 1101 | protected: |
| 1102 | /// The last operand is the called operand. |
| 1103 | static constexpr int CalledOperandOpEndIdx = -1; |
| 1104 | |
| 1105 | AttributeList Attrs; ///< parameter attributes for callable |
| 1106 | FunctionType *FTy; |
| 1107 | |
| 1108 | template <class... ArgsTy> |
| 1109 | CallBase(AttributeList const &A, FunctionType *FT, ArgsTy &&... Args) |
| 1110 | : Instruction(std::forward<ArgsTy>(Args)...), Attrs(A), FTy(FT) {} |
| 1111 | |
| 1112 | using Instruction::Instruction; |
| 1113 | |
| 1114 | bool hasDescriptor() const { return Value::HasDescriptor; } |
| 1115 | |
| 1116 | unsigned getNumSubclassExtraOperands() const { |
| 1117 | switch (getOpcode()) { |
| 1118 | case Instruction::Call: |
| 1119 | return 0; |
| 1120 | case Instruction::Invoke: |
| 1121 | return 2; |
| 1122 | case Instruction::CallBr: |
| 1123 | return getNumSubclassExtraOperandsDynamic(); |
| 1124 | } |
| 1125 | llvm_unreachable("Invalid opcode!")::llvm::llvm_unreachable_internal("Invalid opcode!", "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1125); |
| 1126 | } |
| 1127 | |
| 1128 | /// Get the number of extra operands for instructions that don't have a fixed |
| 1129 | /// number of extra operands. |
| 1130 | unsigned getNumSubclassExtraOperandsDynamic() const; |
| 1131 | |
| 1132 | public: |
| 1133 | using Instruction::getContext; |
| 1134 | |
| 1135 | static bool classof(const Instruction *I) { |
| 1136 | return I->getOpcode() == Instruction::Call || |
| 1137 | I->getOpcode() == Instruction::Invoke || |
| 1138 | I->getOpcode() == Instruction::CallBr; |
| 1139 | } |
| 1140 | static bool classof(const Value *V) { |
| 1141 | return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| 1142 | } |
| 1143 | |
| 1144 | FunctionType *getFunctionType() const { return FTy; } |
| 1145 | |
| 1146 | void mutateFunctionType(FunctionType *FTy) { |
| 1147 | Value::mutateType(FTy->getReturnType()); |
| 1148 | this->FTy = FTy; |
| 1149 | } |
| 1150 | |
| 1151 | DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void setOperand(unsigned, Value*); inline op_iterator op_begin(); inline const_op_iterator op_begin() const; inline op_iterator op_end(); inline const_op_iterator op_end() const; protected : template <int> inline Use &Op(); template <int > inline const Use &Op() const; public: inline unsigned getNumOperands() const; |
| 1152 | |
| 1153 | /// data_operands_begin/data_operands_end - Return iterators iterating over |
| 1154 | /// the call / invoke argument list and bundle operands. For invokes, this is |
| 1155 | /// the set of instruction operands except the invoke target and the two |
| 1156 | /// successor blocks; and for calls this is the set of instruction operands |
| 1157 | /// except the call target. |
| 1158 | User::op_iterator data_operands_begin() { return op_begin(); } |
| 1159 | User::const_op_iterator data_operands_begin() const { |
| 1160 | return const_cast<CallBase *>(this)->data_operands_begin(); |
| 1161 | } |
| 1162 | User::op_iterator data_operands_end() { |
| 1163 | // Walk from the end of the operands over the called operand and any |
| 1164 | // subclass operands. |
| 1165 | return op_end() - getNumSubclassExtraOperands() - 1; |
| 1166 | } |
| 1167 | User::const_op_iterator data_operands_end() const { |
| 1168 | return const_cast<CallBase *>(this)->data_operands_end(); |
| 1169 | } |
| 1170 | iterator_range<User::op_iterator> data_ops() { |
| 1171 | return make_range(data_operands_begin(), data_operands_end()); |
| 1172 | } |
| 1173 | iterator_range<User::const_op_iterator> data_ops() const { |
| 1174 | return make_range(data_operands_begin(), data_operands_end()); |
| 1175 | } |
| 1176 | bool data_operands_empty() const { |
| 1177 | return data_operands_end() == data_operands_begin(); |
| 1178 | } |
| 1179 | unsigned data_operands_size() const { |
| 1180 | return std::distance(data_operands_begin(), data_operands_end()); |
| 1181 | } |
| 1182 | |
| 1183 | bool isDataOperand(const Use *U) const { |
| 1184 | assert(this == U->getUser() &&((this == U->getUser() && "Only valid to query with a use of this instruction!" ) ? static_cast<void> (0) : __assert_fail ("this == U->getUser() && \"Only valid to query with a use of this instruction!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1185, __PRETTY_FUNCTION__)) |
| 1185 | "Only valid to query with a use of this instruction!")((this == U->getUser() && "Only valid to query with a use of this instruction!" ) ? static_cast<void> (0) : __assert_fail ("this == U->getUser() && \"Only valid to query with a use of this instruction!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1185, __PRETTY_FUNCTION__)); |
| 1186 | return data_operands_begin() <= U && U < data_operands_end(); |
| 1187 | } |
| 1188 | bool isDataOperand(Value::const_user_iterator UI) const { |
| 1189 | return isDataOperand(&UI.getUse()); |
| 1190 | } |
| 1191 | |
| 1192 | /// Given a value use iterator, return the data operand corresponding to it. |
| 1193 | /// Iterator must actually correspond to a data operand. |
| 1194 | unsigned getDataOperandNo(Value::const_user_iterator UI) const { |
| 1195 | return getDataOperandNo(&UI.getUse()); |
| 1196 | } |
| 1197 | |
| 1198 | /// Given a use for a data operand, get the data operand number that |
| 1199 | /// corresponds to it. |
| 1200 | unsigned getDataOperandNo(const Use *U) const { |
| 1201 | assert(isDataOperand(U) && "Data operand # out of range!")((isDataOperand(U) && "Data operand # out of range!") ? static_cast<void> (0) : __assert_fail ("isDataOperand(U) && \"Data operand # out of range!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1201, __PRETTY_FUNCTION__)); |
| 1202 | return U - data_operands_begin(); |
| 1203 | } |
| 1204 | |
| 1205 | /// Return the iterator pointing to the beginning of the argument list. |
| 1206 | User::op_iterator arg_begin() { return op_begin(); } |
| 1207 | User::const_op_iterator arg_begin() const { |
| 1208 | return const_cast<CallBase *>(this)->arg_begin(); |
| 1209 | } |
| 1210 | |
| 1211 | /// Return the iterator pointing to the end of the argument list. |
| 1212 | User::op_iterator arg_end() { |
| 1213 | // From the end of the data operands, walk backwards past the bundle |
| 1214 | // operands. |
| 1215 | return data_operands_end() - getNumTotalBundleOperands(); |
| 1216 | } |
| 1217 | User::const_op_iterator arg_end() const { |
| 1218 | return const_cast<CallBase *>(this)->arg_end(); |
| 1219 | } |
| 1220 | |
| 1221 | /// Iteration adapter for range-for loops. |
| 1222 | iterator_range<User::op_iterator> args() { |
| 1223 | return make_range(arg_begin(), arg_end()); |
| 1224 | } |
| 1225 | iterator_range<User::const_op_iterator> args() const { |
| 1226 | return make_range(arg_begin(), arg_end()); |
| 1227 | } |
| 1228 | bool arg_empty() const { return arg_end() == arg_begin(); } |
| 1229 | unsigned arg_size() const { return arg_end() - arg_begin(); } |
| 1230 | |
| 1231 | // Legacy API names that duplicate the above and will be removed once users |
| 1232 | // are migrated. |
| 1233 | iterator_range<User::op_iterator> arg_operands() { |
| 1234 | return make_range(arg_begin(), arg_end()); |
| 1235 | } |
| 1236 | iterator_range<User::const_op_iterator> arg_operands() const { |
| 1237 | return make_range(arg_begin(), arg_end()); |
| 1238 | } |
| 1239 | unsigned getNumArgOperands() const { return arg_size(); } |
| 1240 | |
| 1241 | Value *getArgOperand(unsigned i) const { |
| 1242 | assert(i < getNumArgOperands() && "Out of bounds!")((i < getNumArgOperands() && "Out of bounds!") ? static_cast <void> (0) : __assert_fail ("i < getNumArgOperands() && \"Out of bounds!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1242, __PRETTY_FUNCTION__)); |
| 1243 | return getOperand(i); |
| 1244 | } |
| 1245 | |
| 1246 | void setArgOperand(unsigned i, Value *v) { |
| 1247 | assert(i < getNumArgOperands() && "Out of bounds!")((i < getNumArgOperands() && "Out of bounds!") ? static_cast <void> (0) : __assert_fail ("i < getNumArgOperands() && \"Out of bounds!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1247, __PRETTY_FUNCTION__)); |
| 1248 | setOperand(i, v); |
| 1249 | } |
| 1250 | |
| 1251 | /// Wrappers for getting the \c Use of a call argument. |
| 1252 | const Use &getArgOperandUse(unsigned i) const { |
| 1253 | assert(i < getNumArgOperands() && "Out of bounds!")((i < getNumArgOperands() && "Out of bounds!") ? static_cast <void> (0) : __assert_fail ("i < getNumArgOperands() && \"Out of bounds!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1253, __PRETTY_FUNCTION__)); |
| 1254 | return User::getOperandUse(i); |
| 1255 | } |
| 1256 | Use &getArgOperandUse(unsigned i) { |
| 1257 | assert(i < getNumArgOperands() && "Out of bounds!")((i < getNumArgOperands() && "Out of bounds!") ? static_cast <void> (0) : __assert_fail ("i < getNumArgOperands() && \"Out of bounds!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1257, __PRETTY_FUNCTION__)); |
| 1258 | return User::getOperandUse(i); |
| 1259 | } |
| 1260 | |
| 1261 | bool isArgOperand(const Use *U) const { |
| 1262 | assert(this == U->getUser() &&((this == U->getUser() && "Only valid to query with a use of this instruction!" ) ? static_cast<void> (0) : __assert_fail ("this == U->getUser() && \"Only valid to query with a use of this instruction!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1263, __PRETTY_FUNCTION__)) |
| 1263 | "Only valid to query with a use of this instruction!")((this == U->getUser() && "Only valid to query with a use of this instruction!" ) ? static_cast<void> (0) : __assert_fail ("this == U->getUser() && \"Only valid to query with a use of this instruction!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1263, __PRETTY_FUNCTION__)); |
| 1264 | return arg_begin() <= U && U < arg_end(); |
| 1265 | } |
| 1266 | bool isArgOperand(Value::const_user_iterator UI) const { |
| 1267 | return isArgOperand(&UI.getUse()); |
| 1268 | } |
| 1269 | |
| 1270 | /// Returns true if this CallSite passes the given Value* as an argument to |
| 1271 | /// the called function. |
| 1272 | bool hasArgument(const Value *V) const { |
| 1273 | return llvm::any_of(args(), [V](const Value *Arg) { return Arg == V; }); |
| 1274 | } |
| 1275 | |
| 1276 | Value *getCalledOperand() const { return Op<CalledOperandOpEndIdx>(); } |
| 1277 | |
| 1278 | // DEPRECATED: This routine will be removed in favor of `getCalledOperand` in |
| 1279 | // the near future. |
| 1280 | Value *getCalledValue() const { return getCalledOperand(); } |
| 1281 | |
| 1282 | const Use &getCalledOperandUse() const { return Op<CalledOperandOpEndIdx>(); } |
| 1283 | Use &getCalledOperandUse() { return Op<CalledOperandOpEndIdx>(); } |
| 1284 | |
| 1285 | /// Returns the function called, or null if this is an |
| 1286 | /// indirect function invocation. |
| 1287 | Function *getCalledFunction() const { |
| 1288 | return dyn_cast_or_null<Function>(getCalledOperand()); |
| 1289 | } |
| 1290 | |
| 1291 | /// Return true if the callsite is an indirect call. |
| 1292 | bool isIndirectCall() const; |
| 1293 | |
| 1294 | /// Determine whether the passed iterator points to the callee operand's Use. |
| 1295 | bool isCallee(Value::const_user_iterator UI) const { |
| 1296 | return isCallee(&UI.getUse()); |
| 1297 | } |
| 1298 | |
| 1299 | /// Determine whether this Use is the callee operand's Use. |
| 1300 | bool isCallee(const Use *U) const { return &getCalledOperandUse() == U; } |
| 1301 | |
| 1302 | /// Helper to get the caller (the parent function). |
| 1303 | Function *getCaller(); |
| 1304 | const Function *getCaller() const { |
| 1305 | return const_cast<CallBase *>(this)->getCaller(); |
| 1306 | } |
| 1307 | |
| 1308 | /// Tests if this call site must be tail call optimized. Only a CallInst can |
| 1309 | /// be tail call optimized. |
| 1310 | bool isMustTailCall() const; |
| 1311 | |
| 1312 | /// Tests if this call site is marked as a tail call. |
| 1313 | bool isTailCall() const; |
| 1314 | |
| 1315 | /// Returns the intrinsic ID of the intrinsic called or |
| 1316 | /// Intrinsic::not_intrinsic if the called function is not an intrinsic, or if |
| 1317 | /// this is an indirect call. |
| 1318 | Intrinsic::ID getIntrinsicID() const; |
| 1319 | |
| 1320 | void setCalledOperand(Value *V) { Op<CalledOperandOpEndIdx>() = V; } |
| 1321 | |
| 1322 | /// Sets the function called, including updating the function type. |
| 1323 | void setCalledFunction(Function *Fn) { |
| 1324 | setCalledFunction(Fn->getFunctionType(), Fn); |
| 1325 | } |
| 1326 | |
| 1327 | /// Sets the function called, including updating the function type. |
| 1328 | void setCalledFunction(FunctionCallee Fn) { |
| 1329 | setCalledFunction(Fn.getFunctionType(), Fn.getCallee()); |
| 1330 | } |
| 1331 | |
| 1332 | /// Sets the function called, including updating to the specified function |
| 1333 | /// type. |
| 1334 | void setCalledFunction(FunctionType *FTy, Value *Fn) { |
| 1335 | this->FTy = FTy; |
| 1336 | assert(FTy == cast<FunctionType>(((FTy == cast<FunctionType>( cast<PointerType>(Fn ->getType())->getElementType())) ? static_cast<void> (0) : __assert_fail ("FTy == cast<FunctionType>( cast<PointerType>(Fn->getType())->getElementType())" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1337, __PRETTY_FUNCTION__)) |
| 1337 | cast<PointerType>(Fn->getType())->getElementType()))((FTy == cast<FunctionType>( cast<PointerType>(Fn ->getType())->getElementType())) ? static_cast<void> (0) : __assert_fail ("FTy == cast<FunctionType>( cast<PointerType>(Fn->getType())->getElementType())" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1337, __PRETTY_FUNCTION__)); |
| 1338 | // This function doesn't mutate the return type, only the function |
| 1339 | // type. Seems broken, but I'm just gonna stick an assert in for now. |
| 1340 | assert(getType() == FTy->getReturnType())((getType() == FTy->getReturnType()) ? static_cast<void > (0) : __assert_fail ("getType() == FTy->getReturnType()" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1340, __PRETTY_FUNCTION__)); |
| 1341 | setCalledOperand(Fn); |
| 1342 | } |
| 1343 | |
| 1344 | CallingConv::ID getCallingConv() const { |
| 1345 | return static_cast<CallingConv::ID>(getSubclassDataFromInstruction() >> 2); |
| 1346 | } |
| 1347 | |
| 1348 | void setCallingConv(CallingConv::ID CC) { |
| 1349 | auto ID = static_cast<unsigned>(CC); |
| 1350 | assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention")((!(ID & ~CallingConv::MaxID) && "Unsupported calling convention" ) ? static_cast<void> (0) : __assert_fail ("!(ID & ~CallingConv::MaxID) && \"Unsupported calling convention\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1350, __PRETTY_FUNCTION__)); |
| 1351 | setInstructionSubclassData((getSubclassDataFromInstruction() & 3) | |
| 1352 | (ID << 2)); |
| 1353 | } |
| 1354 | |
| 1355 | /// Check if this call is an inline asm statement. |
| 1356 | bool isInlineAsm() const { return isa<InlineAsm>(getCalledOperand()); } |
| 1357 | |
| 1358 | /// \name Attribute API |
| 1359 | /// |
| 1360 | /// These methods access and modify attributes on this call (including |
| 1361 | /// looking through to the attributes on the called function when necessary). |
| 1362 | ///@{ |
| 1363 | |
| 1364 | /// Return the parameter attributes for this call. |
| 1365 | /// |
| 1366 | AttributeList getAttributes() const { return Attrs; } |
| 1367 | |
| 1368 | /// Set the parameter attributes for this call. |
| 1369 | /// |
| 1370 | void setAttributes(AttributeList A) { Attrs = A; } |
| 1371 | |
| 1372 | /// Determine whether this call has the given attribute. |
| 1373 | bool hasFnAttr(Attribute::AttrKind Kind) const { |
| 1374 | assert(Kind != Attribute::NoBuiltin &&((Kind != Attribute::NoBuiltin && "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin" ) ? static_cast<void> (0) : __assert_fail ("Kind != Attribute::NoBuiltin && \"Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1375, __PRETTY_FUNCTION__)) |
| 1375 | "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin")((Kind != Attribute::NoBuiltin && "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin" ) ? static_cast<void> (0) : __assert_fail ("Kind != Attribute::NoBuiltin && \"Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1375, __PRETTY_FUNCTION__)); |
| 1376 | return hasFnAttrImpl(Kind); |
| 1377 | } |
| 1378 | |
| 1379 | /// Determine whether this call has the given attribute. |
| 1380 | bool hasFnAttr(StringRef Kind) const { return hasFnAttrImpl(Kind); } |
| 1381 | |
| 1382 | /// adds the attribute to the list of attributes. |
| 1383 | void addAttribute(unsigned i, Attribute::AttrKind Kind) { |
| 1384 | AttributeList PAL = getAttributes(); |
| 1385 | PAL = PAL.addAttribute(getContext(), i, Kind); |
| 1386 | setAttributes(PAL); |
| 1387 | } |
| 1388 | |
| 1389 | /// adds the attribute to the list of attributes. |
| 1390 | void addAttribute(unsigned i, Attribute Attr) { |
| 1391 | AttributeList PAL = getAttributes(); |
| 1392 | PAL = PAL.addAttribute(getContext(), i, Attr); |
| 1393 | setAttributes(PAL); |
| 1394 | } |
| 1395 | |
| 1396 | /// Adds the attribute to the indicated argument |
| 1397 | void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) { |
| 1398 | assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ? static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1398, __PRETTY_FUNCTION__)); |
| 1399 | AttributeList PAL = getAttributes(); |
| 1400 | PAL = PAL.addParamAttribute(getContext(), ArgNo, Kind); |
| 1401 | setAttributes(PAL); |
| 1402 | } |
| 1403 | |
| 1404 | /// Adds the attribute to the indicated argument |
| 1405 | void addParamAttr(unsigned ArgNo, Attribute Attr) { |
| 1406 | assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ? static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1406, __PRETTY_FUNCTION__)); |
| 1407 | AttributeList PAL = getAttributes(); |
| 1408 | PAL = PAL.addParamAttribute(getContext(), ArgNo, Attr); |
| 1409 | setAttributes(PAL); |
| 1410 | } |
| 1411 | |
| 1412 | /// removes the attribute from the list of attributes. |
| 1413 | void removeAttribute(unsigned i, Attribute::AttrKind Kind) { |
| 1414 | AttributeList PAL = getAttributes(); |
| 1415 | PAL = PAL.removeAttribute(getContext(), i, Kind); |
| 1416 | setAttributes(PAL); |
| 1417 | } |
| 1418 | |
| 1419 | /// removes the attribute from the list of attributes. |
| 1420 | void removeAttribute(unsigned i, StringRef Kind) { |
| 1421 | AttributeList PAL = getAttributes(); |
| 1422 | PAL = PAL.removeAttribute(getContext(), i, Kind); |
| 1423 | setAttributes(PAL); |
| 1424 | } |
| 1425 | |
| 1426 | /// Removes the attribute from the given argument |
| 1427 | void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) { |
| 1428 | assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ? static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1428, __PRETTY_FUNCTION__)); |
| 1429 | AttributeList PAL = getAttributes(); |
| 1430 | PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind); |
| 1431 | setAttributes(PAL); |
| 1432 | } |
| 1433 | |
| 1434 | /// Removes the attribute from the given argument |
| 1435 | void removeParamAttr(unsigned ArgNo, StringRef Kind) { |
| 1436 | assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ? static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1436, __PRETTY_FUNCTION__)); |
| 1437 | AttributeList PAL = getAttributes(); |
| 1438 | PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind); |
| 1439 | setAttributes(PAL); |
| 1440 | } |
| 1441 | |
| 1442 | /// adds the dereferenceable attribute to the list of attributes. |
| 1443 | void addDereferenceableAttr(unsigned i, uint64_t Bytes) { |
| 1444 | AttributeList PAL = getAttributes(); |
| 1445 | PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes); |
| 1446 | setAttributes(PAL); |
| 1447 | } |
| 1448 | |
| 1449 | /// adds the dereferenceable_or_null attribute to the list of |
| 1450 | /// attributes. |
| 1451 | void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) { |
| 1452 | AttributeList PAL = getAttributes(); |
| 1453 | PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes); |
| 1454 | setAttributes(PAL); |
| 1455 | } |
| 1456 | |
| 1457 | /// Determine whether the return value has the given attribute. |
| 1458 | bool hasRetAttr(Attribute::AttrKind Kind) const; |
| 1459 | |
| 1460 | /// Determine whether the argument or parameter has the given attribute. |
| 1461 | bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const; |
| 1462 | |
| 1463 | /// Get the attribute of a given kind at a position. |
| 1464 | Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const { |
| 1465 | return getAttributes().getAttribute(i, Kind); |
| 1466 | } |
| 1467 | |
| 1468 | /// Get the attribute of a given kind at a position. |
| 1469 | Attribute getAttribute(unsigned i, StringRef Kind) const { |
| 1470 | return getAttributes().getAttribute(i, Kind); |
| 1471 | } |
| 1472 | |
| 1473 | /// Get the attribute of a given kind from a given arg |
| 1474 | Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const { |
| 1475 | assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ? static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1475, __PRETTY_FUNCTION__)); |
| 1476 | return getAttributes().getParamAttr(ArgNo, Kind); |
| 1477 | } |
| 1478 | |
| 1479 | /// Get the attribute of a given kind from a given arg |
| 1480 | Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const { |
| 1481 | assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ? static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1481, __PRETTY_FUNCTION__)); |
| 1482 | return getAttributes().getParamAttr(ArgNo, Kind); |
| 1483 | } |
| 1484 | |
| 1485 | /// Return true if the data operand at index \p i has the attribute \p |
| 1486 | /// A. |
| 1487 | /// |
| 1488 | /// Data operands include call arguments and values used in operand bundles, |
| 1489 | /// but does not include the callee operand. This routine dispatches to the |
| 1490 | /// underlying AttributeList or the OperandBundleUser as appropriate. |
| 1491 | /// |
| 1492 | /// The index \p i is interpreted as |
| 1493 | /// |
| 1494 | /// \p i == Attribute::ReturnIndex -> the return value |
| 1495 | /// \p i in [1, arg_size + 1) -> argument number (\p i - 1) |
| 1496 | /// \p i in [arg_size + 1, data_operand_size + 1) -> bundle operand at index |
| 1497 | /// (\p i - 1) in the operand list. |
| 1498 | bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const { |
| 1499 | // Note that we have to add one because `i` isn't zero-indexed. |
| 1500 | assert(i < (getNumArgOperands() + getNumTotalBundleOperands() + 1) &&((i < (getNumArgOperands() + getNumTotalBundleOperands() + 1) && "Data operand index out of bounds!") ? static_cast <void> (0) : __assert_fail ("i < (getNumArgOperands() + getNumTotalBundleOperands() + 1) && \"Data operand index out of bounds!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1501, __PRETTY_FUNCTION__)) |
| 1501 | "Data operand index out of bounds!")((i < (getNumArgOperands() + getNumTotalBundleOperands() + 1) && "Data operand index out of bounds!") ? static_cast <void> (0) : __assert_fail ("i < (getNumArgOperands() + getNumTotalBundleOperands() + 1) && \"Data operand index out of bounds!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1501, __PRETTY_FUNCTION__)); |
| 1502 | |
| 1503 | // The attribute A can either be directly specified, if the operand in |
| 1504 | // question is a call argument; or be indirectly implied by the kind of its |
| 1505 | // containing operand bundle, if the operand is a bundle operand. |
| 1506 | |
| 1507 | if (i == AttributeList::ReturnIndex) |
| 1508 | return hasRetAttr(Kind); |
| 1509 | |
| 1510 | // FIXME: Avoid these i - 1 calculations and update the API to use |
| 1511 | // zero-based indices. |
| 1512 | if (i < (getNumArgOperands() + 1)) |
| 1513 | return paramHasAttr(i - 1, Kind); |
| 1514 | |
| 1515 | assert(hasOperandBundles() && i >= (getBundleOperandsStartIndex() + 1) &&((hasOperandBundles() && i >= (getBundleOperandsStartIndex () + 1) && "Must be either a call argument or an operand bundle!" ) ? static_cast<void> (0) : __assert_fail ("hasOperandBundles() && i >= (getBundleOperandsStartIndex() + 1) && \"Must be either a call argument or an operand bundle!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1516, __PRETTY_FUNCTION__)) |
| 1516 | "Must be either a call argument or an operand bundle!")((hasOperandBundles() && i >= (getBundleOperandsStartIndex () + 1) && "Must be either a call argument or an operand bundle!" ) ? static_cast<void> (0) : __assert_fail ("hasOperandBundles() && i >= (getBundleOperandsStartIndex() + 1) && \"Must be either a call argument or an operand bundle!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1516, __PRETTY_FUNCTION__)); |
| 1517 | return bundleOperandHasAttr(i - 1, Kind); |
| 1518 | } |
| 1519 | |
| 1520 | /// Determine whether this data operand is not captured. |
| 1521 | // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to |
| 1522 | // better indicate that this may return a conservative answer. |
| 1523 | bool doesNotCapture(unsigned OpNo) const { |
| 1524 | return dataOperandHasImpliedAttr(OpNo + 1, Attribute::NoCapture); |
| 1525 | } |
| 1526 | |
| 1527 | /// Determine whether this argument is passed by value. |
| 1528 | bool isByValArgument(unsigned ArgNo) const { |
| 1529 | return paramHasAttr(ArgNo, Attribute::ByVal); |
| 1530 | } |
| 1531 | |
| 1532 | /// Determine whether this argument is passed in an alloca. |
| 1533 | bool isInAllocaArgument(unsigned ArgNo) const { |
| 1534 | return paramHasAttr(ArgNo, Attribute::InAlloca); |
| 1535 | } |
| 1536 | |
| 1537 | /// Determine whether this argument is passed by value or in an alloca. |
| 1538 | bool isByValOrInAllocaArgument(unsigned ArgNo) const { |
| 1539 | return paramHasAttr(ArgNo, Attribute::ByVal) || |
| 1540 | paramHasAttr(ArgNo, Attribute::InAlloca); |
| 1541 | } |
| 1542 | |
| 1543 | /// Determine if there are is an inalloca argument. Only the last argument can |
| 1544 | /// have the inalloca attribute. |
| 1545 | bool hasInAllocaArgument() const { |
| 1546 | return !arg_empty() && paramHasAttr(arg_size() - 1, Attribute::InAlloca); |
| 1547 | } |
| 1548 | |
| 1549 | // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to |
| 1550 | // better indicate that this may return a conservative answer. |
| 1551 | bool doesNotAccessMemory(unsigned OpNo) const { |
| 1552 | return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone); |
| 1553 | } |
| 1554 | |
| 1555 | // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to |
| 1556 | // better indicate that this may return a conservative answer. |
| 1557 | bool onlyReadsMemory(unsigned OpNo) const { |
| 1558 | return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadOnly) || |
| 1559 | dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone); |
| 1560 | } |
| 1561 | |
| 1562 | // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to |
| 1563 | // better indicate that this may return a conservative answer. |
| 1564 | bool doesNotReadMemory(unsigned OpNo) const { |
| 1565 | return dataOperandHasImpliedAttr(OpNo + 1, Attribute::WriteOnly) || |
| 1566 | dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone); |
| 1567 | } |
| 1568 | |
| 1569 | /// Extract the alignment of the return value. |
| 1570 | unsigned getRetAlignment() const { return Attrs.getRetAlignment(); } |
| 1571 | |
| 1572 | /// Extract the alignment for a call or parameter (0=unknown). |
| 1573 | unsigned getParamAlignment(unsigned ArgNo) const { |
| 1574 | return Attrs.getParamAlignment(ArgNo); |
| 1575 | } |
| 1576 | |
| 1577 | /// Extract the byval type for a call or parameter. |
| 1578 | Type *getParamByValType(unsigned ArgNo) const { |
| 1579 | Type *Ty = Attrs.getParamByValType(ArgNo); |
| 1580 | return Ty ? Ty : getArgOperand(ArgNo)->getType()->getPointerElementType(); |
| 1581 | } |
| 1582 | |
| 1583 | /// Extract the number of dereferenceable bytes for a call or |
| 1584 | /// parameter (0=unknown). |
| 1585 | uint64_t getDereferenceableBytes(unsigned i) const { |
| 1586 | return Attrs.getDereferenceableBytes(i); |
| 1587 | } |
| 1588 | |
| 1589 | /// Extract the number of dereferenceable_or_null bytes for a call or |
| 1590 | /// parameter (0=unknown). |
| 1591 | uint64_t getDereferenceableOrNullBytes(unsigned i) const { |
| 1592 | return Attrs.getDereferenceableOrNullBytes(i); |
| 1593 | } |
| 1594 | |
| 1595 | /// Return true if the return value is known to be not null. |
| 1596 | /// This may be because it has the nonnull attribute, or because at least |
| 1597 | /// one byte is dereferenceable and the pointer is in addrspace(0). |
| 1598 | bool isReturnNonNull() const; |
| 1599 | |
| 1600 | /// Determine if the return value is marked with NoAlias attribute. |
| 1601 | bool returnDoesNotAlias() const { |
| 1602 | return Attrs.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias); |
| 1603 | } |
| 1604 | |
| 1605 | /// If one of the arguments has the 'returned' attribute, returns its |
| 1606 | /// operand value. Otherwise, return nullptr. |
| 1607 | Value *getReturnedArgOperand() const; |
| 1608 | |
| 1609 | /// Return true if the call should not be treated as a call to a |
| 1610 | /// builtin. |
| 1611 | bool isNoBuiltin() const { |
| 1612 | return hasFnAttrImpl(Attribute::NoBuiltin) && |
| 1613 | !hasFnAttrImpl(Attribute::Builtin); |
| 1614 | } |
| 1615 | |
| 1616 | /// Determine if the call requires strict floating point semantics. |
| 1617 | bool isStrictFP() const { return hasFnAttr(Attribute::StrictFP); } |
| 1618 | |
| 1619 | /// Return true if the call should not be inlined. |
| 1620 | bool isNoInline() const { return hasFnAttr(Attribute::NoInline); } |
| 1621 | void setIsNoInline() { |
| 1622 | addAttribute(AttributeList::FunctionIndex, Attribute::NoInline); |
| 1623 | } |
| 1624 | /// Determine if the call does not access memory. |
| 1625 | bool doesNotAccessMemory() const { return hasFnAttr(Attribute::ReadNone); } |
| 1626 | void setDoesNotAccessMemory() { |
| 1627 | addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone); |
| 1628 | } |
| 1629 | |
| 1630 | /// Determine if the call does not access or only reads memory. |
| 1631 | bool onlyReadsMemory() const { |
| 1632 | return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly); |
| 1633 | } |
| 1634 | void setOnlyReadsMemory() { |
| 1635 | addAttribute(AttributeList::FunctionIndex, Attribute::ReadOnly); |
| 1636 | } |
| 1637 | |
| 1638 | /// Determine if the call does not access or only writes memory. |
| 1639 | bool doesNotReadMemory() const { |
| 1640 | return doesNotAccessMemory() || hasFnAttr(Attribute::WriteOnly); |
| 1641 | } |
| 1642 | void setDoesNotReadMemory() { |
| 1643 | addAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly); |
| 1644 | } |
| 1645 | |
| 1646 | /// Determine if the call can access memmory only using pointers based |
| 1647 | /// on its arguments. |
| 1648 | bool onlyAccessesArgMemory() const { |
| 1649 | return hasFnAttr(Attribute::ArgMemOnly); |
| 1650 | } |
| 1651 | void setOnlyAccessesArgMemory() { |
| 1652 | addAttribute(AttributeList::FunctionIndex, Attribute::ArgMemOnly); |
| 1653 | } |
| 1654 | |
| 1655 | /// Determine if the function may only access memory that is |
| 1656 | /// inaccessible from the IR. |
| 1657 | bool onlyAccessesInaccessibleMemory() const { |
| 1658 | return hasFnAttr(Attribute::InaccessibleMemOnly); |
| 1659 | } |
| 1660 | void setOnlyAccessesInaccessibleMemory() { |
| 1661 | addAttribute(AttributeList::FunctionIndex, Attribute::InaccessibleMemOnly); |
| 1662 | } |
| 1663 | |
| 1664 | /// Determine if the function may only access memory that is |
| 1665 | /// either inaccessible from the IR or pointed to by its arguments. |
| 1666 | bool onlyAccessesInaccessibleMemOrArgMem() const { |
| 1667 | return hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly); |
| 1668 | } |
| 1669 | void setOnlyAccessesInaccessibleMemOrArgMem() { |
| 1670 | addAttribute(AttributeList::FunctionIndex, |
| 1671 | Attribute::InaccessibleMemOrArgMemOnly); |
| 1672 | } |
| 1673 | /// Determine if the call cannot return. |
| 1674 | bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); } |
| 1675 | void setDoesNotReturn() { |
| 1676 | addAttribute(AttributeList::FunctionIndex, Attribute::NoReturn); |
| 1677 | } |
| 1678 | |
| 1679 | /// Determine if the call should not perform indirect branch tracking. |
| 1680 | bool doesNoCfCheck() const { return hasFnAttr(Attribute::NoCfCheck); } |
| 1681 | |
| 1682 | /// Determine if the call cannot unwind. |
| 1683 | bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); } |
| 1684 | void setDoesNotThrow() { |
| 1685 | addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind); |
| 1686 | } |
| 1687 | |
| 1688 | /// Determine if the invoke cannot be duplicated. |
| 1689 | bool cannotDuplicate() const { return hasFnAttr(Attribute::NoDuplicate); } |
| 1690 | void setCannotDuplicate() { |
| 1691 | addAttribute(AttributeList::FunctionIndex, Attribute::NoDuplicate); |
| 1692 | } |
| 1693 | |
| 1694 | /// Determine if the invoke is convergent |
| 1695 | bool isConvergent() const { return hasFnAttr(Attribute::Convergent); } |
| 1696 | void setConvergent() { |
| 1697 | addAttribute(AttributeList::FunctionIndex, Attribute::Convergent); |
| 1698 | } |
| 1699 | void setNotConvergent() { |
| 1700 | removeAttribute(AttributeList::FunctionIndex, Attribute::Convergent); |
| 1701 | } |
| 1702 | |
| 1703 | /// Determine if the call returns a structure through first |
| 1704 | /// pointer argument. |
| 1705 | bool hasStructRetAttr() const { |
| 1706 | if (getNumArgOperands() == 0) |
| 1707 | return false; |
| 1708 | |
| 1709 | // Be friendly and also check the callee. |
| 1710 | return paramHasAttr(0, Attribute::StructRet); |
| 1711 | } |
| 1712 | |
| 1713 | /// Determine if any call argument is an aggregate passed by value. |
| 1714 | bool hasByValArgument() const { |
| 1715 | return Attrs.hasAttrSomewhere(Attribute::ByVal); |
| 1716 | } |
| 1717 | |
| 1718 | ///@{ |
| 1719 | // End of attribute API. |
| 1720 | |
| 1721 | /// \name Operand Bundle API |
| 1722 | /// |
| 1723 | /// This group of methods provides the API to access and manipulate operand |
| 1724 | /// bundles on this call. |
| 1725 | /// @{ |
| 1726 | |
| 1727 | /// Return the number of operand bundles associated with this User. |
| 1728 | unsigned getNumOperandBundles() const { |
| 1729 | return std::distance(bundle_op_info_begin(), bundle_op_info_end()); |
| 1730 | } |
| 1731 | |
| 1732 | /// Return true if this User has any operand bundles. |
| 1733 | bool hasOperandBundles() const { return getNumOperandBundles() != 0; } |
| 1734 | |
| 1735 | /// Return the index of the first bundle operand in the Use array. |
| 1736 | unsigned getBundleOperandsStartIndex() const { |
| 1737 | assert(hasOperandBundles() && "Don't call otherwise!")((hasOperandBundles() && "Don't call otherwise!") ? static_cast <void> (0) : __assert_fail ("hasOperandBundles() && \"Don't call otherwise!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1737, __PRETTY_FUNCTION__)); |
| 1738 | return bundle_op_info_begin()->Begin; |
| 1739 | } |
| 1740 | |
| 1741 | /// Return the index of the last bundle operand in the Use array. |
| 1742 | unsigned getBundleOperandsEndIndex() const { |
| 1743 | assert(hasOperandBundles() && "Don't call otherwise!")((hasOperandBundles() && "Don't call otherwise!") ? static_cast <void> (0) : __assert_fail ("hasOperandBundles() && \"Don't call otherwise!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1743, __PRETTY_FUNCTION__)); |
| 1744 | return bundle_op_info_end()[-1].End; |
| 1745 | } |
| 1746 | |
| 1747 | /// Return true if the operand at index \p Idx is a bundle operand. |
| 1748 | bool isBundleOperand(unsigned Idx) const { |
| 1749 | return hasOperandBundles() && Idx >= getBundleOperandsStartIndex() && |
| 1750 | Idx < getBundleOperandsEndIndex(); |
| 1751 | } |
| 1752 | |
| 1753 | /// Returns true if the use is a bundle operand. |
| 1754 | bool isBundleOperand(const Use *U) const { |
| 1755 | assert(this == U->getUser() &&((this == U->getUser() && "Only valid to query with a use of this instruction!" ) ? static_cast<void> (0) : __assert_fail ("this == U->getUser() && \"Only valid to query with a use of this instruction!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1756, __PRETTY_FUNCTION__)) |
| 1756 | "Only valid to query with a use of this instruction!")((this == U->getUser() && "Only valid to query with a use of this instruction!" ) ? static_cast<void> (0) : __assert_fail ("this == U->getUser() && \"Only valid to query with a use of this instruction!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1756, __PRETTY_FUNCTION__)); |
| 1757 | return hasOperandBundles() && isBundleOperand(U - op_begin()); |
| 1758 | } |
| 1759 | bool isBundleOperand(Value::const_user_iterator UI) const { |
| 1760 | return isBundleOperand(&UI.getUse()); |
| 1761 | } |
| 1762 | |
| 1763 | /// Return the total number operands (not operand bundles) used by |
| 1764 | /// every operand bundle in this OperandBundleUser. |
| 1765 | unsigned getNumTotalBundleOperands() const { |
| 1766 | if (!hasOperandBundles()) |
| 1767 | return 0; |
| 1768 | |
| 1769 | unsigned Begin = getBundleOperandsStartIndex(); |
| 1770 | unsigned End = getBundleOperandsEndIndex(); |
| 1771 | |
| 1772 | assert(Begin <= End && "Should be!")((Begin <= End && "Should be!") ? static_cast<void > (0) : __assert_fail ("Begin <= End && \"Should be!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1772, __PRETTY_FUNCTION__)); |
| 1773 | return End - Begin; |
| 1774 | } |
| 1775 | |
| 1776 | /// Return the operand bundle at a specific index. |
| 1777 | OperandBundleUse getOperandBundleAt(unsigned Index) const { |
| 1778 | assert(Index < getNumOperandBundles() && "Index out of bounds!")((Index < getNumOperandBundles() && "Index out of bounds!" ) ? static_cast<void> (0) : __assert_fail ("Index < getNumOperandBundles() && \"Index out of bounds!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1778, __PRETTY_FUNCTION__)); |
| 1779 | return operandBundleFromBundleOpInfo(*(bundle_op_info_begin() + Index)); |
| 1780 | } |
| 1781 | |
| 1782 | /// Return the number of operand bundles with the tag Name attached to |
| 1783 | /// this instruction. |
| 1784 | unsigned countOperandBundlesOfType(StringRef Name) const { |
| 1785 | unsigned Count = 0; |
| 1786 | for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) |
| 1787 | if (getOperandBundleAt(i).getTagName() == Name) |
| 1788 | Count++; |
| 1789 | |
| 1790 | return Count; |
| 1791 | } |
| 1792 | |
| 1793 | /// Return the number of operand bundles with the tag ID attached to |
| 1794 | /// this instruction. |
| 1795 | unsigned countOperandBundlesOfType(uint32_t ID) const { |
| 1796 | unsigned Count = 0; |
| 1797 | for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) |
| 1798 | if (getOperandBundleAt(i).getTagID() == ID) |
| 1799 | Count++; |
| 1800 | |
| 1801 | return Count; |
| 1802 | } |
| 1803 | |
| 1804 | /// Return an operand bundle by name, if present. |
| 1805 | /// |
| 1806 | /// It is an error to call this for operand bundle types that may have |
| 1807 | /// multiple instances of them on the same instruction. |
| 1808 | Optional<OperandBundleUse> getOperandBundle(StringRef Name) const { |
| 1809 | assert(countOperandBundlesOfType(Name) < 2 && "Precondition violated!")((countOperandBundlesOfType(Name) < 2 && "Precondition violated!" ) ? static_cast<void> (0) : __assert_fail ("countOperandBundlesOfType(Name) < 2 && \"Precondition violated!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1809, __PRETTY_FUNCTION__)); |
| 1810 | |
| 1811 | for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) { |
| 1812 | OperandBundleUse U = getOperandBundleAt(i); |
| 1813 | if (U.getTagName() == Name) |
| 1814 | return U; |
| 1815 | } |
| 1816 | |
| 1817 | return None; |
| 1818 | } |
| 1819 | |
| 1820 | /// Return an operand bundle by tag ID, if present. |
| 1821 | /// |
| 1822 | /// It is an error to call this for operand bundle types that may have |
| 1823 | /// multiple instances of them on the same instruction. |
| 1824 | Optional<OperandBundleUse> getOperandBundle(uint32_t ID) const { |
| 1825 | assert(countOperandBundlesOfType(ID) < 2 && "Precondition violated!")((countOperandBundlesOfType(ID) < 2 && "Precondition violated!" ) ? static_cast<void> (0) : __assert_fail ("countOperandBundlesOfType(ID) < 2 && \"Precondition violated!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1825, __PRETTY_FUNCTION__)); |
| 1826 | |
| 1827 | for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) { |
| 1828 | OperandBundleUse U = getOperandBundleAt(i); |
| 1829 | if (U.getTagID() == ID) |
| 1830 | return U; |
| 1831 | } |
| 1832 | |
| 1833 | return None; |
| 1834 | } |
| 1835 | |
| 1836 | /// Return the list of operand bundles attached to this instruction as |
| 1837 | /// a vector of OperandBundleDefs. |
| 1838 | /// |
| 1839 | /// This function copies the OperandBundeUse instances associated with this |
| 1840 | /// OperandBundleUser to a vector of OperandBundleDefs. Note: |
| 1841 | /// OperandBundeUses and OperandBundleDefs are non-trivially *different* |
| 1842 | /// representations of operand bundles (see documentation above). |
| 1843 | void getOperandBundlesAsDefs(SmallVectorImpl<OperandBundleDef> &Defs) const { |
| 1844 | for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) |
| 1845 | Defs.emplace_back(getOperandBundleAt(i)); |
| 1846 | } |
| 1847 | |
| 1848 | /// Return the operand bundle for the operand at index OpIdx. |
| 1849 | /// |
| 1850 | /// It is an error to call this with an OpIdx that does not correspond to an |
| 1851 | /// bundle operand. |
| 1852 | OperandBundleUse getOperandBundleForOperand(unsigned OpIdx) const { |
| 1853 | return operandBundleFromBundleOpInfo(getBundleOpInfoForOperand(OpIdx)); |
| 1854 | } |
| 1855 | |
| 1856 | /// Return true if this operand bundle user has operand bundles that |
| 1857 | /// may read from the heap. |
| 1858 | bool hasReadingOperandBundles() const { |
| 1859 | // Implementation note: this is a conservative implementation of operand |
| 1860 | // bundle semantics, where *any* operand bundle forces a callsite to be at |
| 1861 | // least readonly. |
| 1862 | return hasOperandBundles(); |
| 1863 | } |
| 1864 | |
| 1865 | /// Return true if this operand bundle user has operand bundles that |
| 1866 | /// may write to the heap. |
| 1867 | bool hasClobberingOperandBundles() const { |
| 1868 | for (auto &BOI : bundle_op_infos()) { |
| 1869 | if (BOI.Tag->second == LLVMContext::OB_deopt || |
| 1870 | BOI.Tag->second == LLVMContext::OB_funclet) |
| 1871 | continue; |
| 1872 | |
| 1873 | // This instruction has an operand bundle that is not known to us. |
| 1874 | // Assume the worst. |
| 1875 | return true; |
| 1876 | } |
| 1877 | |
| 1878 | return false; |
| 1879 | } |
| 1880 | |
| 1881 | /// Return true if the bundle operand at index \p OpIdx has the |
| 1882 | /// attribute \p A. |
| 1883 | bool bundleOperandHasAttr(unsigned OpIdx, Attribute::AttrKind A) const { |
| 1884 | auto &BOI = getBundleOpInfoForOperand(OpIdx); |
| 1885 | auto OBU = operandBundleFromBundleOpInfo(BOI); |
| 1886 | return OBU.operandHasAttr(OpIdx - BOI.Begin, A); |
| 1887 | } |
| 1888 | |
| 1889 | /// Return true if \p Other has the same sequence of operand bundle |
| 1890 | /// tags with the same number of operands on each one of them as this |
| 1891 | /// OperandBundleUser. |
| 1892 | bool hasIdenticalOperandBundleSchema(const CallBase &Other) const { |
| 1893 | if (getNumOperandBundles() != Other.getNumOperandBundles()) |
| 1894 | return false; |
| 1895 | |
| 1896 | return std::equal(bundle_op_info_begin(), bundle_op_info_end(), |
| 1897 | Other.bundle_op_info_begin()); |
| 1898 | } |
| 1899 | |
| 1900 | /// Return true if this operand bundle user contains operand bundles |
| 1901 | /// with tags other than those specified in \p IDs. |
| 1902 | bool hasOperandBundlesOtherThan(ArrayRef<uint32_t> IDs) const { |
| 1903 | for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) { |
| 1904 | uint32_t ID = getOperandBundleAt(i).getTagID(); |
| 1905 | if (!is_contained(IDs, ID)) |
| 1906 | return true; |
| 1907 | } |
| 1908 | return false; |
| 1909 | } |
| 1910 | |
| 1911 | /// Is the function attribute S disallowed by some operand bundle on |
| 1912 | /// this operand bundle user? |
| 1913 | bool isFnAttrDisallowedByOpBundle(StringRef S) const { |
| 1914 | // Operand bundles only possibly disallow readnone, readonly and argmenonly |
| 1915 | // attributes. All String attributes are fine. |
| 1916 | return false; |
| 1917 | } |
| 1918 | |
| 1919 | /// Is the function attribute A disallowed by some operand bundle on |
| 1920 | /// this operand bundle user? |
| 1921 | bool isFnAttrDisallowedByOpBundle(Attribute::AttrKind A) const { |
| 1922 | switch (A) { |
| 1923 | default: |
| 1924 | return false; |
| 1925 | |
| 1926 | case Attribute::InaccessibleMemOrArgMemOnly: |
| 1927 | return hasReadingOperandBundles(); |
| 1928 | |
| 1929 | case Attribute::InaccessibleMemOnly: |
| 1930 | return hasReadingOperandBundles(); |
| 1931 | |
| 1932 | case Attribute::ArgMemOnly: |
| 1933 | return hasReadingOperandBundles(); |
| 1934 | |
| 1935 | case Attribute::ReadNone: |
| 1936 | return hasReadingOperandBundles(); |
| 1937 | |
| 1938 | case Attribute::ReadOnly: |
| 1939 | return hasClobberingOperandBundles(); |
| 1940 | } |
| 1941 | |
| 1942 | llvm_unreachable("switch has a default case!")::llvm::llvm_unreachable_internal("switch has a default case!" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 1942); |
| 1943 | } |
| 1944 | |
| 1945 | /// Used to keep track of an operand bundle. See the main comment on |
| 1946 | /// OperandBundleUser above. |
| 1947 | struct BundleOpInfo { |
| 1948 | /// The operand bundle tag, interned by |
| 1949 | /// LLVMContextImpl::getOrInsertBundleTag. |
| 1950 | StringMapEntry<uint32_t> *Tag; |
| 1951 | |
| 1952 | /// The index in the Use& vector where operands for this operand |
| 1953 | /// bundle starts. |
| 1954 | uint32_t Begin; |
| 1955 | |
| 1956 | /// The index in the Use& vector where operands for this operand |
| 1957 | /// bundle ends. |
| 1958 | uint32_t End; |
| 1959 | |
| 1960 | bool operator==(const BundleOpInfo &Other) const { |
| 1961 | return Tag == Other.Tag && Begin == Other.Begin && End == Other.End; |
| 1962 | } |
| 1963 | }; |
| 1964 | |
| 1965 | /// Simple helper function to map a BundleOpInfo to an |
| 1966 | /// OperandBundleUse. |
| 1967 | OperandBundleUse |
| 1968 | operandBundleFromBundleOpInfo(const BundleOpInfo &BOI) const { |
| 1969 | auto begin = op_begin(); |
| 1970 | ArrayRef<Use> Inputs(begin + BOI.Begin, begin + BOI.End); |
| 1971 | return OperandBundleUse(BOI.Tag, Inputs); |
| 1972 | } |
| 1973 | |
| 1974 | using bundle_op_iterator = BundleOpInfo *; |
| 1975 | using const_bundle_op_iterator = const BundleOpInfo *; |
| 1976 | |
| 1977 | /// Return the start of the list of BundleOpInfo instances associated |
| 1978 | /// with this OperandBundleUser. |
| 1979 | /// |
| 1980 | /// OperandBundleUser uses the descriptor area co-allocated with the host User |
| 1981 | /// to store some meta information about which operands are "normal" operands, |
| 1982 | /// and which ones belong to some operand bundle. |
| 1983 | /// |
| 1984 | /// The layout of an operand bundle user is |
| 1985 | /// |
| 1986 | /// +-----------uint32_t End-------------------------------------+ |
| 1987 | /// | | |
| 1988 | /// | +--------uint32_t Begin--------------------+ | |
| 1989 | /// | | | | |
| 1990 | /// ^ ^ v v |
| 1991 | /// |------|------|----|----|----|----|----|---------|----|---------|----|----- |
| 1992 | /// | BOI0 | BOI1 | .. | DU | U0 | U1 | .. | BOI0_U0 | .. | BOI1_U0 | .. | Un |
| 1993 | /// |------|------|----|----|----|----|----|---------|----|---------|----|----- |
| 1994 | /// v v ^ ^ |
| 1995 | /// | | | | |
| 1996 | /// | +--------uint32_t Begin------------+ | |
| 1997 | /// | | |
| 1998 | /// +-----------uint32_t End-----------------------------+ |
| 1999 | /// |
| 2000 | /// |
| 2001 | /// BOI0, BOI1 ... are descriptions of operand bundles in this User's use |
| 2002 | /// list. These descriptions are installed and managed by this class, and |
| 2003 | /// they're all instances of OperandBundleUser<T>::BundleOpInfo. |
| 2004 | /// |
| 2005 | /// DU is an additional descriptor installed by User's 'operator new' to keep |
| 2006 | /// track of the 'BOI0 ... BOIN' co-allocation. OperandBundleUser does not |
| 2007 | /// access or modify DU in any way, it's an implementation detail private to |
| 2008 | /// User. |
| 2009 | /// |
| 2010 | /// The regular Use& vector for the User starts at U0. The operand bundle |
| 2011 | /// uses are part of the Use& vector, just like normal uses. In the diagram |
| 2012 | /// above, the operand bundle uses start at BOI0_U0. Each instance of |
| 2013 | /// BundleOpInfo has information about a contiguous set of uses constituting |
| 2014 | /// an operand bundle, and the total set of operand bundle uses themselves |
| 2015 | /// form a contiguous set of uses (i.e. there are no gaps between uses |
| 2016 | /// corresponding to individual operand bundles). |
| 2017 | /// |
| 2018 | /// This class does not know the location of the set of operand bundle uses |
| 2019 | /// within the use list -- that is decided by the User using this class via |
| 2020 | /// the BeginIdx argument in populateBundleOperandInfos. |
| 2021 | /// |
| 2022 | /// Currently operand bundle users with hung-off operands are not supported. |
| 2023 | bundle_op_iterator bundle_op_info_begin() { |
| 2024 | if (!hasDescriptor()) |
| 2025 | return nullptr; |
| 2026 | |
| 2027 | uint8_t *BytesBegin = getDescriptor().begin(); |
| 2028 | return reinterpret_cast<bundle_op_iterator>(BytesBegin); |
| 2029 | } |
| 2030 | |
| 2031 | /// Return the start of the list of BundleOpInfo instances associated |
| 2032 | /// with this OperandBundleUser. |
| 2033 | const_bundle_op_iterator bundle_op_info_begin() const { |
| 2034 | auto *NonConstThis = const_cast<CallBase *>(this); |
| 2035 | return NonConstThis->bundle_op_info_begin(); |
| 2036 | } |
| 2037 | |
| 2038 | /// Return the end of the list of BundleOpInfo instances associated |
| 2039 | /// with this OperandBundleUser. |
| 2040 | bundle_op_iterator bundle_op_info_end() { |
| 2041 | if (!hasDescriptor()) |
| 2042 | return nullptr; |
| 2043 | |
| 2044 | uint8_t *BytesEnd = getDescriptor().end(); |
| 2045 | return reinterpret_cast<bundle_op_iterator>(BytesEnd); |
| 2046 | } |
| 2047 | |
| 2048 | /// Return the end of the list of BundleOpInfo instances associated |
| 2049 | /// with this OperandBundleUser. |
| 2050 | const_bundle_op_iterator bundle_op_info_end() const { |
| 2051 | auto *NonConstThis = const_cast<CallBase *>(this); |
| 2052 | return NonConstThis->bundle_op_info_end(); |
| 2053 | } |
| 2054 | |
| 2055 | /// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end). |
| 2056 | iterator_range<bundle_op_iterator> bundle_op_infos() { |
| 2057 | return make_range(bundle_op_info_begin(), bundle_op_info_end()); |
| 2058 | } |
| 2059 | |
| 2060 | /// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end). |
| 2061 | iterator_range<const_bundle_op_iterator> bundle_op_infos() const { |
| 2062 | return make_range(bundle_op_info_begin(), bundle_op_info_end()); |
| 2063 | } |
| 2064 | |
| 2065 | /// Populate the BundleOpInfo instances and the Use& vector from \p |
| 2066 | /// Bundles. Return the op_iterator pointing to the Use& one past the last |
| 2067 | /// last bundle operand use. |
| 2068 | /// |
| 2069 | /// Each \p OperandBundleDef instance is tracked by a OperandBundleInfo |
| 2070 | /// instance allocated in this User's descriptor. |
| 2071 | op_iterator populateBundleOperandInfos(ArrayRef<OperandBundleDef> Bundles, |
| 2072 | const unsigned BeginIndex); |
| 2073 | |
| 2074 | /// Return the BundleOpInfo for the operand at index OpIdx. |
| 2075 | /// |
| 2076 | /// It is an error to call this with an OpIdx that does not correspond to an |
| 2077 | /// bundle operand. |
| 2078 | const BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx) const { |
| 2079 | for (auto &BOI : bundle_op_infos()) |
| 2080 | if (BOI.Begin <= OpIdx && OpIdx < BOI.End) |
| 2081 | return BOI; |
| 2082 | |
| 2083 | llvm_unreachable("Did not find operand bundle for operand!")::llvm::llvm_unreachable_internal("Did not find operand bundle for operand!" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 2083); |
| 2084 | } |
| 2085 | |
| 2086 | protected: |
| 2087 | /// Return the total number of values used in \p Bundles. |
| 2088 | static unsigned CountBundleInputs(ArrayRef<OperandBundleDef> Bundles) { |
| 2089 | unsigned Total = 0; |
| 2090 | for (auto &B : Bundles) |
| 2091 | Total += B.input_size(); |
| 2092 | return Total; |
| 2093 | } |
| 2094 | |
| 2095 | /// @} |
| 2096 | // End of operand bundle API. |
| 2097 | |
| 2098 | private: |
| 2099 | bool hasFnAttrOnCalledFunction(Attribute::AttrKind Kind) const; |
| 2100 | bool hasFnAttrOnCalledFunction(StringRef Kind) const; |
| 2101 | |
| 2102 | template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const { |
| 2103 | if (Attrs.hasAttribute(AttributeList::FunctionIndex, Kind)) |
| 2104 | return true; |
| 2105 | |
| 2106 | // Operand bundles override attributes on the called function, but don't |
| 2107 | // override attributes directly present on the call instruction. |
| 2108 | if (isFnAttrDisallowedByOpBundle(Kind)) |
| 2109 | return false; |
| 2110 | |
| 2111 | return hasFnAttrOnCalledFunction(Kind); |
| 2112 | } |
| 2113 | }; |
| 2114 | |
| 2115 | template <> |
| 2116 | struct OperandTraits<CallBase> : public VariadicOperandTraits<CallBase, 1> {}; |
| 2117 | |
| 2118 | DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CallBase, Value)CallBase::op_iterator CallBase::op_begin() { return OperandTraits <CallBase>::op_begin(this); } CallBase::const_op_iterator CallBase::op_begin() const { return OperandTraits<CallBase >::op_begin(const_cast<CallBase*>(this)); } CallBase ::op_iterator CallBase::op_end() { return OperandTraits<CallBase >::op_end(this); } CallBase::const_op_iterator CallBase::op_end () const { return OperandTraits<CallBase>::op_end(const_cast <CallBase*>(this)); } Value *CallBase::getOperand(unsigned i_nocapture) const { ((i_nocapture < OperandTraits<CallBase >::operands(this) && "getOperand() out of range!") ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<CallBase>::operands(this) && \"getOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 2118, __PRETTY_FUNCTION__)); return cast_or_null<Value> ( OperandTraits<CallBase>::op_begin(const_cast<CallBase *>(this))[i_nocapture].get()); } void CallBase::setOperand (unsigned i_nocapture, Value *Val_nocapture) { ((i_nocapture < OperandTraits<CallBase>::operands(this) && "setOperand() out of range!" ) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<CallBase>::operands(this) && \"setOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 2118, __PRETTY_FUNCTION__)); OperandTraits<CallBase>:: op_begin(this)[i_nocapture] = Val_nocapture; } unsigned CallBase ::getNumOperands() const { return OperandTraits<CallBase> ::operands(this); } template <int Idx_nocapture> Use & CallBase::Op() { return this->OpFrom<Idx_nocapture>( this); } template <int Idx_nocapture> const Use &CallBase ::Op() const { return this->OpFrom<Idx_nocapture>(this ); } |
| 2119 | |
| 2120 | //===----------------------------------------------------------------------===// |
| 2121 | // FuncletPadInst Class |
| 2122 | //===----------------------------------------------------------------------===// |
| 2123 | class FuncletPadInst : public Instruction { |
| 2124 | private: |
| 2125 | FuncletPadInst(const FuncletPadInst &CPI); |
| 2126 | |
| 2127 | explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad, |
| 2128 | ArrayRef<Value *> Args, unsigned Values, |
| 2129 | const Twine &NameStr, Instruction *InsertBefore); |
| 2130 | explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad, |
| 2131 | ArrayRef<Value *> Args, unsigned Values, |
| 2132 | const Twine &NameStr, BasicBlock *InsertAtEnd); |
| 2133 | |
| 2134 | void init(Value *ParentPad, ArrayRef<Value *> Args, const Twine &NameStr); |
| 2135 | |
| 2136 | protected: |
| 2137 | // Note: Instruction needs to be a friend here to call cloneImpl. |
| 2138 | friend class Instruction; |
| 2139 | friend class CatchPadInst; |
| 2140 | friend class CleanupPadInst; |
| 2141 | |
| 2142 | FuncletPadInst *cloneImpl() const; |
| 2143 | |
| 2144 | public: |
| 2145 | /// Provide fast operand accessors |
| 2146 | DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void setOperand(unsigned, Value*); inline op_iterator op_begin(); inline const_op_iterator op_begin() const; inline op_iterator op_end(); inline const_op_iterator op_end() const; protected : template <int> inline Use &Op(); template <int > inline const Use &Op() const; public: inline unsigned getNumOperands() const; |
| 2147 | |
| 2148 | /// getNumArgOperands - Return the number of funcletpad arguments. |
| 2149 | /// |
| 2150 | unsigned getNumArgOperands() const { return getNumOperands() - 1; } |
| 2151 | |
| 2152 | /// Convenience accessors |
| 2153 | |
| 2154 | /// Return the outer EH-pad this funclet is nested within. |
| 2155 | /// |
| 2156 | /// Note: This returns the associated CatchSwitchInst if this FuncletPadInst |
| 2157 | /// is a CatchPadInst. |
| 2158 | Value *getParentPad() const { return Op<-1>(); } |
| 2159 | void setParentPad(Value *ParentPad) { |
| 2160 | assert(ParentPad)((ParentPad) ? static_cast<void> (0) : __assert_fail ("ParentPad" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 2160, __PRETTY_FUNCTION__)); |
| 2161 | Op<-1>() = ParentPad; |
| 2162 | } |
| 2163 | |
| 2164 | /// getArgOperand/setArgOperand - Return/set the i-th funcletpad argument. |
| 2165 | /// |
| 2166 | Value *getArgOperand(unsigned i) const { return getOperand(i); } |
| 2167 | void setArgOperand(unsigned i, Value *v) { setOperand(i, v); } |
| 2168 | |
| 2169 | /// arg_operands - iteration adapter for range-for loops. |
| 2170 | op_range arg_operands() { return op_range(op_begin(), op_end() - 1); } |
| 2171 | |
| 2172 | /// arg_operands - iteration adapter for range-for loops. |
| 2173 | const_op_range arg_operands() const { |
| 2174 | return const_op_range(op_begin(), op_end() - 1); |
| 2175 | } |
| 2176 | |
| 2177 | // Methods for support type inquiry through isa, cast, and dyn_cast: |
| 2178 | static bool classof(const Instruction *I) { return I->isFuncletPad(); } |
| 2179 | static bool classof(const Value *V) { |
| 2180 | return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| 2181 | } |
| 2182 | }; |
| 2183 | |
| 2184 | template <> |
| 2185 | struct OperandTraits<FuncletPadInst> |
| 2186 | : public VariadicOperandTraits<FuncletPadInst, /*MINARITY=*/1> {}; |
| 2187 | |
| 2188 | DEFINE_TRANSPARENT_OPERAND_ACCESSORS(FuncletPadInst, Value)FuncletPadInst::op_iterator FuncletPadInst::op_begin() { return OperandTraits<FuncletPadInst>::op_begin(this); } FuncletPadInst ::const_op_iterator FuncletPadInst::op_begin() const { return OperandTraits<FuncletPadInst>::op_begin(const_cast< FuncletPadInst*>(this)); } FuncletPadInst::op_iterator FuncletPadInst ::op_end() { return OperandTraits<FuncletPadInst>::op_end (this); } FuncletPadInst::const_op_iterator FuncletPadInst::op_end () const { return OperandTraits<FuncletPadInst>::op_end (const_cast<FuncletPadInst*>(this)); } Value *FuncletPadInst ::getOperand(unsigned i_nocapture) const { ((i_nocapture < OperandTraits<FuncletPadInst>::operands(this) && "getOperand() out of range!") ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<FuncletPadInst>::operands(this) && \"getOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 2188, __PRETTY_FUNCTION__)); return cast_or_null<Value> ( OperandTraits<FuncletPadInst>::op_begin(const_cast< FuncletPadInst*>(this))[i_nocapture].get()); } void FuncletPadInst ::setOperand(unsigned i_nocapture, Value *Val_nocapture) { (( i_nocapture < OperandTraits<FuncletPadInst>::operands (this) && "setOperand() out of range!") ? static_cast <void> (0) : __assert_fail ("i_nocapture < OperandTraits<FuncletPadInst>::operands(this) && \"setOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-10~svn374710/include/llvm/IR/InstrTypes.h" , 2188, __PRETTY_FUNCTION__)); OperandTraits<FuncletPadInst >::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned FuncletPadInst::getNumOperands() const { return OperandTraits <FuncletPadInst>::operands(this); } template <int Idx_nocapture > Use &FuncletPadInst::Op() { return this->OpFrom< Idx_nocapture>(this); } template <int Idx_nocapture> const Use &FuncletPadInst::Op() const { return this-> OpFrom<Idx_nocapture>(this); } |
| 2189 | |
| 2190 | } // end namespace llvm |
| 2191 | |
| 2192 | #endif // LLVM_IR_INSTRTYPES_H |