[Assignment Tracking][4/*] Add llvm.dbg.assign intrinsic boilerplate

[Orlando]

Summary

The Assignment Tracking debug-info feature is outlined in this RFC. This first series of patches adds documentation, the changes necessary to start emitting and using the new metadata, and updates clang with an option to enable the feature. Working with the new metadata in the middle and back end will come later. There are still a few rough edges but I'm putting these patches up now hoping to get feedback on the design and implementation from the upstream community.

---

Add the llvm.dbg.assign intrinsic boilerplate. This updates the textual-bitcode roundtrip test to also check that round-tripping with the intrinsic works.

The intrinsic marks the position of a source level assignment.

The llvm.dbg.assign interface looks like this (each parameter is wrapped in MetadataAsValue, and Value * type parameters are
first wrapped in ValueAsMetadata):

void @llvm.dbg.assign(Value *Value,
                      DIExpression *ValueExpression,
                      DILocalVariable *Variable,
                      DIAssignID *ID,
                      Value *Address,
                      DIExpression *AddressExpression)

The first three parameters look and behave like an llvm.dbg.value. ID is a reference to a store. The intrinsic is "linked to" instructions in the same function that use the same ID as an attachment. That is mostly conceptual at this point; the two-way link infrastructure will come in another patch. Address is the destination address of the store and it is modified by AddressExpression. llvm currently encodes variable fragment information in DIExpressions, so as an implementation quirk the FragmentInfo for Variable is contained within ValueExpression only.

[Orlando]

+ Add context to diff

[jmorse]

Looks good with some hand waving in comments; as before, it's good practice to have tests covering the verifier failures.

llvm/include/llvm/IR/IntrinsicInst.h

293–296

This wants three slashes rather than two; I get the feeling the comment is a bit too verbose, in that it's writing a bit too much about one intrinsic in a generic class. IMO, better to focus on "this abstracts where that information is stored".

377

Hmm -- so this is going to mean that feeding a dbg.assign into isa<DbgValueInst>(...) is true, doesn't that risk some misinterpretation out there?

If this is activating some code paths that are necessary for handling / accounting for debug intrinsics, we might want to handle that by putting a new superclass in rather than having dbg.values alias dbg.addrs.

(/me reads further) Ah, because dbg.addr subclasses dbg.value. I can see that there's precedent for this elsewhere (all these things are subclasses of CallInst), I suspect we'll need to think through carefully what the implications are.

llvm/lib/IR/IntrinsicInst.cpp

119

Hmmmm. So this is called _inside_ an assertion, but it also has a side-effect / assignment... doesn't that mean we'll get different behaviour if LLVM is compiled with/without assertions?

130–131

Missing () on the DbgAssignAddrReplaced call?

215–220

Will this work with DIArgList's? (Probably, figured I'd ask though). Seeing how DbgAddrInst is acting as a DbgValueInst, AFAIUI the loop-strength-reduce and similar code will try and RAUW the value with a DIArgList of values occasionally. I think the semantics of this is obvious, the only risk is that we encode assumptions that the Value is only ever a single ValueAsMetadata.

[Orlando]

Thanks for all the reviews. I just wanted to check something (inline) before updating this patch.

llvm/lib/IR/IntrinsicInst.cpp

119

DbgAssignAddrReplaced is a bool assigned the result of the in-line call to the lambda. I can re-arrange this to get rid of the lambda if you'd prefer?

215–220

Ah, sorry, I had intended to remove replaceUsesOfWith and replace calls with replaceVariableLocationOp. I must've missed that change from this patch.

[jmorse]

llvm/lib/IR/IntrinsicInst.cpp

119

Aaaaaahhhh cool, I'd missed the trailing parentheses (and "bool" became "auto" in my mind for some reason). I'm not especially bothered about the style, but IMO best to have a dedicated line where the lambda is called, so that someone casually scanning this sees "here's a lambda, here's me calling the lambda". I think that matches the pattern in the rest of llvm.

[Orlando]

+ Address feedback
+ Add test for verifier checks

[Orlando]

+ Tidy up comments in test (use ;; rather than ; for non-filecheck-directive comments)
+ Add getRawX versions of DbgAssignIntrinsic methods, following the other intrinsics' examples.
+ Call the getRawX functions in the verifier, rather than using hard-coded getOperand(int) calls.
+ Rename getAssignId -> getAssignID

[jmorse]

LGTM

[Orlando]

(I accidently had an not submitted an inline reply)

llvm/include/llvm/IR/IntrinsicInst.h

377

I did this early on to reduce friction when working on the prototype. I have not tried making DbgAssignIntrinsic a sibling in the inheritance hierarchy and don't have a strong gut feeling for whether the number of clarifying isa<> casts would increase or decrease.

llvm/include/llvm/IR/IntrinsicInst.h

public:
 
   /// Checks if the intrinsic is an annotation.
   bool isAssumeLikeIntrinsic() const {
     switch (getIntrinsicID()) {
     default: break;
     case Intrinsic::assume:
     case Intrinsic::sideeffect:
     case Intrinsic::pseudoprobe:
+    case Intrinsic::dbg_assign:
     case Intrinsic::dbg_declare:
     case Intrinsic::dbg_value:
     case Intrinsic::dbg_label:
     case Intrinsic::invariant_start:
     case Intrinsic::invariant_end:
     case Intrinsic::lifetime_start:
     case Intrinsic::lifetime_end:
     case Intrinsic::experimental_noalias_scope_decl:

 
 /// Check if \p ID corresponds to a debug info intrinsic.
 static inline bool isDbgInfoIntrinsic(Intrinsic::ID ID) {
   switch (ID) {
   case Intrinsic::dbg_declare:
   case Intrinsic::dbg_value:
   case Intrinsic::dbg_addr:
   case Intrinsic::dbg_label:
+  case Intrinsic::dbg_assign:
     return true;
   default:
     return false;
   }
 }
 
 /// This is the common base class for debug info intrinsics.
 class DbgInfoIntrinsic : public IntrinsicInst {
public:
   unsigned getNumVariableLocationOps() const {
     if (hasArgList())
       return cast<DIArgList>(getRawLocation())->getArgs().size();
     return 1;
   }
 
   bool hasArgList() const { return isa<DIArgList>(getRawLocation()); }
 
-  /// Does this describe the address of a local variable. True for dbg.addr
-  /// and dbg.declare, but not dbg.value, which describes its value.
+  /// Does this describe the address of a local variable. True for dbg.addr and
+  /// dbg.declare, but not dbg.value, which describes its value, or dbg.assign,
+  /// which describes a combination of the variable's value and address.
   bool isAddressOfVariable() const {
-    return getIntrinsicID() != Intrinsic::dbg_value;
+    return getIntrinsicID() != Intrinsic::dbg_value &&
+           getIntrinsicID() != Intrinsic::dbg_assign;
   }
 
   void setUndef() {
     // TODO: When/if we remove duplicate values from DIArgLists, we don't need
     // this set anymore.
     SmallPtrSet<Value *, 4> RemovedValues;
     for (Value *OldValue : location_ops()) {
       if (!RemovedValues.insert(OldValue).second)
public:
   void setRawLocation(Metadata *Location) {
     return setArgOperand(0, MetadataAsValue::get(getContext(), Location));
   }
 
   /// Get the size (in bits) of the variable, or fragment of the variable that
   /// is described.
   Optional<uint64_t> getFragmentSizeInBits() const;
 
+  /// Get the FragmentInfo for the variable.
+  Optional<DIExpression::FragmentInfo> getFragment() const {
+    return getExpression()->getFragmentInfo();
+  }
+
   /// \name Casting methods
   /// @{
   static bool classof(const IntrinsicInst *I) {
     switch (I->getIntrinsicID()) {
     case Intrinsic::dbg_declare:
     case Intrinsic::dbg_value:
     case Intrinsic::dbg_addr:
+    case Intrinsic::dbg_assign:
       return true;
     default:
       return false;
     }
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
   /// @}
-private:
+protected:
   void setArgOperand(unsigned i, Value *v) {
     DbgInfoIntrinsic::setArgOperand(i, v);
   }
   void setOperand(unsigned i, Value *v) { DbgInfoIntrinsic::setOperand(i, v); }
 };
 
 /// This represents the llvm.dbg.declare instruction.
 class DbgDeclareInst : public DbgVariableIntrinsic {
public:
   }
   iterator_range<location_op_iterator> getValues() const {
     return location_ops();
   }
 
   /// \name Casting methods
   /// @{
   static bool classof(const IntrinsicInst *I) {
-    return I->getIntrinsicID() == Intrinsic::dbg_value;
+    return I->getIntrinsicID() == Intrinsic::dbg_value ||
+           I->getIntrinsicID() == Intrinsic::dbg_assign;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+  /// @}
+};
+
+/// This represents the llvm.dbg.assign instruction.
+class DbgAssignIntrinsic : public DbgValueInst {
+  enum Operands {
+    OpValue,
+    OpVar,
+    OpExpr,
+    OpAssignID,
+    OpAddress,
+    OpAddressExpr,
+  };
+
+public:
+  Value *getAddress() const;
+  Metadata *getRawAddress() const {
+    return cast<MetadataAsValue>(getArgOperand(OpAddress))->getMetadata();
+  }
+  Metadata *getRawAssignID() const {
+    return cast<MetadataAsValue>(getArgOperand(OpAssignID))->getMetadata();
+  }
+  DIAssignID *getAssignID() const { return cast<DIAssignID>(getRawAssignID()); }
+  Metadata *getRawAddressExpression() const {
+    return cast<MetadataAsValue>(getArgOperand(OpAddressExpr))->getMetadata();
+  }
+  DIExpression *getAddressExpression() const {
+    return cast<DIExpression>(getRawAddressExpression());
+  }
+  void setAddressExpression(DIExpression *NewExpr) {
+    setArgOperand(OpAddressExpr,
+                  MetadataAsValue::get(NewExpr->getContext(), NewExpr));
+  }
+  void setAssignId(DIAssignID *New);
+  void setAddress(Value *V);
+  void setValue(Value *V);
+  /// \name Casting methods
+  /// @{
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::dbg_assign;
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
   /// @}
 };
 
 /// This represents the llvm.dbg.label instruction.

llvm/include/llvm/IR/Intrinsics.td

let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {
   def int_dbg_value        : DefaultAttrsIntrinsic<[],
                                        [llvm_metadata_ty,
                                         llvm_metadata_ty,
                                         llvm_metadata_ty]>;
   def int_dbg_addr         : DefaultAttrsIntrinsic<[],
                                        [llvm_metadata_ty,
                                         llvm_metadata_ty,
                                         llvm_metadata_ty]>;
+  def int_dbg_assign        : DefaultAttrsIntrinsic<[],
+                                       [llvm_metadata_ty,
+                                        llvm_metadata_ty,
+                                        llvm_metadata_ty,
+                                        llvm_metadata_ty,
+                                        llvm_metadata_ty,
+                                        llvm_metadata_ty]>;
   def int_dbg_label        : DefaultAttrsIntrinsic<[],
                                        [llvm_metadata_ty]>;
 }
 
 //===------------------ Exception Handling Intrinsics----------------------===//
 //
 
 // The result of eh.typeid.for depends on the enclosing function, but inside a

llvm/lib/IR/IntrinsicInst.cpp

 static ValueAsMetadata *getAsMetadata(Value *V) {
   return isa<MetadataAsValue>(V) ? dyn_cast<ValueAsMetadata>(
                                        cast<MetadataAsValue>(V)->getMetadata())
                                  : ValueAsMetadata::get(V);
 }
 
 void DbgVariableIntrinsic::replaceVariableLocationOp(Value *OldValue,
                                                      Value *NewValue) {
+  // If OldValue is used as the address part of a dbg.assign intrinsic replace
+  // it with NewValue and return true.
+  auto ReplaceDbgAssignAddress = [this, OldValue, NewValue]() -> bool {
+    auto *DAI = dyn_cast<DbgAssignIntrinsic>(this);
+    if (!DAI || OldValue != DAI->getAddress())
+      return false;
+    DAI->setAddress(NewValue);
+    return true;
+  };
+  bool DbgAssignAddrReplaced = ReplaceDbgAssignAddress();
+  (void)DbgAssignAddrReplaced;
+
   assert(NewValue && "Values must be non-null");
   auto Locations = location_ops();
   auto OldIt = find(Locations, OldValue);
-  assert(OldIt != Locations.end() && "OldValue must be a current location");
+  assert((OldIt != Locations.end() || DbgAssignAddrReplaced) &&
+         "OldValue must be a current location");
   if (!hasArgList()) {
     Value *NewOperand = isa<MetadataAsValue>(NewValue)
                             ? NewValue
                             : MetadataAsValue::get(
                                   getContext(), ValueAsMetadata::get(NewValue));
     return setArgOperand(0, NewOperand);
   }
   SmallVector<ValueAsMetadata *, 4> MDs;

 }
 
 Optional<uint64_t> DbgVariableIntrinsic::getFragmentSizeInBits() const {
   if (auto Fragment = getExpression()->getFragmentInfo())
     return Fragment->SizeInBits;
   return getVariable()->getSizeInBits();
 }
 
+Value *DbgAssignIntrinsic::getAddress() const {
+  auto *MD = getRawAddress();
+  if (auto *V = dyn_cast<ValueAsMetadata>(MD))
+    return V->getValue();
+
+  // When the value goes to null, it gets replaced by an empty MDNode.
+  assert(!cast<MDNode>(MD)->getNumOperands() && "Expected an empty MDNode");
+  return nullptr;
+}
+
+void DbgAssignIntrinsic::setAssignId(DIAssignID *New) {
+  setOperand(OpAssignID, MetadataAsValue::get(getContext(), New));
+}
+
+void DbgAssignIntrinsic::setAddress(Value *V) {
+  assert(V->getType()->isPointerTy() &&
+         "Destination Component must be a pointer type");
+  setOperand(OpAddress,
+             MetadataAsValue::get(getContext(), ValueAsMetadata::get(V)));
+}
+
+void DbgAssignIntrinsic::setValue(Value *V) {
+  setOperand(OpValue,
+             MetadataAsValue::get(getContext(), ValueAsMetadata::get(V)));
+}
+
 int llvm::Intrinsic::lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable,
                                                StringRef Name) {
   assert(Name.startswith("llvm."));
 
   // Do successive binary searches of the dotted name components. For
   // "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of
   // intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then
   // "llvm.gc.experimental.statepoint", and then we will stop as the range is
   // size 1. During the search, we can skip the prefix that we already know is
   // identical. By using strncmp we consider names with differing suffixes to
   // be part of the equal range.
   size_t CmpEnd = 4; // Skip the "llvm" component.
   const char *const *Low = NameTable.begin();
   const char *const *High = NameTable.end();
   const char *const *LastLow = Low;

llvm/lib/IR/Verifier.cpp

 }
 
 void Verifier::visitDIAssignIDMetadata(Instruction &I, MDNode *MD) {
   assert(I.hasMetadata(LLVMContext::MD_DIAssignID));
   bool ExpectedInstTy =
       isa<AllocaInst>(I) || isa<StoreInst>(I) || isa<MemIntrinsic>(I);
   CheckDI(ExpectedInstTy, "!DIAssignID attached to unexpected instruction kind",
           I, MD);
+  // Iterate over the MetadataAsValue uses of the DIAssignID - these should
+  // only be found as DbgAssignIntrinsic operands.
+  if (auto *AsValue = MetadataAsValue::getIfExists(Context, MD)) {
+    for (auto *User : AsValue->users()) {
+      CheckDI(isa<DbgAssignIntrinsic>(User),
+              "!DIAssignID should only be used by llvm.dbg.assign intrinsics",
+              MD, User);
+    }
+  }
 }
 
 void Verifier::visitCallStackMetadata(MDNode *MD) {
   // Call stack metadata should consist of a list of at least 1 constant int
   // (representing a hash of the location).
   Check(MD->getNumOperands() >= 1,
         "call stack metadata should have at least 1 operand", MD);
 
case Intrinsic::dbg_declare: // llvm.dbg.declare
     visitDbgIntrinsic("declare", cast<DbgVariableIntrinsic>(Call));
     break;
   case Intrinsic::dbg_addr: // llvm.dbg.addr
     visitDbgIntrinsic("addr", cast<DbgVariableIntrinsic>(Call));
     break;
   case Intrinsic::dbg_value: // llvm.dbg.value
     visitDbgIntrinsic("value", cast<DbgVariableIntrinsic>(Call));
     break;
+  case Intrinsic::dbg_assign: // llvm.dbg.assign
+    visitDbgIntrinsic("assign", cast<DbgVariableIntrinsic>(Call));
+    break;
   case Intrinsic::dbg_label: // llvm.dbg.label
     visitDbgLabelIntrinsic("label", cast<DbgLabelInst>(Call));
     break;
   case Intrinsic::memcpy:
   case Intrinsic::memcpy_inline:
   case Intrinsic::memmove:
   case Intrinsic::memset:
   case Intrinsic::memset_inline: {
CheckDI(isa<ValueAsMetadata>(MD) || isa<DIArgList>(MD) ||
           "invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD);
   CheckDI(isa<DILocalVariable>(DII.getRawVariable()),
           "invalid llvm.dbg." + Kind + " intrinsic variable", &DII,
           DII.getRawVariable());
   CheckDI(isa<DIExpression>(DII.getRawExpression()),
           "invalid llvm.dbg." + Kind + " intrinsic expression", &DII,
           DII.getRawExpression());
 
+  if (auto *DAI = dyn_cast<DbgAssignIntrinsic>(&DII)) {
+    CheckDI(isa<DIAssignID>(DAI->getRawAssignID()),
+            "invalid llvm.dbg.assign intrinsic DIAssignID", &DII,
+            DAI->getRawAssignID());
+    CheckDI(isa<ValueAsMetadata>(DAI->getRawAddress()),
+            "invalid llvm.dbg.assign intrinsic address)", &DII,
+            DAI->getRawAddress());
+    CheckDI(isa<DIExpression>(DAI->getRawAddressExpression()),
+            "invalid llvm.dbg.assign intrinsic address expression", &DII,
+            DAI->getRawAddressExpression());
+  }
+
   // Ignore broken !dbg attachments; they're checked elsewhere.
   if (MDNode *N = DII.getDebugLoc().getAsMDNode())
     if (!isa<DILocation>(N))
       return;
 
   BasicBlock *BB = DII.getParent();
   Function *F = BB ? BB->getParent() : nullptr;
 

llvm/test/DebugInfo/Generic/assignment-tracking/parse-and-verify/roundtrip.ll

 ; RUN: opt %s -verify -experimental-assignment-tracking   \
 ; RUN: | opt -verify -S -experimental-assignment-tracking \
 ; RUN: | FileCheck %s
 
-;; Roundtrip test (text -> bitcode -> text) for DIAssignID attachments.
-
-; CHECK: %local = alloca i32, align 4, !DIAssignID ![[ID:[0-9]+]]
-; CHECK-DAG: ![[ID]] = distinct !DIAssignID()
+;; Roundtrip test (text -> bitcode -> text) for DIAssignID metadata and
+;; llvm.dbg.assign intrinsics.
 
+;; DIAssignID attachment only.
+; CHECK-LABEL: @fun()
+; CHECK: %local = alloca i32, align 4, !DIAssignID ![[ID1:[0-9]+]]
 define dso_local void @fun() !dbg !7 {
 entry:
   %local = alloca i32, align 4, !DIAssignID !14
   ret void, !dbg !13
 }
 
+;; Unlinked llvm.dbg.assign.
+; CHECK-DAG: @fun2()
+; CHECK: llvm.dbg.assign(metadata i32 undef, metadata ![[VAR2:[0-9]+]], metadata !DIExpression(), metadata ![[ID2:[0-9]+]], metadata i32 undef, metadata !DIExpression()), !dbg ![[DBG2:[0-9]+]]
+define dso_local void @fun2() !dbg !15 {
+entry:
+  %local = alloca i32, align 4
+  call void @llvm.dbg.assign(metadata i32 undef, metadata !16, metadata !DIExpression(), metadata !18, metadata i32 undef, metadata !DIExpression()), !dbg !17
+  ret void, !dbg !17
+}
+
+;; An llvm.dbg.assign linked to an alloca.
+; CHECK-LABEL: @fun3()
+; CHECK: %local = alloca i32, align 4, !DIAssignID ![[ID3:[0-9]+]]
+; CHECK-NEXT: llvm.dbg.assign(metadata i32 undef, metadata ![[VAR3:[0-9]+]], metadata !DIExpression(), metadata ![[ID3]], metadata i32 undef, metadata !DIExpression()), !dbg ![[DBG3:[0-9]+]]
+define dso_local void @fun3() !dbg !19 {
+entry:
+  %local = alloca i32, align 4, !DIAssignID !22
+  call void @llvm.dbg.assign(metadata i32 undef, metadata !20, metadata !DIExpression(), metadata !22, metadata i32 undef, metadata !DIExpression()), !dbg !21
+  ret void, !dbg !21
+}
+
+;; Check that using a DIAssignID as an operand before using it as an attachment
+;; works (the order of the alloca and dbg.assign has been swapped).
+; CHECK-LABEL: @fun4()
+; CHECK: llvm.dbg.assign(metadata i32 undef, metadata ![[VAR4:[0-9]+]], metadata !DIExpression(), metadata ![[ID4:[0-9]+]], metadata i32 undef, metadata !DIExpression()), !dbg ![[DBG4:[0-9]+]]
+; CHECK-NEXT: %local = alloca i32, align 4, !DIAssignID ![[ID4]]
+define dso_local void @fun4() !dbg !23 {
+entry:
+  call void @llvm.dbg.assign(metadata i32 undef, metadata !24, metadata !DIExpression(), metadata !26, metadata i32 undef, metadata !DIExpression()), !dbg !25
+  %local = alloca i32, align 4, !DIAssignID !26
+  ret void, !dbg !25
+}
+
+;; Check that the value and address operands print correctly.
+;; There are currently no plans to support DIArgLists for the address component.
+; CHECK-LABEL: @fun5
+; CHECK: %local = alloca i32, align 4, !DIAssignID ![[ID5:[0-9]+]]
+; CHECK-NEXT: llvm.dbg.assign(metadata i32 %v, metadata ![[VAR5:[0-9]+]], metadata !DIExpression(), metadata ![[ID5]], metadata i32* %local, metadata !DIExpression()), !dbg ![[DBG5:[0-9]+]]
+; CHECK-NEXT: llvm.dbg.assign(metadata !DIArgList(i32 %v, i32 1), metadata ![[VAR5]], metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_minus, DW_OP_stack_value), metadata ![[ID5]], metadata i32* %local, metadata !DIExpression()), !dbg ![[DBG5]]
+define dso_local void @fun5(i32 %v) !dbg !27 {
+entry:
+  %local = alloca i32, align 4, !DIAssignID !30
+  call void @llvm.dbg.assign(metadata i32 %v, metadata !28, metadata !DIExpression(), metadata !30, metadata i32* %local, metadata !DIExpression()), !dbg !29
+  call void @llvm.dbg.assign(metadata !DIArgList(i32 %v, i32 1), metadata !28, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_minus, DW_OP_stack_value), metadata !30, metadata i32* %local, metadata !DIExpression()), !dbg !29
+  ret void
+}
+
+; CHECK-DAG: ![[ID1]] = distinct !DIAssignID()
+; CHECK-DAG: ![[ID2]] = distinct !DIAssignID()
+; CHECK-DAG: ![[VAR2]] = !DILocalVariable(name: "local2",
+; CHECK-DAG: ![[DBG2]] = !DILocation(line: 2
+; CHECK-DAG: ![[ID3]] = distinct !DIAssignID()
+; CHECK-DAG: ![[VAR3]] = !DILocalVariable(name: "local3",
+; CHECK-DAG: ![[DBG3]] = !DILocation(line: 3,
+; CHECK-DAG: ![[ID4]] = distinct !DIAssignID()
+; CHECK-DAG: ![[VAR4]] = !DILocalVariable(name: "local4",
+; CHECK-DAG: ![[DBG4]] = !DILocation(line: 4,
+; CHECK-DAG: ![[ID5]] = distinct !DIAssignID()
+; CHECK-DAG: ![[VAR5]] = !DILocalVariable(name: "local5",
+; CHECK-DAG: ![[DBG5]] = !DILocation(line: 5,
+
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
+
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4, !5}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.c", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}
 !6 = !{!"clang version 14.0.0"}
 !7 = distinct !DISubprogram(name: "fun", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
 !8 = !DISubroutineType(types: !9)
 !9 = !{null}
 !10 = !DILocalVariable(name: "local", scope: !7, file: !1, line: 2, type: !11)
 !11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
-!13 = !DILocation(line: 3, column: 1, scope: !7)
+!13 = !DILocation(line: 1, column: 1, scope: !7)
 !14 = distinct !DIAssignID()
+!15 = distinct !DISubprogram(name: "fun2", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!16 = !DILocalVariable(name: "local2", scope: !15, file: !1, line: 2, type: !11)
+!17 = !DILocation(line: 2, column: 1, scope: !15)
+!18 = distinct !DIAssignID()
+!19 = distinct !DISubprogram(name: "fun3", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!20 = !DILocalVariable(name: "local3", scope: !19, file: !1, line: 2, type: !11)
+!21 = !DILocation(line: 3, column: 1, scope: !19)
+!22 = distinct !DIAssignID()
+!23 = distinct !DISubprogram(name: "fun4", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!24 = !DILocalVariable(name: "local4", scope: !23, file: !1, line: 2, type: !11)
+!25 = !DILocation(line: 4, column: 1, scope: !23)
+!26 = distinct !DIAssignID()
+!27 = distinct !DISubprogram(name: "fun5", scope: !1, file: !1, line: 1, type: !31, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!28 = !DILocalVariable(name: "local5", scope: !27, file: !1, line: 2, type: !11)
+!29 = !DILocation(line: 5, column: 1, scope: !27)
+!30 = distinct !DIAssignID()
+!31 = !DISubroutineType(types: !32)
+!32 = !{null, !11}

llvm/test/DebugInfo/Generic/assignment-tracking/parse-and-verify/verify.ll

+; RUN: opt %s -S -verify -experimental-assignment-tracking 2>&1 \
+; RUN: | FileCheck %s
+
+;; Check that badly formed assignment tracking metadata is caught either
+;; while parsing or by the verifier.
+;;
+;; Checks for this one are inline.
+
+define dso_local void @fun() !dbg !7 {
+entry:
+  %a = alloca i32, align 4, !DIAssignID !14
+  ;; Here something other than a dbg.assign intrinsic is using a DIAssignID.
+  ; CHECK: !DIAssignID should only be used by llvm.dbg.assign intrinsics
+  call void @llvm.dbg.value(metadata !14, metadata !10, metadata !DIExpression()), !dbg !13
+
+  ;; Each following dbg.assign has an argument of the incorrect type.
+  ; CHECK: invalid llvm.dbg.assign intrinsic address/value
+  call void @llvm.dbg.assign(metadata !3, metadata !10, metadata !DIExpression(), metadata !14, metadata i32* undef, metadata !DIExpression()), !dbg !13
+  ; CHECK: invalid llvm.dbg.assign intrinsic variable
+  call void @llvm.dbg.assign(metadata i32 0, metadata !2, metadata !DIExpression(), metadata !14, metadata i32* undef, metadata !DIExpression()), !dbg !13
+  ; CHECK: invalid llvm.dbg.assign intrinsic expression
+  call void @llvm.dbg.assign(metadata !14, metadata !10, metadata !2, metadata !14, metadata i32* undef, metadata !DIExpression()), !dbg !13
+  ; CHECK: invalid llvm.dbg.assign intrinsic DIAssignID
+  call void @llvm.dbg.assign(metadata !14, metadata !10, metadata !DIExpression(), metadata !2, metadata i32* undef, metadata !DIExpression()), !dbg !13
+  ; CHECK: invalid llvm.dbg.assign intrinsic address
+  call void @llvm.dbg.assign(metadata !14, metadata !10, metadata !DIExpression(), metadata !14, metadata !3, metadata !DIExpression()), !dbg !13
+  ; CHECK: invalid llvm.dbg.assign intrinsic address expression
+  call void @llvm.dbg.assign(metadata !14, metadata !10, metadata !DIExpression(), metadata !14, metadata i32* undef, metadata !2), !dbg !13
+  ret void
+}
+
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 14.0.0"}
+!7 = distinct !DISubprogram(name: "fun", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !DILocalVariable(name: "local", scope: !7, file: !1, line: 2, type: !11)
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!13 = !DILocation(line: 1, column: 1, scope: !7)
+!14 = distinct !DIAssignID()