Remove legacy LLCallBasePtr

Author: kinke

gen/funcgenstate.cpp

@@ -103,10 +103,10 @@ FuncGenState::FuncGenState(IrFunction &irFunc, IRState &irs)
     : irFunc(irFunc), scopes(irs), localVariableLifetimeAnnotator(irs),
       jumpTargets(scopes), switchTargets(), irs(irs) {}
 
-LLCallBasePtr FuncGenState::callOrInvoke(llvm::Value *callee,
-                                         llvm::FunctionType *calleeType,
-                                         llvm::ArrayRef<llvm::Value *> args,
-                                         const char *name, bool isNothrow) {
+llvm::CallBase *FuncGenState::callOrInvoke(llvm::Value *callee,
+                                           llvm::FunctionType *calleeType,
+                                           llvm::ArrayRef<llvm::Value *> args,
+                                           const char *name, bool isNothrow) {
   // If this is a direct call, we might be able to use the callee attributes
   // to our advantage.
   llvm::Function *calleeFn = llvm::dyn_cast<llvm::Function>(callee);

gen/funcgenstate.h

@@ -202,10 +202,10 @@ class FuncGenState {
 
   /// Emits a call or invoke to the given callee, depending on whether there
   /// are catches/cleanups active or not.
-  LLCallBasePtr callOrInvoke(llvm::Value *callee,
-                             llvm::FunctionType *calleeType,
-                             llvm::ArrayRef<llvm::Value *> args,
-                             const char *name = "", bool isNothrow = false);
+  llvm::CallBase *callOrInvoke(llvm::Value *callee,
+                               llvm::FunctionType *calleeType,
+                               llvm::ArrayRef<llvm::Value *> args,
+                               const char *name = "", bool isNothrow = false);
 
 private:
   IRState &irs;

gen/llvm.h

@@ -60,5 +60,3 @@ using llvm::IRBuilder;
 #define LLConstantFP llvm::ConstantFP
 
 #define LLSmallVector llvm::SmallVector
-
-using LLCallBasePtr = llvm::CallBase *;

gen/passes/GarbageCollect2Stack.cpp

@@ -91,7 +91,7 @@ static void EmitMemZero(IRBuilder<> &B, Value *Dst, Value *Len,
 
 //namespace {
 
-Value* FunctionInfo::promote(LLCallBasePtr CB, IRBuilder<> &B, const G2StackAnalysis &A) {
+Value* FunctionInfo::promote(CallBase *CB, IRBuilder<> &B, const G2StackAnalysis &A) {
   NumGcToStack++;
 
   auto &BB = CB->getCaller()->getEntryBlock();
@@ -128,7 +128,7 @@ static bool isKnownLessThan(Value *Val, uint64_t Limit, const G2StackAnalysis &A
   return true;
 }
 
-bool TypeInfoFI::analyze(LLCallBasePtr CB, const G2StackAnalysis &A) {
+bool TypeInfoFI::analyze(CallBase *CB, const G2StackAnalysis &A) {
   Value *TypeInfo = CB->getArgOperand(TypeInfoArgNr);
   Ty = A.getTypeFor(TypeInfo, 0);
   if (!Ty) {
@@ -137,7 +137,7 @@ bool TypeInfoFI::analyze(LLCallBasePtr CB, const G2StackAnalysis &A) {
   return A.DL.getTypeAllocSize(Ty) < SizeLimit;
 }
 
-bool ArrayFI::analyze(LLCallBasePtr CB, const G2StackAnalysis &A) {
+bool ArrayFI::analyze(CallBase *CB, const G2StackAnalysis &A) {
   if (!TypeInfoFI::analyze(CB, A)) {
     return false;
   }
@@ -160,7 +160,7 @@ bool ArrayFI::analyze(LLCallBasePtr CB, const G2StackAnalysis &A) {
   return true;
 }
 
-Value* ArrayFI::promote(LLCallBasePtr CB, IRBuilder<> &B, const G2StackAnalysis &A) {
+Value* ArrayFI::promote(CallBase *CB, IRBuilder<> &B, const G2StackAnalysis &A) {
   // If the allocation is of constant size it's best to put it in the
   // entry block, so do so if we're not already there.
   // For dynamically-sized allocations it's best to avoid the overhead
@@ -203,7 +203,7 @@ Value* ArrayFI::promote(LLCallBasePtr CB, IRBuilder<> &B, const G2StackAnalysis
 
   return alloca;
 }
-bool AllocClassFI::analyze(LLCallBasePtr CB, const G2StackAnalysis &A) {
+bool AllocClassFI::analyze(CallBase *CB, const G2StackAnalysis &A) {
   if (CB->arg_size() != 1) {
     return false;
   }
@@ -238,7 +238,7 @@ bool AllocClassFI::analyze(LLCallBasePtr CB, const G2StackAnalysis &A) {
            ->getType();
   return A.DL.getTypeAllocSize(Ty) < SizeLimit;
 }
-bool UntypedMemoryFI::analyze(LLCallBasePtr CB, const G2StackAnalysis &A) {
+bool UntypedMemoryFI::analyze(CallBase *CB, const G2StackAnalysis &A) {
   if (CB->arg_size() < SizeArgNr + 1) {
     return false;
   }
@@ -260,7 +260,7 @@ bool UntypedMemoryFI::analyze(LLCallBasePtr CB, const G2StackAnalysis &A) {
   Ty = llvm::Type::getInt8Ty(CB->getContext());
   return true;
 }
-Value* UntypedMemoryFI::promote(LLCallBasePtr CB, IRBuilder<> &B, const G2StackAnalysis &A) {
+Value* UntypedMemoryFI::promote(CallBase *CB, IRBuilder<> &B, const G2StackAnalysis &A) {
   // If the allocation is of constant size it's best to put it in the
   // entry block, so do so if we're not already there.
   // For dynamically-sized allocations it's best to avoid the overhead
@@ -341,7 +341,7 @@ GarbageCollect2Stack::GarbageCollect2Stack()
       NewArrayT(ReturnType::Array, 0, 1, true), AllocMemory(0) {
 }
 
-static void RemoveCall(LLCallBasePtr CB, const G2StackAnalysis &A) {
+static void RemoveCall(CallBase *CB, const G2StackAnalysis &A) {
   // For an invoke instruction, we insert a branch to the normal target BB
   // immediately before it. Ideally, we would find a way to not invalidate
   // the dominator tree here.

gen/passes/GarbageCollect2Stack.h

@@ -27,11 +27,11 @@ class FunctionInfo {
 
   // Analyze the current call, filling in some fields. Returns true if
   // this is an allocation we can stack-allocate.
-  virtual bool analyze(LLCallBasePtr CB, const G2StackAnalysis &A) = 0;
+  virtual bool analyze(llvm::CallBase *CB, const G2StackAnalysis &A) = 0;
 
   // Returns the alloca to replace this call.
   // It will always be inserted before the call.
-  virtual llvm::Value *promote(LLCallBasePtr CB, IRBuilder<> &B, const G2StackAnalysis &A);
+  virtual llvm::Value *promote(llvm::CallBase *CB, IRBuilder<> &B, const G2StackAnalysis &A);
 
   explicit FunctionInfo(ReturnType::Type returnType) : ReturnType(returnType) {}
   virtual ~FunctionInfo() = default;
@@ -43,7 +43,7 @@ class TypeInfoFI : public FunctionInfo {
   TypeInfoFI(ReturnType::Type returnType, unsigned tiArgNr)
       : FunctionInfo(returnType), TypeInfoArgNr(tiArgNr) {}
 
-  bool analyze(LLCallBasePtr CB, const G2StackAnalysis &A) override;
+  bool analyze(llvm::CallBase *CB, const G2StackAnalysis &A) override;
 };
 class ArrayFI : public TypeInfoFI {
   int ArrSizeArgNr;
@@ -56,15 +56,15 @@ class ArrayFI : public TypeInfoFI {
       : TypeInfoFI(returnType, tiArgNr), ArrSizeArgNr(arrSizeArgNr),
         Initialized(initialized) {}
 
-  bool analyze(LLCallBasePtr CB, const G2StackAnalysis &A) override;
+  bool analyze(llvm::CallBase *CB, const G2StackAnalysis &A) override;
 
-  llvm::Value *promote(LLCallBasePtr CB, IRBuilder<> &B, const G2StackAnalysis &A) override;
+  llvm::Value *promote(llvm::CallBase *CB, IRBuilder<> &B, const G2StackAnalysis &A) override;
 
 };
 // FunctionInfo for _d_allocclass
 class AllocClassFI : public FunctionInfo {
 public:
-  bool analyze(LLCallBasePtr CB, const G2StackAnalysis &A) override;
+  bool analyze(llvm::CallBase *CB, const G2StackAnalysis &A) override;
 
   // The default promote() should be fine.
 
@@ -77,9 +77,9 @@ class UntypedMemoryFI : public FunctionInfo {
   llvm::Value *SizeArg;
 
 public:
-  bool analyze(LLCallBasePtr CB, const G2StackAnalysis &A) override;
+  bool analyze(llvm::CallBase *CB, const G2StackAnalysis &A) override;
 
-  llvm::Value *promote(LLCallBasePtr CB, IRBuilder<> &B, const G2StackAnalysis &A) override;
+  llvm::Value *promote(llvm::CallBase *CB, IRBuilder<> &B, const G2StackAnalysis &A) override;
 
   explicit UntypedMemoryFI(unsigned sizeArgNr)
       : FunctionInfo(ReturnType::Pointer), SizeArgNr(sizeArgNr) {}

gen/tocall.cpp

@@ -916,8 +916,8 @@ DValue *DtoCallFunction(const Loc &loc, Type *resulttype, DValue *fnval,
   }
 
   // call the function
-  LLCallBasePtr call = gIR->funcGen().callOrInvoke(callable, callableTy, args,
-                                                   "", tf->isnothrow());
+  llvm::CallBase *call = gIR->funcGen().callOrInvoke(callable, callableTy, args,
+                                                     "", tf->isnothrow());
 
   // PGO: Insert instrumentation or attach profile metadata at indirect call
   // sites.