[Assignment Tracking][NFC] Replace LLVM command line option with a new module flag

[Orlando]

Summary

Remove LLVM flag -experimental-assignment-tracking. Assignment tracking is still enabled from Clang with the command line -Xclang -fexperimental-assignment-tracking which tells Clang to ask LLVM to run the pass declare-to-assign. That pass converts conventional debug intrinsics to assignment tracking metadata. With this patch it now also sets a module flag debug-info-assignment-tracking with the value i1 true (using the flag conflict rule Max since enabling assignment tracking on IR that contains only conventional debug intrinsics should cause no issues).

Update the docs and tests too.

[CarlosAlbertoEnciso]

llvm/include/llvm/IR/DebugInfo.h

299–301

Any reason for the change to private?

[CarlosAlbertoEnciso]

May be add some explanatory notes for the change to 'private'.

[Orlando]

llvm/include/llvm/IR/DebugInfo.h

299–301

runOnFunction doesn't itself set the module flag - the other two run methods call runOnFunction then set the module flag themselves, so that in the case of the Module override it is only set once. I've made runOnFunction private to avoid the pass functionality being used without the module flag being set. IMO it should always have been private anyway.

clang/lib/Driver/ToolChains/Clang.cpp

for (auto Arg : Args.filtered(options::OPT_Xclang)) {
     Arg->claim();
     // -finclude-default-header flag is for preprocessor,
     // do not pass it to other cc1 commands when save-temps is enabled
     if (C.getDriver().isSaveTempsEnabled() &&
         !isa<PreprocessJobAction>(JA)) {
       if (StringRef(Arg->getValue()) == "-finclude-default-header")
         continue;
     }
-    if (StringRef(Arg->getValue()) == "-fexperimental-assignment-tracking") {
-      // Add the llvm version of this flag too.
-      CmdArgs.push_back("-mllvm");
-      CmdArgs.push_back("-experimental-assignment-tracking");
-    }
     CmdArgs.push_back(Arg->getValue());
   }
   for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
     A->claim();
 
     // We translate this by hand to the -cc1 argument, since nightly test uses
     // it and developers have been trained to spell it with -mllvm. Both
     // spellings are now deprecated and should be removed.

clang/test/Driver/assignment-tracking-opts.c

-// RUN: %clang -### -S %s -g -target x86_64-linux-gnu 2>&1 | FileCheck --check-prefix=CHECK-NO-AT %s
-// RUN: %clang -### -S %s -g -target x86_64-linux-gnu 2>&1              \
-// RUN:                      -Xclang -fexperimental-assignment-tracking \
-// RUN: | FileCheck --check-prefix=CHECK-AT %s
-
-// CHECK-NO-AT-NOT: "-mllvm" "-experimental-assignment-tracking"
-// CHECK-NO-AT-NOT: "-fexperimental-assignment-tracking"
-
-// CHECK-AT: "-mllvm" "-experimental-assignment-tracking"
-// CHECK-AT: "-fexperimental-assignment-tracking"

llvm/docs/AssignmentTracking.md

 
 ## Status and usage
 
 **Status**: Experimental work in progress. Enabling is strongly advised against
 except for development and testing.
 
 **Enable in Clang**: `-Xclang -fexperimental-assignment-tracking`
 
-**Enable in LLVM tools**: `-experimental-assignment-tracking`
+That causes Clang to get LLVM to run the pass `declare-to-assign`. The pass
+converts conventional debug intrinsics to assignment tracking metadata and sets
+the module flag `debug-info-assignment-tracking` to the value `i1 true`. To
+check whether assignment tracking is enabled for a module call
+`isAssignmentTrackingEnabled(const Module &M)` (from `llvm/IR/DebugInfo.h`).
 
 ## Design and implementation
 
 ### Assignment markers: `llvm.dbg.assign`
 
 `llvm.dbg.value`, a conventional debug intrinsic, marks out a position in the
 IR where a variable takes a particular value. Similarly, Assignment Tracking
 marks out the position of assignments with a new intrinsic called

llvm/include/llvm/IR/DebugInfo.h

std::optional<AssignmentInfo> getAssignmentInfo(const DataLayout &DL,
                                                 const AllocaInst *AI);
 
 } // end namespace at
 
 /// Convert @llvm.dbg.declare intrinsics into sets of @llvm.dbg.assign
 /// intrinsics by treating stores to the dbg.declare'd address as assignments
 /// to the variable. Not all kinds of variables are supported yet; those will
 /// be left with their dbg.declare intrinsics.
+/// The pass sets the debug-info-assignment-tracking module flag to true to
+/// indicate assignment tracking has been enabled.
 class AssignmentTrackingPass : public PassInfoMixin<AssignmentTrackingPass> {
-public:
+  /// Note: this method does not set the debug-info-assignment-tracking module
+  /// flag.
   void runOnFunction(Function &F);
+
+public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 };
 
-/// Return true if assignment tracking is enabled.
-bool getEnableAssignmentTracking();
+/// Return true if assignment tracking is enabled for module \p M.
+bool isAssignmentTrackingEnabled(const Module &M);
 } // end namespace llvm
 
 #endif // LLVM_IR_DEBUGINFO_H

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

if (Changed) {
     // important job. That is to work around some SelectionDAG quirks. See
     // removeRedundantDbgLocsUsingForwardScan comments for more info on that.
     for (auto &BB : Fn)
       removeRedundantDbgLocs(&BB, *FnVarLocs);
   }
 }
 
 bool AssignmentTrackingAnalysis::runOnFunction(Function &F) {
+  if (!isAssignmentTrackingEnabled(*F.getParent()))
+    return false;
+
   LLVM_DEBUG(dbgs() << "AssignmentTrackingAnalysis run on " << F.getName()
                     << "\n");
   auto DL = std::make_unique<DataLayout>(F.getParent());
 
   // Clear previous results.
   Results->clear();
 
   FunctionVarLocsBuilder Builder;

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

SDValue Res = DAG.getNode(
         DAG.getVTList(TLI.getPointerTy(DAG.getDataLayout()), MVT::Other), Ops);
     setValue(&I, Res);
     DAG.setRoot(Res.getValue(1));
     return;
   }
   case Intrinsic::dbg_addr:
   case Intrinsic::dbg_declare: {
     // Debug intrinsics are handled seperately in assignment tracking mode.
-    if (getEnableAssignmentTracking())
+    if (isAssignmentTrackingEnabled(*I.getFunction()->getParent()))
       return;
     // Assume dbg.addr and dbg.declare can not currently use DIArgList, i.e.
     // they are non-variadic.
     const auto &DI = cast<DbgVariableIntrinsic>(I);
     assert(!DI.hasArgList() && "Only dbg.value should currently use DIArgList");
     DILocalVariable *Variable = DI.getVariable();
     DIExpression *Expression = DI.getExpression();
     dropDanglingDebugInfo(Variable, Expression);
case Intrinsic::dbg_label: {
 
     SDDbgLabel *SDV;
     SDV = DAG.getDbgLabel(Label, dl, SDNodeOrder);
     DAG.AddDbgLabel(SDV);
     return;
   }
   case Intrinsic::dbg_assign: {
     // Debug intrinsics are handled seperately in assignment tracking mode.
-    assert(getEnableAssignmentTracking() &&
+    assert(isAssignmentTrackingEnabled(*I.getFunction()->getParent()) &&
            "expected assignment tracking to be enabled");
     return;
   }
   case Intrinsic::dbg_value: {
     // Debug intrinsics are handled seperately in assignment tracking mode.
-    if (getEnableAssignmentTracking())
+    if (isAssignmentTrackingEnabled(*I.getFunction()->getParent()))
       return;
     const DbgValueInst &DI = cast<DbgValueInst>(I);
     assert(DI.getVariable() && "Missing variable");
 
     DILocalVariable *Variable = DI.getVariable();
     DIExpression *Expression = DI.getExpression();
     dropDanglingDebugInfo(Variable, Expression);
     SmallVector<Value *, 4> Values(DI.getValues());

llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

void SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<StackProtector>();
   AU.addPreserved<GCModuleInfo>();
   AU.addRequired<TargetLibraryInfoWrapperPass>();
   AU.addRequired<TargetTransformInfoWrapperPass>();
   AU.addRequired<AssumptionCacheTracker>();
   if (UseMBPI && OptLevel != CodeGenOpt::None)
     AU.addRequired<BranchProbabilityInfoWrapperPass>();
   AU.addRequired<ProfileSummaryInfoWrapperPass>();
-  if (getEnableAssignmentTracking()) {
-    AU.addRequired<AssignmentTrackingAnalysis>();
-    AU.addPreserved<AssignmentTrackingAnalysis>();
-  }
+  // AssignmentTrackingAnalysis only runs if assignment tracking is enabled for
+  // the module.
   if (OptLevel != CodeGenOpt::None)
     LazyBlockFrequencyInfoPass::getLazyBFIAnalysisUsage(AU);
   MachineFunctionPass::getAnalysisUsage(AU);
 }
 
 static void computeUsesMSVCFloatingPoint(const Triple &TT, const Function &F,
                                          MachineModuleInfo &MMI) {
   // Only needed for MSVC
bool SelectionDAGISel::runOnMachineFunction(MachineFunction &mf) {
   ORE = std::make_unique<OptimizationRemarkEmitter>(&Fn);
   AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(mf.getFunction());
   auto *PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
   BlockFrequencyInfo *BFI = nullptr;
   if (PSI && PSI->hasProfileSummary() && OptLevel != CodeGenOpt::None)
     BFI = &getAnalysis<LazyBlockFrequencyInfoPass>().getBFI();
 
   FunctionVarLocs const *FnVarLocs = nullptr;
-  if (getEnableAssignmentTracking())
+  if (isAssignmentTrackingEnabled(*Fn.getParent()))
     FnVarLocs = getAnalysis<AssignmentTrackingAnalysis>().getResults();
 
   LLVM_DEBUG(dbgs() << "\n\n\n=== " << Fn.getName() << "\n");
 
   CurDAG->init(*MF, *ORE, this, LibInfo,
                getAnalysisIfAvailable<LegacyDivergenceAnalysis>(), PSI, BFI,
                FnVarLocs);
   FuncInfo->set(Fn, *MF, CurDAG);
else
       FastIS->setLastLocalValue(nullptr);
   }
 
   bool Inserted = SwiftError->createEntriesInEntryBlock(SDB->getCurDebugLoc());
 
   if (FastIS && Inserted)
     FastIS->setLastLocalValue(&*std::prev(FuncInfo->InsertPt));
 
-  if (getEnableAssignmentTracking()) {
+  if (isAssignmentTrackingEnabled(*Fn.getParent())) {
     assert(CurDAG->getFunctionVarLocs() &&
            "expected AssignmentTrackingAnalysis pass results");
     processSingleLocVars(*FuncInfo, CurDAG->getFunctionVarLocs());
   } else {
     processDbgDeclares(*FuncInfo);
   }
 
   // Iterate over all basic blocks in the function.

llvm/lib/IR/DebugInfo.cpp

 #include <cassert>
 #include <optional>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::at;
 using namespace llvm::dwarf;
 
-static cl::opt<bool>
-    ExperimentalAssignmentTracking("experimental-assignment-tracking",
-                                   cl::init(false));
-bool llvm::getEnableAssignmentTracking() {
-  return ExperimentalAssignmentTracking;
-}
-
 /// Finds all intrinsics declaring local variables as living in the memory that
 /// 'V' points to. This may include a mix of dbg.declare and
 /// dbg.addr intrinsics.
 TinyPtrVector<DbgVariableIntrinsic *> llvm::FindDbgAddrUses(Value *V) {
   // This function is hot. Check whether the value has any metadata to avoid a
   // DenseMap lookup.
   if (!V->isUsedByMetadata())
     return {};
for (DbgDeclareInst *DDI : P.second) {
       }));
       // Delete DDI because the variable location is now tracked using
       // assignment tracking.
       DDI->eraseFromParent();
     }
   }
 }
 
+static const char *AssignmentTrackingModuleFlag =
+    "debug-info-assignment-tracking";
+
+static void setAssignmentTrackingModuleFlag(Module &M) {
+  M.setModuleFlag(Module::ModFlagBehavior::Max, AssignmentTrackingModuleFlag,
+                  ConstantAsMetadata::get(
+                      ConstantInt::get(Type::getInt1Ty(M.getContext()), 1)));
+}
+
+static bool getAssignmentTrackingModuleFlag(const Module &M) {
+  Metadata *Value = M.getModuleFlag(AssignmentTrackingModuleFlag);
+  return Value && !cast<ConstantAsMetadata>(Value)->getValue()->isZeroValue();
+}
+
+bool llvm::isAssignmentTrackingEnabled(const Module &M) {
+  return getAssignmentTrackingModuleFlag(M);
+}
+
 PreservedAnalyses AssignmentTrackingPass::run(Function &F,
                                               FunctionAnalysisManager &AM) {
   runOnFunction(F);
+
+  // Record that this module uses assignment tracking. It doesn't matter that
+  // some functons in the module may not use it - the debug info in those
+  // functions will still be handled properly.
+  setAssignmentTrackingModuleFlag(*F.getParent());
+
   // Q: Can we return a less conservative set than just CFGAnalyses? Can we
   // return PreservedAnalyses::all()?
   PreservedAnalyses PA;
   PA.preserveSet<CFGAnalyses>();
   return PA;
 }
 
 PreservedAnalyses AssignmentTrackingPass::run(Module &M,
                                               ModuleAnalysisManager &AM) {
   for (auto &F : M)
     runOnFunction(F);
+
+  // Record that this module uses assignment tracking.
+  setAssignmentTrackingModuleFlag(M);
+
   // Q: Can we return a less conservative set than just CFGAnalyses? Can we
   // return PreservedAnalyses::all()?
   PreservedAnalyses PA;
   PA.preserveSet<CFGAnalyses>();
   return PA;
 }
 
 #undef DEBUG_TYPE

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

static bool combineInstructionsOverFunction(
   // Lower dbg.declare intrinsics otherwise their value may be clobbered
   // by instcombiner.
   bool MadeIRChange = false;
   if (ShouldLowerDbgDeclare)
     MadeIRChange = LowerDbgDeclare(F);
   // LowerDbgDeclare calls RemoveRedundantDbgInstrs, but LowerDbgDeclare will
   // almost never return true when running an assignment tracking build. Take
   // this opportunity to do some clean up for assignment tracking builds too.
-  if (!MadeIRChange && getEnableAssignmentTracking()) {
+  if (!MadeIRChange && isAssignmentTrackingEnabled(*F.getParent())) {
     for (auto &BB : F)
       RemoveRedundantDbgInstrs(&BB);
   }
 
   // Iterate while there is work to do.
   unsigned Iteration = 0;
   while (true) {
     ++NumWorklistIterations;

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

bool llvm::RemoveRedundantDbgInstrs(BasicBlock *BB) {
   //       ...
   //   (2) dbg.value V2, "x", DIExpression()
   //   (3) dbg.value V1, "x", DIExpression()
   //
   // The backward scan will remove (2), it is made obsolete by (3). After
   // getting (2) out of the way, the foward scan will remove (3) since "x"
   // already is described as having the value V1 at (1).
   MadeChanges |= removeRedundantDbgInstrsUsingBackwardScan(BB);
-  if (BB->isEntryBlock() && getEnableAssignmentTracking())
+  if (BB->isEntryBlock() &&
+      isAssignmentTrackingEnabled(*BB->getParent()->getParent()))
     MadeChanges |= remomveUndefDbgAssignsFromEntryBlock(BB);
   MadeChanges |= removeRedundantDbgInstrsUsingForwardScan(BB);
 
   if (MadeChanges)
     LLVM_DEBUG(dbgs() << "Removed redundant dbg instrs from: "
                       << BB->getName() << "\n");
   return MadeChanges;
 }

llvm/lib/Transforms/Utils/InlineFunction.cpp

if (IFI.CG)
       UpdateCallGraphAfterInlining(CB, FirstNewBlock, VMap, IFI);
 
     // For 'nodebug' functions, the associated DISubprogram is always null.
     // Conservatively avoid propagating the callsite debug location to
     // instructions inlined from a function whose DISubprogram is not null.
     fixupLineNumbers(Caller, FirstNewBlock, &CB,
                      CalledFunc->getSubprogram() != nullptr);
 
-    if (getEnableAssignmentTracking()) {
+    if (isAssignmentTrackingEnabled(*Caller->getParent())) {
       // Interpret inlined stores to caller-local variables as assignments.
       trackInlinedStores(FirstNewBlock, Caller->end(), CB);
 
       // Update DIAssignID metadata attachments and uses so that they are
       // unique to this inlined instance.
       fixupAssignments(FirstNewBlock, Caller->end());
     }
 

llvm/test/DebugInfo/Generic/assignment-tracking/adce/no-delete.ll

-; RUN: opt %s -passes=adce -experimental-assignment-tracking -S -o - \
+; RUN: opt %s -passes=adce -S -o - \
 ; RUN: | FileCheck %s
 
 ;; $ cat test.c
 ;; void fun(int local) {}
 ;;
 ;; $ clang test.c -g -O1 -Xclang -disable-llvm-passes | opt -S -passes=declare-to-assign
 
 ;; Check that the dbg.assign intrinsics that are considered "out of scope" (dbg
entry:
   call void @llvm.dbg.assign(metadata i32 %local, metadata !12, metadata !DIExpression(), metadata !19, metadata ptr %local.addr, metadata !DIExpression()), !dbg !14
   ret void
 }
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.c", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}
 !6 = !{!"clang version 14.0.0"}
 !7 = distinct !DISubprogram(name: "fun", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
 !8 = !DISubroutineType(types: !9)
 !9 = !{null, !10}
 !10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !11 = !{!12}
 !12 = !DILocalVariable(name: "local", arg: 1, scope: !7, file: !1, line: 1, type: !10)
 !13 = distinct !DIAssignID()
 !14 = !DILocation(line: 0, scope: !7)
 !19 = distinct !DIAssignID()
 !20 = !DILocation(line: 1, column: 22, scope: !7)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/codegenprepare/sunk-addr.ll

 ; REQUIRES: x86-registered-target
 ; RUN: llc -start-before=codegenprepare -stop-after=codegenprepare \
-; RUN:   -mtriple=x86_64-unknown-unknown -experimental-assignment-tracking %s -o - \
+; RUN:   -mtriple=x86_64-unknown-unknown %s -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg."
 
 ;; Check that when CodeGenPrepare moves an address computation to a block it's
 ;; used in its dbg.assign uses are updated.
 ;;
 ;; Based on llvm/test/DebugInfo/X86/codegenprepare-addrsink.ll
 
 define dso_local i8 @foo(ptr %p, i32 %cond) !dbg !7 {
ret:
   ret i8 0
 }
 
 ; CHECK: ![[DIVAR]] = !DILocalVariable(name: "p",
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: ".")
 !2 = !{}
 !3 = !{i32 2, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}
 !6 = !{!"clang version 8.0.0 (trunk 348209)"}
 !7 = distinct !DISubprogram(name: "foo", linkageName: "foo", scope: !1, file: !1, line: 4, type: !8, scopeLine: 5, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
 !8 = !DISubroutineType(types: !9)
 !9 = !{null, !10}
 !10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !11 = !{!12}
 !12 = !DILocalVariable(name: "p", arg: 1, scope: !7, file: !1, line: 4, type: !10)
 !14 = !DILocation(line: 4, column: 15, scope: !7)
 !20 = distinct !DILexicalBlock(scope: !7, file: !1, line: 8, column: 7)
 !21 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/dse/dse-after-memcpyopt-merge.ll

-; RUN: opt %s -S -passes=dse -o - -experimental-assignment-tracking | FileCheck %s
+; RUN: opt %s -S -passes=dse -o - | FileCheck %s
 
 ;; Observed in the wild, but test is created by running memcpyopt on
 ;; assignment-tracking/memcpyopt/merge-stores.ll then manually inserting
 ;; two stores that overwrite each end of the memset.
 ;;
 ;; A memory intrinsic (or vector instruction) might have multiple dbg.assigns
 ;; linked to it if it has been created as a result of merging scalar stores,
 ;; such as in this example. DSE is going to shorten the memset because there's

 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture)
 declare !dbg !64 dso_local void @_Z3escP1v(ptr) local_unnamed_addr
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 declare void @llvm.memset.p0i8.i64(ptr nocapture writeonly, i8, i64, i1 immarg)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "reduce.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !59 = !DILocation(line: 5, column: 5, scope: !38)
 !60 = !DILocation(line: 5, column: 10, scope: !38)
 !61 = !DILocation(line: 6, column: 5, scope: !38)
 !62 = !DILocation(line: 6, column: 10, scope: !38)
 !63 = !DILocation(line: 7, column: 3, scope: !27)
 !64 = !DISubprogram(name: "esc", linkageName: "_Z3escP1v", scope: !1, file: !1, line: 10, type: !65, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !65 = !DISubroutineType(types: !66)
 !66 = !{null, !30}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/dse/shorten.ll

-; RUN: opt %s -S -passes=dse -o - -experimental-assignment-tracking | FileCheck %s
+; RUN: opt %s -S -passes=dse -o - | FileCheck %s
 
 ;; $ cat test.cpp
 ;; void esc(int*);
 ;; void shortenEnd() {
 ;;   int local[20];
 ;;   __builtin_memset(local, 0, 6 * 4);
 ;;   __builtin_memset(local + 4, 8, 10 * 4);
 ;;   esc(local);
entry:
   call void @_Z3escPi(ptr noundef nonnull %arraydecay), !dbg !44
   call void @llvm.lifetime.end.p0i8(i64 40, ptr nonnull %local2) #5, !dbg !45
   ret void, !dbg !45
 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}

 !38 = !DILocation(line: 0, scope: !31)
 !39 = !DILocation(line: 9, column: 3, scope: !31)
 !40 = !DILocation(line: 10, column: 3, scope: !31)
 !41 = distinct !DIAssignID()
 !42 = !DILocation(line: 11, column: 3, scope: !31)
 !43 = distinct !DIAssignID()
 !44 = !DILocation(line: 12, column: 3, scope: !31)
 !45 = !DILocation(line: 13, column: 1, scope: !31)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/inline/id.ll

-; RUN: opt %s -S -passes=inline -o - -experimental-assignment-tracking \
+; RUN: opt %s -S -passes=inline -o - \
 ; RUN: | FileCheck %s
 
 ;; Check that all DIAssignID metadata that are inlined are replaced with new
 ;; versions. Otherwise two inlined instances of an assignment will be considered
 ;; to be the same assignment.
 ;;
 ;; $cat test.cpp
 ;; __attribute__((always_inline))

 define dso_local void @_Z3funv() !dbg !25 {
 entry:
   %call = call i32 @_Z3getv(), !dbg !28
   %call1 = call i32 @_Z3getv(), !dbg !29
   ret void, !dbg !30
 }
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !23 = !DILocation(line: 2, column: 38, scope: !7)
 !24 = !DILocation(line: 2, column: 26, scope: !7)
 !25 = distinct !DISubprogram(name: "fun", linkageName: "_Z3funv", scope: !1, file: !1, line: 3, type: !26, scopeLine: 3, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)
 !26 = !DISubroutineType(types: !27)
 !27 = !{null}
 !28 = !DILocation(line: 4, column: 3, scope: !25)
 !29 = !DILocation(line: 5, column: 3, scope: !25)
 !30 = !DILocation(line: 6, column: 1, scope: !25)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/inline/inline-stores.ll

-; RUN: opt -passes=inline %s -S -o - -experimental-assignment-tracking \
+; RUN: opt -passes=inline %s -S -o - \
 ; RUN: | FileCheck %s
 
 ;; $ cat test.cpp
 ;; __attribute__((always_inline))
 ;; static void a(int* p2, int v2) { *p2 = v2; }
 ;;
 ;; __attribute__((always_inline))
 ;; void b(int* p1, int v1) { a(p1, v1); }

 ; CHECK-DAG: [[ID_1]] = distinct !DIAssignID()
 ; CHECK-DAG: [[ID_2]] = distinct !DIAssignID()
 ; CHECK-DAG: [[ID_3]] = distinct !DIAssignID()
 ; CHECK-DAG: [[ID_4]] = distinct !DIAssignID()
 ; CHECK-DAG: [[ID_5]] = distinct !DIAssignID()
 ; CHECK-DAG: [[ID_6]] = distinct !DIAssignID()
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !101 = !DILocalVariable(name: "f6_local", scope: !99, file: !1, line: 37, type: !11)
 !102 = distinct !DIAssignID()
 !103 = !DILocation(line: 0, scope: !99)
 !104 = !DILocation(line: 37, column: 3, scope: !99)
 !105 = !DILocation(line: 38, column: 3, scope: !99)
 !106 = !DILocation(line: 39, column: 10, scope: !99)
 !107 = !DILocation(line: 40, column: 1, scope: !99)
 !108 = !DILocation(line: 39, column: 3, scope: !99)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/inline/use-before-def.ll

-; RUN: opt -passes=inline %s -S -o - -experimental-assignment-tracking \
+; RUN: opt -passes=inline %s -S -o - \
 ; RUN: | FileCheck %s
 
 ;; Hand modified from:
 ;; $ cat test.c
 ;; int g = 5;
 ;; static int callee() {
 ;;   int local = g;
 ;;   return local;
entry:
   %0 = load i32, ptr @g, align 4, !dbg !19
   ret i32 %0, !dbg !25
 }
 
 declare void @llvm.dbg.value(metadata, metadata, metadata) #2
 
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!7, !8, !9}
+!llvm.module.flags = !{!7, !8, !9, !1000}
 !llvm.ident = !{!10}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.c", directory: "/")
 !4 = !{}
 !5 = !{!0}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = !{i32 7, !"Dwarf Version", i32 4}
 !8 = !{i32 2, !"Debug Info Version", i32 3}
 !9 = !{i32 1, !"wchar_size", i32 4}
 !10 = !{!"clang version 12.0.0"}
 !11 = distinct !DISubprogram(name: "fun", scope: !3, file: !3, line: 7, type: !12, scopeLine: 7, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !4)
 !12 = !DISubroutineType(types: !13)
 !13 = !{!6}
 !14 = !DILocation(line: 8, column: 10, scope: !11)
 !15 = !DILocation(line: 8, column: 3, scope: !11)
 !16 = distinct !DISubprogram(name: "callee", scope: !3, file: !3, line: 2, type: !12, scopeLine: 2, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !17)
 !17 = !{!18}
 !18 = !DILocalVariable(name: "local", scope: !16, file: !3, line: 3, type: !6)
 !19 = !DILocation(line: 3, column: 15, scope: !16)
 !24 = !DILocation(line: 0, scope: !16)
 !25 = !DILocation(line: 4, column: 3, scope: !16)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/instcombine/alloca-bitcast.ll

-; RUN: opt -opaque-pointers=0 -passes=instcombine -S %s -o - -experimental-assignment-tracking \
+; RUN: opt -opaque-pointers=0 -passes=instcombine -S %s -o - \
 ; RUN: | FileCheck %s
 
 ;; NOTE: This test uses typed pointers because it is testing a code path that
 ;; doesn't get exercised with opaque pointers. If/when PromoteCastOfAllocation
 ;; is removed from visitBitCast this test should just be deleted.
 
 ;; Check that allocas generated in InstCombine's PromoteCastOfAllocation
 ;; have DIAssignID copied from the original alloca.
entry:
   %1 = load i64, i64* %0, align 4, !dbg !24
   ret i64 %1, !dbg !24
 }
 
 declare dso_local void @_ZN1cC1Ei(%struct.c*, i32) unnamed_addr
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "reduce.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !17 = !{null, !18, !13}
 !18 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
 !19 = !{!20}
 !20 = !DILocalVariable(name: "e", scope: !7, file: !1, line: 6, type: !10)
 !21 = distinct !DIAssignID()
 !22 = !DILocation(line: 0, scope: !7)
 !23 = !DILocation(line: 6, column: 5, scope: !7)
 !24 = !DILocation(line: 7, column: 3, scope: !7)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/instcombine/memset.ll

-; RUN: opt %s -S -passes=instcombine -o - -experimental-assignment-tracking \
+; RUN: opt %s -S -passes=instcombine -o - \
 ; RUN: | FileCheck %s
 
 ;; $ cat test.cpp
 ;; void esc(int*);
 ;; void fun() {
 ;;   int local[5];
 ;;   __builtin_memset(local, 8, 4 * 4);
 ;;   __builtin_memset(local, 0, 2 * 4);

 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.memset.p0i8.i64(ptr nocapture writeonly, i8, i64, i1 immarg)
 declare !dbg !25 dso_local void @_Z3escPi(ptr noundef) local_unnamed_addr
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}

 !22 = distinct !DIAssignID()
 !23 = !DILocation(line: 6, column: 3, scope: !7)
 !24 = !DILocation(line: 7, column: 1, scope: !7)
 !25 = !DISubprogram(name: "esc", linkageName: "_Z3escPi", scope: !1, file: !1, line: 1, type: !26, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !29)
 !26 = !DISubroutineType(types: !27)
 !27 = !{null, !28}
 !28 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !13, size: 64)
 !29 = !{}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/instcombine/remove-redundant-dbg.ll

-; RUN: opt -passes=instcombine -S %s -o - -experimental-assignment-tracking \
+; RUN: opt -passes=instcombine -S %s -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ;; Check that instcombine removes redundant debug intrinsics. This has a
 ;; significant positive impact on peak memory. CTMark's tramp3d-v4's peak
 ;; memory with assignment tracking enabled is reduced by about 15% with this
 ;; change.
 
 ; CHECK: @llvm.dbg.assign(metadata i32 1
 
 define dso_local void @_Z3funv() local_unnamed_addr !dbg !7 {
 entry:
    call void @llvm.dbg.assign(metadata i32 undef, metadata !11, metadata !DIExpression(), metadata !13, metadata ptr undef, metadata !DIExpression()), !dbg !14
    call void @_Z3extv(), !dbg !15
   call void @llvm.dbg.assign(metadata i32 0, metadata !11, metadata !DIExpression(), metadata !13, metadata ptr undef, metadata !DIExpression()), !dbg !14
   call void @llvm.dbg.assign(metadata i32 1, metadata !11, metadata !DIExpression(), metadata !13, metadata ptr undef, metadata !DIExpression()), !dbg !14
   ret void, !dbg !16
 }
 
 declare !dbg !17 dso_local void @_Z3extv() local_unnamed_addr
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}
 !6 = !{!"clang version 14.0.0)"}
 !7 = distinct !DISubprogram(name: "fun", linkageName: "_Z3funv", scope: !1, file: !1, line: 2, type: !8, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
 !8 = !DISubroutineType(types: !9)
 !9 = !{null}
 !10 = !{!11}
 !11 = !DILocalVariable(name: "a", scope: !7, file: !1, line: 2, type: !12)
 !12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !13 = distinct !DIAssignID()
 !14 = !DILocation(line: 0, scope: !7)
 !15 = !DILocation(line: 2, column: 25, scope: !7)
 !16 = !DILocation(line: 2, column: 32, scope: !7)
 !17 = !DISubprogram(name: "ext", linkageName: "_Z3extv", scope: !1, file: !1, line: 1, type: !8, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !18)
 !18 = !{}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/instcombine/sink-store.ll

-; RUN: opt %s -S -passes=instcombine -experimental-assignment-tracking | FileCheck %s
+; RUN: opt %s -S -passes=instcombine | FileCheck %s
 
 ;; Check that instcombine merges the DIAssignID metadata when merging two
 ;; stores into a successor. Filecheck directives inline.
 ;;
 ;; Generated from the following source:
 ;; int c;
 ;; void esc(int*);
 ;; int get();

 
 declare !dbg !34 dso_local i32 @_Z3getv() local_unnamed_addr
 declare !dbg !37 dso_local void @_Z3escPi(ptr) local_unnamed_addr
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!7, !8, !9}
+!llvm.module.flags = !{!7, !8, !9, !1000}
 !llvm.ident = !{!10}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "c", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{}
 !5 = !{!0}

 !33 = !DILocation(line: 13, column: 1, scope: !11)
 !34 = !DISubprogram(name: "get", linkageName: "_Z3getv", scope: !3, file: !3, line: 3, type: !35, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !4)
 !35 = !DISubroutineType(types: !36)
 !36 = !{!6}
 !37 = !DISubprogram(name: "esc", linkageName: "_Z3escPi", scope: !3, file: !3, line: 2, type: !38, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !4)
 !38 = !DISubroutineType(types: !39)
 !39 = !{null, !40}
 !40 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !6, size: 64)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/instcombine/sink.ll

-; RUN: opt %s -S -passes=instcombine -o - -experimental-assignment-tracking \
+; RUN: opt %s -S -passes=instcombine -o - \
 ; RUN: | FileCheck %s
 
 ;; Check that when instcombine sinks an instruction used by a dbg.assign, the
 ;; usual debug intrinsic updating doesn't take place (i.e. do not
 ;; clone-and-sink a dbg.assign). Assignment tracking should be able to handle
 ;; this gracefully for variables that still have a stack home. For fully
 ;; promoted variables we may need to revisit this.
 

 }
 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture) #3
 declare dso_local void @g(...) local_unnamed_addr #1
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #3
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #4
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!7, !8, !9}
+!llvm.module.flags = !{!7, !8, !9, !1000}
 !llvm.ident = !{!10}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "d", scope: !2, file: !3, line: 4, type: !6, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.c", directory: "/")
 !4 = !{}
 !5 = !{!0}

 !45 = !DILocation(line: 7, column: 7, scope: !15, inlinedAt: !46)
 !46 = distinct !DILocation(line: 15, column: 3, scope: !35)
 !47 = !DILocation(line: 7, column: 7, scope: !11, inlinedAt: !46)
 !48 = !DILocation(line: 9, column: 3, scope: !11, inlinedAt: !46)
 !49 = !DILocation(line: 16, column: 7, scope: !35)
 !53 = distinct !DIAssignID()
 !54 = !DILocation(line: 17, column: 3, scope: !35)
 !55 = !DILocation(line: 18, column: 1, scope: !35)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/instcombine/storemerge.ll

-; RUN: opt %s -S -passes=instcombine -o - -experimental-assignment-tracking | FileCheck %s
+; RUN: opt %s -S -passes=instcombine -o - | FileCheck %s
 
 ;; $ cat test.cpp
 ;; class a {
 ;;   float b;
 ;; };
 ;; class c {
 ;; public:
 ;;   a d();

 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 
 declare dso_local void @_ZN1g1hER1a(ptr, ptr nonnull align 4 dereferenceable(4)) local_unnamed_addr #2
 
 ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !72 = !DILocation(line: 29, column: 7, scope: !53)
 !73 = !DILocation(line: 31, column: 13, scope: !53)
 !74 = !DILocation(line: 31, column: 17, scope: !53)
 !75 = !DILocation(line: 31, column: 9, scope: !53)
 !76 = distinct !DIAssignID()
 !77 = !DILocation(line: 32, column: 3, scope: !7)
 !78 = !DILocation(line: 32, column: 5, scope: !7)
 !79 = !DILocation(line: 33, column: 1, scope: !7)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/licm/merge.ll

-; RUN: opt -passes=licm %s -S -experimental-assignment-tracking | FileCheck %s
+; RUN: opt -passes=licm %s -S | FileCheck %s
 
 ;; Ensure that we correctly merge the DIAssignID's from the sunk stores, add it
 ;; to the new new store instruction, and update the dbg.assign intrinsics using
 ;; them to use it instead.
 
 ;; Generated from the following, with some changes to the IR by hand:
 ;; $ cat test.c
 ;; void b(int c) {
for.end:                                          ; preds = %for.cond.for.end_crit_edge, %entry
   ret void, !dbg !27
 }
 
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 declare !dbg !28 dso_local void @esc(ptr)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: true, 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}

 !27 = !DILocation(line: 6, column: 1, scope: !7)
 !28 = !DISubprogram(name: "esc", scope: !1, file: !1, line: 1, type: !29, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !29 = !DISubroutineType(types: !30)
 !30 = !{null, !31}
 !31 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
 !36 = distinct !DIAssignID()
 !37 = distinct !DIAssignID()
 !38 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/licm/multi-exit.ll

-; RUN: opt %s -S -passes=licm -o - -experimental-assignment-tracking | FileCheck %s
+; RUN: opt %s -S -passes=licm -o - | FileCheck %s
 
 ;; $ cat test.c
 ;; int b, c, d;
 ;; void e();
 ;; void f(int *g) { *g = b; }
 ;; void i() {
 ;;   int h, a;
 ;;   for (;;) {

 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #1
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture) #3
 declare !dbg !64 dso_local void @e(...) local_unnamed_addr #4
 declare void @llvm.dbg.value(metadata, metadata, metadata) #1
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!11, !12, !13}
+!llvm.module.flags = !{!11, !12, !13, !1000}
 !llvm.ident = !{!14}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 1, type: !8, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.c", directory: "/")
 !4 = !{}
 !5 = !{!0, !6, !9}

 !59 = !DILocation(line: 12, column: 11, scope: !54)
 !60 = distinct !DIAssignID()
 !61 = !DILocation(line: 13, column: 5, scope: !54)
 !62 = !DILocation(line: 14, column: 5, scope: !45)
 !63 = !DILocation(line: 6, column: 3, scope: !46)
 !64 = !DISubprogram(name: "e", scope: !3, file: !3, line: 2, type: !65, spFlags: DISPFlagOptimized, retainedNodes: !4)
 !65 = !DISubroutineType(types: !66)
 !66 = !{null, null}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/loop-deletion/dead-loop.ll

-; RUN: opt %s -passes=loop-deletion -S -o - -experimental-assignment-tracking \
+; RUN: opt %s -passes=loop-deletion -S -o - \
 ; RUN: | FileCheck %s
 
 ;; $ cat test.cpp:
 ;; void esc(int*);
 ;; void fun() {
 ;;   int Counter = 0;
 ;;   for (; Counter < 2; Counter++) {}
 ;;   esc(&Counter);

 }
 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture)
 declare !dbg !29 dso_local void @_Z3escPi(ptr noundef) local_unnamed_addr
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}

 !22 = !{!"llvm.loop.mustprogress"}
 !27 = !DILocation(line: 5, column: 3, scope: !7)
 !28 = !DILocation(line: 6, column: 1, scope: !7)
 !29 = !DISubprogram(name: "esc", linkageName: "_Z3escPi", scope: !1, file: !1, line: 1, type: !30, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !33)
 !30 = !DISubroutineType(types: !31)
 !31 = !{null, !32}
 !32 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
 !33 = !{}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/mem2reg/phi.ll

-; RUN: opt -passes=mem2reg -S %s -o - -experimental-assignment-tracking \
+; RUN: opt -passes=mem2reg -S %s -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ;; Test assignment tracking debug info when mem2reg promotes an alloca with
 ;; stores requiring insertion of a phi. Check the output when the stores are
 ;; tagged and also untagged (test manually updated for the latter by linking a
 ;; dbg.assgin for another variable "b" to the alloca).
 
 ; CHECK: entry:

 if.end:                                           ; preds = %if.else, %if.then
   %2 = load i32, ptr %a.addr, align 4, !dbg !28
   ret i32 %2, !dbg !29
 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}

 !23 = !DILocation(line: 3, column: 7, scope: !21)
 !24 = distinct !DIAssignID()
 !25 = !DILocation(line: 3, column: 5, scope: !21)
 !26 = !DILocation(line: 5, column: 7, scope: !21)
 !27 = distinct !DIAssignID()
 !28 = !DILocation(line: 6, column: 10, scope: !7)
 !29 = !DILocation(line: 6, column: 3, scope: !7)
 !30 = !DILocalVariable(name: "b", arg: 2, scope: !7, file: !1, line: 1, type: !10)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/mem2reg/single-block-alloca.ll

-; RUN: opt -passes=mem2reg -S %s -o - -experimental-assignment-tracking \
+; RUN: opt -passes=mem2reg -S %s -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ;; Test assignment tracking debug info when mem2reg promotes a single-block
 ;; alloca. Check the output when the stores are tagged and also untagged (test
 ;; manually updated for the latter by linking a dbg.assgin for another variable
 ;; "b" to the alloca).
 
 ; CHECK: entry:
entry:
   call void @llvm.dbg.assign(metadata i32 %add, metadata !12, metadata !DIExpression(), metadata !21, metadata ptr %a.addr, metadata !DIExpression()), !dbg !14
   %1 = load i32, ptr %a.addr, align 4, !dbg !22
   ret i32 %1, !dbg !23
 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}
 !6 = !{!"clang version 14.0.0"}
 !7 = distinct !DISubprogram(name: "f", linkageName: "_Z1fi", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
 !8 = !DISubroutineType(types: !9)
 !9 = !{!10, !10}
 !10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !11 = !{!12}
 !12 = !DILocalVariable(name: "a", arg: 1, scope: !7, file: !1, line: 1, type: !10)
 !13 = distinct !DIAssignID()
 !14 = !DILocation(line: 0, scope: !7)
 !19 = distinct !DIAssignID()
 !20 = !DILocation(line: 2, column: 5, scope: !7)
 !21 = distinct !DIAssignID()
 !22 = !DILocation(line: 3, column: 10, scope: !7)
 !23 = !DILocation(line: 3, column: 3, scope: !7)
 !24 = !DILocalVariable(name: "b", scope: !7, file: !1, line: 1, type: !10)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/mem2reg/single-store-alloca.ll

-; RUN: opt -passes=mem2reg -S %s -o - -experimental-assignment-tracking \
+; RUN: opt -passes=mem2reg -S %s -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ;; Test assignment tracking debug info when mem2reg promotes a single-store
 ;; alloca. Additionally, check that all the dbg.assigns linked to the alloca
 ;; are cleaned up, including duplciates.
 
 ; CHECK: entry:
 ; CHECK-NEXT: call void @llvm.dbg.value(metadata i32 %a, metadata ![[B:[0-9]+]]
entry:
   call void @llvm.dbg.assign(metadata i32 %a, metadata !12, metadata !DIExpression(), metadata !19, metadata ptr %a.addr, metadata !DIExpression()), !dbg !14
   %0 = load i32, ptr %a.addr, align 4, !dbg !20
   ret i32 %0, !dbg !21
 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}
 !6 = !{!"clang version 14.0.0)"}
 !7 = distinct !DISubprogram(name: "f", linkageName: "_Z1fi", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
 !8 = !DISubroutineType(types: !9)
 !9 = !{!10, !10}
 !10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !11 = !{!12}
 !12 = !DILocalVariable(name: "a", arg: 1, scope: !7, file: !1, line: 1, type: !10)
 !13 = distinct !DIAssignID()
 !14 = !DILocation(line: 0, scope: !7)
 !19 = distinct !DIAssignID()
 !20 = !DILocation(line: 1, column: 23, scope: !7)
 !21 = !DILocation(line: 1, column: 16, scope: !7)
 !22 = !DILocalVariable(name: "b", scope: !7, file: !1, line: 1, type: !10)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/memcpyopt/merge-stores.ll

-; RUN: opt %s -S -passes=memcpyopt -o - -experimental-assignment-tracking | FileCheck %s
+; RUN: opt %s -S -passes=memcpyopt -o - | FileCheck %s
 
 ;; $ cat test.cpp
 ;; struct v {
 ;;   float c[4];
 ;;
 ;;   v(float d) {
 ;;     c[0] = c[1] = c[2] = d;
 ;;     c[3] = 0.f;
entry:
   ret void, !dbg !69
 }
 
 declare !dbg !70 dso_local void @_Z3escP1v(ptr) local_unnamed_addr
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "reduce.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !65 = !DILocation(line: 5, column: 5, scope: !38)
 !66 = !DILocation(line: 5, column: 10, scope: !38)
 !67 = !DILocation(line: 6, column: 5, scope: !38)
 !68 = !DILocation(line: 6, column: 10, scope: !38)
 !69 = !DILocation(line: 7, column: 3, scope: !27)
 !70 = !DISubprogram(name: "esc", linkageName: "_Z3escP1v", scope: !1, file: !1, line: 10, type: !71, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !71 = !DISubroutineType(types: !72)
 !72 = !{null, !30}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/mldst-motion/diamond.ll

-; RUN: opt -passes=mldst-motion -S %s -o - -experimental-assignment-tracking \
+; RUN: opt -passes=mldst-motion -S %s -o - \
 ; RUN: | FileCheck %s
 
 ;; $ cat test.cpp
 ;; int cond;
 ;; void esc(int*);
 ;; void fun() {
 ;;   int a[4];
 ;;   if (cond)

 }
 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture)
 declare !dbg !38 dso_local void @_Z3escPi(i32* noundef)
 declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!6, !7, !8, !9}
+!llvm.module.flags = !{!6, !7, !8, !9, !1000}
 !llvm.ident = !{!10}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "cond", scope: !2, file: !3, line: 1, type: !5, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{!0}
 !5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)

 !35 = !DILocation(line: 9, column: 7, scope: !11)
 !36 = !DILocation(line: 9, column: 3, scope: !11)
 !37 = !DILocation(line: 10, column: 1, scope: !11)
 !38 = !DISubprogram(name: "esc", linkageName: "_Z3escPi", scope: !3, file: !3, line: 2, type: !39, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !42)
 !39 = !DISubroutineType(types: !40)
 !40 = !{null, !41}
 !41 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !5, size: 64)
 !42 = !{}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

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

-; RUN: not opt -S %s -experimental-assignment-tracking 2>&1 \
+; RUN: not opt -S %s 2>&1 \
 ; RUN: | FileCheck %s
 
 ;; Check that badly formed assignment tracking metadata is caught either
 ;; while parsing or by the verifier.
 
 ; CHECK: error: missing 'distinct', required for !DIAssignID()
 
 !1 = !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

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

-; RUN: opt -S %s -passes=verify -experimental-assignment-tracking 2>&1 \
+; RUN: opt -S %s -passes=verify 2>&1 \
 ; RUN: | FileCheck %s
 
 ;; NOTE: Expect opt to return zero because the badly formed debug info
 ;; is going to be stripped.
 
 ;; Check that badly formed assignment tracking metadata is caught either
 ;; while parsing or by the verifier.
 
 ;; Check verifier output.
 ; CHECK: !DIAssignID attached to unexpected instruction kind
 
 ;; Check DIAssignID is stripped from IR.
 ; CHECK: define dso_local void @fun() {
 ; CHECK-NOT: DIAssignID
 
 define dso_local void @fun() !dbg !7 {
 entry:
   ret void, !DIAssignID !14
 }
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !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}
 !14 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

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

-; RUN: not opt -S %s -experimental-assignment-tracking 2>&1 \
+; RUN: not opt -S %s 2>&1 \
 ; RUN: | FileCheck %s
 
 ;; Check that badly formed assignment tracking metadata is caught either
 ;; while parsing or by the verifier.
 
 ; CHECK: error: expected ')' here
 
 !1 = distinct !DIAssignID(0)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

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

-; RUN: opt %s -passes=verify -experimental-assignment-tracking   \
-; RUN: | opt -passes=verify -S -experimental-assignment-tracking \
+; RUN: opt %s -passes=verify   \
+; RUN: | opt -passes=verify -S \
 ; RUN: | FileCheck %s
 
 ;; 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]+]]

 ; 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.module.flags = !{!3, !4, !5, !1000}
 !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}

 !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}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

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

-; RUN: opt %s -S -passes=verify -experimental-assignment-tracking 2>&1 \
+; RUN: opt %s -S -passes=verify 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 @fun2() !dbg !15 {
entry:
   call void @llvm.dbg.assign(metadata !14, metadata !10, metadata !DIExpression(), metadata !14, metadata ptr 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.module.flags = !{!3, !4, !5, !1000}
 !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()
 !15 = distinct !DISubprogram(name: "fun2", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/remove-redundant-fwd-scan-linked.ll

-; RUN: opt -passes=redundant-dbg-inst-elim -S %s -o - -experimental-assignment-tracking \
+; RUN: opt -passes=redundant-dbg-inst-elim -S %s -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ;; $ cat -n reduce.c
 ;;  1 void ext();
 ;;  2 typedef struct {
 ;;  3   short *a;
 ;;  4   char *b;
 ;;  5 } c;

 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture) #1
 declare !dbg !47 dso_local void @ext(...) local_unnamed_addr #2
 declare dso_local void @f(...) local_unnamed_addr #2
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
 declare void @llvm.memset.p0i8.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #4
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!6, !7, !8, !9, !10}
+!llvm.module.flags = !{!6, !7, !8, !9, !10, !1000}
 !llvm.ident = !{!11}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "d", scope: !2, file: !3, line: 6, type: !5, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 16.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "reduce.c", directory: "/")
 !4 = !{!0}
 !5 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)

 !35 = !DILocation(line: 14, scope: !12)
 !36 = !DILocation(line: 15, scope: !12)
 !37 = !DILocation(line: 16, scope: !12)
 !44 = distinct !DIAssignID()
 !45 = !DILocation(line: 17, scope: !12)
 !46 = !DILocation(line: 18, scope: !12)
 !47 = !DISubprogram(name: "ext", scope: !3, file: !3, line: 1, type: !13, spFlags: DISPFlagOptimized, retainedNodes: !48)
 !48 = !{}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/remove-redundant.ll

-; RUN: opt -passes=redundant-dbg-inst-elim -S %s -o - -experimental-assignment-tracking \
+; RUN: opt -passes=redundant-dbg-inst-elim -S %s -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ;; Hand-written. Test how RemoveRedundantDbgInstrs interacts with dbg.assign
 ;; intrinsics. FileCehck directives are inline.
 
 define dso_local void @_Z1fv() !dbg !7 {
 entry:
   %test = alloca i32, align 4, !DIAssignID !20

 ; CHECK-DAG: ![[Local2]] = !DILocalVariable(name: "Local2",
 ; CHECK-DAG: ![[Local]] = !DILocalVariable(name: "Local",
 
 declare dso_local void @step()
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}
 !6 = !{!"clang version 14.0.0"}
 !7 = distinct !DISubprogram(name: "f", linkageName: "_Z1fv", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
 !8 = !DISubroutineType(types: !9)
 !9 = !{null}
 !10 = !{!11, !19}
 !11 = !DILocalVariable(name: "Local", scope: !7, file: !1, line: 2, type: !12)
 !12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !13 = distinct !DIAssignID()
 !14 = !DILocation(line: 0, scope: !7)
 !15 = distinct !DIAssignID()
 !16 = distinct !DIAssignID()
 !17 = distinct !DIAssignID()
 !18 = !DILocation(line: 6, column: 1, scope: !7)
 !19 = !DILocalVariable(name: "Local2", scope: !7, file: !1, line: 2, type: !12)
 !20 = distinct !DIAssignID()
 !21 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/salvage-value.ll

-; RUN: opt %s -S -o - -passes=instcombine -experimental-assignment-tracking \
+; RUN: opt %s -S -o - -passes=instcombine \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ;; Hand-written (the debug info doesn't necessarily make sense and isn't fully
 ;; formed). Test salvaging a dbg.assign value and address. Checks and comments
 ;; are inline.
 
 define dso_local void @fun(i32  %x, i32 %y, ptr %p) !dbg !7 {
 entry:

 ; CHECK-NEXT: call void @llvm.dbg.assign(metadata i32 %x,{{.+}}, metadata !DIExpression(),{{.+}}, metadata ptr undef, metadata !DIExpression())
 
   ret void
 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}

 !22 = !DILocation(line: 3, column: 17, scope: !7)
 !28 = distinct !DIAssignID()
 !29 = !DILocation(line: 4, column: 13, scope: !7)
 !31 = distinct !DIAssignID()
 !32 = !DILocalVariable(name: "Local1", scope: !7, file: !1, line: 3, type: !10)
 !33 = !DILocalVariable(name: "Local2", scope: !7, file: !1, line: 3, type: !10)
 !34 = !DILocalVariable(name: "Local3", scope: !7, file: !1, line: 3, type: !10)
 !35 = !DILocalVariable(name: "Local4", scope: !7, file: !1, line: 3, type: !10)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/simplifycfg/empty-block.ll

-; RUN: opt -S %s -passes=simplifycfg -o - -experimental-assignment-tracking \
+; RUN: opt -S %s -passes=simplifycfg -o - \
 ; RUN: | FileCheck %s
 
 ;; $ cat test.cpp
 ;; class a {};
 ;; void operator*(a, float &);
 ;; class b {
 ;; public:
 ;;   a c;

 }
 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture) #1
 declare !dbg !49 dso_local void @_Zml1aRf(ptr nonnull align 4 dereferenceable(4)) local_unnamed_addr #2
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!7, !8, !9}
+!llvm.module.flags = !{!7, !8, !9, !1000}
 !llvm.ident = !{!10}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "d", scope: !2, file: !3, line: 7, type: !6, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{}
 !5 = !{!0}

 !43 = distinct !DIAssignID()
 !44 = !DILocation(line: 17, column: 5, scope: !37)
 !45 = !DILocation(line: 0, scope: !37)
 !48 = !DILocation(line: 20, column: 1, scope: !11)
 !49 = !DISubprogram(name: "operator*", linkageName: "_Zml1aRf", scope: !3, file: !3, line: 2, type: !50, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !4)
 !50 = !DISubroutineType(types: !51)
 !51 = !{null, !19, !52}
 !52 = !DIDerivedType(tag: DW_TAG_reference_type, baseType: !23, size: 64)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/simplifycfg/speculated-store.ll

-; RUN: opt -passes=simplifycfg %s -S -experimental-assignment-tracking  \
+; RUN: opt -passes=simplifycfg %s -S  \
 ; RUN: | FileCheck %s
 
 ;; Ensure that we correctly update the value component of dbg.assign intrinsics
 ;; after merging a conditional block with a store its the predecessor. The
 ;; value stored is still conditional, but the store itself is now
 ;; unconditionally run, so we must be sure that any linked dbg.assign intrinsics
 ;; are tracking the new stored value (the result of the select). If we don't,
 ;; and the store were to be removed by another pass (e.g. DSE), then we'd
if.end:                                           ; preds = %if.then, %entry
   ret void, !dbg !27
 }
 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!7, !8, !9}
+!llvm.module.flags = !{!7, !8, !9, !1000}
 !llvm.ident = !{!10}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "a", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.c", directory: "/")
 !4 = !{}
 !5 = !{!0}

 !22 = !DILocation(line: 4, column: 7, scope: !23)
 !23 = distinct !DILexicalBlock(scope: !11, file: !3, line: 4, column: 7)
 !24 = !DILocation(line: 4, column: 7, scope: !11)
 !25 = !DILocation(line: 5, column: 7, scope: !23)
 !26 = !DILocation(line: 5, column: 5, scope: !23)
 !27 = !DILocation(line: 6, column: 1, scope: !11)
 !36 = distinct !DIAssignID()
 !37 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/slp-vectorizer/merge-scalars.ll

 ; REQUIRES: x86-registered-target
-; RUN: opt -passes=slp-vectorizer -S -o - %s -experimental-assignment-tracking \
+; RUN: opt -passes=slp-vectorizer -S -o - %s \
 ; RUN: | FileCheck %s
 
 ;; $ cat test.cpp
 ;; float get();
 ;; float ext(float*);
 ;; void fun(float k1, float k2, float k3, float k4) {
 ;;   float quad[4];
 ;;   float c1 = get();

 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture) #1
 declare !dbg !63 dso_local float @_Z3getv() local_unnamed_addr #2
 declare !dbg !66 dso_local float @_Z3extPf(ptr) local_unnamed_addr #2
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !62 = !DILocation(line: 12, column: 1, scope: !7)
 !63 = !DISubprogram(name: "get", linkageName: "_Z3getv", scope: !1, file: !1, line: 1, type: !64, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !64 = !DISubroutineType(types: !65)
 !65 = !{!10}
 !66 = !DISubprogram(name: "ext", linkageName: "_Z3extPf", scope: !1, file: !1, line: 2, type: !67, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !67 = !DISubroutineType(types: !68)
 !68 = !{!10, !69}
 !69 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/after-inlining.ll

-; RUN: opt %s -S -passes=sroa -o - -experimental-assignment-tracking | FileCheck %s
+; RUN: opt %s -S -passes=sroa -o - | FileCheck %s
 
 ;; Check that SROA preserves the InlinedAt status of new dbg.assign intriniscs
 ;; it inserts.
 
 ;; $cat test.c
 ;; typedef struct {
 ;;   int a;
 ;;   int b[];
entry:
   %1 = load i32, ptr %arrayidx.i.i, align 4, !dbg !78
   store i32 1, ptr @f, align 4, !dbg !80
   store i32 %1, ptr @e, align 4, !dbg !81
   call void @llvm.lifetime.end.p0i8(i64 4, ptr nonnull %0) #5, !dbg !82
   ret void, !dbg !83
 }
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!11, !12, !13}
+!llvm.module.flags = !{!11, !12, !13, !1000}
 !llvm.ident = !{!14}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "d", scope: !2, file: !3, line: 5, type: !8, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.c", directory: "/")
 !4 = !{}
 !5 = !{!0, !6, !9}

 !76 = distinct !DILocation(line: 21, column: 12, scope: !73)
 !77 = !DILocation(line: 17, column: 3, scope: !60, inlinedAt: !76)
 !78 = !DILocation(line: 13, column: 10, scope: !47, inlinedAt: !79)
 !79 = distinct !DILocation(line: 19, column: 3, scope: !60, inlinedAt: !76)
 !80 = !DILocation(line: 0, scope: !40, inlinedAt: !79)
 !81 = !DILocation(line: 14, column: 5, scope: !40, inlinedAt: !79)
 !82 = !DILocation(line: 20, column: 1, scope: !60, inlinedAt: !76)
 !83 = !DILocation(line: 21, column: 17, scope: !73)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/alloca-single-slice.ll

-; RUN: opt -passes=sroa,verify -S %s -o - -experimental-assignment-tracking \
+; RUN: opt -passes=sroa,verify -S %s -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ; Check that single sliced allocas retain their assignment tracking debug info.
 
 ;; $ cat test.c
 ;; struct a {
 ;;   char b[8];
 ;; };

 }
 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture)
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg)
 declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!7, !8, !9}
+!llvm.module.flags = !{!7, !8, !9, !1000}
 !llvm.ident = !{!10}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "c", scope: !2, file: !3, line: 4, type: !6, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.c", directory: "/")
 !4 = !{}
 !5 = !{!0}

 !22 = !DISubrange(count: 8)
 !23 = distinct !DIAssignID()
 !24 = !DILocation(line: 0, scope: !11)
 !25 = !DILocation(line: 6, column: 3, scope: !11)
 !26 = !DILocation(line: 7, column: 12, scope: !11)
 !27 = !DILocation(line: 7, column: 3, scope: !11)
 !28 = !DILocation(line: 7, column: 18, scope: !11)
 !33 = !DILocation(line: 8, column: 1, scope: !11)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/complex.ll

-; RUN: opt -passes=sroa -S -o - %s -experimental-assignment-tracking | FileCheck %s
+; RUN: opt -passes=sroa -S -o - %s | FileCheck %s
 ;
 ;; Based on llvm/test/DebugInfo/ARM/sroa-complex.ll
 ;; generated from:
 ;; $ cat test.c
 ;; void f(_Complex double c) { c = 0; }
 ;; $ clang test.c -g -O2 -c -Xclang -disable-llvm-passes -S \
 ;;     -emit-llvm -o - --target="thumbv7-apple-unknown"
 ;;
entry:
   ;call void @llvm.dbg.assign(metadata double 0.000000e+00, metadata !13, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64), metadata !19, metadata ptr %c.imagp, metadata !DIExpression()), !dbg !15
   ret void, !dbg !20
 }
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5, !6}
+!llvm.module.flags = !{!3, !4, !5, !6, !1000}
 !llvm.ident = !{!7}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: true, 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 = !{i32 1, !"min_enum_size", i32 4}
 !7 = !{!"clang version 12.0.0"}
 !8 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 2, type: !9, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
 !9 = !DISubroutineType(types: !10)
 !10 = !{null, !11}
 !11 = !DIBasicType(name: "complex", size: 128, encoding: DW_ATE_complex_float)
 !12 = !{!13}
 !13 = !DILocalVariable(name: "c", arg: 1, scope: !8, file: !1, line: 2, type: !11)
 !14 = distinct !DIAssignID()
 !15 = !DILocation(line: 0, scope: !8)
 !16 = distinct !DIAssignID()
 !17 = !DILocation(line: 2, column: 31, scope: !8)
 !18 = distinct !DIAssignID()
 !19 = distinct !DIAssignID()
 !20 = !DILocation(line: 2, column: 36, scope: !8)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/frag-2.ll

-; RUN: opt -passes=sroa -S %s -o - -experimental-assignment-tracking | FileCheck %s
+; RUN: opt -passes=sroa -S %s -o - | FileCheck %s
 
 ;; $ cat test.cpp
 ;; class a {
 ;; public:
 ;;   float b[4];
 ;;   void c();
 ;; };
 ;; class B {

 }
 
 declare dso_local void @_ZN1a1cEv(ptr) local_unnamed_addr #5
 
 ; Function Attrs: argmemonly nofree nosync nounwind willreturn
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "reduce.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !95 = !DILocalVariable(name: "this", arg: 1, scope: !93, type: !51, flags: DIFlagArtificial | DIFlagObjectPointer)
 !96 = distinct !DILocation(line: 22, column: 11, scope: !57)
 !97 = !DILocation(line: 22, column: 9, scope: !57)
 !98 = distinct !DIAssignID()
 !99 = !DILocation(line: 23, column: 5, scope: !57)
 !100 = !DILocation(line: 24, column: 1, scope: !57)
 !101 = !DILocation(line: 9, column: 19, scope: !93)
 !102 = !DILocation(line: 9, column: 12, scope: !93)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/frag.ll

-; RUN: opt %s -S -passes=sroa -o - -experimental-assignment-tracking | FileCheck %s
+; RUN: opt %s -S -passes=sroa -o - | FileCheck %s
 
 ;; $ cat test.cpp
 ;; class c {
 ;;   float b[4];
 ;; };
 ;; c fn1();
 ;; void d() {
 ;;   c a[3];

 
 ; Function Attrs: argmemonly nofree nosync nounwind willreturn
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 
 ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "reduce.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !25 = !DILocation(line: 7, column: 10, scope: !7)
 !26 = !DILocation(line: 7, column: 3, scope: !7)
 !27 = !DILocation(line: 7, column: 8, scope: !7)
 !32 = distinct !DIAssignID()
 !33 = !DILocation(line: 8, column: 1, scope: !7)
 !34 = !DISubprogram(name: "fn1", linkageName: "_Z3fn1v", scope: !1, file: !1, line: 4, type: !35, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !35 = !DISubroutineType(types: !36)
 !36 = !{!13}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/id.ll

-; RUN: opt -passes=sroa -S %s -o - -experimental-assignment-tracking | FileCheck %s
+; RUN: opt -passes=sroa -S %s -o - | FileCheck %s
 
 ;; Check that multiple dbg.assign intrinsics linked to a store that is getting
 ;; split (or at least that is touched by SROA, causing a replacement store to
 ;; be generated) are still both linked to the new store(s).
 ;;
 ;; Additionally, check that SROA inserts new dbg.assign intrinsics by the
 ;; originals.
 

 
 ; Function Attrs: argmemonly nofree nosync nounwind willreturn
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 
 ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!12, !13, !14}
+!llvm.module.flags = !{!12, !13, !14, !1000}
 !llvm.ident = !{!15}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 5, type: !8, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "reduce.cpp", directory: "")
 !4 = !{}
 !5 = !{!0, !6, !9}

 !63 = distinct !DIAssignID()
 !64 = !DILocation(line: 0, scope: !42)
 !65 = distinct !DIAssignID()
 !66 = distinct !DIAssignID()
 !67 = distinct !DIAssignID()
 !68 = distinct !DIAssignID()
 !69 = distinct !DIAssignID()
 !70 = !DILocation(line: 3, column: 20, scope: !42)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/memcpy.ll

-; RUN: opt -passes=sroa,verify -S %s -o - -experimental-assignment-tracking \
+; RUN: opt -passes=sroa,verify -S %s -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ;; Check that the new slices of an alloca and memcpy intructions get dbg.assign
 ;; intrinsics with the correct fragment info.
 ;;
 ;; Also check that the new dbg.assign intrinsics are inserted after each split
 ;; store. See llvm/test/DebugInfo/Generic/dbg-assign-sroa-id.ll for the
 ;; counterpart check. Ensure that only the value-expression gets fragment info;

 ; Function Attrs: argmemonly nofree nosync nounwind willreturn
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 
 ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
 
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!16, !17, !18}
+!llvm.module.flags = !{!16, !17, !18, !1000}
 !llvm.ident = !{!19}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "From", scope: !2, file: !3, line: 6, type: !6, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "sroa-test.cpp", directory: "/")
 !4 = !{}
 !5 = !{!0}

 !25 = distinct !DIAssignID()
 !26 = !DILocation(line: 0, scope: !20)
 !27 = !DILocation(line: 8, column: 3, scope: !20)
 !28 = !DILocation(line: 8, column: 20, scope: !20)
 !34 = distinct !DIAssignID()
 !35 = !DILocation(line: 9, column: 13, scope: !20)
 !38 = !DILocation(line: 10, column: 1, scope: !20)
 !39 = !DILocation(line: 9, column: 3, scope: !20)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/memmove-to-from-same-alloca.ll

-; RUN: opt %s -passes=sroa -o - -S -experimental-assignment-tracking \
+; RUN: opt %s -passes=sroa -o - -S \
 ; RUN: | FileCheck %s
 
 ;; Generated from this C++ source:
 ;; __attribute__((nodebug)) struct Blob {int P[6];} Glob;
 ;; __attribute__((nodebug)) int Cond;
 ;; __attribute__((nodebug)) Blob *C;
 ;; __attribute__((nodebug)) void call(int);
 ;; 

 declare void @llvm.dbg.declare(metadata, metadata, metadata) #2
 declare void @llvm.memmove.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1 immarg) #3
 declare void @_Z4calli(i32 noundef) #4
 declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
 
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5, !6, !7}
+!llvm.module.flags = !{!2, !3, !4, !5, !6, !7, !1000}
 !llvm.ident = !{!8}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 16.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 8, !"PIC Level", i32 2}

 !42 = !DILocation(line: 18, column: 7, scope: !9)
 !43 = !DILocation(line: 20, column: 23, scope: !41)
 !46 = !DILocation(line: 20, column: 27, scope: !41)
 !47 = !DILocation(line: 20, column: 5, scope: !41)
 !48 = !DILocation(line: 23, column: 23, scope: !41)
 !49 = !DILocation(line: 23, column: 27, scope: !41)
 !50 = !DILocation(line: 23, column: 5, scope: !41)
 !51 = !DILocation(line: 24, column: 1, scope: !9)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/rewrite.ll

-; RUN: opt -passes=sroa,verify -S %s -experimental-assignment-tracking -o - \
+; RUN: opt -passes=sroa,verify -S %s -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ; Check that the new slices of an alloca and memset intructions get dbg.assign
 ; intrinsics with the correct fragment info. Ensure that only the
 ; value-expression gets fragment info; that the address-expression remains
 ; untouched.
 
 ;; $ cat test.cpp

 
 ; Function Attrs: argmemonly nofree nosync nounwind willreturn
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 
 ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!10, !11, !12}
+!llvm.module.flags = !{!10, !11, !12, !1000}
 !llvm.ident = !{!13}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "Glob", scope: !2, file: !3, line: 7, type: !9, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{}
 !5 = !{!0, !6}

 !32 = distinct !DIAssignID()
 !33 = !DILocation(line: 11, column: 11, scope: !14)
 !38 = !DILocation(line: 11, column: 5, scope: !14)
 !39 = !DILocation(line: 11, column: 9, scope: !14)
 !42 = distinct !DIAssignID()
 !43 = !DILocation(line: 12, column: 12, scope: !14)
 !44 = !DILocation(line: 13, column: 1, scope: !14)
 !45 = !DILocation(line: 12, column: 3, scope: !14)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/store.ll

-; RUN: opt -passes=sroa,verify -S %s -o - -experimental-assignment-tracking \
+; RUN: opt -passes=sroa,verify -S %s -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ; Check that the new slices of an alloca and memset intructions get dbg.assign
 ; intrinsics with the correct fragment info. Ensure that only the
 ; value-expression gets fragment info; that the address-expression remains
 ; untouched.
 
 ;; $ cat test.cpp

 
 ; Function Attrs: argmemonly nofree nosync nounwind willreturn
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 
 ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #4
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!10, !11, !12}
+!llvm.module.flags = !{!10, !11, !12, !1000}
 !llvm.ident = !{!13}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "Glob", scope: !2, file: !3, line: 7, type: !9, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{}
 !5 = !{!0, !6}

 !43 = !DILocation(line: 13, column: 7, scope: !14)
 !45 = !DILocation(line: 13, column: 3, scope: !14)
 !46 = !DILocation(line: 14, column: 12, scope: !14)
 !47 = !DILocation(line: 15, column: 1, scope: !14)
 !48 = !DILocation(line: 14, column: 3, scope: !14)
 !49 = !DISubprogram(name: "use", linkageName: "_Z3use11LargeStruct", scope: !3, file: !3, line: 9, type: !50, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !4)
 !50 = !DISubroutineType(types: !51)
 !51 = !{!9, !19}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/unspecified-var-size.ll

-; RUN: opt -S %s -passes=sroa -o - -experimental-assignment-tracking | FileCheck %s
+; RUN: opt -S %s -passes=sroa -o - | FileCheck %s
 
 ;; $ cat test.cpp
 ;; #include <cstddef>
 ;; void fun(std::nullptr_t) {}
 ;;
 ;; Check that migrateDebugInfo doesn't crash when encountering an alloca for a
 ;; variable with a type of unspecified size (e.g. DW_TAG_unspecified_type).
 
 ; CHECK: @llvm.dbg.assign(metadata ptr %0,{{.+}}, metadata !DIExpression(),{{.+}}, metadata ptr undef, {{.+}})
 ;; There should be no new fragment and the value component should remain as %0.
 
 define dso_local void @_Z3funDn(ptr %0) #0 !dbg !14 {
 entry:
   %.addr = alloca i8*, align 8, !DIAssignID !22
   call void @llvm.dbg.assign(metadata i1 undef, metadata !21, metadata !DIExpression(), metadata !22, metadata ptr %.addr, metadata !DIExpression()), !dbg !23
   store ptr %0, ptr %.addr, align 8, !DIAssignID !28
   call void @llvm.dbg.assign(metadata ptr %0, metadata !21, metadata !DIExpression(), metadata !28, metadata ptr %.addr, metadata !DIExpression()), !dbg !23
   ret void, !dbg !29
 }
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #1
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!10, !11, !12}
+!llvm.module.flags = !{!10, !11, !12, !1000}
 !llvm.ident = !{!13}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, imports: !3, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{}
 !3 = !{!4}
 !4 = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: !5, entity: !6, file: !9, line: 56)
 !5 = !DINamespace(name: "std", scope: null)

 !18 = !DIFile(filename: "include/x86_64-linux-gnu/c++/7.5.0/bits/c++config.h", directory: "")
 !19 = !DIBasicType(tag: DW_TAG_unspecified_type, name: "decltype(nullptr)")
 !20 = !{!21}
 !21 = !DILocalVariable(arg: 1, scope: !14, file: !1, line: 20, type: !17)
 !22 = distinct !DIAssignID()
 !23 = !DILocation(line: 0, scope: !14)
 !28 = distinct !DIAssignID()
 !29 = !DILocation(line: 20, column: 27, scope: !14)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/user-memcpy.ll

-; RUN: opt -passes=sroa -S %s -o - -experimental-assignment-tracking \
+; RUN: opt -passes=sroa -S %s -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ;; Check that the fragments generated in SROA for a split alloca that has a
 ;; dbg.assign with non-zero-offset fragment already are correct.  Ensure that
 ;; only the value-expression gets fragment info; that the address-expression
 ;; remains untouched.
 
 ;; $ cat test.cpp

 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.memset.p0i8.i64(ptr nocapture writeonly, i8, i64, i1 immarg)
 declare void @llvm.memcpy.p0i8.p0i8.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg)
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!96, !97, !98}
+!llvm.module.flags = !{!96, !97, !98, !1000}
 !llvm.ident = !{!99}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, imports: !3, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{}
 !3 = !{!4, !18, !22, !28, !32, !36, !46, !50, !52, !54, !58, !62, !66, !70, !74, !76, !78, !80, !84, !88, !92, !94}
 !4 = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: !5, entity: !6, file: !17, line: 75)
 !5 = !DINamespace(name: "std", scope: null)

 !126 = !DILocation(line: 7, column: 3, scope: !100)
 !127 = !DILocation(line: 7, column: 7, scope: !100)
 !128 = distinct !DIAssignID()
 !129 = !DILocation(line: 8, column: 22, scope: !100)
 !130 = !DILocation(line: 8, column: 3, scope: !100)
 !131 = !DILocation(line: 8, column: 32, scope: !100)
 !132 = distinct !DIAssignID()
 !133 = !DILocation(line: 9, column: 1, scope: !100)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/vec-1.ll

-; RUN: opt %s -S -passes=sroa -o - -experimental-assignment-tracking | FileCheck %s
+; RUN: opt %s -S -passes=sroa -o - | FileCheck %s
 
 ;; Ensure that only the value-expression gets fragment info; that the
 ;; address-expression remains untouched.
 
 ;; $ cat test.cpp
 ;; class a {
 ;;   float b[4];
 ;; };

 declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture) #2
 declare dso_local { <2 x float>, <2 x float> } @_ZNK1c5m_fn1Ev(ptr) #3
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #2
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #1
 
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !30 = !DILocation(line: 0, scope: !7)
 !31 = distinct !DIAssignID()
 !36 = distinct !DIAssignID()
 !37 = !DILocation(line: 8, column: 21, scope: !7)
 !38 = !DILocation(line: 8, column: 27, scope: !7)
 !39 = distinct !DIAssignID()
 !40 = distinct !DIAssignID()
 !41 = !DILocation(line: 8, column: 36, scope: !7)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/sroa/vec-2.ll

-; RUN: opt %s -S -passes=sroa -o - -experimental-assignment-tracking | FileCheck %s
+; RUN: opt %s -S -passes=sroa -o - | FileCheck %s
 
 ;; $ cat test.cpp
 ;; class a {
 ;; protected:
 ;;   float b[4];
 ;; };
 ;; float c;
 ;; class d : a {
entry:
   store float %0, ptr %arrayidx, align 4, !dbg !87
   ret void, !dbg !88
 }
 
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #4
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!7, !8, !9}
+!llvm.module.flags = !{!7, !8, !9, !1000}
 !llvm.ident = !{!10}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "c", scope: !2, file: !3, line: 5, type: !6, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{}
 !5 = !{!0}

 !82 = distinct !DIAssignID()
 !83 = !DILocation(line: 0, scope: !57)
 !84 = distinct !DIAssignID()
 !85 = !DILocation(line: 8, column: 16, scope: !64)
 !86 = !DILocation(line: 8, column: 9, scope: !64)
 !87 = !DILocation(line: 8, column: 14, scope: !64)
 !88 = !DILocation(line: 8, column: 19, scope: !57)
 
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/Generic/assignment-tracking/track-assignments.ll

-; RUN: opt -passes='declare-to-assign,verify' %s -S -o - -experimental-assignment-tracking \
+; RUN: opt -passes='declare-to-assign,verify' %s -S -o - \
 ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 ;; This test checks that `trackAssignments` is working correctly by using the
 ;; pass-wrapper `declare-to-assign`. Each function checks some specific
 ;; functionality and has its checks inline.
 
 ;; $ cat test.cpp
 ;; struct Inner { int A, B; };

 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture) #1
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #2
 declare void @llvm.memset.p0i8.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #3
 declare void @llvm.memcpy.p0i8.p0i8.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #4
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 declare dso_local void @_ZN9LCopyCtorC1Ev(ptr noundef nonnull align 4 dereferenceable(16)) unnamed_addr
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!26, !27, !28, !29}
+!llvm.module.flags = !{!26, !27, !28, !29, !1000}
 !llvm.ident = !{!30}
 
 ; CHECK-DAG: ![[VAR_0]] = !DILocalVariable(name: "Z",
 ; CHECK-DAG: ![[VAR_1]] = !DILocalVariable(name: "A",
 ; CHECK-DAG: ![[VAR_2]] = !DILocalVariable(name: "O",
 ; CHECK-DAG: ![[VAR_3]] = !DILocalVariable(name: "A",
 ; CHECK-DAG: ![[VAR_4]] = !DILocalVariable(name: "B",
 ; CHECK-DAG: ![[VAR_5]] = !DILocalVariable(name: "A",

 !141 = !DILocation(line: 3, column: 13, scope: !139)
 !142 = !DILocation(line: 3, column: 29, scope: !139)
 !143 = !DILocation(line: 2, column: 13, scope: !129, inlinedAt: !144)
 !144 = distinct !DILocation(line: 3, column: 25, scope: !139)
 !145 = !DILocation(line: 2, column: 25, scope: !129, inlinedAt: !144)
 !146 = !DILocation(line: 2, column: 29, scope: !129, inlinedAt: !144)
 !147 = !DILocation(line: 2, column: 27, scope: !129, inlinedAt: !144)
 !148 = !DILocation(line: 3, column: 18, scope: !139)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/DSE.ll

 ; RUN: llc %s -stop-before=finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking  \
 ; RUN: | FileCheck %s
 
 ; Check basic lowering behaviour of dbg.assign intrinsics. The first
 ; assignment to `local`, which has been DSE'd, should be represented with a
 ; constant value DBG_VALUE. The second assignment should have a DBG_VALUE
 ; describing the stack home of the variable.
 
 ; $ cat test.c
entry:
   ret void, !dbg !25
 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 declare !dbg !26 dso_local void @esc(ptr) local_unnamed_addr
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: true, 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}

 !25 = !DILocation(line: 7, column: 1, scope: !7)
 !26 = !DISubprogram(name: "esc", scope: !1, file: !1, line: 1, type: !27, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !27 = !DISubroutineType(types: !28)
 !28 = !{null, !29}
 !29 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
 !30 = distinct !DIAssignID()
 !31 = distinct !DIAssignID()
 
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/dbg-phi-produces-undef.ll

-; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: llc %s -stop-after=finalize-isel -o - \
 ; RUN: | FileCheck %s
 
 ;; Hand written test because the scenario is unlikely. Check that the "value"
 ;; of a debug def PHIs is "undef" (because we don't actually track PHIs).
 ;;
 ;; entry:
 ;;   memdef 5, !1
 ;;   dbgdef !1

 }
 
 
 declare !dbg !24 dso_local void @d(...) local_unnamed_addr #2
 declare !dbg !27 dso_local void @a(ptr) local_unnamed_addr #2
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "reduce.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}

 !24 = !DISubprogram(name: "d", scope: !1, file: !1, line: 2, type: !25, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !25 = !DISubroutineType(types: !26)
 !26 = !{null, null}
 !27 = !DISubprogram(name: "a", scope: !1, file: !1, line: 1, type: !28, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !28 = !DISubroutineType(types: !29)
 !29 = !{null, !30}
 !30 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
 !31 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/diamond-1.ll

-; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: llc %s -stop-after=finalize-isel -o - \
 ; RUN: | FileCheck %s
 
 ;; cat test.cpp
 ;; void d();
 ;; void e();
 ;; void es(int*);
 ;; int  f(int a) {
 ;;   if (a) {

 }
 
 declare !dbg !33 dso_local void @_Z1ev() local_unnamed_addr #1
 declare !dbg !37 dso_local void @_Z1dv() local_unnamed_addr #1
 declare !dbg !38 dso_local void @_Z2esPi(ptr noundef) local_unnamed_addr #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}

 !34 = !DISubroutineType(types: !35)
 !35 = !{null}
 !36 = !{}
 !37 = !DISubprogram(name: "d", linkageName: "_Z1dv", scope: !1, file: !1, line: 1, type: !34, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !36)
 !38 = !DISubprogram(name: "es", linkageName: "_Z2esPi", scope: !1, file: !1, line: 3, type: !39, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !36)
 !39 = !DISubroutineType(types: !40)
 !40 = !{null, !41}
 !41 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/diamond-2.ll

-; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: llc %s -stop-after=finalize-isel -o - \
 ; RUN: | FileCheck %s
 
 ;; Same as diamond-1.ll except that the DIAssignID attached to the store has
 ;; been deleted. In this case, we expect the same output as for diamond-1.ll
 ;; because we choose to interpret stores to stack slots that don't link to
 ;; debug intrinsics for a variable in the stack slot as a though they're linked
 ;; to one placed immediately after.
 ;;

 }
 
 declare !dbg !33 dso_local void @_Z1ev() local_unnamed_addr #1
 declare !dbg !37 dso_local void @_Z1dv() local_unnamed_addr #1
 declare !dbg !38 dso_local void @_Z2esPi(ptr noundef) local_unnamed_addr #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}

 !34 = !DISubroutineType(types: !35)
 !35 = !{null}
 !36 = !{}
 !37 = !DISubprogram(name: "d", linkageName: "_Z1dv", scope: !1, file: !1, line: 1, type: !34, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !36)
 !38 = !DISubprogram(name: "es", linkageName: "_Z2esPi", scope: !1, file: !1, line: 3, type: !39, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !36)
 !39 = !DISubroutineType(types: !40)
 !40 = !{null, !41}
 !41 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/diamond-3.ll

-; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: llc %s -stop-after=finalize-isel -o - \
 ; RUN: | FileCheck %s --implicit-check-not=DBG_
 
 ;; Hand written to test scenario we can definitely run into in the wild. This
 ;; file name includes "diamond" because the idea is that we lose (while
 ;; optimizing) one of the diamond branches which was empty except for a debug
 ;; intrinsic. In this case, the debug intrinsic linked to the common-and-sunk
 ;; store now in if.end. So we've got this:
 ;;
if.end:                                           ; preds = %do.body
   ret i32 0
 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
 declare void @e()
 declare void @es(ptr)
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!7, !8, !9, !10}
+!llvm.module.flags = !{!7, !8, !9, !10, !1000}
 !llvm.ident = !{!11}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 4, type: !5, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{!0}
 !5 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !6, size: 64)

 !45 = !{null}
 !46 = !{}
 !47 = !DISubprogram(name: "d", linkageName: "_Z1dv", scope: !3, file: !3, line: 1, type: !48, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !46)
 !48 = !DISubroutineType(types: !49)
 !49 = !{!6}
 !50 = !DISubprogram(name: "es", linkageName: "_Z2esPi", scope: !3, file: !3, line: 3, type: !51, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !46)
 !51 = !DISubroutineType(types: !52)
 !52 = !{null, !5}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/loop-hoist.ll

-; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: llc %s -stop-after=finalize-isel -o - \
 ; RUN: | FileCheck %s --implicit-check-not=DBG_
 
 ;; $ cat test.cpp
 ;; int d();
 ;; void e();
 ;; void es(int*);
 ;; int *g;
 ;; int f(int a, int b, int c) {

 
 declare !dbg !43 dso_local void @_Z1ev() local_unnamed_addr #1
 declare !dbg !47 dso_local noundef i32 @_Z1dv() local_unnamed_addr #1
 declare !dbg !50 dso_local void @_Z2esPi(ptr noundef) local_unnamed_addr #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
 declare void @llvm.dbg.value(metadata, metadata, metadata) #3
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!7, !8, !9, !10}
+!llvm.module.flags = !{!7, !8, !9, !10, !1000}
 !llvm.ident = !{!11}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 4, type: !5, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{!0}
 !5 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !6, size: 64)

 !45 = !{null}
 !46 = !{}
 !47 = !DISubprogram(name: "d", linkageName: "_Z1dv", scope: !3, file: !3, line: 1, type: !48, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !46)
 !48 = !DISubroutineType(types: !49)
 !49 = !{!6}
 !50 = !DISubprogram(name: "es", linkageName: "_Z2esPi", scope: !3, file: !3, line: 3, type: !51, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !46)
 !51 = !DISubroutineType(types: !52)
 !52 = !{null, !5}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/loop-sink.ll

-; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: llc %s -stop-after=finalize-isel -o - \
 ; RUN: | FileCheck %s --implicit-check-not=DBG
 
 ;; Tiny loop with a store sunk out of it:
 ;; void e();
 ;; void es(int*);
 ;; int *g;
 ;; int getInt();
 ;; int f(int a, int b) {

 }
 
 declare !dbg !38 dso_local void @_Z1ev() local_unnamed_addr #1
 declare !dbg !42 dso_local void @_Z2esPi(ptr noundef) local_unnamed_addr #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
 declare dso_local i32 @getInt()
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!7, !8, !9, !10}
+!llvm.module.flags = !{!7, !8, !9, !10, !1000}
 !llvm.ident = !{!11}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 4, type: !5, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{!0}
 !5 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !6, size: 64)

 !37 = !DILocation(line: 11, column: 3, scope: !12)
 !38 = !DISubprogram(name: "e", linkageName: "_Z1ev", scope: !3, file: !3, line: 2, type: !39, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !41)
 !39 = !DISubroutineType(types: !40)
 !40 = !{null}
 !41 = !{}
 !42 = !DISubprogram(name: "es", linkageName: "_Z2esPi", scope: !3, file: !3, line: 3, type: !43, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !41)
 !43 = !DISubroutineType(types: !44)
 !44 = !{null, !5}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/loop-unroll.ll

 ; RUN: llc %s -stop-after=finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking \
 ; RUN: | FileCheck %s
 ;;
 ;; Backend counterpart to ../Generic/dbg-assign-loop-unroll.  This IR was
 ;; generated by running `opt -loop-unroll -S` on the IR in that test.
 ;;
 ;; Check that the backend can handle a mesh of dbg.assign and linked
 ;; instructions.
 ;;
for.body:                                         ; preds = %entry
   call void @llvm.dbg.assign(metadata i32 2, metadata !13, metadata !DIExpression(), metadata !29, metadata ptr undef, metadata !DIExpression()), !dbg !30
   ret void, !dbg !31
 }
 
 declare !dbg !32 dso_local void @_Z3escPi(ptr) local_unnamed_addr
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !28 = !DILocation(line: 5, column: 5, scope: !25)
 !29 = distinct !DIAssignID()
 !30 = !DILocation(line: 3, column: 26, scope: !26)
 !31 = !DILocation(line: 7, column: 1, scope: !7)
 !32 = !DISubprogram(name: "esc", linkageName: "_Z3escPi", scope: !1, file: !1, line: 1, type: !33, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !33 = !DISubroutineType(types: !34)
 !34 = !{null, !35}
 !35 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/lower-offset-expression.ll

 ; RUN: llc %s -stop-after=finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking  \
 ; RUN: | FileCheck %s
 
 ;; Handwritten test.
 
 ;; Here we have dbg.assign intrinsics with fragments (in the value-expression)
 ;; and address-expressions that involve arithmetic. The generated DBG_VALUE
 ;; intructions needs a DIExpression that:
 ;;     a) Uses the fragment from the value-expression,
entry:
   store i32 100, i32* %idx2, !DIAssignID !25
   call void @llvm.dbg.assign(metadata i32 100, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32), metadata !25, metadata i32* %a, metadata !DIExpression(DW_OP_plus_uconst, 8)), !dbg !34
   ret void
 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !50 = !DISubprogram(name: "get", linkageName: "_Z3getv", scope: !1, file: !1, line: 1, type: !51, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !51 = !DISubroutineType(types: !52)
 !52 = !{!10}
 !53 = !DISubprogram(name: "ext", linkageName: "_Z3extPf", scope: !1, file: !1, line: 2, type: !54, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !54 = !DISubroutineType(types: !55)
 !55 = !{!10, !56}
 !56 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
 
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/lower-to-value.ll

 ; RUN: llc %s -stop-before finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking   \
 ; RUN:    -experimental-debug-variable-locations=false \
 ; RUN: | FileCheck %s --check-prefixes=CHECK,DBGVALUE --implicit-check-not=DBG_VALUE
 ; RUN: llc %s -stop-before finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking   \
 ; RUN:    -experimental-debug-variable-locations=true \
 ; RUN: | FileCheck %s --check-prefixes=CHECK,INSTRREF --implicit-check-not=DBG_VALUE \
 ; RUN:    --implicit-check-not=DBG_INSTR_REF
 
 ;; Check that dbg.assigns for an aggregate variable which lives on the stack
 ;; for some of its lifetime are lowered into an appropriate set of DBG_VALUEs.
 ;;
 ;; $ cat test.cpp

 }
 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture)
 declare !dbg !33 dso_local void @_Z3escPl(ptr) local_unnamed_addr
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !29 = !DILocation(line: 10, column: 7, scope: !7)
 !30 = distinct !DIAssignID()
 !31 = !DILocation(line: 12, column: 1, scope: !7)
 !32 = !DILocation(line: 11, column: 3, scope: !7)
 !33 = !DISubprogram(name: "esc", linkageName: "_Z3escPl", scope: !1, file: !1, line: 1, type: !34, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !34 = !DISubroutineType(types: !35)
 !35 = !{null, !36}
 !36 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/mem-loc-frag-fill-cfg.ll

 ; RUN: llc %s -stop-before finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking \
 ; RUN:    -experimental-debug-variable-locations=false \
 ; RUN: | FileCheck %s --implicit-check-not=DBG_
 ; RUN: llc %s -stop-before finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking \
 ; RUN:    -experimental-debug-variable-locations=true \
 ; RUN: | FileCheck %s --implicit-check-not=DBG_
 
 ;; Check that the mem-loc-frag-fill pseudo-pass works on a simple CFG. When
 ;; LLVM sees a dbg.value with an overlapping fragment it essentially considers
 ;; the previous location as valid for all bits in that fragment. The pass
 ;; inserts dbg.value fragments to preserve memory locations for bits in memory
 ;; when overlapping fragments are encountered.

 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture) #4
 declare !dbg !65 dso_local noundef zeroext i1 @_Z4stepv() local_unnamed_addr #5
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #4
 declare void @llvm.memcpy.p0i8.p0i8.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!11, !12, !13, !14}
+!llvm.module.flags = !{!11, !12, !13, !14, !1000}
 !llvm.ident = !{!15}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "glob", scope: !2, file: !3, line: 2, type: !5, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{!0}
 !5 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Nums", file: !3, line: 1, size: 96, flags: DIFlagTypePassByValue, elements: !6, identifier: "_ZTS4Nums")

 !62 = !DILocation(line: 19, column: 3, scope: !40)
 !63 = !DILocation(line: 21, column: 1, scope: !40)
 !64 = !DILocation(line: 20, column: 3, scope: !40)
 !65 = !DISubprogram(name: "step", linkageName: "_Z4stepv", scope: !3, file: !3, line: 5, type: !66, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !69)
 !66 = !DISubroutineType(types: !67)
 !67 = !{!68}
 !68 = !DIBasicType(name: "bool", size: 8, encoding: DW_ATE_boolean)
 !69 = !{}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/mem-loc-frag-fill.ll

 ; RUN: llc %s -stop-before finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking \
 ; RUN:    -experimental-debug-variable-locations=false \
 ; RUN: | FileCheck %s --implicit-check-not=DBG_
 ; RUN: llc %s -stop-before finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking \
 ; RUN:    -experimental-debug-variable-locations=true \
 ; RUN: | FileCheck %s  --implicit-check-not=DBG_
 
 ;; Check that the mem-loc-frag-fill analysis works on a simple case; ensure
 ;; that location definitions are added to preserve memory locations of
 ;; fragments of variables at subsequent location definitions for other
 ;; fragments of the variable are not currently in memory.
 

 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture) #1
 declare !dbg !36 dso_local void @_Z4stepv() local_unnamed_addr #2
 declare !dbg !40 dso_local void @_Z3escP4Nums(ptr noundef) local_unnamed_addr #2
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}

 !36 = !DISubprogram(name: "step", linkageName: "_Z4stepv", scope: !1, file: !1, line: 3, type: !37, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !39)
 !37 = !DISubroutineType(types: !38)
 !38 = !{null}
 !39 = !{}
 !40 = !DISubprogram(name: "esc", linkageName: "_Z3escP4Nums", scope: !1, file: !1, line: 2, type: !41, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !39)
 !41 = !DISubroutineType(types: !42)
 !42 = !{null, !43}
 !43 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !13, size: 64)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/nested-loop-frags.ll

-; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: llc %s -stop-after=finalize-isel -o - \
 ; RUN: | FileCheck %s --implicit-check-not=DBG
 
 ;; Test a variety of block inputs and lattice configurations for the assignment
 ;; tracking analysis (debug-ata). This is similar to nested-loop.ll and
 ;; nested-loop-sroa.ll except that the allocas are 64 bits and the stores are a
 ;; mix of 32 and 64 bits. Unlike nested-loop-sroa.ll this one is not a clone
 ;; of nested-loop.ll.
 

 }
 
 declare !dbg !54 void @_Z4calli(i32 noundef) local_unnamed_addr #1
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!10, !11, !12, !13, !14, !15}
+!llvm.module.flags = !{!10, !11, !12, !13, !14, !15, !1000}
 !llvm.ident = !{!16}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "g_a", scope: !2, file: !3, line: 1, type: !7, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 16.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{!0, !5, !8}
 !5 = !DIGlobalVariableExpression(var: !6, expr: !DIExpression())

 !72 = !DILocalVariable(name: "d", scope: !17, file: !3, line: 3, type: !7)
 !73 = distinct !DIAssignID()
 !74 = distinct !DIAssignID()
 !75 = !DILocalVariable(name: "e", scope: !17, file: !3, line: 3, type: !7)
 !76 = distinct !DIAssignID()
 !77 = distinct !DIAssignID()
 !78 = distinct !DIAssignID()
 !82 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/nested-loop-sroa.ll

-; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: llc %s -stop-after=finalize-isel -o - \
 ; RUN: | FileCheck %s --implicit-check-not=DBG
 
 ;; Test a variety of block inputs and lattice configurations for the assignment
 ;; tracking analysis (debug-ata). This is the same as nested-loop.ll except each
 ;; alloca holds a fragment of a variable instead of a whole variable.
 ;; The CFG looks like this:
 ;;     entry
 ;;     |

 }
 
 declare !dbg !54 void @_Z4calli(i32 noundef) local_unnamed_addr #1
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!10, !11, !12, !13, !14, !15}
+!llvm.module.flags = !{!10, !11, !12, !13, !14, !15, !1000}
 !llvm.ident = !{!16}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "g_a", scope: !2, file: !3, line: 1, type: !7, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 16.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{!0, !5, !8}
 !5 = !DIGlobalVariableExpression(var: !6, expr: !DIExpression())

 !77 = distinct !DIAssignID()
 !78 = distinct !DIAssignID()
 !79 = !DILocalVariable(name: "f", scope: !17, file: !3, line: 3, type: !7)
 !80 = distinct !DIAssignID()
 !81 = distinct !DIAssignID()
 !82 = !DILocalVariable(name: "g", scope: !17, file: !3, line: 3, type: !7)
 !83 = distinct !DIAssignID()
 !84 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/nested-loop.ll

-; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: llc %s -stop-after=finalize-isel -o - \
 ; RUN: | FileCheck %s --implicit-check-not=DBG
 
 ;; Test a variety of block inputs and lattice configurations for the assignment
 ;; tracking analysis (debug-ata).
 
 ;; The CFG looks like this:
 ;;     entry
 ;;     |

 }
 
 declare !dbg !54 void @_Z4calli(i32 noundef) local_unnamed_addr #1
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!10, !11, !12, !13, !14, !15}
+!llvm.module.flags = !{!10, !11, !12, !13, !14, !15, !1000}
 !llvm.ident = !{!16}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "g_a", scope: !2, file: !3, line: 1, type: !7, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 16.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{!0, !5, !8}
 !5 = !DIGlobalVariableExpression(var: !6, expr: !DIExpression())

 !77 = distinct !DIAssignID()
 !78 = distinct !DIAssignID()
 !79 = !DILocalVariable(name: "f", scope: !17, file: !3, line: 3, type: !7)
 !80 = distinct !DIAssignID()
 !81 = distinct !DIAssignID()
 !82 = !DILocalVariable(name: "g", scope: !17, file: !3, line: 3, type: !7)
 !83 = distinct !DIAssignID()
 !84 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/no-redundant-def-after-alloca.ll

 ; RUN: llc %s -o - -stop-after=finalize-isel \
-; RUN:    -experimental-assignment-tracking  \
 ; RUN: | FileCheck %s --implicit-check-not=DBG_
 
 ;; Hand written. Check that no unnecessary undef is inserted after an alloca
 ;; that has a linked dbg.assign that doesn't immediately follow it.
 
 ; CHECK: CALL64pcrel32 @a
 ; CHECK-NEXT: ADJCALLSTACKUP64
 ; CHECK-NEXT: DBG_VALUE %stack.0.c, $noreg, !{{.+}}, !DIExpression(DW_OP_deref), debug-location
entry:
   ret void, !dbg !17
 }
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
 declare dso_local void @a(...)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.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 12.0.0)"}
 !7 = distinct !DISubprogram(name: "b", scope: !1, file: !1, line: 2, type: !8, scopeLine: 2, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
 !8 = !DISubroutineType(types: !9)
 !9 = !{null}
 !10 = distinct !DIAssignID()
 !11 = !DILocalVariable(name: "c", scope: !7, file: !1, line: 3, type: !12)
 !12 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
 !13 = !DILocation(line: 0, scope: !7)
 !14 = !DILocation(line: 3, column: 8, scope: !7)
 !15 = distinct !DIAssignID()
 !16 = !DILocation(line: 4, column: 3, scope: !7)
 !17 = !DILocation(line: 5, column: 1, scope: !7)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/order-of-defs.ll

-; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: llc %s -stop-after=finalize-isel -o - \
 ; RUN: | FileCheck %s --implicit-check-not=DBG_
 
 ;; Ensure that the order of several debug intrinsics between non-debug
 ;; instructions is maintained.
 
 ; CHECK-DAG: ![[A:[0-9]+]] = !DILocalVariable(name: "a",
 ; CHECK-DAG: ![[B:[0-9]+]] = !DILocalVariable(name: "b",
 ; CHECK-DAG: ![[C:[0-9]+]] = !DILocalVariable(name: "c",
entry:
   call void @llvm.dbg.assign(metadata i32 %c, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 32, 32), metadata !23, metadata ptr undef, metadata !DIExpression()), !dbg !20
   %mul = mul nsw i32 %c, %b, !dbg !24
   ret i32 %mul, !dbg !25
 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.c", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}

 !18 = !DILocalVariable(name: "c", arg: 3, scope: !7, file: !1, line: 3, type: !10)
 !19 = distinct !DIAssignID()
 !20 = !DILocation(line: 0, scope: !7)
 !21 = distinct !DIAssignID()
 !22 = distinct !DIAssignID()
 !23 = distinct !DIAssignID()
 !24 = !DILocation(line: 6, column: 14, scope: !7)
 !25 = !DILocation(line: 6, column: 3, scope: !7)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/remove-redundant-defs-to-prevent-reordering.ll

 ; RUN: llc %s -stop-before finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking \
 ; RUN:    -experimental-debug-variable-locations=false \
 ; RUN: | FileCheck %s --check-prefixes=CHECK,DBGVALUE --implicit-check-not="DBG_VALUE \$noreg"
 ; RUN: llc %s -stop-before finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking \
 ; RUN:    -experimental-debug-variable-locations=true \
 ; RUN: | FileCheck %s --check-prefixes=CHECK,INSTRREF --implicit-check-not="DBG_VALUE \$noreg"
 
 ;; Found in the wild, but this test involves modifications from:
 ;; int b;
 ;; void ext();
 ;; int fun(int a) {
 ;;   if (b == 0)

 }
 
 declare !dbg !32 dso_local void @_Z3extv() local_unnamed_addr #1
 
 ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!7, !8, !9}
+!llvm.module.flags = !{!7, !8, !9, !1000}
 !llvm.ident = !{!10}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "test.cpp", directory: "/")
 !4 = !{}
 !5 = !{!0}

 !27 = !DILocation(line: 5, column: 5, scope: !20)
 !28 = !DILocation(line: 7, column: 8, scope: !11)
 !29 = !DILocation(line: 7, column: 5, scope: !11)
 !30 = distinct !DIAssignID()
 !31 = !DILocation(line: 8, column: 3, scope: !11)
 !32 = !DISubprogram(name: "ext", linkageName: "_Z3extv", scope: !3, file: !3, line: 2, type: !33, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !4)
 !33 = !DISubroutineType(types: !34)
 !34 = !{null}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll

 ; RUN: llc %s -o - -stop-after=finalize-isel \
-; RUN:    -experimental-assignment-tracking  \
 ; RUN: | FileCheck %s --implicit-check-not=DBG
 
 ;; In the IR below, for variable n, we get dbg intrinsics that describe this:
 ;;
 ;; entry-block:
 ;;     Frag (off=0,  sz=32): non-undef
 ;;     Frag (off=64, sz=64): undef
 ;;     Frag (off=64, sz=32): non-undef
entry:
   tail call void poison(<2 x float> zeroinitializer, <2 x float> zeroinitializer, <2 x float> %ah.sroa.0.0.vec.insert, <2 x float> zeroinitializer)
   ret void
 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5, !6}
+!llvm.module.flags = !{!2, !3, !4, !5, !6, !1000}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "reduce.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}
 !6 = !{i32 7, !"frame-pointer", i32 2}
 !7 = distinct !DISubprogram(name: "k", linkageName: "_Z1kv", scope: !1, file: !1, line: 25, type: !8, scopeLine: 25, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
 !8 = !DISubroutineType(types: !9)
 !9 = !{null}
 !10 = !{!11}
 !11 = !DILocalVariable(name: "n", scope: !7, file: !1, line: 29, type: !12)
 !12 = !DICompositeType(tag: DW_TAG_class_type, name: "a", file: !1, line: 1, size: 128, flags: DIFlagFwdDecl | DIFlagNonTrivial, identifier: "_ZTS1a")
 !13 = !DILocation(line: 26, scope: !7)
 !14 = distinct !DIAssignID()
 !15 = !DILocation(line: 0, scope: !7)
 !16 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/sdag-dangling-dbgassign.ll

 ; RUN: llc %s -stop-before finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking   \
 ; RUN:    -experimental-debug-variable-locations=false \
 ; RUN: | FileCheck %s --check-prefixes=CHECK,DBGVALUE
 ; RUN: llc %s -stop-before finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking   \
 ; RUN:    -experimental-debug-variable-locations=true \
 ; RUN: | FileCheck %s --check-prefixes=CHECK,INSTRREF
 
 ;--------------------------------------------------------------------
 ; Adapted from sdag-dangling-dbgvalue.ll to test dbg.assign intrinsics. This
 ; ensures that dbg.assigns with no linked store are treated as dbg.values.  For
 ; ease of writing, all the dbg.assign intrinsics refer to the same DIAssignID
 ; !54. There is no linked store in any case.

 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #1
 
 attributes #0 = { nounwind readnone uwtable }
 attributes #1 = { nounwind readnone speculatable }
 
 !llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!12, !13, !14, !15}
+!llvm.module.flags = !{!12, !13, !14, !15, !1000}
 !llvm.ident = !{!16}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "S", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 7.0.0 (trunk 327229) (llvm/trunk 327239)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !5, globals: !7)
 !3 = !DIFile(filename: "sdag-dangling-dbgvalue.c", directory: "/repo/uabbpet/llvm-master")
 !4 = !{}
 !5 = !{!6}

 !47 = distinct !DISubprogram(name: "test5", scope: !3, file: !3, line: 31, type: !18, isLocal: false, isDefinition: true, scopeLine: 31, isOptimized: true, unit: !2, retainedNodes: !48)
 !48 = !{!49, !50}
 !49 = !DILocalVariable(name: "bar5", scope: !47, file: !3, line: 32, type: !21)
 !50 = !DILocalVariable(name: "foo5", scope: !47, file: !3, line: 33, type: !21)
 !51 = !DILocation(line: 32, column: 14, scope: !47)
 !52 = !DILocation(line: 33, column: 14, scope: !47)
 !53 = !DILocation(line: 35, column: 3, scope: !47)
 !54 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/sdag-ir-salvage-assign.ll

 ; RUN: llc -mtriple=x86_64-unknown-unknown -start-after=codegenprepare \
-; RUN:    -experimental-assignment-tracking   \
 ; RUN:    -stop-before finalize-isel %s -o -  \
 ; RUN:    -experimental-debug-variable-locations=false \
 ; RUN: | FileCheck %s --check-prefixes=CHECK,DBGVALUE
 ; RUN: llc -mtriple=x86_64-unknown-unknown -start-after=codegenprepare \
-; RUN:    -experimental-assignment-tracking   \
 ; RUN:    -stop-before finalize-isel %s -o -  \
 ; RUN:    -experimental-debug-variable-locations=true \
 ; RUN: | FileCheck %s --check-prefixes=CHECK,INSTRREF
 
 ; Adapted from sdag-ir-salvage.ll to test dbg.assign intrinsics. This ensures
 ; that dbg.assigns with no linked store are treated as dbg.values.
 
 ; Test that the dbg.value for %baz, which doesn't exist in the 'next' bb,

 }
 
 ; Function Attrs: nounwind readnone speculatable
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #0
 
 attributes #0 = { nounwind readnone speculatable }
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!25, !26, !27, !28}
+!llvm.module.flags = !{!25, !26, !27, !28, !1000}
 !llvm.ident = !{!29}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
 !1 = !DIFile(filename: "test.c", directory: ".")
 !2 = !{}
 !6 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 18, type: !7, scopeLine: 19, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !14)
 !7 = !DISubroutineType(types: !8)
 !8 = !{!13}
 !13 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_unsigned)
 !14 = !{!15}
 !15 = !DILocalVariable(name: "aaa", scope: !6, file: !1, line: 18, type: !13)
 !25 = !{i32 2, !"Dwarf Version", i32 4}
 !26 = !{i32 2, !"Debug Info Version", i32 3}
 !27 = !{i32 1, !"wchar_size", i32 4}
 !28 = !{i32 7, !"PIC Level", i32 2}
 !29 = !{!"clang"}
 !30 = !DILocation(line: 18, column: 14, scope: !6)
 !31 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/sdag-transfer-dbgassign.ll

 ; RUN: llc %s -start-after=codegenprepare -stop-before finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking   \
 ; RUN:    -experimental-debug-variable-locations=false \
 ; RUN: | FileCheck %s --check-prefixes=CHECK,DBGVALUE
 ; RUN: llc %s -start-after=codegenprepare -stop-before finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking   \
 ; RUN:    -experimental-debug-variable-locations=true \
 ; RUN: | FileCheck %s --check-prefixes=CHECK,INSTRREF
 
 ; Adapted from sdag-transfer-dbgvalue.ll to test dbg.assign intrinsics. This
 ; ensures that dbg.assigns with no linked store are treated as dbg.values.
 
 ; This tests that transferDbgValues() changes order of SDDbgValue transferred
 ; to another node and debug info for 'ADD32ri' appears *after* the instruction.

 if.end:                                           ; preds = %entry, %if.then
   ret i32 %add, !dbg !18
 }
 
 ; Function Attrs: nounwind readnone speculatable willreturn
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
 !1 = !DIFile(filename: "test.c", directory: "/")
 !2 = !{}
 !3 = !{i32 2, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}
 !6 = !{!"clang version 10.0.0"}
 !7 = distinct !DISubprogram(name: "foo", scope: !8, file: !8, line: 1, type: !9, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !13)
 !8 = !DIFile(filename: "test.c", directory: "/")
 !9 = !DISubroutineType(types: !10)
 !10 = !{!11, !11, !12}
 !11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !12 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64)
 !13 = !{!14, !15, !16}
 !14 = !DILocalVariable(name: "a", arg: 1, scope: !7, file: !8, line: 1, type: !11)
 !15 = !DILocalVariable(name: "b", arg: 2, scope: !7, file: !8, line: 1, type: !12)
 !16 = !DILocalVariable(name: "c", scope: !7, file: !8, line: 2, type: !11)
 !17 = !DILocation(line: 0, scope: !7)
 !18 = !DILocation(line: 2, column: 13, scope: !7)
 !19 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/single-memory-location-2.ll

 ; RUN: llc -stop-after=finalize-isel %s -o - \
-; RUN:    -experimental-assignment-tracking \
 ; RUN: | FileCheck %s
 
 ;; Check that a dbg.assign for a fully stack-homed variable causes the variable
 ;; location to appear in the Machine Function side table. Similar to
 ;; single-memory-location.ll except this has slightly more complicated input
 ;; (there's a loop and an assignment).
 ;;
 ;; $ cat test.cpp

 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture)
 declare !dbg !33 dso_local void @_Z3escPi(ptr) local_unnamed_addr
 declare !dbg !37 dso_local i32 @_Z3getv() local_unnamed_addr
 declare !dbg !40 dso_local void @_Z11doSomethingi(i32) local_unnamed_addr
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !35 = !{null, !36}
 !36 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
 !37 = !DISubprogram(name: "get", linkageName: "_Z3getv", scope: !1, file: !1, line: 1, type: !38, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !38 = !DISubroutineType(types: !39)
 !39 = !{!12}
 !40 = !DISubprogram(name: "doSomething", linkageName: "_Z11doSomethingi", scope: !1, file: !1, line: 3, type: !41, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !41 = !DISubroutineType(types: !42)
 !42 = !{null, !12}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/single-memory-location.ll

 ; RUN: llc -stop-after=finalize-isel %s -o - \
-; RUN:    -experimental-assignment-tracking \
 ; RUN: | FileCheck %s
 
 ;; Check that a dbg.assign for a fully stack-homed variable causes the variable
 ;; location to appear in the Machine Function side table.
 ;;
 ;; $ cat test.cpp
 ;; void maybe_writes(int*);
 ;; void ext(int, int, int, int, int, int, int, int, int, int);

 
 declare !dbg !25 dso_local void @_Z12maybe_writesPi(ptr) local_unnamed_addr
 declare !dbg !29 dso_local void @_Z3extiiiiiiiiii(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32) local_unnamed_addr
 declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{i32 1, !"wchar_size", i32 4}

 !24 = !DILocation(line: 7, column: 4, scope: !7)
 !25 = !DISubprogram(name: "maybe_writes", linkageName: "_Z12maybe_writesPi", scope: !1, file: !1, line: 1, type: !26, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !26 = !DISubroutineType(types: !27)
 !27 = !{null, !28}
 !28 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
 !29 = !DISubprogram(name: "ext", linkageName: "_Z3extiiiiiiiiii", scope: !1, file: !1, line: 2, type: !30, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !30 = !DISubroutineType(types: !31)
 !31 = !{null, !10, !10, !10, !10, !10, !10, !10, !10, !10, !10}
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/split-alloca.ll

 ; RUN: llc %s -o - -stop-after=finalize-isel \
-; RUN:    -experimental-assignment-tracking  \
 ; RUN: | FileCheck %s --implicit-check-not=DBG
 
 ;; Hand written. Check that we fall back to emitting a list of defs for
 ;; variables with split allocas (i.e. we want to see DBG_VALUEs and no
 ;; debug-info-variable entry in the stack slot table).
 
 ; CHECK: stack:
 ; CHECK:   - { id: 0, name: a, type: default, offset: 0, size: 4, alignment: 4, 
entry:
   call void @llvm.dbg.assign(metadata i1 undef, metadata !11, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32), metadata !20, metadata ptr %c, metadata !DIExpression()), !dbg !17
   store i32 5, ptr %a, !DIAssignID !21
   ret void, !dbg !19
 }
 
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.module.flags = !{!2, !3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.c", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}
 !6 = !{!"clang version 14.0.0"}
 !7 = distinct !DISubprogram(name: "fun", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
 !8 = !DISubroutineType(types: !9)
 !9 = !{null}
 !10 = !{!11}
 !11 = !DILocalVariable(name: "local", scope: !7, file: !1, line: 2, type: !12)
 !12 = !DICompositeType(tag: DW_TAG_array_type, baseType: !13, size: 96, elements: !14)
 !13 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !14 = !{!15}
 !15 = !DISubrange(count: 3)
 !16 = distinct !DIAssignID()
 !17 = !DILocation(line: 0, scope: !7)
 !18 = !DILocation(line: 2, column: 3, scope: !7)
 !19 = !DILocation(line: 3, column: 1, scope: !7)
 !20 = distinct !DIAssignID()
 !21 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/untagged-store-frag.ll

-; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: llc %s -stop-after=finalize-isel -o - \
 ; RUN: | FileCheck %s --implicit-check-not=DBG_
 
 ;; Hand-written to test untagged store handling on a simple case. Here's what
 ;; we're looking at in the IR:
 
 ;; 1. mem(a): bits [0,  64) = !14
 ;; 2. dbg(a): bits [0,  64) = !14 ; Use memory loc
 ;; 3. dbg(a): bits [0,  32) = <unique ID> ; Use implicit loc, dbg.value has no ID
entry:
   %1 = load i64, ptr %a.addr, align 8
   ret i64 %1
 }
 
 declare void @llvm.dbg.value(metadata, metadata, metadata) #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #1
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3, !4, !5, !6}
+!llvm.module.flags = !{!2, !3, !4, !5, !6, !1000}
 !llvm.ident = !{!7}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "test.cpp", directory: "/")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 4}
 !5 = !{i32 7, !"uwtable", i32 1}
 !6 = !{i32 7, !"frame-pointer", i32 2}
 !7 = !{!"clang version 14.0.0"}
 !8 = distinct !DISubprogram(name: "f", linkageName: "_Z1fl", scope: !1, file: !1, line: 1, type: !9, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !12)
 !9 = !DISubroutineType(types: !10)
 !10 = !{!11, !11}
 !11 = !DIBasicType(name: "long", size: 64, encoding: DW_ATE_signed)
 !12 = !{}
 !13 = distinct !DIAssignID()
 !14 = !DILocalVariable(name: "a", arg: 1, scope: !8, file: !1, line: 1, type: !11)
 !15 = !DILocation(line: 0, scope: !8)
 !16 = distinct !DIAssignID()
 !17 = !DILocalVariable(name: "b", arg: 2, scope: !8, file: !1, line: 1, type: !11)
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/use-known-value-at-early-mem-def-2.ll

 ; RUN: llc %s -stop-after=finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking \
 ; RUN: | FileCheck %s --implicit-check-not=DBG_VALUE
 
 ;; Check that sandwiching instructions between a linked store and dbg.assign
 ;; results in a dbg.value(prev_value) being inserted at the store, and a
 ;; dbg.value(deref) at the dbg.assign.
 ;; Same as use-known-value-at-early-mem-def.ll except the "early mem def" is
 ;; for a fragment of the variable rather than the whole.
 

 
 declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #1
 declare !dbg !24 dso_local void @d(...) local_unnamed_addr #2
 declare !dbg !27 dso_local void @a(ptr) local_unnamed_addr #2
 declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "reduce.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}

 !24 = !DISubprogram(name: "d", scope: !1, file: !1, line: 2, type: !25, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !25 = !DISubroutineType(types: !26)
 !26 = !{null, null}
 !27 = !DISubprogram(name: "a", scope: !1, file: !1, line: 1, type: !28, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !28 = !DISubroutineType(types: !29)
 !29 = !{null, !30}
 !30 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
 !31 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}

llvm/test/DebugInfo/assignment-tracking/X86/use-known-value-at-early-mem-def.ll

 ; RUN: llc %s -stop-after=finalize-isel -o - \
-; RUN:    -experimental-assignment-tracking  \
 ; RUN: | FileCheck %s --implicit-check-not=DBG_VALUE
 
 ;; Check that sandwiching instructions between a linked store and dbg.assign
 ;; results in a dbg.value(prev_value) being inserted at the store, and a
 ;; dbg.value(deref) at the dbg.assign.
 
 ; CHECK: bb.0.entry:
 ; CHECK-NEXT: DBG_VALUE %stack.0.c, $noreg, ![[var:[0-9]+]], !DIExpression(DW_OP_deref), debug-location

 
 declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #1
 declare !dbg !24 dso_local void @d(...) local_unnamed_addr #2
 declare !dbg !27 dso_local void @a(ptr) local_unnamed_addr #2
 declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1
 declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
+!llvm.module.flags = !{!3, !4, !5, !1000}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "reduce.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}

 !24 = !DISubprogram(name: "d", scope: !1, file: !1, line: 2, type: !25, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !25 = !DISubroutineType(types: !26)
 !26 = !{null, null}
 !27 = !DISubprogram(name: "a", scope: !1, file: !1, line: 1, type: !28, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
 !28 = !DISubroutineType(types: !29)
 !29 = !{null, !30}
 !30 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
 !31 = distinct !DIAssignID()
+!1000 = !{i32 7, !"debug-info-assignment-tracking", i1 true}