[PATCH 04/27] [noalias] [IR] parse optional ptr_provenance argument on load/store instructions

[jeroen.dobbelaere]

Summary

This is part of the series started by D68484.

Note: support for the ptr_provenance parameter in LLVM IR bitcode is missing.

Note: this is a stable point and tests should run fine with the patches applied up to this point.

[jeroen.dobbelaere]

Rebased

[jeroen.dobbelaere]

Rebased to c06b7e2ab5167ad031745a706204abed1aefd823 (July 14, 2020)

[jeroen.dobbelaere]

Rebased to 9fb46a452d4e5666828c95610ceac8dcd9e4ce16 (September 7, 2020)

[jeroen.dobbelaere]

Rebased to f8dbd61074176bae92ec360a093ac7bc498c9321.

llvm/include/llvm/AsmParser/LLParser.h

bool parseOptionalAlignment(MaybeAlign &Alignment,
                                 bool AllowParens = false);
     bool parseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);
     bool parseScopeAndOrdering(bool IsAtomic, SyncScope::ID &SSID,
                                AtomicOrdering &Ordering);
     bool parseScope(SyncScope::ID &SSID);
     bool parseOrdering(AtomicOrdering &Ordering);
     bool parseOptionalStackAlignment(unsigned &Alignment);
     bool parseOptionalCommaAlign(MaybeAlign &Alignment, bool &AteExtraComma);
+    bool parseOptionalCommaNoaliasProvenance(Value *&V, LocTy &Loc,
+                                             PerFunctionState &PFS,
+                                             bool &AteExtraComma);
     bool parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
                                      bool &AteExtraComma);
     bool parseOptionalCommaInAlloca(bool &IsInAlloca);
     bool parseAllocSizeArguments(unsigned &BaseSizeArg,
                                  Optional<unsigned> &HowManyArg);
     bool parseVScaleRangeArguments(unsigned &MinValue, unsigned &MaxValue);
     bool parseIndexList(SmallVectorImpl<unsigned> &Indices,
                         bool &AteExtraComma);

llvm/include/llvm/AsmParser/LLToken.h

enum Kind {
   kw_notail,
   kw_target,
   kw_triple,
   kw_source_filename,
   kw_unwind,
   kw_deplibs, // FIXME: Remove in 4.0
   kw_datalayout,
   kw_volatile,
+  kw_ptr_provenance,
   kw_atomic,
   kw_unordered,
   kw_monotonic,
   kw_acquire,
   kw_release,
   kw_acq_rel,
   kw_seq_cst,
   kw_syncscope,

llvm/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(notail);
   KEYWORD(target);
   KEYWORD(triple);
   KEYWORD(source_filename);
   KEYWORD(unwind);
   KEYWORD(deplibs);             // FIXME: Remove in 4.0.
   KEYWORD(datalayout);
   KEYWORD(volatile);
+  KEYWORD(ptr_provenance);
   KEYWORD(atomic);
   KEYWORD(unordered);
   KEYWORD(monotonic);
   KEYWORD(acquire);
   KEYWORD(release);
   KEYWORD(acq_rel);
   KEYWORD(seq_cst);
   KEYWORD(syncscope);

llvm/lib/AsmParser/LLParser.cpp

 /// parseOptionalCommaAlign
 ///   ::=
 ///   ::= ',' align 4
 ///
 /// This returns with AteExtraComma set to true if it ate an excess comma at the
 /// end.
 bool LLParser::parseOptionalCommaAlign(MaybeAlign &Alignment,
                                        bool &AteExtraComma) {
+  while (AteExtraComma || EatIfPresent(lltok::comma)) {
     AteExtraComma = false;
-  while (EatIfPresent(lltok::comma)) {
     // Metadata at the end is an early exit.
     if (Lex.getKind() == lltok::MetadataVar) {
       AteExtraComma = true;
       return false;
     }
 
-    if (Lex.getKind() != lltok::kw_align)
+    // if we get here, ptr_provenance must not be possible any more
+    if (Lex.getKind() == lltok::kw_ptr_provenance)
       return error(Lex.getLoc(), "expected metadata or 'align'");
+    if (Lex.getKind() != lltok::kw_align)
+      return error(Lex.getLoc(),
+                   "expected metadata or 'align' or 'ptr_provenance'");
 
     if (parseOptionalAlignment(Alignment))
       return true;
   }
 
   return false;
 }
 
+/// parseOptionalCommandNoaliasProvenance
+///   ::=
+///   ::= ',' ptr_provenance int* %3
+///
+/// This returns with AteExtraComma set to true if it ate an excess comma at the
+/// end.
+bool LLParser::parseOptionalCommaNoaliasProvenance(
+    Value *&V, LLParser::LocTy &Loc, LLParser::PerFunctionState &PFS,
+    bool &AteExtraComma) {
+  assert(AteExtraComma == false);
+  if (EatIfPresent(lltok::comma)) {
+    if (Lex.getKind() == lltok::kw_ptr_provenance) {
+      Lex.Lex();
+      return parseTypeAndValue(V, Loc, PFS);
+    }
+
+    AteExtraComma = true;
+  }
+  return false;
+}
+
 /// parseOptionalCommaAddrSpace
 ///   ::=
 ///   ::= ',' addrspace(1)
 ///
 /// This returns with AteExtraComma set to true if it ate an excess comma at the
 /// end.
 bool LLParser::parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
                                            bool &AteExtraComma) {

 }
 
 /// parseLoad
 ///   ::= 'load' 'volatile'? TypeAndValue (',' 'align' i32)?
 ///   ::= 'load' 'atomic' 'volatile'? TypeAndValue
 ///       'singlethread'? AtomicOrdering (',' 'align' i32)?
 int LLParser::parseLoad(Instruction *&Inst, PerFunctionState &PFS) {
   Value *Val; LocTy Loc;
+  Value *NoaliasProvenance = nullptr;
+  LocTy NoaliasProvenanceLoc;
   MaybeAlign Alignment;
   bool AteExtraComma = false;
   bool isAtomic = false;
   AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
   SyncScope::ID SSID = SyncScope::System;
 
   if (Lex.getKind() == lltok::kw_atomic) {
     isAtomic = true;
     Lex.Lex();
   }
 
   bool isVolatile = false;
   if (Lex.getKind() == lltok::kw_volatile) {
     isVolatile = true;
     Lex.Lex();
   }
 
   Type *Ty;
   LocTy ExplicitTypeLoc = Lex.getLoc();
   if (parseType(Ty) ||
       parseToken(lltok::comma, "expected comma after load's type") ||
       parseTypeAndValue(Val, Loc, PFS) ||
       parseScopeAndOrdering(isAtomic, SSID, Ordering) ||
+      parseOptionalCommaNoaliasProvenance(
+          NoaliasProvenance, NoaliasProvenanceLoc, PFS, AteExtraComma) ||
       parseOptionalCommaAlign(Alignment, AteExtraComma))
     return true;
 
   if (!Val->getType()->isPointerTy() || !Ty->isFirstClassType())
     return error(Loc, "load operand must be a pointer to a first class type");
   if (isAtomic && !Alignment)
     return error(Loc, "atomic load must have explicit non-zero alignment");
   if (Ordering == AtomicOrdering::Release ||
       Ordering == AtomicOrdering::AcquireRelease)
     return error(Loc, "atomic load cannot use Release ordering");
 
   if (Ty != cast<PointerType>(Val->getType())->getElementType()) {
     return error(
         ExplicitTypeLoc,
         typeComparisonErrorMessage(
             "explicit pointee type doesn't match operand's pointee type", Ty,
             cast<PointerType>(Val->getType())->getElementType()));
   }
   SmallPtrSet<Type *, 4> Visited;
   if (!Alignment && !Ty->isSized(&Visited))
     return error(ExplicitTypeLoc, "loading unsized types is not allowed");
   if (!Alignment)
     Alignment = M->getDataLayout().getABITypeAlign(Ty);
-  Inst = new LoadInst(Ty, Val, "", isVolatile, *Alignment, Ordering, SSID);
+  auto *LI = new LoadInst(Ty, Val, "", isVolatile, *Alignment, Ordering, SSID);
+  if (NoaliasProvenance)
+    LI->setNoaliasProvenanceOperand(NoaliasProvenance);
+  Inst = LI;
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
 /// parseStore
 
 ///   ::= 'store' 'volatile'? TypeAndValue ',' TypeAndValue (',' 'align' i32)?
 ///   ::= 'store' 'atomic' 'volatile'? TypeAndValue ',' TypeAndValue
 ///       'singlethread'? AtomicOrdering (',' 'align' i32)?
 int LLParser::parseStore(Instruction *&Inst, PerFunctionState &PFS) {
   Value *Val, *Ptr; LocTy Loc, PtrLoc;
+  Value *NoaliasProvenance = nullptr;
+  LocTy NoaliasProvenanceLoc;
   MaybeAlign Alignment;
   bool AteExtraComma = false;
   bool isAtomic = false;
   AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
   SyncScope::ID SSID = SyncScope::System;
 
   if (Lex.getKind() == lltok::kw_atomic) {
     isAtomic = true;
     Lex.Lex();
   }
 
   bool isVolatile = false;
   if (Lex.getKind() == lltok::kw_volatile) {
     isVolatile = true;
     Lex.Lex();
   }
 
   if (parseTypeAndValue(Val, Loc, PFS) ||
       parseToken(lltok::comma, "expected ',' after store operand") ||
       parseTypeAndValue(Ptr, PtrLoc, PFS) ||
       parseScopeAndOrdering(isAtomic, SSID, Ordering) ||
+      parseOptionalCommaNoaliasProvenance(
+          NoaliasProvenance, NoaliasProvenanceLoc, PFS, AteExtraComma) ||
       parseOptionalCommaAlign(Alignment, AteExtraComma))
     return true;
 
   if (!Ptr->getType()->isPointerTy())
     return error(PtrLoc, "store operand must be a pointer");
   if (!Val->getType()->isFirstClassType())
     return error(Loc, "store operand must be a first class value");
   if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
     return error(Loc, "stored value and pointer type do not match");
   if (isAtomic && !Alignment)
     return error(Loc, "atomic store must have explicit non-zero alignment");
   if (Ordering == AtomicOrdering::Acquire ||
       Ordering == AtomicOrdering::AcquireRelease)
     return error(Loc, "atomic store cannot use Acquire ordering");
   SmallPtrSet<Type *, 4> Visited;
   if (!Alignment && !Val->getType()->isSized(&Visited))
     return error(Loc, "storing unsized types is not allowed");
   if (!Alignment)
     Alignment = M->getDataLayout().getABITypeAlign(Val->getType());
 
-  Inst = new StoreInst(Val, Ptr, isVolatile, *Alignment, Ordering, SSID);
+  auto *SI = new StoreInst(Val, Ptr, isVolatile, *Alignment, Ordering, SSID);
+  if (NoaliasProvenance)
+    SI->setNoaliasProvenanceOperand(NoaliasProvenance);
+  Inst = SI;
+
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
 /// parseCmpXchg
 ///   ::= 'cmpxchg' 'weak'? 'volatile'? TypeAndValue ',' TypeAndValue ','
 ///       TypeAndValue 'singlethread'? AtomicOrdering AtomicOrdering ','
 ///       'Align'?
 int LLParser::parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) {

llvm/test/Bitcode/loadstore_ptr_provenance.ll

+; RUN: opt --verify -S < %s | FileCheck %s
+; Activate when bitcode support is added:
+; R U N: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
+; R U N: verify-uselistorder < %s
+
+define i32 @f(i32* %p, i32* %q, i32* %word, i32** %base) {
+  ; CHECK:      define i32 @f(i32* %p, i32* %q, i32* %word, i32** %base) {
+  store i32 42, i32* %p, ptr_provenance i32* %p
+  ; CHECK-NEXT:   store i32 42, i32* %p, ptr_provenance i32* %p
+  store i32 43, i32* %q, ptr_provenance i32* %q
+  ; CHECK-NEXT:   store i32 43, i32* %q, ptr_provenance i32* %q
+  %r = load i32, i32* %p, ptr_provenance i32* %p
+  ; CHECK-NEXT:   %r = load i32, i32* %p, ptr_provenance i32* %p
+
+  %ld.1p = load atomic i32, i32* %word monotonic, ptr_provenance i32* %word, align 4
+  ; CHECK: %ld.1p = load atomic i32, i32* %word monotonic, ptr_provenance i32* %word, align 4
+  %ld.2p = load atomic volatile i32, i32* %word acquire, ptr_provenance i32* %word, align 8
+  ; CHECK: %ld.2p = load atomic volatile i32, i32* %word acquire, ptr_provenance i32* %word, align 8
+  %ld.3p = load atomic volatile i32, i32* %word syncscope("singlethread") seq_cst, ptr_provenance i32* %word, align 16
+  ; CHECK: %ld.3p = load atomic volatile i32, i32* %word syncscope("singlethread") seq_cst, ptr_provenance i32* %word, align 16
+
+  store atomic i32 23, i32* %word monotonic, align 4
+  ; CHECK: store atomic i32 23, i32* %word monotonic, align 4
+  store atomic volatile i32 24, i32* %word monotonic, align 4
+  ; CHECK: store atomic volatile i32 24, i32* %word monotonic, align 4
+  store atomic volatile i32 25, i32* %word syncscope("singlethread") monotonic, align 4
+   ; CHECK: store atomic volatile i32 25, i32* %word syncscope("singlethread") monotonic, align 4
+
+  load i32*, i32** %base, ptr_provenance i32** %base, align 8, !invariant.load !0, !nontemporal !1, !nonnull !0, !dereferenceable !2, !dereferenceable_or_null !2
+  ; CHECK: load i32*, i32** %base, ptr_provenance i32** %base, align 8, !invariant.load !0, !nontemporal !1, !nonnull !0, !dereferenceable !2, !dereferenceable_or_null !2
+  load volatile i32*, i32** %base, ptr_provenance i32** %base, align 8, !invariant.load !0, !nontemporal !1, !nonnull !0, !dereferenceable !2, !dereferenceable_or_null !2
+  ; CHECK: load volatile i32*, i32** %base, ptr_provenance i32** %base, align 8, !invariant.load !0, !nontemporal !1, !nonnull !0, !dereferenceable !2, !dereferenceable_or_null !2
+
+  store i32* null, i32** %base, ptr_provenance i32** %base, align 4, !nontemporal !1
+  ; CHECK: store i32* null, i32** %base, ptr_provenance i32** %base, align 4, !nontemporal !1
+  store volatile i32* null, i32** %base, ptr_provenance i32** %base, align 4, !nontemporal !1
+  ; CHECK: store volatile i32* null, i32** %base, ptr_provenance i32** %base, align 4, !nontemporal !1
+
+  ret i32 %r
+  ; CHECK-NEXT:   ret i32 %r
+}
+
+!0 = !{i32 1}
+!1 = !{}
+!2 = !{i64 4}