Index: llvm/lib/AsmParser/LLLexer.cpp
===================================================================
--- llvm/lib/AsmParser/LLLexer.cpp
+++ llvm/lib/AsmParser/LLLexer.cpp
@@ -545,6 +545,7 @@
   KEYWORD(deplibs);             // FIXME: Remove in 4.0.
   KEYWORD(datalayout);
   KEYWORD(volatile);
+  KEYWORD(ptr_provenance);
   KEYWORD(atomic);
   KEYWORD(unordered);
   KEYWORD(monotonic);
Index: llvm/lib/AsmParser/LLParser.h
===================================================================
--- llvm/lib/AsmParser/LLParser.h
+++ llvm/lib/AsmParser/LLParser.h
@@ -281,6 +281,9 @@
     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);
Index: llvm/lib/AsmParser/LLParser.cpp
===================================================================
--- llvm/lib/AsmParser/LLParser.cpp
+++ llvm/lib/AsmParser/LLParser.cpp
@@ -2197,16 +2197,20 @@
 /// end.
 bool LLParser::ParseOptionalCommaAlign(MaybeAlign &Alignment,
                                        bool &AteExtraComma) {
-  AteExtraComma = false;
-  while (EatIfPresent(lltok::comma)) {
+  while (AteExtraComma || EatIfPresent(lltok::comma)) {
+    AteExtraComma = false;
     // 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;
   }
@@ -2214,6 +2218,27 @@
   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)
@@ -7073,6 +7098,8 @@
 ///       '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;
@@ -7095,6 +7122,8 @@
   if (ParseType(Ty) ||
       ParseToken(lltok::comma, "expected comma after load's type") ||
       ParseTypeAndValue(Val, Loc, PFS) ||
+      ParseOptionalCommaNoaliasProvenance(
+          NoaliasProvenance, NoaliasProvenanceLoc, PFS, AteExtraComma) ||
       ParseScopeAndOrdering(isAtomic, SSID, Ordering) ||
       ParseOptionalCommaAlign(Alignment, AteExtraComma))
     return true;
@@ -7115,7 +7144,10 @@
     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;
 }
 
@@ -7126,6 +7158,8 @@
 ///       '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;
@@ -7146,6 +7180,8 @@
   if (ParseTypeAndValue(Val, Loc, PFS) ||
       ParseToken(lltok::comma, "expected ',' after store operand") ||
       ParseTypeAndValue(Ptr, PtrLoc, PFS) ||
+      ParseOptionalCommaNoaliasProvenance(
+          NoaliasProvenance, NoaliasProvenanceLoc, PFS, AteExtraComma) ||
       ParseScopeAndOrdering(isAtomic, SSID, Ordering) ||
       ParseOptionalCommaAlign(Alignment, AteExtraComma))
     return true;
@@ -7167,7 +7203,11 @@
   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;
 }
 
Index: llvm/lib/AsmParser/LLToken.h
===================================================================
--- llvm/lib/AsmParser/LLToken.h
+++ llvm/lib/AsmParser/LLToken.h
@@ -90,6 +90,7 @@
   kw_deplibs, // FIXME: Remove in 4.0
   kw_datalayout,
   kw_volatile,
+  kw_ptr_provenance,
   kw_atomic,
   kw_unordered,
   kw_monotonic,
Index: llvm/test/Bitcode/loadstore_ptr_provenance.ll
===================================================================
--- /dev/null
+++ llvm/test/Bitcode/loadstore_ptr_provenance.ll
@@ -0,0 +1,17 @@
+; RUN: opt --verify -S < %s | FileCheck %s
+; JDO_FIXME_NOW: fix the bicode support.. R U N: llvm-as < %s | llvm-dis | FileCheck %s
+; JDO_FIXME_NOW: R U N: verify-uselistorder < %s
+
+define i32 @f(i32* %p, i32* %q) {
+  store i32 42, i32* %p, ptr_provenance i32* %p
+  store i32 43, i32* %q, ptr_provenance i32* %q
+  %r = load i32, i32* %p, ptr_provenance i32* %p
+  ret i32 %r
+}
+
+; CHECK:      define i32 @f(i32* %p, i32* %q) {
+; CHECK-NEXT:   store i32 42, i32* %p, ptr_provenance i32* %p
+; CHECK-NEXT:   store i32 43, i32* %q, ptr_provenance i32* %q
+; CHECK-NEXT:   %r = load i32, i32* %p, ptr_provenance i32* %p
+; CHECK-NEXT:   ret i32 %r
+; CHECK-NEXT: }