Fix remaining LLVM deprecations wrt. instructions as insert positions

Author: kinke

gen/funcgenstate.h

@@ -187,9 +187,6 @@ class FuncGenState {
   /// Tracks basic blocks corresponding to switch cases.
   SwitchCaseTargets switchTargets;
 
-  /// The marker at which to insert `alloca`s in the function entry bb.
-  llvm::Instruction *allocapoint = nullptr;
-
   /// alloca for the nested context of this function
   llvm::Value *nestedVar = nullptr;
 

gen/functions.cpp

@@ -1222,15 +1222,6 @@ void DtoDefineFunction(FuncDeclaration *fd, bool linkageAvailableExternally) {
     return;
   }
 
-  // create alloca point
-  // this gets erased when the function is complete, so alignment etc does not
-  // matter at all
-  llvm::Instruction *allocaPoint =
-      new llvm::AllocaInst(LLType::getInt32Ty(gIR->context()),
-                           0, // Address space
-                           "alloca_point", beginbb);
-  funcGen.allocapoint = allocaPoint;
-
   emitInstrumentationFnEnter(fd);
 
   if (global.params.trace && fd->emitInstrumentation && !fd->isCMain() &&
@@ -1339,13 +1330,6 @@ void DtoDefineFunction(FuncDeclaration *fd, bool linkageAvailableExternally) {
     }
   }
 
-  // erase alloca point
-  if (allocaPoint->getParent()) {
-    funcGen.allocapoint = nullptr;
-    allocaPoint->eraseFromParent();
-    allocaPoint = nullptr;
-  }
-
   if (gIR->dcomputetarget) {
     auto kernAttr = getKernelAttr(fd);
     if (kernAttr) {

gen/irstate.cpp

@@ -45,7 +45,18 @@ IrFunction *IRState::func() { return &funcGen().irFunc; }
 
 llvm::Function *IRState::topfunc() { return func()->getLLVMFunc(); }
 
-llvm::Instruction *IRState::topallocapoint() { return funcGen().allocapoint; }
+#if LDC_LLVM_VER >= 1900
+llvm::BasicBlock::iterator IRState::nextAllocaPos() {
+#else
+llvm::Instruction *IRState::nextAllocaPos() {
+#endif
+  auto it = topfunc()->getEntryBlock().getFirstNonPHIOrDbgOrAlloca();
+#if LDC_LLVM_VER >= 1900
+  return it;
+#else
+  return &(*it);
+#endif
+}
 
 std::unique_ptr<IRBuilderScope> IRState::setInsertPoint(llvm::BasicBlock *bb) {
   auto savedScope = std::make_unique<IRBuilderScope>(builder);

gen/irstate.h

@@ -155,7 +155,12 @@ struct IRState {
   FuncGenState &funcGen();
   IrFunction *func();
   llvm::Function *topfunc();
-  llvm::Instruction *topallocapoint();
+
+#if LDC_LLVM_VER >= 1900
+  llvm::BasicBlock::iterator nextAllocaPos();
+#else
+  llvm::Instruction *nextAllocaPos();
+#endif
 
   // Use this to set the IRBuilder's insertion point for a new function.
   // The previous IRBuilder state is restored when the returned value is

gen/llvmhelpers.cpp

@@ -174,7 +174,7 @@ llvm::AllocaInst *DtoArrayAlloca(Type *type, unsigned arraysize,
   LLType *lltype = DtoType(type);
   auto ai = new llvm::AllocaInst(
       lltype, gIR->module.getDataLayout().getAllocaAddrSpace(),
-      DtoConstUint(arraysize), name, gIR->topallocapoint());
+      DtoConstUint(arraysize), name, gIR->nextAllocaPos());
   if (auto alignment = DtoAlignment(type)) {
     ai->setAlignment(llvm::Align(alignment));
   }
@@ -185,7 +185,7 @@ llvm::AllocaInst *DtoRawAlloca(LLType *lltype, size_t alignment,
                                const char *name) {
   auto ai = new llvm::AllocaInst(
       lltype, gIR->module.getDataLayout().getAllocaAddrSpace(), name,
-      gIR->topallocapoint());
+      gIR->nextAllocaPos());
   if (alignment) {
     ai->setAlignment(llvm::Align(alignment));
   }

gen/passes/GarbageCollect2Stack.cpp

@@ -96,12 +96,16 @@ Value* FunctionInfo::promote(CallBase *CB, IRBuilder<> &B, const G2StackAnalysis
   NumGcToStack++;
 
   auto &BB = CB->getCaller()->getEntryBlock();
-  Instruction *Begin = &(*BB.begin());
 
   // FIXME: set alignment on alloca?
-  return new AllocaInst(Ty,
-      BB.getModule()->getDataLayout().getAllocaAddrSpace(),
-      ".nongc_mem", Begin);
+  return new AllocaInst(
+      Ty, BB.getModule()->getDataLayout().getAllocaAddrSpace(), ".nongc_mem",
+#if LDC_LLVM_VER >= 1900
+      BB.begin()
+#else
+      &(*BB.begin())
+#endif
+  );
 }
 
 static bool isKnownLessThan(Value *Val, uint64_t Limit, const G2StackAnalysis &A) {
@@ -347,7 +351,13 @@ static void RemoveCall(CallBase *CB, const G2StackAnalysis &A) {
   // immediately before it. Ideally, we would find a way to not invalidate
   // the dominator tree here.
   if (auto Invoke = dyn_cast<InvokeInst>(static_cast<Instruction *>(CB))) {
-    BranchInst::Create(Invoke->getNormalDest(), Invoke);
+    BranchInst::Create(Invoke->getNormalDest(),
+#if LDC_LLVM_VER >= 1900
+                       Invoke->getIterator()
+#else
+                       Invoke
+#endif
+    );
     Invoke->getUnwindDest()->removePredecessor(CB->getParent());
   }
 

gen/trycatchfinally.cpp

@@ -213,7 +213,7 @@ void emitBeginCatchMSVC(IRState &irs, Catch *ctch,
     // redirect scope to avoid the generation of debug info before the
     // catchpad
     const auto savedInsertPoint = irs.saveInsertPoint();
-    irs.ir->SetInsertPoint(gIR->topallocapoint());
+    irs.ir->SetInsertPoint(irs.nextAllocaPos());
     DtoVarDeclaration(var);
 
     // catch handler will be outlined, so always treat as a nested reference
@@ -332,6 +332,20 @@ CleanupScope::CleanupScope(llvm::BasicBlock *beginBlock,
     blocks.push_back(endBlock);
 }
 
+namespace {
+#if LDC_LLVM_VER >= 1900
+llvm::BasicBlock::iterator getTerminatorPos(llvm::BasicBlock *bb) {
+  auto it = bb->rbegin().getReverse();
+  assert(it->isTerminator());
+  return it;
+}
+#else
+llvm::Instruction *getTerminatorPos(llvm::BasicBlock *bb) {
+  return bb->getTerminator();
+}
+#endif
+} // anonymous namespace
+
 llvm::BasicBlock *CleanupScope::run(IRState &irs, llvm::BasicBlock *sourceBlock,
                                     llvm::BasicBlock *continueWith) {
   if (useMSVCEH())
@@ -359,12 +373,13 @@ llvm::BasicBlock *CleanupScope::run(IRState &irs, llvm::BasicBlock *sourceBlock,
     branchSelector = new llvm::AllocaInst(
         branchSelectorType, irs.module.getDataLayout().getAllocaAddrSpace(),
         llvm::Twine("branchsel.") + beginBlock()->getName(),
-        irs.topallocapoint());
+        irs.nextAllocaPos());
 
     // Now we also need to store 0 to it to keep the paths that go to the
     // only existing branch target the same.
     for (auto bb : exitTargets.front().sourceBlocks) {
-      new llvm::StoreInst(DtoConstUint(0), branchSelector, bb->getTerminator());
+      new llvm::StoreInst(DtoConstUint(0), branchSelector,
+                          getTerminatorPos(bb));
     }
 
     // And convert the BranchInst to the existing branch target to a
@@ -385,7 +400,7 @@ llvm::BasicBlock *CleanupScope::run(IRState &irs, llvm::BasicBlock *sourceBlock,
     CleanupExitTarget &t = exitTargets[i];
     if (t.branchTarget == continueWith) {
       new llvm::StoreInst(DtoConstUint(i), branchSelector,
-                          sourceBlock->getTerminator());
+                          getTerminatorPos(sourceBlock));
 
       // Note: Strictly speaking, keeping this up to date would not be
       // needed right now, because we never to any optimizations that
@@ -405,7 +420,7 @@ llvm::BasicBlock *CleanupScope::run(IRState &irs, llvm::BasicBlock *sourceBlock,
 
   // ... insert the store into the source block...
   new llvm::StoreInst(selectorVal, branchSelector,
-                      sourceBlock->getTerminator());
+                      getTerminatorPos(sourceBlock));
 
   // ... and keep track of it (again, this is unnecessary right now as
   // discussed in the above note).