[msan] Remove readnone and friends from call sites.

[eugenis]

Summary

MSan removes readnone/readonly and similar attributes from callees,
because after MSan instrumentation those attributes no longer apply.

This change removes the attributes from call sites, as well.

Failing to do this may cause DSE of paramTLS stores before calls to
readonly/readnone functions.

[guiand]

LGTM

llvm/include/llvm/IR/InstrTypes.h

public:
 
   /// removes the attribute from the list of attributes.
   void removeAttribute(unsigned i, StringRef Kind) {
     AttributeList PAL = getAttributes();
     PAL = PAL.removeAttribute(getContext(), i, Kind);
     setAttributes(PAL);
   }
 
+  void removeAttributes(unsigned i, const AttrBuilder &Attrs) {
+    AttributeList PAL = getAttributes();
+    PAL = PAL.removeAttributes(getContext(), i, Attrs);
+    setAttributes(PAL);
+  }
+
   /// Removes the attribute from the given argument
   void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
     assert(ArgNo < getNumArgOperands() && "Out of bounds");
     AttributeList PAL = getAttributes();
     PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
     setAttributes(PAL);
   }
 

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

void visitCallBase(CallBase &CB) {
 
     if (auto *Call = dyn_cast<CallInst>(&CB)) {
       assert(!isa<IntrinsicInst>(Call) && "intrinsics are handled elsewhere");
 
       // We are going to insert code that relies on the fact that the callee
       // will become a non-readonly function after it is instrumented by us. To
       // prevent this code from being optimized out, mark that function
       // non-readonly in advance.
-      if (Function *Func = Call->getCalledFunction()) {
-        // Clear out readonly/readnone attributes.
-        AttrBuilder B;
-        B.addAttribute(Attribute::ReadOnly)
-            .addAttribute(Attribute::ReadNone)
-            .addAttribute(Attribute::WriteOnly)
-            .addAttribute(Attribute::ArgMemOnly)
-            .addAttribute(Attribute::Speculatable);
+
+      Call->removeAttributes(AttributeList::FunctionIndex, B);
+      if (Function *Func = Call->getCalledFunction()) {
         Func->removeAttributes(AttributeList::FunctionIndex, B);
       }
 
       maybeMarkSanitizerLibraryCallNoBuiltin(Call, TLI);
     }
     IRBuilder<> IRB(&CB);
     bool MayCheckCall = ClEagerChecks;
     if (Function *Func = CB.getCalledFunction()) {

llvm/test/Instrumentation/MemorySanitizer/attributes.ll

 ; RUN: opt < %s -S -passes='module(msan-module),function(msan)' 2>&1 | 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-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 
 declare void @a_() sanitize_memory readnone
 declare void @b_() sanitize_memory readonly
 declare void @c_() sanitize_memory writeonly
 declare void @d_(i32* %p) sanitize_memory writeonly argmemonly
 declare void @e_() sanitize_memory speculatable
 
 define void @a() sanitize_memory readnone {
 entry:
   call void @a_()
+  call void @a_() readnone
   ret void
 }
 
 define void @b() sanitize_memory readonly {
 entry:
   call void @b_()
+  call void @b_() readonly
   ret void
 }
 
 define void @c() sanitize_memory writeonly {
 entry:
   call void @c_()
+  call void @c_() writeonly
   ret void
 }
 
 define void @d(i32* %p) sanitize_memory writeonly argmemonly {
 entry:
   call void @d_(i32* %p)
+  call void @d_(i32* %p) writeonly argmemonly
   ret void
 }
 
 define void @e() sanitize_memory speculatable {
 entry:
   call void @e_()
   ret void
 }
 
 ; CHECK-NOT: readnone
 ; CHECK-NOT: readonly
 ; CHECK-NOT: writeonly
 ; CHECK-NOT: argmemonly
 ; CHECK-NOT: speculatable