OpaquePtr: IRBuilder: Add deprecated attribute on CreateCall methods

[nhaehnle]

Summary

Let's not remove them outright just yet, so that other projects get some
more explicit notice that they need to fix their code.

[nhaehnle]

Rebase on recent IRBuilder changes

[dblaikie]

Looks good to me - but wouldn't mind @t.p.northover checking here - so pinging him.

[efriedma]

Deprecating the APIs as an extra step is basically useless; most projects either build with -Werror or don't pay attention to warnings. Probably very few projects in the middle that would actually be helped. I'd be in favor of just zapping them. If you really think the error for downstream projects needs to be extra-clear, you could provide "= delete" overloads, I guess.

[nikic]

Ping. I'm happy with either a removal or deprecation here, but one of them should really go in...

[efriedma]

LGTM. Deprecation isn't strictly necessary, but it's more friendly to downstream projects, which are very likely to be using IRBuilder.

llvm/include/llvm/IR/IRBuilder.h

public:
 
   CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> OpBundles,
                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
     return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args,
                       OpBundles, Name, FPMathTag);
   }
 
-  // Deprecated [opaque pointer types]
-  CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args = None,
+  // Ordinarily, the FunctionCallee overloads above should be sufficient.
+  // These Function * and InlineAsm * overloads are required to hide the
+  // deprecated Value * overloads below.
+  CallInst *CreateCall(Function *Fn, ArrayRef<Value *> Args = None,
                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
-    return CreateCall(
-        cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
-        Args, Name, FPMathTag);
+    return CreateCall(FunctionCallee{Fn}, Args, Name, FPMathTag);
   }
 
-  // Deprecated [opaque pointer types]
-  CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args,
+  CallInst *CreateCall(Function *Fn, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> OpBundles,
                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
-    return CreateCall(
-        cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
-        Args, OpBundles, Name, FPMathTag);
+    return CreateCall(FunctionCallee{Fn}, Args, OpBundles, Name, FPMathTag);
   }
 
+  CallInst *CreateCall(InlineAsm *Fn, ArrayRef<Value *> Args = None,
+                       const Twine &Name = "", MDNode *FPMathTag = nullptr);
+
+  CallInst *CreateCall(InlineAsm *Fn, ArrayRef<Value *> Args,
+                       ArrayRef<OperandBundleDef> OpBundles,
+                       const Twine &Name = "", MDNode *FPMathTag = nullptr);
+
+  // Deprecated [opaque pointer types]
+  LLVM_ATTRIBUTE_DEPRECATED(CallInst *CreateCall(Value *Callee,
+                                                 ArrayRef<Value *> Args = None,
+                                                 const Twine &Name = "",
+                                                 MDNode *FPMathTag = nullptr),
+                            "Pointer types are opaque");
+  LLVM_ATTRIBUTE_DEPRECATED(
+      CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args,
+                           ArrayRef<OperandBundleDef> OpBundles,
+                           const Twine &Name = "", MDNode *FPMathTag = nullptr),
+      "Pointer types are opaque");
+
   CallInst *CreateConstrainedFPCall(
       Function *Callee, ArrayRef<Value *> Args, const Twine &Name = "",
       Optional<fp::RoundingMode> Rounding = None,
       Optional<fp::ExceptionBehavior> Except = None) {
     llvm::SmallVector<Value *, 6> UseArgs;
 
     for (auto *OneArg : Args)
       UseArgs.push_back(OneArg);
public:
 
   /// Avoid copying the full IRBuilder. Prefer using InsertPointGuard
   /// or FastMathFlagGuard instead.
   IRBuilder(const IRBuilder &) = delete;
 
   InserterTy &getInserter() { return Inserter; }
 };
 
+// Deprecated [opaque pointer types]
+inline CallInst *IRBuilderBase::CreateCall(Value *Callee,
+                                           ArrayRef<Value *> Args,
+                                           const Twine &Name,
+                                           MDNode *FPMathTag) {
+  return CreateCall(
+      cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
+      Args, Name, FPMathTag);
+}
+
+// Deprecated [opaque pointer types]
+inline CallInst *IRBuilderBase::CreateCall(Value *Callee,
+                                           ArrayRef<Value *> Args,
+                                           ArrayRef<OperandBundleDef> OpBundles,
+                                           const Twine &Name,
+                                           MDNode *FPMathTag) {
+  return CreateCall(
+      cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
+      Args, OpBundles, Name, FPMathTag);
+}
+
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef)
 
 } // end namespace llvm
 
 #endif // LLVM_IR_IRBUILDER_H

llvm/lib/IR/IRBuilder.cpp

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/NoFolder.h"
 #include "llvm/IR/Statepoint.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/MathExtras.h"
 #include <cassert>
 #include <cstdint>
 #include <vector>
CallInst *IRBuilderBase::CreateIntrinsic(Intrinsic::ID ID,
                                          ArrayRef<Value *> Args,
                                          Instruction *FMFSource,
                                          const Twine &Name) {
   Module *M = BB->getModule();
   Function *Fn = Intrinsic::getDeclaration(M, ID, Types);
   return createCallHelper(Fn, Args, this, Name, FMFSource);
 }
 
+CallInst *IRBuilderBase::CreateCall(InlineAsm *Fn, ArrayRef<Value *> Args,
+                                    const Twine &Name, MDNode *FPMathTag) {
+  return CreateCall(FunctionCallee{Fn}, Args, Name, FPMathTag);
+}
+
+CallInst *IRBuilderBase::CreateCall(InlineAsm *Fn, ArrayRef<Value *> Args,
+                                    ArrayRef<OperandBundleDef> OpBundles,
+                                    const Twine &Name, MDNode *FPMathTag) {
+  return CreateCall(FunctionCallee{Fn}, Args, OpBundles, Name, FPMathTag);
+}
+
 IRBuilderDefaultInserter::~IRBuilderDefaultInserter() {}
 IRBuilderCallbackInserter::~IRBuilderCallbackInserter() {}
 IRBuilderFolder::~IRBuilderFolder() {}
 void ConstantFolder::anchor() {}
 void NoFolder::anchor() {}