enable msan-eager-checks with -fsanitize-memory-param-retval.

[kda]

Summary

follow up to https://reviews.llvm.org/D116633

[vitalybuka]

this patch depends on D116633, but D116633 is useless without this one
a better patch order is :

1. llvm
2. clang
3. compiler-rt (but if it's just test which uses clang flag it should be OK merge with no.2 )

let's do just llvm here, and move clang stuff into D116633 with the rest

we should update third_party/llvm/llvm-project/llvm/lib/Passes/PassBuilder.cpp:640
after that we can update third_party/llvm/llvm-project/llvm/test/Instrumentation/MemorySanitizer/msan_eager.ll
with additional ; RUN: line with "-passes='module(msan-module<OPTION_NAME->),function(msan<OPTION_NAME>)" instead of -msan-eager-checks

compiler-rt/test/msan/noundef_analysis.cpp

5 ↗

(On Diff #397427)

we can land it with driver patch

llvm/include/llvm/Transforms/Instrumentation/MemorySanitizer.h

30

maybe we should use CheckParamRetVal something here?

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

496

mllvm is lower level flag, so it should be opposite
-mllvm flag should override MemorySanitizerOptions

with getOptOrDefault below you don't need anything here

676

EagerChecks(getOptOrDefault(ClEagerChecks, EagerChecks))

[kda]

Reworked for comments and to be llvm only.

[kda]

llvm/include/llvm/Transforms/Instrumentation/MemorySanitizer.h

30

How about EagerChecksRequested?

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

496

I disagree. The variable ClEagerChecks is referenced in the code. If it is not configured based on EagerChecksRequested, there is no way to change the behavior based on the presence of the flag.

I will admit that with the change below, it is a bit circular, because Options.EagerChecksRequested prefers the -msan-eager-checks flag, but may default to EagerChecksRequested parameter, and then here the flag variable (ClEagerChecks) is set based on Options.EagerChecksRequested.

An alternative is to have a member variable of MemorySanitizer that is consulted in the code. It is configured based on Options.EagerChecksRequested. The flag (-msan-eager-checks) is only consulted below with the call to getOptOrDefault. (I coded this up: https://reviews.llvm.org/D116855)

[kda]

add 3 parameter constructor for MemorySanitizerOptions

llvm/include/llvm/Transforms/Instrumentation/MemorySanitizer.h

 #define LLVM_TRANSFORMS_INSTRUMENTATION_MEMORYSANITIZER_H
 
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
 
 struct MemorySanitizerOptions {
-  MemorySanitizerOptions() : MemorySanitizerOptions(0, false, false){};
-  MemorySanitizerOptions(int TrackOrigins, bool Recover, bool Kernel);
+  MemorySanitizerOptions() : MemorySanitizerOptions(0, false, false, false){};
+  MemorySanitizerOptions(int TrackOrigins, bool Recover, bool Kernel)
+      : MemorySanitizerOptions(TrackOrigins, Recover, Kernel, false) {}
+  MemorySanitizerOptions(int TrackOrigins, bool Recover, bool Kernel,
+                         bool EagerChecksRequested);
   bool Kernel;
   int TrackOrigins;
   bool Recover;
+  bool EagerChecksRequested;
 };
 
 // Insert MemorySanitizer instrumentation (detection of uninitialized reads)
 FunctionPass *
 createMemorySanitizerLegacyPassPass(MemorySanitizerOptions Options = {});
 
 /// A function pass for msan instrumentation.
 ///

llvm/lib/Passes/PassBuilder.cpp

while (!Params.empty()) {
     } else if (ParamName.consume_front("track-origins=")) {
       if (ParamName.getAsInteger(0, Result.TrackOrigins))
         return make_error<StringError>(
             formatv("invalid argument to MemorySanitizer pass track-origins "
                     "parameter: '{0}' ",
                     ParamName)
                 .str(),
             inconvertibleErrorCode());
+    } else if (ParamName == "param-retval") {
+      Result.EagerChecksRequested = true;
     } else {
       return make_error<StringError>(
           formatv("invalid MemorySanitizer pass parameter '{0}' ", ParamName)
               .str(),
           inconvertibleErrorCode());
     }
   }
   return Result;

llvm/lib/Passes/PassRegistry.def

FUNCTION_PASS_WITH_PARAMS("asan",
                           parseASanPassOptions,
                           "kernel")
 FUNCTION_PASS_WITH_PARAMS("msan",
                           "MemorySanitizerPass",
                            [](MemorySanitizerOptions Opts) {
                              return MemorySanitizerPass(Opts);
                            },
                           parseMSanPassOptions,
-                          "recover;kernel;track-origins=N")
+                          "recover;kernel;track-origins=N,param-retval")
 FUNCTION_PASS_WITH_PARAMS("simplifycfg",
                           "SimplifyCFGPass",
                            [](SimplifyCFGOptions Opts) {
                              return SimplifyCFGPass(Opts);
                            },
                           parseSimplifyCFGOptions,
                           "no-forward-switch-cond;forward-switch-cond;"
                           "no-switch-to-lookup;switch-to-lookup;"

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

 /// declarations into the module if they don't exist already. Instantiating
 /// ensures the __msan_init function is in the list of global constructors for
 /// the module.
 class MemorySanitizer {
 public:
   MemorySanitizer(Module &M, MemorySanitizerOptions Options)
       : CompileKernel(Options.Kernel), TrackOrigins(Options.TrackOrigins),
         Recover(Options.Recover) {
+    if (Options.EagerChecksRequested) {
+      ClEagerChecks = true;
+    }
     initializeModule(M);
   }
 
   // MSan cannot be moved or copied because of MapParams.
   MemorySanitizer(MemorySanitizer &&) = delete;
   MemorySanitizer &operator=(MemorySanitizer &&) = delete;
   MemorySanitizer(const MemorySanitizer &) = delete;
   MemorySanitizer &operator=(const MemorySanitizer &) = delete;

 };
 
 template <class T> T getOptOrDefault(const cl::opt<T> &Opt, T Default) {
   return (Opt.getNumOccurrences() > 0) ? Opt : Default;
 }
 
 } // end anonymous namespace
 
-MemorySanitizerOptions::MemorySanitizerOptions(int TO, bool R, bool K)
+MemorySanitizerOptions::MemorySanitizerOptions(int TO, bool R, bool K,
+                                               bool EagerChecksRequested)
     : Kernel(getOptOrDefault(ClEnableKmsan, K)),
       TrackOrigins(getOptOrDefault(ClTrackOrigins, Kernel ? 2 : TO)),
-      Recover(getOptOrDefault(ClKeepGoing, Kernel || R)) {}
+      Recover(getOptOrDefault(ClKeepGoing, Kernel || R)),
+      EagerChecksRequested(
+          getOptOrDefault(ClEagerChecks, EagerChecksRequested)) {}
 
 PreservedAnalyses MemorySanitizerPass::run(Function &F,
                                            FunctionAnalysisManager &FAM) {
   MemorySanitizer Msan(*F.getParent(), Options);
   if (Msan.sanitizeFunction(F, FAM.getResult<TargetLibraryAnalysis>(F)))
     return PreservedAnalyses::none();
   return PreservedAnalyses::all();
 }
void MemorySanitizerPass::printPipeline(
     raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
   static_cast<PassInfoMixin<MemorySanitizerPass> *>(this)->printPipeline(
       OS, MapClassName2PassName);
   OS << "<";
   if (Options.Recover)
     OS << "recover;";
   if (Options.Kernel)
     OS << "kernel;";
-  OS << "track-origins=" << Options.TrackOrigins;
+  OS << "track-origins=" << Options.TrackOrigins << ";";
+  if (Options.EagerChecksRequested)
+    OS << "param-retval;";
   OS << ">";
 }
 
 char MemorySanitizerLegacyPass::ID = 0;
 
 INITIALIZE_PASS_BEGIN(MemorySanitizerLegacyPass, "msan",
                       "MemorySanitizer: detects uninitialized reads.", false,
                       false)

llvm/test/Instrumentation/MemorySanitizer/msan_eager.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -msan-eager-checks -S -passes='module(msan-module),function(msan)' 2>&1 | \
 ; RUN:   FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK %s
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S -passes='msan<param-retval>' 2>&1 | \
+; RUN:   FileCheck -allow-deprecated-dag-overlap --check-prefix=CHECK %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-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define noundef i32 @NormalRet() nounwind uwtable sanitize_memory {
 ; CHECK-LABEL: @NormalRet(
 ; CHECK-NEXT:    call void @llvm.donothing()
 ; CHECK-NEXT:    ret i32 123