[asan] Pass argc/argv/envp module constructor arguments to __asan_init

[eugenis]

No, I don't like this.
It's glibc/bionic specifc first of all.
And this way we are stuck with .preinit_array even with the shared runtime library, because otherwise asan initialization happens from an interceptor.

include/llvm/Transforms/Utils/ModuleUtils.h

 
 /// \brief Creates sanitizer constructor function, and calls sanitizer's init
 /// function from it.
 /// \return Returns pair of pointers to constructor, and init functions
 /// respectively.
 std::pair<Function *, Function *> createSanitizerCtorAndInitFunctions(
     Module &M, StringRef CtorName, StringRef InitName,
     ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs,
-    StringRef VersionCheckName = StringRef());
+    StringRef VersionCheckName = StringRef(),
+    bool PassArgcArgvEnvp = false);
 
 /// Rename all the anon functions in the module using a hash computed from
 /// the list of public globals in the module.
 bool nameUnamedFunctions(Module &M);
 
 } // End llvm namespace
 
 #endif //  LLVM_TRANSFORMS_UTILS_MODULEUTILS_H

lib/Transforms/Instrumentation/AddressSanitizer.cpp

bool AddressSanitizer::doInitialization(Module &M) {
   GlobalsMD.init(M);
 
   C = &(M.getContext());
   LongSize = M.getDataLayout().getPointerSizeInBits();
   IntptrTy = Type::getIntNTy(*C, LongSize);
   TargetTriple = Triple(M.getTargetTriple());
 
   if (!CompileKernel) {
+    Triple TargetTriple(M.getTargetTriple());
+    bool WithArgcArgvEnvp = TargetTriple.isOSLinux();
     std::tie(AsanCtorFunction, AsanInitFunction) =
         createSanitizerCtorAndInitFunctions(
             M, kAsanModuleCtorName, kAsanInitName,
-            /*InitArgTypes=*/{}, /*InitArgs=*/{}, kAsanVersionCheckName);
+            /*InitArgTypes=*/{}, /*InitArgs=*/{}, kAsanVersionCheckName, WithArgcArgvEnvp);
     appendToGlobalCtors(M, AsanCtorFunction, kAsanCtorAndDtorPriority);
   }
   Mapping = getShadowMapping(TargetTriple, LongSize, CompileKernel);
   return true;
 }
 
 bool AddressSanitizer::doFinalization(Module &M) {
   GlobalsMD.reset();

lib/Transforms/Utils/ModuleUtils.cpp

 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 static void appendToGlobalArray(const char *Array, Module &M, Function *F,
                                 int Priority, Constant *Data) {
   IRBuilder<> IRB(M.getContext());
   FunctionType *FnTy = FunctionType::get(IRB.getVoidTy(), false);
+  Constant *FnPtr = ConstantExpr::getPointerCast(F, FnTy->getPointerTo());
 
   // Get the current set of static global constructors and add the new ctor
   // to the list.
   SmallVector<Constant *, 16> CurrentCtors;
   StructType *EltTy;
   if (GlobalVariable *GVCtor = M.getNamedGlobal(Array)) {
     ArrayType *ATy = cast<ArrayType>(GVCtor->getValueType());
     StructType *OldEltTy = cast<StructType>(ATy->getElementType());
if (GlobalVariable *GVCtor = M.getNamedGlobal(Array)) {
     // Use the new three-field struct if there isn't one already.
     EltTy = StructType::get(IRB.getInt32Ty(), PointerType::getUnqual(FnTy),
                             IRB.getInt8PtrTy(), nullptr);
   }
 
   // Build a 2 or 3 field global_ctor entry.  We don't take a comdat key.
   Constant *CSVals[3];
   CSVals[0] = IRB.getInt32(Priority);
-  CSVals[1] = F;
+  CSVals[1] = FnPtr;
   // FIXME: Drop support for the two element form in LLVM 4.0.
   if (EltTy->getNumElements() >= 3)
     CSVals[2] = Data ? ConstantExpr::getPointerCast(Data, IRB.getInt8PtrTy())
                      : Constant::getNullValue(IRB.getInt8PtrTy());
   Constant *RuntimeCtorInit =
       ConstantStruct::get(EltTy, makeArrayRef(CSVals, EltTy->getNumElements()));
 
   CurrentCtors.push_back(RuntimeCtorInit);
Function *llvm::checkSanitizerInterfaceFunction(Constant *FuncOrBitcast) {
   raw_string_ostream Stream(Err);
   Stream << "Sanitizer interface function redefined: " << *FuncOrBitcast;
   report_fatal_error(Err);
 }
 
 std::pair<Function *, Function *> llvm::createSanitizerCtorAndInitFunctions(
     Module &M, StringRef CtorName, StringRef InitName,
     ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs,
-    StringRef VersionCheckName) {
+    StringRef VersionCheckName, bool PassArgcArgvEnvp) {
   assert(!InitName.empty() && "Expected init function name");
   assert(InitArgTypes.size() == InitArgTypes.size() &&
          "Sanitizer's init function expects different number of arguments");
-  Function *Ctor = Function::Create(
-      FunctionType::get(Type::getVoidTy(M.getContext()), false),
-      GlobalValue::InternalLinkage, CtorName, &M);
+  LLVMContext &C = M.getContext();
+  Type *VoidTy = Type::getVoidTy(C);
+  FunctionType *CtorTy, *InitTy;
+  if (PassArgcArgvEnvp) {
+    Type *IntTy = Type::getInt32Ty(C);
+    Type *CharPtrPtrTy = Type::getInt8Ty(C)->getPointerTo(0)->getPointerTo(0);
+    SmallVector<Type *, 8> CtorParamTypes{IntTy, CharPtrPtrTy, CharPtrPtrTy};
+    SmallVector<Type *, 8> InitParamTypes{IntTy, CharPtrPtrTy, CharPtrPtrTy};
+    InitParamTypes.append(InitArgTypes.begin(), InitArgTypes.end());
+    CtorTy = FunctionType::get(VoidTy, CtorParamTypes, false);
+    InitTy = FunctionType::get(VoidTy, InitParamTypes, false);
+  } else {
+    CtorTy = FunctionType::get(VoidTy, false);
+    InitTy = FunctionType::get(VoidTy, InitArgTypes, false);
+  }
+  Function *Ctor =
+      Function::Create(CtorTy, GlobalValue::InternalLinkage, CtorName, &M);
   BasicBlock *CtorBB = BasicBlock::Create(M.getContext(), "", Ctor);
   IRBuilder<> IRB(ReturnInst::Create(M.getContext(), CtorBB));
-  Function *InitFunction =
-      checkSanitizerInterfaceFunction(M.getOrInsertFunction(
-          InitName, FunctionType::get(IRB.getVoidTy(), InitArgTypes, false),
-          AttributeSet()));
+  Function *InitFunction = checkSanitizerInterfaceFunction(
+      M.getOrInsertFunction(InitName, InitTy, AttributeSet()));
   InitFunction->setLinkage(Function::ExternalLinkage);
+  if (PassArgcArgvEnvp) {
+    SmallVector<Value *, 8> Args;
+    for (auto &CtorArg : Ctor->args())
+      Args.push_back(&CtorArg);
+    Args.append(InitArgs.begin(), InitArgs.end());
+    IRB.CreateCall(InitFunction, Args);
+  } else {
     IRB.CreateCall(InitFunction, InitArgs);
+  }
   if (!VersionCheckName.empty()) {
     Function *VersionCheckFunction =
         checkSanitizerInterfaceFunction(M.getOrInsertFunction(
             VersionCheckName, FunctionType::get(IRB.getVoidTy(), {}, false),
             AttributeSet()));
     IRB.CreateCall(VersionCheckFunction, {});
   }
   return std::make_pair(Ctor, InitFunction);
 }

test/Instrumentation/AddressSanitizer/basic.ll

 ; Test basic address sanitizer instrumentation.
 ;
 ; RUN: opt < %s -asan -asan-module -S | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
-; CHECK: @llvm.global_ctors = {{.*}}@asan.module_ctor
 
 define i32 @test_load(i32* %a) sanitize_address {
 ; CHECK-LABEL: @test_load
 ; CHECK-NOT: load
 ; CHECK:   %[[LOAD_ADDR:[^ ]*]] = ptrtoint i32* %a to i64
 ; CHECK:   lshr i64 %[[LOAD_ADDR]], 3
 ; CHECK:   {{or|add}}
 ; CHECK:   %[[LOAD_SHADOW_PTR:[^ ]*]] = inttoptr

 }
 
 ; CHECK-LABEL: memintr_test
 ; CHECK: __asan_memset
 ; CHECK: __asan_memmove
 ; CHECK: __asan_memcpy
 ; CHECK: ret void
 
-; CHECK: define internal void @asan.module_ctor()
-; CHECK: call void @__asan_init()
-
 ; PROF
 ; CHECK: ![[PROF]] = !{!"branch_weights", i32 1, i32 100000}

test/Instrumentation/AddressSanitizer/ctor.ll

+; RUN: opt -mtriple=x86_64-unknown-linux-gnu < %s -asan -asan-module -S | FileCheck %s --check-prefix=CHECK-ARGS
+; RUN: opt -mtriple=x86_64-unknown-unknown < %s -asan -asan-module -S | FileCheck %s --check-prefix=CHECK-NO-ARGS
+; RUN: opt -mtriple=x86_64-apple-darwin < %s -asan -asan-module -S | FileCheck %s --check-prefix=CHECK-NO-ARGS
+
+; CHECK-ARGS: @llvm.global_ctors = appending global [{{.*}}void ()* bitcast (void (i32, i8**, i8**)* @asan.module_ctor to void ()*
+; CHECK-NO-ARGS: @llvm.global_ctors = appending global [{{.*}}void ()* @asan.module_ctor
+
+; CHECK-ARGS: define internal void @asan.module_ctor(i32{{.*}}, i8**{{.*}}, i8**{{.*}})
+; CHECK-ARGS: call void @__asan_init(i32{{.*}}, i8**{{.*}}, i8**{{.*}})
+
+; CHECK-NO-ARGS: define internal void @asan.module_ctor()
+; CHECK-NO-ARGS: call void @__asan_init()