Add deduction guides for IRBuilder

[kparzysz]

Summary

This will help in using CTAD with IRBuilder.

[kparzysz]

I'm not sure if we want/need all of these. Feedback welcome.

[kparzysz]

Ping.

[nikic]

For the uninitiated, could you provide an example of what practical impact this would have?

[kparzysz]

We have a policy that classes that are meant to be used in CTAD should have at least one deduction guide. There is a warning (-Wctad-maybe-unsupported) that was added to LLVM build options to warn about using CTAD with classes that may not have been intended to be auto-deduced. The practical impact of this change would be that we could "officially" use IRBuilder without explicitly specifying template argument (in compliance with the CTAD policy).

[dblaikie]

Maybe cover it with a unit test (or if it can be tested with a static_assert, that'd be great - but not sure it can)? Or not, not sure the guides are sufficiently interesting.

Do you have particular use cases in mind?

[kparzysz]

The use case for me was not having to write IRBuilder<InstSimplifyFolder>. Since we need at least one guide for CTAD, I added them for each constructor.

[kparzysz]

Added static_assert tests to the unit tests.

[dblaikie]

In D137173#3913066, @kparzysz wrote:

The use case for me was not having to write IRBuilder<InstSimplifyFolder>. Since we need at least one guide for CTAD, I added them for each constructor.

Fair enough, sounds good.

llvm/include/llvm/IR/IRBuilder.h

public:
 
   /// Avoid copying the full IRBuilder. Prefer using InsertPointGuard
   /// or FastMathFlagGuard instead.
   IRBuilder(const IRBuilder &) = delete;
 
   InserterTy &getInserter() { return Inserter; }
 };
 
+template <typename FolderTy, typename InserterTy>
+IRBuilder(LLVMContext &, FolderTy, InserterTy, MDNode *,
+          ArrayRef<OperandBundleDef>) -> IRBuilder<FolderTy, InserterTy>;
+IRBuilder(LLVMContext &, MDNode *, ArrayRef<OperandBundleDef>) -> IRBuilder<>;
+template <typename FolderTy>
+IRBuilder(BasicBlock *, FolderTy, MDNode *, ArrayRef<OperandBundleDef>)
+    -> IRBuilder<FolderTy>;
+IRBuilder(BasicBlock *, MDNode *, ArrayRef<OperandBundleDef>) -> IRBuilder<>;
+IRBuilder(Instruction *, MDNode *, ArrayRef<OperandBundleDef>) -> IRBuilder<>;
+template <typename FolderTy>
+IRBuilder(BasicBlock *, BasicBlock::iterator, FolderTy, MDNode *,
+          ArrayRef<OperandBundleDef>) -> IRBuilder<FolderTy>;
+IRBuilder(BasicBlock *, BasicBlock::iterator, MDNode *,
+          ArrayRef<OperandBundleDef>) -> IRBuilder<>;
+
+
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef)
 
 } // end namespace llvm
 
 #endif // LLVM_IR_IRBUILDER_H

llvm/unittests/IR/IRBuilderTest.cpp

 //===- llvm/unittest/IR/IRBuilderTest.cpp - IRBuilder tests ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Analysis/InstSimplifyFolder.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/IntrinsicsAArch64.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/NoFolder.h"
 #include "llvm/IR/Verifier.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+#include <type_traits>
+
 using namespace llvm;
 using ::testing::UnorderedElementsAre;
 
 namespace {
 
 class IRBuilderTest : public testing::Test {
 protected:
   void SetUp() override {

 }
 
 TEST_F(IRBuilderTest, NoFolderNames) {
   IRBuilder<NoFolder> Builder(BB);
   auto *Add =
       Builder.CreateAdd(Builder.getInt32(1), Builder.getInt32(2), "add");
   EXPECT_EQ(Add->getName(), "add");
 }
+
+TEST_F(IRBuilderTest, CTAD) {
+  struct TestInserter : public IRBuilderDefaultInserter {
+    TestInserter() = default;
+  };
+  InstSimplifyFolder Folder(M->getDataLayout());
+
+  IRBuilder Builder1(Ctx, Folder, TestInserter());
+  static_assert(std::is_same_v<decltype(Builder1),
+                               IRBuilder<InstSimplifyFolder, TestInserter>>);
+  IRBuilder Builder2(Ctx);
+  static_assert(std::is_same_v<decltype(Builder2), IRBuilder<>>);
+  IRBuilder Builder3(BB, Folder);
+  static_assert(
+      std::is_same_v<decltype(Builder3), IRBuilder<InstSimplifyFolder>>);
+  IRBuilder Builder4(BB);
+  static_assert(std::is_same_v<decltype(Builder4), IRBuilder<>>);
+  // The block BB is empty, so don't test this one.
+  // IRBuilder Builder5(BB->getTerminator());
+  // static_assert(std::is_same_v<decltype(Builder5), IRBuilder<>>);
+  IRBuilder Builder6(BB, BB->end(), Folder);
+  static_assert(
+      std::is_same_v<decltype(Builder6), IRBuilder<InstSimplifyFolder>>);
+  IRBuilder Builder7(BB, BB->end());
+  static_assert(std::is_same_v<decltype(Builder7), IRBuilder<>>);
+}
 }