[WIP] Ignore list for noundef

[vitalybuka]

Summary

Depends on D116064.

[vitalybuka]

Not ready for review, we probably don't needs this patch.

clang/include/clang/Basic/NoSanitizeList.h

 public:
   NoSanitizeList(const std::vector<std::string> &NoSanitizeListPaths,
                  SourceManager &SM);
   ~NoSanitizeList();
   bool containsGlobal(SanitizerMask Mask, StringRef GlobalName,
                       StringRef Category = StringRef()) const;
   bool containsType(SanitizerMask Mask, StringRef MangledTypeName,
                     StringRef Category = StringRef()) const;
-  bool containsFunction(SanitizerMask Mask, StringRef FunctionName) const;
+  bool containsFunction(SanitizerMask Mask, StringRef FunctionName,
+                        StringRef Category = StringRef()) const;
   bool containsFile(SanitizerMask Mask, StringRef FileName,
                     StringRef Category = StringRef()) const;
   bool containsLocation(SanitizerMask Mask, SourceLocation Loc,
                         StringRef Category = StringRef()) const;
 };
 
 } // end namespace clang
 
 #endif

clang/lib/Basic/NoSanitizeList.cpp

 }
 
 bool NoSanitizeList::containsType(SanitizerMask Mask, StringRef MangledTypeName,
                                   StringRef Category) const {
   return SSCL->inSection(Mask, "type", MangledTypeName, Category);
 }
 
 bool NoSanitizeList::containsFunction(SanitizerMask Mask,
-                                      StringRef FunctionName) const {
-  return SSCL->inSection(Mask, "fun", FunctionName);
+                                      StringRef FunctionName,
+                                      StringRef Category) const {
+
+  return SSCL->inSection(Mask, "fun", FunctionName, Category);
 }
 
 bool NoSanitizeList::containsFile(SanitizerMask Mask, StringRef FileName,
                                   StringRef Category) const {
   return SSCL->inSection(Mask, "src", FileName, Category);
 }
 
 bool NoSanitizeList::containsLocation(SanitizerMask Mask, SourceLocation Loc,
                                       StringRef Category) const {
   return Loc.isValid() &&
          containsFile(Mask, SM.getFilename(SM.getFileLoc(Loc)), Category);
 }

clang/lib/CodeGen/CGCall.cpp

void CodeGenModule::ConstructAttributeList(StringRef Name,
   if (TargetDecl && HasStrictReturn) {
     if (const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(TargetDecl))
       HasStrictReturn &= !FDecl->isExternC();
     else if (const VarDecl *VDecl = dyn_cast<VarDecl>(TargetDecl))
       // Function pointer
       HasStrictReturn &= !VDecl->isExternC();
   }
 
+  bool EnableNoundefAttrs =
+      CodeGenOpts.EnableNoundefAttrs &&
+      !(getLangOpts().Sanitize.has(SanitizerKind::Memory) &&
+        isInNoSanitizeList(SanitizerKind::Memory, Name,
+                           /* "by location" is not supported */ {}, "noundef"));
+
   // We don't want to be too aggressive with the return checking, unless
   // it's explicit in the code opts or we're using an appropriate sanitizer.
   // Try to respect what the programmer intended.
   HasStrictReturn &= getCodeGenOpts().StrictReturn ||
                      !MayDropFunctionReturn(getContext(), RetTy) ||
                      getLangOpts().Sanitize.has(SanitizerKind::Memory) ||
                      getLangOpts().Sanitize.has(SanitizerKind::Return);
 
   // Determine if the return type could be partially undef
-  if (CodeGenOpts.EnableNoundefAttrs && HasStrictReturn) {
+  if (EnableNoundefAttrs && HasStrictReturn) {
     if (!RetTy->isVoidType() && RetAI.getKind() != ABIArgInfo::Indirect &&
         DetermineNoUndef(RetTy, getTypes(), DL, RetAI))
       RetAttrs.addAttribute(llvm::Attribute::NoUndef);
   }
 
   switch (RetAI.getKind()) {
   case ABIArgInfo::Extend:
     if (RetAI.isSignExt())
if (IRFunctionArgs.hasPaddingArg(ArgNo)) {
         ArgAttrs[IRFunctionArgs.getPaddingArgNo(ArgNo)] =
             llvm::AttributeSet::get(
                 getLLVMContext(),
                 llvm::AttrBuilder().addAttribute(llvm::Attribute::InReg));
       }
     }
 
     // Decide whether the argument we're handling could be partially undef
-    bool ArgNoUndef = DetermineNoUndef(ParamType, getTypes(), DL, AI);
-    if (CodeGenOpts.EnableNoundefAttrs && ArgNoUndef)
+    if (EnableNoundefAttrs && DetermineNoUndef(ParamType, getTypes(), DL, AI))
       Attrs.addAttribute(llvm::Attribute::NoUndef);
 
     // 'restrict' -> 'noalias' is done in EmitFunctionProlog when we
     // have the corresponding parameter variable.  It doesn't make
     // sense to do it here because parameters are so messed up.
     switch (AI.getKind()) {
     case ABIArgInfo::Extend:
       if (AI.isSignExt())

clang/lib/CodeGen/CGDeclCXX.cpp

llvm::Function *CodeGenModule::CreateGlobalInitOrCleanUpFunction(
   SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);
 
   Fn->setCallingConv(getRuntimeCC());
 
   if (!getLangOpts().Exceptions)
     Fn->setDoesNotThrow();
 
   if (getLangOpts().Sanitize.has(SanitizerKind::Address) &&
-      !isInNoSanitizeList(SanitizerKind::Address, Fn, Loc))
+      !isInNoSanitizeList(SanitizerKind::Address, Fn->getName(), Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::KernelAddress) &&
-      !isInNoSanitizeList(SanitizerKind::KernelAddress, Fn, Loc))
+      !isInNoSanitizeList(SanitizerKind::KernelAddress, Fn->getName(), Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::HWAddress) &&
-      !isInNoSanitizeList(SanitizerKind::HWAddress, Fn, Loc))
+      !isInNoSanitizeList(SanitizerKind::HWAddress, Fn->getName(), Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::KernelHWAddress) &&
-      !isInNoSanitizeList(SanitizerKind::KernelHWAddress, Fn, Loc))
+      !isInNoSanitizeList(SanitizerKind::KernelHWAddress, Fn->getName(), Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::MemTag) &&
-      !isInNoSanitizeList(SanitizerKind::MemTag, Fn, Loc))
+      !isInNoSanitizeList(SanitizerKind::MemTag, Fn->getName(), Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::Thread) &&
-      !isInNoSanitizeList(SanitizerKind::Thread, Fn, Loc))
+      !isInNoSanitizeList(SanitizerKind::Thread, Fn->getName(), Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeThread);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::Memory) &&
-      !isInNoSanitizeList(SanitizerKind::Memory, Fn, Loc))
+      !isInNoSanitizeList(SanitizerKind::Memory, Fn->getName(), Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::KernelMemory) &&
-      !isInNoSanitizeList(SanitizerKind::KernelMemory, Fn, Loc))
+      !isInNoSanitizeList(SanitizerKind::KernelMemory, Fn->getName(), Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::SafeStack) &&
-      !isInNoSanitizeList(SanitizerKind::SafeStack, Fn, Loc))
+      !isInNoSanitizeList(SanitizerKind::SafeStack, Fn->getName(), Loc))
     Fn->addFnAttr(llvm::Attribute::SafeStack);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::ShadowCallStack) &&
-      !isInNoSanitizeList(SanitizerKind::ShadowCallStack, Fn, Loc))
+      !isInNoSanitizeList(SanitizerKind::ShadowCallStack, Fn->getName(), Loc))
     Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
 
   return Fn;
 }
 
 /// Create a global pointer to a function that will initialize a global
 /// variable.  The user has requested that this pointer be emitted in a specific
 /// section.

clang/lib/CodeGen/CodeGenFunction.cpp

void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
 
   // If this function is ignored for any of the enabled sanitizers,
   // disable the sanitizer for the function.
   do {
 #define SANITIZER(NAME, ID)                                                    \
   if (SanOpts.empty())                                                         \
     break;                                                                     \
   if (SanOpts.has(SanitizerKind::ID))                                          \
-    if (CGM.isInNoSanitizeList(SanitizerKind::ID, Fn, Loc))                    \
+    if (CGM.isInNoSanitizeList(SanitizerKind::ID, Fn->getName(), Loc))         \
       SanOpts.set(SanitizerKind::ID, false);
 
 #include "clang/Basic/Sanitizers.def"
 #undef SANITIZER
   } while (0);
 
   if (D) {
     bool NoSanitizeCoverage = false;

clang/lib/CodeGen/CodeGenModule.h

public:
   llvm::Constant *EmitAnnotateAttr(llvm::GlobalValue *GV,
                                    const AnnotateAttr *AA,
                                    SourceLocation L);
 
   /// Add global annotations that are set on D, for the global GV. Those
   /// annotations are emitted during finalization of the LLVM code.
   void AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV);
 
-  bool isInNoSanitizeList(SanitizerMask Kind, llvm::Function *Fn,
-                          SourceLocation Loc) const;
+  bool isInNoSanitizeList(SanitizerMask Kind, StringRef FunctionName,
+                          SourceLocation Loc,
+                          StringRef Category = StringRef()) const;
 
   bool isInNoSanitizeList(llvm::GlobalVariable *GV, SourceLocation Loc,
                           QualType Ty, StringRef Category = StringRef()) const;
 
   /// Imbue XRay attributes to a function, applying the always/never attribute
   /// lists in the process. Returns true if we did imbue attributes this way,
   /// false otherwise.
   bool imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,

clang/lib/CodeGen/CodeGenModule.cpp

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Version.h"
 #include "clang/CodeGen/ConstantInitBuilder.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"

 void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
                                          llvm::GlobalValue *GV) {
   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
   // Get the struct elements for these annotations.
   for (const auto *I : D->specific_attrs<AnnotateAttr>())
     Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation()));
 }
 
-bool CodeGenModule::isInNoSanitizeList(SanitizerMask Kind, llvm::Function *Fn,
-                                       SourceLocation Loc) const {
+bool CodeGenModule::isInNoSanitizeList(SanitizerMask Kind,
+                                       StringRef FunctionName,
+                                       SourceLocation Loc,
+                                       StringRef Category) const {
   const auto &NoSanitizeL = getContext().getNoSanitizeList();
   // NoSanitize by function name.
-  if (NoSanitizeL.containsFunction(Kind, Fn->getName()))
+  if (NoSanitizeL.containsFunction(Kind, FunctionName, Category))
     return true;
   // NoSanitize by location.
   if (Loc.isValid())
-    return NoSanitizeL.containsLocation(Kind, Loc);
+    return NoSanitizeL.containsLocation(Kind, Loc, Category);
   // If location is unknown, this may be a compiler-generated function. Assume
   // it's located in the main file.
   auto &SM = Context.getSourceManager();
   if (const auto *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
-    return NoSanitizeL.containsFile(Kind, MainFile->getName());
+    return NoSanitizeL.containsFile(Kind, MainFile->getName(), Category);
   }
   return false;
 }
 
 bool CodeGenModule::isInNoSanitizeList(llvm::GlobalVariable *GV,
                                        SourceLocation Loc, QualType Ty,
                                        StringRef Category) const {
   // For now globals can be ignored only in ASan and KASan.

clang/test/CodeGen/Inputs/sanitizer-special-case-list.sanitized.txt

 [unsigned-integer-overflow]
 fun:*cfi*
 [cfi]
 fun:*overflow*
+[memory]
+fun:*ret_ignored*=noundef
+fun:*pass_ignored*=noundef