Implement `createSanitizerCtor`, common helper function for all sanitizers

[ismailp]

Summary

This helper function creates a ctor function, which calls sanitizer's
init function with given arguments. This constructor is then expected
to be added to module's ctors. The patch helps unifying how sanitizer
constructor functions are created, and how init functions are called
across all sanitizers.

[ismailp]

Ping!

[dvyukov]

Alexey, please review this while Kostya is away.

[samsonov]

Sorry for the late response.

include/llvm/Transforms/Utils/ModuleUtils.h

54

This function looks overly complicated to me. Essentially, you create *both* sanitizer initialization function,
and sanitizer module constructor here. Consider splitting this function into two functions. Or rename it accordingly
and return std::pair<Function *, Function *> to clearly indicate that you create two objects. Note that in the latter case
you will not need an overload.

55

I'd rather not provide the default argument values - passing {} explicitly is easy.

[ismailp]

Addressed comments:

• Renamed function, and say that it creates both ctor and init functions
• Returned a std::pair<Function *, Function *>
• Removed default arguments

[ismailp]

include/llvm/Transforms/Utils/ModuleUtils.h

54

I used std::pair at my first attempt, but I didn't want to #include <utility>.

[samsonov]

LGTM with a couple of nits.

include/llvm/Transforms/Utils/ModuleUtils.h

58

This is not really InitType, this is InitArgTypes, right?

lib/Transforms/Utils/ModuleUtils.cpp

112

assert that two ArrayRef's have equal size?

[ismailp]

Thank you for your time!

include/llvm/Transforms/Utils/ModuleUtils.h

58

Yes, this is InitArgsType.

lib/Transforms/Utils/ModuleUtils.cpp

112

Yes, I will add assertion. But, IIRC, it is already done by CreateCall below. I have a vague recollection of such an assertion.

[samsonov]

include/llvm/Transforms/Utils/ModuleUtils.h

58

Please rename accordingly.

lib/Transforms/Utils/ModuleUtils.cpp

112

OK, feel free to disregard this.

include/llvm/Transforms/Utils/ModuleUtils.h

 //===-- ModuleUtils.h - Functions to manipulate Modules ---------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This family of functions perform manipulations on Modules.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_MODULEUTILS_H
 #define LLVM_TRANSFORMS_UTILS_MODULEUTILS_H
 
+#include "llvm/ADT/ArrayRef.h"
+
 namespace llvm {
 
 class Module;
 class Function;
 class GlobalValue;
 class GlobalVariable;
 class Constant;
+class StringRef;
+class Value;
+class Type;
 template <class PtrType> class SmallPtrSetImpl;
 
 /// Append F to the list of global ctors of module M with the given Priority.
 /// This wraps the function in the appropriate structure and stores it along
 /// side other global constructors. For details see
 /// http://llvm.org/docs/LangRef.html#intg_global_ctors
 void appendToGlobalCtors(Module &M, Function *F, int Priority);
 
 /// Same as appendToGlobalCtors(), but for global dtors.
 void appendToGlobalDtors(Module &M, Function *F, int Priority);
 
 /// \brief Given "llvm.used" or "llvm.compiler.used" as a global name, collect
 /// the initializer elements of that global in Set and return the global itself.
 GlobalVariable *collectUsedGlobalVariables(Module &M,
                                            SmallPtrSetImpl<GlobalValue *> &Set,
                                            bool CompilerUsed);
 
 // Validate the result of Module::getOrInsertFunction called for an interface
 // function of given sanitizer. If the instrumented module defines a function
 // with the same name, their prototypes must match, otherwise
 // getOrInsertFunction returns a bitcast.
 Function *checkInterfaceFunction(Constant *FuncOrBitcast);
+
+/// \brief Creates sanitizer constructor function, and calls sanitizer's init
+/// function from it.
+Function *createSanitizerCtor(Module &M, StringRef CtorName, StringRef InitName,
+                              ArrayRef<Type *> InitType = ArrayRef<Type *>(),
+                              ArrayRef<Value *> InitArgs = ArrayRef<Value *>(),
+                              Function **InitFunctionPtr = nullptr);
+Function *createSanitizerCtor(Module &M, StringRef CtorName, StringRef InitName,
+                              Function **InitFunctionPtr);
 } // End llvm namespace
 
 #endif //  LLVM_TRANSFORMS_UTILS_MODULEUTILS_H

lib/Transforms/Utils/ModuleUtils.cpp

Function *llvm::checkInterfaceFunction(Constant *FuncOrBitcast) {
   if (isa<Function>(FuncOrBitcast))
     return cast<Function>(FuncOrBitcast);
   FuncOrBitcast->dump();
   std::string Err;
   raw_string_ostream Stream(Err);
   Stream << "Sanitizer interface function redefined: " << *FuncOrBitcast;
   report_fatal_error(Err);
 }
+
+Function *llvm::createSanitizerCtor(Module &M, llvm::StringRef CtorName,
+                                    llvm::StringRef InitName,
+                                    llvm::ArrayRef<Type *> InitType,
+                                    llvm::ArrayRef<Value *> InitArgs,
+                                    llvm::Function **InitFunctionPtr) {
+  assert(!InitName.empty() && "Expected init function name");
+  Function *Ctor = Function::Create(
+      FunctionType::get(Type::getVoidTy(M.getContext()), false),
+      GlobalValue::InternalLinkage, CtorName, &M);
+  BasicBlock *CtorBB = BasicBlock::Create(M.getContext(), "", Ctor);
+  IRBuilder<> IRB(ReturnInst::Create(M.getContext(), CtorBB));
+  Function *InitFunction = checkInterfaceFunction(M.getOrInsertFunction(
+      InitName, FunctionType::get(IRB.getVoidTy(), InitType, false),
+      AttributeSet()));
+  InitFunction->setLinkage(Function::ExternalLinkage);
+  IRB.CreateCall(InitFunction, InitArgs);
+  if (InitFunctionPtr)
+    *InitFunctionPtr = InitFunction;
+  return Ctor;
+}
+
+Function *llvm::createSanitizerCtor(Module &M, llvm::StringRef CtorName,
+                                    llvm::StringRef InitName,
+                                    llvm::Function **InitFunctionPtr) {
+  return llvm::createSanitizerCtor(M, CtorName, InitName, {}, {},
+                                   InitFunctionPtr);
+}
+