Add read_write_arg_mem attribute

[igor-laevsky]

Summary

This change adds new attribute called "read_write_arg_mem"

Function marked with this attribute can only access memory through it's argument pointers. This attribute directly corresponds to the "OnlyAccessesArgumentPointees" ModRef behaviour in alias analysis.

[sanjoy]

A meta comment: why not mark a _specific_ set of arguments with ReadWriteOnlyViaArg? That seems to convey more information. Some other comments inline.

lib/AsmParser/LLParser.cpp

937

There's a whitespace issue here.

lib/IR/Verifier.cpp

1449

I'm not sure these should fail the verifier -- we should just drop ReadWriteArgMem in the readonly case, in in the readnone case replace with ReadArgMem.

[igor-laevsky]

I believe that all pointer arguments are ReadWrite by default. So there is no point in adding explicit ReadWrite attribute for each argument separately, if I understood you correctly.

If user wants to encode function which can read and write only from specific set of arguments he can use readonly or readnone attributes. I will add a test for this case.

lib/AsmParser/LLParser.cpp

937

Since length of "kw_read_write_arg_mem" is one symbol more than maximum length of other kw_* identifiers in this case, I was forced to align all cases accordingly. Not sure what llvm coding standart says about such cases, but it seems reasonable to keep the alignment.

lib/IR/Verifier.cpp

1449

I think it should fail here. It is safe to consider readonly function as ReadWriteArgMem, but not safe to do the opposite. If function is marked with both attributes it would mean that we can always consider it as readonly. If in reality it was ReadWriteArgMem, something would fail. Anyway even from intuitive point of view it is weird two have this two attributes on one function. It is like saying this function can write memory, but it also can not write memory.

[igor-laevsky]

In D10398#187332, @igor-laevsky wrote:

If user wants to encode function which can read and write only from specific set of arguments he can use readonly or readnone attributes. I will add a test for this case.

Actually this does not work :) But it's easy to fix, so I will send a separate follow-up patch.

[reames]

include/llvm/Analysis/AliasAnalysis.h

208

This now matches read_write_arg_mem + readonly right? If so, please update comment.

lib/Analysis/BasicAliasAnalysis.cpp

684

I think you can get the only reads arguments from this attribute and readonly.

lib/IR/Verifier.cpp

1449

It is specifically not legal to consider a readonly function as ReadWriteArgMem. A readonly function could read from a global which is not passed as an argument.

I think the combination of read_write_arg_mem and readonly is meaningful. This is specifically read_arg_mem (i.e. only read memory pointer to by arguments).

One way of framing this is that read_write_arg_mem is a special form of a read/write set for the function. Where the set is interpreted as RW or just R depends on other knowledge of the function (i.e. the readonly attribute.)

For this reason, I'd be tempted to rename this as "access_arg_mem_only" or something. Before actually doing that mechanical change, please raise this in an email to llvmdev. I think this needs broader attention. (In particular, I wouldn't feel comfortable signing off on this. The scope is too large.)

[igor-laevsky]

@reames,

It is specifically not legal to consider a readonly function as ReadWriteArgMem. A readonly function could read from a global which is not passed as an argument.

Your are right. I probably confused readonly with readnone here.

One way of framing this is that read_write_arg_mem is a special form of a read/write set for the function. Where the set is interpreted as RW or just R depends on other knowledge of the function (i.e. the readonly attribute.)

For this reason, I'd be tempted to rename this as "access_arg_mem_only" or something. Before actually doing that mechanical change, please raise this in an email to llvmdev. I think this needs broader attention. (In particular, I wouldn't feel comfortable signing off on this. The scope is too large.)

I agree, this framing of a problem is better. It reduces confusion regarding dependencies between different function attributes.

[hfinkel]

In D10398#190292, @igor-laevsky wrote:

@reames,

...

For this reason, I'd be tempted to rename this as "access_arg_mem_only" or something. Before actually doing that mechanical change, please raise this in an email to llvmdev. I think this needs broader attention. (In particular, I wouldn't feel comfortable signing off on this. The scope is too large.)

I agree with this suggestion, access or accesses is better. I also agree that we should discuss this on llvmdev, as with any other change to the IR.

...

[igor-laevsky]

Renamed attribute to the argmemonly.

[igor-laevsky]

Gentle ping.

[hfinkel]

docs/LangRef.rst

1318

acesses -> accesses

1319

Also non-atomic?

1321

this -> its

1324

it's -> its

include/llvm/IR/Attributes.h

102

passed in as -> based on its

include/llvm/IR/CallSite.h

271

using it's -> based on its

273

For grammatical consistency, we should name this:

onlyAccessesArgMemory

and the same goes for the other functions below.

include/llvm/IR/Function.h

284

using it's -> based on its

include/llvm/IR/Instructions.h

1555

using it's -> based on its

3300

using it's -> based on its

lib/AsmParser/LLParser.cpp

937–965

We treat the 80 column limit as strict. You'll need to reformat these in some other way.

[hfinkel]

include/llvm/IR/CallSite.h

273

I will not approve this patch without this change. All of the other functions read correctly by placing "it" in front of the function name:

"it does Not Access Memory"
"it does Not Return"
"it is NoInline"

and so this needs to be "it only Accesses ArgMemory" because "it only Access ArgMemory" is not grammatically correct.

[igor-laevsky]

include/llvm/IR/CallSite.h

273

Sorry, didn't notice "es" suffix.

[hfinkel]

With the change below, LGTM.

docs/LangRef.rst

1319

Actually, I think these are orthogonal concepts. Can you remove mentioning both volatile and atomic? How it accesses memory, and whether that access might have side effects, can be specified separately (via readonly, or the lack thereof, etc.) from which memory might be accessed.

docs/LangRef.rst

``readonly``
     returns the same value (or unwinds an exception identically) when
     called with the same set of arguments and global state. It cannot
     unwind an exception by calling the ``C++`` exception throwing
     methods.
 
     On an argument, this attribute indicates that the function does not write
     through this pointer argument, even though it may write to the memory that
     the pointer points to.
+``read_write_arg_mem``
+    This attribute indicates that the only memory acesses inside function are
+    non-volatile loads and stores from objects pointed to by its pointer-typed
+    arguments, with arbitrary offsets.
 ``returns_twice``
     This attribute indicates that this function can return twice. The C
     ``setjmp`` is an example of such a function. The compiler disables
     some optimizations (like tail calls) in the caller of these
     functions.
 ``sanitize_address``
     This attribute indicates that AddressSanitizer checks
     (dynamic address safety analysis) are enabled for this function.
 ``sanitize_memory``
     This attribute indicates that MemorySanitizer checks (dynamic detection
     of accesses to uninitialized memory) are enabled for this function.
 ``sanitize_thread``

include/llvm/Analysis/AliasAnalysis.h

enum ModRefBehavior {
     /// This property corresponds to the LLVM IR 'readnone' attribute.
     /// This property corresponds to the IntrNoMem LLVM intrinsic flag.
     DoesNotAccessMemory = Nowhere | NoModRef,
 
     /// OnlyReadsArgumentPointees - The only memory references in this function
     /// (if it has any) are non-volatile loads from objects pointed to by its
     /// pointer-typed arguments, with arbitrary offsets.
     ///
     /// This property corresponds to the IntrReadArgMem LLVM intrinsic flag.
     OnlyReadsArgumentPointees = ArgumentPointees | Ref,
 
     /// OnlyAccessesArgumentPointees - The only memory references in this
     /// function (if it has any) are non-volatile loads and stores from objects
     /// pointed to by its pointer-typed arguments, with arbitrary offsets.
     ///
+    /// This property corresponds to the LLVM IR 'read_write_arg_mem' attribute.
     /// This property corresponds to the IntrReadWriteArgMem LLVM intrinsic flag.
     OnlyAccessesArgumentPointees = ArgumentPointees | ModRef,
 
     /// OnlyReadsMemory - This function does not perform any non-local stores or
     /// volatile loads, but may read from any memory location.
     ///
     /// This property corresponds to the GCC 'pure' attribute.
     /// This property corresponds to the LLVM IR 'readonly' attribute.

include/llvm/Bitcode/LLVMBitCodes.h

enum AttributeKindCodes {
     ATTR_KIND_BUILTIN = 35,
     ATTR_KIND_COLD = 36,
     ATTR_KIND_OPTIMIZE_NONE = 37,
     ATTR_KIND_IN_ALLOCA = 38,
     ATTR_KIND_NON_NULL = 39,
     ATTR_KIND_JUMP_TABLE = 40,
     ATTR_KIND_DEREFERENCEABLE = 41,
     ATTR_KIND_DEREFERENCEABLE_OR_NULL = 42,
-    ATTR_KIND_CONVERGENT = 43
+    ATTR_KIND_CONVERGENT = 43,
+    ATTR_KIND_READ_WRITE_ARG_MEM = 44
   };
 
   enum ComdatSelectionKindCodes {
     COMDAT_SELECTION_KIND_ANY = 1,
     COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
     COMDAT_SELECTION_KIND_LARGEST = 3,
     COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
     COMDAT_SELECTION_KIND_SAME_SIZE = 5,
   };
 
 } // End bitc namespace
 } // End llvm namespace
 
 #endif

include/llvm/IR/Attributes.h

enum AttrKind {
     DereferenceableOrNull, ///< Pointer is either null or dereferenceable
     NoRedZone,             ///< Disable redzone
     NoReturn,              ///< Mark the function as not returning
     NoUnwind,              ///< Function doesn't unwind stack
     OptimizeForSize,       ///< opt_size
     OptimizeNone,          ///< Function must not be optimized.
     ReadNone,              ///< Function does not access memory
     ReadOnly,              ///< Function only reads from memory
+    ReadWriteArgMem,       ///< Function reads and writes only to/from memory
+                           ///< pointed to by it's arguments with arbitrary
+                           ///< offsets.
     Returned,              ///< Return value is always equal to this argument
     ReturnsTwice,          ///< Function can return twice
     SExt,                  ///< Sign extended before/after call
     StackAlignment,        ///< Alignment of stack for function (3 bits)
                            ///< stored as log2 of alignment with +1 bias 0
                            ///< means unaligned (different from
                            ///< alignstack=(1))
     StackProtect,          ///< Stack protection.

include/llvm/IR/CallSite.h

#define CALLSITE_DELEGATE_SETTER(METHOD) \
   /// @brief Determine if the call does not access or only reads memory.
   bool onlyReadsMemory() const {
     CALLSITE_DELEGATE_GETTER(onlyReadsMemory());
   }
   void setOnlyReadsMemory() {
     CALLSITE_DELEGATE_SETTER(setOnlyReadsMemory());
   }
 
+  /// @brief Determine if the call only reads and writes to/from memory
+  /// locations pointed by it's pointer arguments with arbitrary offsets or
+  /// does not access memory at all.
+  bool readsWritesOnlyArgMem() const {
+    CALLSITE_DELEGATE_GETTER(readsWritesOnlyArgMem());
+  }
+  void setReadWriteOnlyArgMem() {
+    CALLSITE_DELEGATE_SETTER(setReadWriteOnlyArgMem());
+  }
+  
   /// @brief Determine if the call cannot return.
   bool doesNotReturn() const {
     CALLSITE_DELEGATE_GETTER(doesNotReturn());
   }
   void setDoesNotReturn() {
     CALLSITE_DELEGATE_SETTER(setDoesNotReturn());
   }
 

include/llvm/IR/Function.h

bool onlyReadsMemory() const {
     return doesNotAccessMemory() ||
       AttributeSets.hasAttribute(AttributeSet::FunctionIndex,
                                  Attribute::ReadOnly);
   }
   void setOnlyReadsMemory() {
     addFnAttr(Attribute::ReadOnly);
   }
 
+  /// @brief Determine if function only reads and writes to/from memory
+  /// locations pointed by it's pointer arguments with arbitrary offsets or
+  /// does not access memory at all.
+  bool readsWritesOnlyArgMem() const {
+    return doesNotAccessMemory() ||
+           AttributeSets.hasAttribute(AttributeSet::FunctionIndex,
+                                      Attribute::ReadWriteArgMem);
+  }
+  void setReadWriteOnlyArgMem() {
+    addFnAttr(Attribute::ReadWriteArgMem);
+  }
+
   /// @brief Determine if the function cannot return.
   bool doesNotReturn() const {
     return AttributeSets.hasAttribute(AttributeSet::FunctionIndex,
                                       Attribute::NoReturn);
   }
   void setDoesNotReturn() {
     addFnAttr(Attribute::NoReturn);
   }

include/llvm/IR/Instructions.h

public:
   /// \brief Determine if the call does not access or only reads memory.
   bool onlyReadsMemory() const {
     return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
   }
   void setOnlyReadsMemory() {
     addAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly);
   }
 
+  /// \brief Determine if the call only reads and writes to/from memory
+  /// locations pointed by it's pointer arguments with arbitrary offsets or
+  /// does not access memory at all.
+  bool readsWritesOnlyArgMem() const {
+    return doesNotAccessMemory() || hasFnAttr(Attribute::ReadWriteArgMem);
+  }
+  void setReadWriteOnlyArgMem() {
+    addAttribute(AttributeSet::FunctionIndex, Attribute::ReadWriteArgMem);
+  }
+
   /// \brief Determine if the call cannot return.
   bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
   void setDoesNotReturn() {
     addAttribute(AttributeSet::FunctionIndex, Attribute::NoReturn);
   }
 
   /// \brief Determine if the call cannot unwind.
   bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
public:
   /// \brief Determine if the call does not access or only reads memory.
   bool onlyReadsMemory() const {
     return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
   }
   void setOnlyReadsMemory() {
     addAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly);
   }
 
+  /// \brief Determine if the call only reads and writes to/from memory
+  /// locations pointed by it's pointer arguments with arbitrary offsets or
+  /// does not access memory at all.
+  bool readsWritesOnlyArgMem() const {
+    return doesNotAccessMemory() || hasFnAttr(Attribute::ReadWriteArgMem);
+  }
+  void setReadWriteOnlyArgMem() {
+    addAttribute(AttributeSet::FunctionIndex, Attribute::ReadWriteArgMem);
+  }
+
   /// \brief Determine if the call cannot return.
   bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
   void setDoesNotReturn() {
     addAttribute(AttributeSet::FunctionIndex, Attribute::NoReturn);
   }
 
   /// \brief Determine if the call cannot unwind.
   bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }

lib/Analysis/BasicAliasAnalysis.cpp

BasicAliasAnalysis::getModRefBehavior(ImmutableCallSite CS) {
 
   ModRefBehavior Min = UnknownModRefBehavior;
 
   // If the callsite knows it only reads memory, don't return worse
   // than that.
   if (CS.onlyReadsMemory())
     Min = OnlyReadsMemory;
 
+  if (CS.readsWritesOnlyArgMem())
+    Min = OnlyAccessesArgumentPointees;
+
   // The AliasAnalysis base class has some smarts, lets use them.
   return ModRefBehavior(AliasAnalysis::getModRefBehavior(CS) & Min);
 }
 
 /// getModRefBehavior - Return the behavior when calling the given function.
 /// For use when the call site is not known.
 AliasAnalysis::ModRefBehavior
 BasicAliasAnalysis::getModRefBehavior(const Function *F) {
#undef GET_INTRINSIC_MODREF_BEHAVIOR
   }
 
   ModRefBehavior Min = UnknownModRefBehavior;
 
   // If the function declares it only reads memory, go with that.
   if (F->onlyReadsMemory())
     Min = OnlyReadsMemory;
 
+  if (F->readsWritesOnlyArgMem())
+    Min = OnlyAccessesArgumentPointees;
+
+  // TODO: Mark memset with read_write_arg_mem attribute
   const TargetLibraryInfo &TLI =
       getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
   if (isMemsetPattern16(F, TLI))
     Min = OnlyAccessesArgumentPointees;
 
   // Otherwise be conservative.
   return ModRefBehavior(AliasAnalysis::getModRefBehavior(F) & Min);
 }

lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(nonnull);
   KEYWORD(noredzone);
   KEYWORD(noreturn);
   KEYWORD(nounwind);
   KEYWORD(optnone);
   KEYWORD(optsize);
   KEYWORD(readnone);
   KEYWORD(readonly);
+  KEYWORD(read_write_arg_mem);
   KEYWORD(returned);
   KEYWORD(returns_twice);
   KEYWORD(signext);
   KEYWORD(sret);
   KEYWORD(ssp);
   KEYWORD(sspreq);
   KEYWORD(sspstrong);
   KEYWORD(sanitize_address);

lib/AsmParser/LLParser.cpp

case lltok::kw_alignstack: {
           return true;
       } else {
         if (ParseOptionalStackAlignment(Alignment))
           return true;
       }
       B.addStackAlignmentAttr(Alignment);
       continue;
     }
-    case lltok::kw_alwaysinline:      B.addAttribute(Attribute::AlwaysInline); break;
-    case lltok::kw_builtin:           B.addAttribute(Attribute::Builtin); break;
-    case lltok::kw_cold:              B.addAttribute(Attribute::Cold); break;
-    case lltok::kw_convergent:        B.addAttribute(Attribute::Convergent); break;
-    case lltok::kw_inlinehint:        B.addAttribute(Attribute::InlineHint); break;
-    case lltok::kw_jumptable:         B.addAttribute(Attribute::JumpTable); break;
-    case lltok::kw_minsize:           B.addAttribute(Attribute::MinSize); break;
-    case lltok::kw_naked:             B.addAttribute(Attribute::Naked); break;
-    case lltok::kw_nobuiltin:         B.addAttribute(Attribute::NoBuiltin); break;
-    case lltok::kw_noduplicate:       B.addAttribute(Attribute::NoDuplicate); break;
-    case lltok::kw_noimplicitfloat:   B.addAttribute(Attribute::NoImplicitFloat); break;
-    case lltok::kw_noinline:          B.addAttribute(Attribute::NoInline); break;
-    case lltok::kw_nonlazybind:       B.addAttribute(Attribute::NonLazyBind); break;
-    case lltok::kw_noredzone:         B.addAttribute(Attribute::NoRedZone); break;
-    case lltok::kw_noreturn:          B.addAttribute(Attribute::NoReturn); break;
-    case lltok::kw_nounwind:          B.addAttribute(Attribute::NoUnwind); break;
-    case lltok::kw_optnone:           B.addAttribute(Attribute::OptimizeNone); break;
-    case lltok::kw_optsize:           B.addAttribute(Attribute::OptimizeForSize); break;
-    case lltok::kw_readnone:          B.addAttribute(Attribute::ReadNone); break;
-    case lltok::kw_readonly:          B.addAttribute(Attribute::ReadOnly); break;
-    case lltok::kw_returns_twice:     B.addAttribute(Attribute::ReturnsTwice); break;
-    case lltok::kw_ssp:               B.addAttribute(Attribute::StackProtect); break;
-    case lltok::kw_sspreq:            B.addAttribute(Attribute::StackProtectReq); break;
-    case lltok::kw_sspstrong:         B.addAttribute(Attribute::StackProtectStrong); break;
-    case lltok::kw_sanitize_address:  B.addAttribute(Attribute::SanitizeAddress); break;
-    case lltok::kw_sanitize_thread:   B.addAttribute(Attribute::SanitizeThread); break;
-    case lltok::kw_sanitize_memory:   B.addAttribute(Attribute::SanitizeMemory); break;
-    case lltok::kw_uwtable:           B.addAttribute(Attribute::UWTable); break;
+    case lltok::kw_alwaysinline:       B.addAttribute(Attribute::AlwaysInline); break;
+    case lltok::kw_builtin:            B.addAttribute(Attribute::Builtin); break;
+    case lltok::kw_cold:               B.addAttribute(Attribute::Cold); break;
+    case lltok::kw_convergent:         B.addAttribute(Attribute::Convergent); break;
+    case lltok::kw_inlinehint:         B.addAttribute(Attribute::InlineHint); break;
+    case lltok::kw_jumptable:          B.addAttribute(Attribute::JumpTable); break;
+    case lltok::kw_minsize:            B.addAttribute(Attribute::MinSize); break;
+    case lltok::kw_naked:              B.addAttribute(Attribute::Naked); break;
+    case lltok::kw_nobuiltin:          B.addAttribute(Attribute::NoBuiltin); break;
+    case lltok::kw_noduplicate:        B.addAttribute(Attribute::NoDuplicate); break;
+    case lltok::kw_noimplicitfloat:    B.addAttribute(Attribute::NoImplicitFloat); break;
+    case lltok::kw_noinline:           B.addAttribute(Attribute::NoInline); break;
+    case lltok::kw_nonlazybind:        B.addAttribute(Attribute::NonLazyBind); break;
+    case lltok::kw_noredzone:          B.addAttribute(Attribute::NoRedZone); break;
+    case lltok::kw_noreturn:           B.addAttribute(Attribute::NoReturn); break;
+    case lltok::kw_nounwind:           B.addAttribute(Attribute::NoUnwind); break;
+    case lltok::kw_optnone:            B.addAttribute(Attribute::OptimizeNone); break;
+    case lltok::kw_optsize:            B.addAttribute(Attribute::OptimizeForSize); break;
+    case lltok::kw_readnone:           B.addAttribute(Attribute::ReadNone); break;
+    case lltok::kw_readonly:           B.addAttribute(Attribute::ReadOnly); break;
+    case lltok::kw_read_write_arg_mem: B.addAttribute(Attribute::ReadWriteArgMem); break;
+    case lltok::kw_returns_twice:      B.addAttribute(Attribute::ReturnsTwice); break;
+    case lltok::kw_ssp:                B.addAttribute(Attribute::StackProtect); break;
+    case lltok::kw_sspreq:             B.addAttribute(Attribute::StackProtectReq); break;
+    case lltok::kw_sspstrong:          B.addAttribute(Attribute::StackProtectStrong); break;
+    case lltok::kw_sanitize_address:   B.addAttribute(Attribute::SanitizeAddress); break;
+    case lltok::kw_sanitize_thread:    B.addAttribute(Attribute::SanitizeThread); break;
+    case lltok::kw_sanitize_memory:    B.addAttribute(Attribute::SanitizeMemory); break;
+    case lltok::kw_uwtable:            B.addAttribute(Attribute::UWTable); break;
 
     // Error handling.
     case lltok::kw_inreg:
     case lltok::kw_signext:
     case lltok::kw_zeroext:
       HaveError |=
         Error(Lex.getLoc(),
               "invalid use of attribute on a function");
while (1) {
     case lltok::kw_returns_twice:
     case lltok::kw_sanitize_address:
     case lltok::kw_sanitize_memory:
     case lltok::kw_sanitize_thread:
     case lltok::kw_ssp:
     case lltok::kw_sspreq:
     case lltok::kw_sspstrong:
     case lltok::kw_uwtable:
+    case lltok::kw_read_write_arg_mem:
       HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
       break;
     }
 
     Lex.Lex();
   }
 }
 
while (1) {
     case lltok::kw_returns_twice:
     case lltok::kw_sanitize_address:
     case lltok::kw_sanitize_memory:
     case lltok::kw_sanitize_thread:
     case lltok::kw_ssp:
     case lltok::kw_sspreq:
     case lltok::kw_sspstrong:
     case lltok::kw_uwtable:
+    case lltok::kw_read_write_arg_mem:
       HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
       break;
 
     case lltok::kw_readnone:
     case lltok::kw_readonly:
       HaveError |= Error(Lex.getLoc(), "invalid use of attribute on return type");
     }
 

lib/AsmParser/LLToken.h

enum Kind {
     kw_nonnull,
     kw_noredzone,
     kw_noreturn,
     kw_nounwind,
     kw_optnone,
     kw_optsize,
     kw_readnone,
     kw_readonly,
+    kw_read_write_arg_mem,
     kw_returned,
     kw_returns_twice,
     kw_signext,
     kw_ssp,
     kw_sspreq,
     kw_sspstrong,
     kw_sret,
     kw_sanitize_thread,

lib/Bitcode/Reader/BitcodeReader.cpp

static Attribute::AttrKind GetAttrFromCode(uint64_t Code) {
   case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE:
     return Attribute::OptimizeForSize;
   case bitc::ATTR_KIND_OPTIMIZE_NONE:
     return Attribute::OptimizeNone;
   case bitc::ATTR_KIND_READ_NONE:
     return Attribute::ReadNone;
   case bitc::ATTR_KIND_READ_ONLY:
     return Attribute::ReadOnly;
+  case bitc::ATTR_KIND_READ_WRITE_ARG_MEM:
+    return Attribute::ReadWriteArgMem;
   case bitc::ATTR_KIND_RETURNED:
     return Attribute::Returned;
   case bitc::ATTR_KIND_RETURNS_TWICE:
     return Attribute::ReturnsTwice;
   case bitc::ATTR_KIND_S_EXT:
     return Attribute::SExt;
   case bitc::ATTR_KIND_STACK_ALIGNMENT:
     return Attribute::StackAlignment;

lib/Bitcode/Writer/BitcodeWriter.cpp

static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
   case Attribute::OptimizeForSize:
     return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE;
   case Attribute::OptimizeNone:
     return bitc::ATTR_KIND_OPTIMIZE_NONE;
   case Attribute::ReadNone:
     return bitc::ATTR_KIND_READ_NONE;
   case Attribute::ReadOnly:
     return bitc::ATTR_KIND_READ_ONLY;
+  case Attribute::ReadWriteArgMem:
+    return bitc::ATTR_KIND_READ_WRITE_ARG_MEM;
   case Attribute::Returned:
     return bitc::ATTR_KIND_RETURNED;
   case Attribute::ReturnsTwice:
     return bitc::ATTR_KIND_RETURNS_TWICE;
   case Attribute::SExt:
     return bitc::ATTR_KIND_S_EXT;
   case Attribute::StackAlignment:
     return bitc::ATTR_KIND_STACK_ALIGNMENT;

lib/IR/Attributes.cpp

std::string Attribute::getAsString(bool InAttrGrp) const {
   if (hasAttribute(Attribute::OptimizeNone))
     return "optnone";
   if (hasAttribute(Attribute::OptimizeForSize))
     return "optsize";
   if (hasAttribute(Attribute::ReadNone))
     return "readnone";
   if (hasAttribute(Attribute::ReadOnly))
     return "readonly";
+  if (hasAttribute(Attribute::ReadWriteArgMem))
+    return "read_write_arg_mem";
   if (hasAttribute(Attribute::Returned))
     return "returned";
   if (hasAttribute(Attribute::ReturnsTwice))
     return "returns_twice";
   if (hasAttribute(Attribute::SExt))
     return "signext";
   if (hasAttribute(Attribute::StackProtect))
     return "ssp";
uint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) {
   case Attribute::Convergent:      return 1ULL << 46;
   case Attribute::Dereferenceable:
     llvm_unreachable("dereferenceable attribute not supported in raw format");
     break;
   case Attribute::DereferenceableOrNull:
     llvm_unreachable("dereferenceable_or_null attribute not supported in raw "
                      "format");
     break;
+  case Attribute::ReadWriteArgMem:
+    llvm_unreachable("read_write_arg_mem attribute not supported in raw format");
+    break;
   }
   llvm_unreachable("Unsupported attribute type");
 }
 
 //===----------------------------------------------------------------------===//
 // AttributeSetNode Definition
 //===----------------------------------------------------------------------===//
 

 
 AttrBuilder &AttrBuilder::addRawValue(uint64_t Val) {
   // FIXME: Remove this in 4.0.
   if (!Val) return *this;
 
   for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
        I = Attribute::AttrKind(I + 1)) {
     if (I == Attribute::Dereferenceable ||
-        I == Attribute::DereferenceableOrNull)
+        I == Attribute::DereferenceableOrNull ||
+        I == Attribute::ReadWriteArgMem)
       continue;
     if (uint64_t A = (Val & AttributeImpl::getAttrMask(I))) {
       Attrs[I] = true;
  
       if (I == Attribute::Alignment)
         Alignment = 1ULL << ((A >> 16) - 1);
       else if (I == Attribute::StackAlignment)
         StackAlignment = 1ULL << ((A >> 26)-1);

lib/IR/Verifier.cpp

if (I->getKindAsEnum() == Attribute::NoReturn ||
         I->getKindAsEnum() == Attribute::SanitizeMemory ||
         I->getKindAsEnum() == Attribute::MinSize ||
         I->getKindAsEnum() == Attribute::NoDuplicate ||
         I->getKindAsEnum() == Attribute::Builtin ||
         I->getKindAsEnum() == Attribute::NoBuiltin ||
         I->getKindAsEnum() == Attribute::Cold ||
         I->getKindAsEnum() == Attribute::OptimizeNone ||
         I->getKindAsEnum() == Attribute::JumpTable ||
-        I->getKindAsEnum() == Attribute::Convergent) {
+        I->getKindAsEnum() == Attribute::Convergent ||
+        I->getKindAsEnum() == Attribute::ReadWriteArgMem) {
       if (!isFunction) {
         CheckFailed("Attribute '" + I->getAsString() +
                     "' only applies to functions!", V);
         return;
       }
     } else if (I->getKindAsEnum() == Attribute::ReadOnly ||
                I->getKindAsEnum() == Attribute::ReadNone) {
       if (Idx == 0) {
void Verifier::VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs,
   VerifyAttributeTypes(Attrs, AttributeSet::FunctionIndex, true, V);
 
   Assert(
       !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) &&
         Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly)),
       "Attributes 'readnone and readonly' are incompatible!", V);
 
   Assert(
+      !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) &&
+        Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadWriteArgMem)),
+      "Attributes 'readnone and read_write_arg_mem' are incompatible!", V);
+
+  Assert(
+      !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly) &&
+        Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadWriteArgMem)),
+      "Attributes 'readonly and read_write_arg_mem' are incompatible!", V);
+  
+  Assert(
       !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline) &&
         Attrs.hasAttribute(AttributeSet::FunctionIndex,
                            Attribute::AlwaysInline)),
       "Attributes 'noinline and alwaysinline' are incompatible!", V);
 
   if (Attrs.hasAttribute(AttributeSet::FunctionIndex, 
                          Attribute::OptimizeNone)) {
     Assert(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline),

 /// \brief Verify that statepoint intrinsic is well formed.
 void Verifier::VerifyStatepoint(ImmutableCallSite CS) {
   assert(CS.getCalledFunction() &&
          CS.getCalledFunction()->getIntrinsicID() ==
            Intrinsic::experimental_gc_statepoint);
 
   const Instruction &CI = *CS.getInstruction();
 
-  Assert(!CS.doesNotAccessMemory() && !CS.onlyReadsMemory(),
+  Assert(!CS.doesNotAccessMemory() && !CS.onlyReadsMemory() &&
+         !CS.readsWritesOnlyArgMem(),
          "gc.statepoint must read and write memory to preserve "
          "reordering restrictions required by safepoint semantics",
          &CI);
 
   const Value *IDV = CS.getArgument(0);
   Assert(isa<ConstantInt>(IDV), "gc.statepoint ID must be a constant integer",
          &CI);
 

test/Analysis/BasicAA/modref.ll

entry:
   %tmp = load i32, i32* %x, align 4
   ret i32 %tmp
 ; CHECK-LABEL: @test7(
 ; CHECK: store i32 0
 ; CHECK: call void @test7decl
 ; CHECK: load i32, i32*
 }
 
+;; Check that aa correctly handles functions marked with read_write_arg_mem
+;; attribute.
+declare i32 @func_read_write_arg_mem(i32 *byval %P)
+
+;; Can not remove redundant load, function may write to it.
+; CHECK-LABEL: @test8(
+define i32 @test8(i32 *%P) {
+  %V1 = load i32, i32* %P
+  call i32 @func_read_write_arg_mem(i32* %P)
+  %V2 = load i32, i32* %P
+  %Diff = sub i32 %V1, %V2
+  ret i32 %Diff
+  ; CHECK: load
+  ; CHECK: load
+  ; CHECK: sub
+  ; CHECK: ret i32 %Diff
+}
+
+;; In this case load can be removed, function clobbers only %P2.
+; CHECK-LABEL: @test9(
+define i32 @test9(i32 *byval %P, i32 *byval %P2) {
+  %V1 = load i32, i32* %P
+  call i32 @func_read_write_arg_mem(i32* %P2)
+  %V2 = load i32, i32* %P
+  %Diff = sub i32 %V1, %V2
+  ret i32 %Diff
+  ; CHECK-NOT: load
+  ; CHECK: ret i32 0
+}
+
+;; In this case load can *not* be removed. Function clobers only %P2 but it may
+;; alias with %P.
+; CHECK-LABEL: @test10(
+define i32 @test10(i32* %P, i32* %P2) {
+  %V1 = load i32, i32* %P
+  call i32 @func_read_write_arg_mem(i32* %P2)
+  %V2 = load i32, i32* %P
+  %Diff = sub i32 %V1, %V2
+  ret i32 %Diff
+  ; CHECK: load
+  ; CHECK: load
+  ; CHECK: sub
+  ; CHECK: ret i32 %Diff
+}
+
 declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) nounwind
 declare void @llvm.memset.p0i8.i8(i8* nocapture, i8, i8, i32, i1) nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i8(i8* nocapture, i8* nocapture, i8, i32, i1) nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind

test/Bitcode/attributes.ll

 }
 
 declare void @nobuiltin()
 
 define void @f34()
 ; CHECK: define void @f34()
 {
         call void @nobuiltin() nobuiltin
-; CHECK: call void @nobuiltin() #26
+; CHECK: call void @nobuiltin() #27
         ret void;
 }
 
 define void @f35() optnone noinline
 ; CHECK: define void @f35() #23
 {
         ret void;
 }
entry:
   ret i8* %foo
 }
 
 ; CHECK: define void @f43() #25
 define void @f43() convergent {
   ret void
 }
 
+define void @f44() read_write_arg_mem
+; CHECK: define void @f44() #26
+{
+        ret void;
+}
+
 ; CHECK: attributes #0 = { noreturn }
 ; CHECK: attributes #1 = { nounwind }
 ; CHECK: attributes #2 = { readnone }
 ; CHECK: attributes #3 = { readonly }
 ; CHECK: attributes #4 = { noinline }
 ; CHECK: attributes #5 = { alwaysinline }
 ; CHECK: attributes #6 = { optsize }
 ; CHECK: attributes #7 = { ssp }

 ; CHECK: attributes #18 = { sanitize_thread }
 ; CHECK: attributes #19 = { sanitize_memory }
 ; CHECK: attributes #20 = { "cpu"="cortex-a8" }
 ; CHECK: attributes #21 = { sspstrong }
 ; CHECK: attributes #22 = { minsize }
 ; CHECK: attributes #23 = { noinline optnone }
 ; CHECK: attributes #24 = { jumptable }
 ; CHECK: attributes #25 = { convergent }
-; CHECK: attributes #26 = { nobuiltin }
+; CHECK: attributes #26 = { read_write_arg_mem }
+; CHECK: attributes #27 = { nobuiltin }

test/Verifier/invalid-statepoint3.ll

+; RUN: not opt -S < %s -verify 2>&1 | FileCheck %s
+
+; CHECK: gc.statepoint must read and write memory to preserve reordering restrictions required by safepoint semantics
+
+declare void @use(...)
+declare i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32, i32, i32)
+declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
+
+define i8 addrspace(1)* @test1(i8 addrspace(1)* %arg) gc "statepoint-example" {
+entry:
+  %safepoint_token = call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* undef, i32 0, i32 0, i32 0, i32 0, i8 addrspace(1)* %arg) readnone
+  %reloc = call i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %safepoint_token, i32 7, i32 7)
+  ret i8 addrspace(1)* %reloc
+}
+
+; CHECK: gc.statepoint must read and write memory to preserve reordering restrictions required by safepoint semantics
+
+define i8 addrspace(1)* @test2(i8 addrspace(1)* %arg) gc "statepoint-example" {
+entry:
+  %safepoint_token = call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* undef, i32 0, i32 0, i32 0, i32 0, i8 addrspace(1)* %arg) readnone
+  %reloc = call i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %safepoint_token, i32 7, i32 7)
+  ret i8 addrspace(1)* %reloc
+}
+
+; CHECK: gc.statepoint must read and write memory to preserve reordering restrictions required by safepoint semantics
+
+define i8 addrspace(1)* @test3(i8 addrspace(1)* %arg) gc "statepoint-example" {
+entry:
+  %safepoint_token = call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* undef, i32 0, i32 0, i32 0, i32 0, i8 addrspace(1)* %arg) readnone
+  %reloc = call i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %safepoint_token, i32 7, i32 7)
+  ret i8 addrspace(1)* %reloc
+}

test/Verifier/read_write_arg_mem.ll

+; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
+; Sanity checks for read_write_arg_mem attribute
+
+declare void @a(i64* %p) readnone read_write_arg_mem
+; CHECK: Attributes {{.*}} are incompatible
+
+declare void @b(i64* %p) readonly read_write_arg_mem
+; CHECK: Attributes {{.*}} are incompatible