[ptr_provenance] Parser support for the optional ptr_provenance operand

[jeroen.dobbelaere]

Summary

This patch introduces parser support for the optional ptr_provenance operand for load/store instructions.

Note: this patch corresponds to D68489

[jeroen.dobbelaere]

• Rebased

[jeroen.dobbelaere]

Rebased

[jeroen.dobbelaere]

Also test that parsing unknown_provenance works.

[jeroen.dobbelaere]

Updated after LLLexer change in D111160

[jeroen.dobbelaere]

Rebase to 49cb4fef02e635bf304906232214166c7531d753

[jeroen.dobbelaere]

Rebased to ffe262a198a9f9030991df6d3ddd812e74fa3523

[jdoerfert]

This looks fine, one comment to consider.

llvm/lib/AsmParser/LLParser.cpp

2351–2352

Are we sure AteExtraComma is initialized here? Often people pass an unitialized value into a reference.

[jeroen.dobbelaere]

Rebased to ef545ef62a833152d8975ff16333b57cc41befcc (Jan 9, 2023)

[jeroen.dobbelaere]

Rebased to: 8c7cfa357280dd93d33b10bbba0fe33797e27d63 (Feb 14, 2023)

llvm/include/llvm/AsmParser/LLParser.h

private:
     bool parseAllocKind(AllocFnKind &Kind);
     std::optional<MemoryEffects> parseMemoryAttr();
     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 parseOptionalCommaPtrProvenance(Value *&V, LocTy &Loc,
+                                         PerFunctionState &PFS,
+                                         bool &AteExtraComma);
     bool parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
                                      bool &AteExtraComma);
     bool parseAllocSizeArguments(unsigned &BaseSizeArg,
                                  std::optional<unsigned> &HowManyArg);
     bool parseVScaleRangeArguments(unsigned &MinValue, unsigned &MaxValue);
     bool parseIndexList(SmallVectorImpl<unsigned> &Indices,
                         bool &AteExtraComma);
     bool parseIndexList(SmallVectorImpl<unsigned> &Indices) {

llvm/include/llvm/AsmParser/LLToken.h

enum Kind {
   kw_musttail,
   kw_notail,
   kw_target,
   kw_triple,
   kw_source_filename,
   kw_unwind,
   kw_datalayout,
   kw_volatile,
+  kw_ptr_provenance,
   kw_unknown_provenance,
   kw_atomic,
   kw_unordered,
   kw_monotonic,
   kw_acquire,
   kw_release,
   kw_acq_rel,
   kw_seq_cst,

llvm/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(musttail);
   KEYWORD(notail);
   KEYWORD(target);
   KEYWORD(triple);
   KEYWORD(source_filename);
   KEYWORD(unwind);
   KEYWORD(datalayout);
   KEYWORD(volatile);
+  KEYWORD(ptr_provenance);
   KEYWORD(unknown_provenance);
   KEYWORD(atomic);
   KEYWORD(unordered);
   KEYWORD(monotonic);
   KEYWORD(acquire);
   KEYWORD(release);
   KEYWORD(acq_rel);
   KEYWORD(seq_cst);

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;
 }
 
+/// parseOptionalCommandPtrProvenance
+///   ::=
+///   ::= ',' ptr_provenance int* %3
+///
+/// This returns with AteExtraComma set to true if it ate an excess comma at the
+/// end.
+bool LLParser::parseOptionalCommaPtrProvenance(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 *PtrProvenance = nullptr;
+  LocTy PtrProvenanceLoc;
   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) ||
+      parseOptionalCommaPtrProvenance(PtrProvenance, PtrProvenanceLoc, 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 (!cast<PointerType>(Val->getType())->isOpaqueOrPointeeTypeMatches(Ty)) {
     return error(
         ExplicitTypeLoc,
         typeComparisonErrorMessage(
             "explicit pointee type doesn't match operand's pointee type", Ty,
             Val->getType()->getNonOpaquePointerElementType()));
   }
   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 (PtrProvenance)
+    LI->setPtrProvenanceOperand(PtrProvenance);
+  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 *PtrProvenance = nullptr;
+  LocTy PtrProvenanceLoc;
   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) ||
+      parseOptionalCommaPtrProvenance(PtrProvenance, PtrProvenanceLoc, 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())
            ->isOpaqueOrPointeeTypeMatches(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 (PtrProvenance)
+    SI->setPtrProvenanceOperand(PtrProvenance);
+  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 -passes=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(ptr %p, ptr %q, ptr %word, ptr %base) {
+  ; CHECK:      define i32 @f(ptr %p, ptr %q, ptr %word, ptr %base) {
+  store i32 42, ptr %p, ptr_provenance ptr %p
+  ; CHECK-NEXT:   store i32 42, ptr %p, ptr_provenance ptr %p
+  store i32 43, ptr %q, ptr_provenance ptr %q
+  ; CHECK-NEXT:   store i32 43, ptr %q, ptr_provenance ptr %q
+  %r = load i32, ptr %p, ptr_provenance ptr %p
+  ; CHECK-NEXT:   %r = load i32, ptr %p, ptr_provenance ptr %p
+
+  store i32 42, ptr %p, ptr_provenance ptr unknown_provenance
+  ; CHECK-NEXT:   store i32 42, ptr %p, ptr_provenance ptr unknown_provenance
+  store i32 43, ptr %q, ptr_provenance ptr unknown_provenance
+  ; CHECK-NEXT:   store i32 43, ptr %q, ptr_provenance ptr unknown_provenance
+  %r2 = load i32, ptr %p, ptr_provenance ptr unknown_provenance
+  ; CHECK-NEXT:   %r2 = load i32, ptr %p, ptr_provenance ptr unknown_provenance
+
+  %ld.1p = load atomic i32, ptr %word monotonic, ptr_provenance ptr %word, align 4
+  ; CHECK: %ld.1p = load atomic i32, ptr %word monotonic, ptr_provenance ptr %word, align 4
+  %ld.2p = load atomic volatile i32, ptr %word acquire, ptr_provenance ptr %word, align 8
+  ; CHECK: %ld.2p = load atomic volatile i32, ptr %word acquire, ptr_provenance ptr %word, align 8
+  %ld.3p = load atomic volatile i32, ptr %word syncscope("singlethread") seq_cst, ptr_provenance ptr %word, align 16
+  ; CHECK: %ld.3p = load atomic volatile i32, ptr %word syncscope("singlethread") seq_cst, ptr_provenance ptr %word, align 16
+
+  store atomic i32 23, ptr %word monotonic, align 4
+  ; CHECK: store atomic i32 23, ptr %word monotonic, align 4
+  store atomic volatile i32 24, ptr %word monotonic, align 4
+  ; CHECK: store atomic volatile i32 24, ptr %word monotonic, align 4
+  store atomic volatile i32 25, ptr %word syncscope("singlethread") monotonic, align 4
+   ; CHECK: store atomic volatile i32 25, ptr %word syncscope("singlethread") monotonic, align 4
+
+  load ptr, ptr %base, ptr_provenance ptr %base, align 8, !invariant.load !0, !nontemporal !1, !nonnull !1, !dereferenceable !2, !dereferenceable_or_null !2
+  ; CHECK: load ptr, ptr %base, ptr_provenance ptr %base, align 8, !invariant.load !0, !nontemporal !1, !nonnull !1, !dereferenceable !2, !dereferenceable_or_null !2
+  load volatile ptr, ptr %base, ptr_provenance ptr %base, align 8, !invariant.load !0, !nontemporal !1, !nonnull !1, !dereferenceable !2, !dereferenceable_or_null !2
+  ; CHECK: load volatile ptr, ptr %base, ptr_provenance ptr %base, align 8, !invariant.load !0, !nontemporal !1, !nonnull !1, !dereferenceable !2, !dereferenceable_or_null !2
+
+  store ptr null, ptr %base, ptr_provenance ptr %base, align 4, !nontemporal !1
+  ; CHECK: store ptr null, ptr %base, ptr_provenance ptr %base, align 4, !nontemporal !1
+  store volatile ptr null, ptr %base, ptr_provenance ptr %base, align 4, !nontemporal !1
+  ; CHECK: store volatile ptr null, ptr %base, ptr_provenance ptr %base, align 4, !nontemporal !1
+
+  ret i32 %r
+  ; CHECK-NEXT:   ret i32 %r
+}
+
+!0 = !{i32 1}
+!1 = !{}
+!2 = !{i64 4}