[IR] Add DebugEntryValues pass

[milica-lazarevic]

Summary

This IR pass collects the function parameters and maps them to their entry values. If parameter's value remains unchanged we can restore it original value and make it available in the debugging process. This pass introduces the using of DW_OP_LLVM_entry_value operation on IR level. Pass has been added to the default<O2> pass pipeline, right after the DeadArgumentEliminationPass.

When a function inlining happens, there is no typical parameter passing. This situation is handled by deleting calls to llvm.dbg.value instructions which describe the location of the variable as an entry value.

For understanding motivation for introducing this kind of feature, consider an example below:

extern void fn1 ();
long int __attribute__((noinline)) fn2 (long int x)
{
  fn1();
  return 0;
}
void fn3 (){
  fn2(1);
}

Due to DeadArgumentEliminationPass, parameter x will be mark as undef and reported as <optimized_out> by the debugger. After applying DebugEntryValues pass, and with existence of corresponding DW_TAG_call_site_parameter, the parameter value will be available in the debugging process.

[jmorse]

This patch is a great use of entry values, however I think there's an awkward semantic gap caused by having it in a separate pass to DAE: any undef dbg.value can be promoted to being an entry value. When DAE runs and sets args to be undef we know for certain that the dbg.values being set to undef referred to arguments, but the inverse isn't true, any old undef dbg.value didn't necessarily refer to an argument.

It's probably OK if there's only one dbg.value, as mentioned in the code comments -- however, I don't believe the implementation in this patch counts to see that there's only one dbg.value, it just converts all undef dbg.values to entry values.

In comparison, if this were done in DAE there wouldn't be that uncertainty, plus I think we'd be able to support scenarios where there are other dbg.values of parameter variables, as we would know which dbg.values used to refer to the argument. (Unless I've missed something). I hate to be the reviewer who says "Why not do it completely differently", but wouldn't that be better?

I believe this code should ignore any functions marked "internal", because DAE can change the function signature of those functions, making the parameter-numbers in DILocalVariables not line up with the arguments. See: llvm/test/Transforms/DeadArgElim/dbginfo.ll .

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

393–396

What's the motivation behind this change -- it's not covered by any of the tests changed / added, no?

llvm/lib/Transforms/Utils/DebugEntryValues.cpp

40

Would just the idx < F.arg_size() clause be sufficient?

llvm/lib/Transforms/Utils/InlineFunction.cpp

1757

Am I right in thinking this RAUWs a dbg.value instruction? I don't believe there should be any users of the dbg.value, as it doesn't produce a Value.

llvm/test/Transforms/DebugEntryValues/no-param-change.ll

27–30

Any un-necessary attributes should be dropped to reduce future maintenance

[djtodoro]

I think this should be closed (and revisited) in favor of the patches that are currently in the process of upstreaming (e.g. D151330 ant the others from @fdeazeve).

[milica-lazarevic]

Because of the patches currently upstreaming (e.g. D151330 and the others from @fdeazeve), this patch should be closed.

llvm/include/llvm/IR/DebugInfoMetadata.h

bool fragmentsOverlap(const DIExpression *Other) const {
     if (!isFragment() || !Other->isFragment())
       return true;
     return fragmentCmp(Other) == 0;
   }
 
   /// Check if the expression consists of exactly one entry value operand.
   /// (This is the only configuration of entry values that is supported.)
   bool isEntryValue() const {
-    return getNumElements() > 0 &&
-           getElement(0) == dwarf::DW_OP_LLVM_entry_value;
+    // Entry value can appear anywhere in expression.
+    for (size_t i = 0; i < getNumElements(); i++) {
+      if (getElement(i) == dwarf::DW_OP_LLVM_entry_value) {
+        return true;
+      }
+    }
+    return false;
   }
 
   /// Try to shorten an expression with an initial constant operand.
   /// Returns a new expression and constant on success, or the original
   /// expression and constant on failure.
   std::pair<DIExpression *, const ConstantInt *>
   constantFold(const ConstantInt *CI);
 };

llvm/include/llvm/Transforms/Utils/DebugEntryValues.h

+#ifndef LLVM_TRANSFORMS_UTILS_DEBUG_ENTRY_VALUES_H
+#define LLVM_TRANSFORMS_UTILS_DEBUG_ENTRY_VALUES_H
+
+#include "llvm/IR/PassManager.h"
+#include "llvm/Pass.h"
+
+namespace llvm {
+void markEntryValues(Function &F);
+} // namespace llvm
+
+struct DebugEntryValues : public llvm::PassInfoMixin<DebugEntryValues> {
+  llvm::PreservedAnalyses run(llvm::Function &F,
+                              llvm::FunctionAnalysisManager &AM);
+};
+
+#endif // LLVM_TRANSFORMS_UTILS_DEBUG_ENTRY_VALUES_H

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

void DwarfExpression::setLocation(const MachineLocation &Loc,
   if (DIExpr->isEntryValue())
     setEntryValueFlags(Loc);
 }
 
 void DwarfExpression::beginEntryValueExpression(
     DIExpressionCursor &ExprCursor) {
   auto Op = ExprCursor.take();
   (void)Op;
+  if (Op->getOp() != dwarf::DW_OP_LLVM_entry_value) {
+    // TODO: Handle this kind of entry-value expression.
+    Op = ExprCursor.take();
+  }
   assert(Op && Op->getOp() == dwarf::DW_OP_LLVM_entry_value);
   assert(!IsEmittingEntryValue && "Already emitting entry value?");
   assert(Op->getArg(0) == 1 &&
          "Can currently only emit entry values covering a single operation");
 
   SavedLocationKind = LocationKind;
   LocationKind = Register;
   IsEmittingEntryValue = true;

llvm/lib/IR/DebugInfoMetadata.cpp

case dwarf::DW_OP_swap: {
       // DW_LLVM_OP_implicit_location as a placeholder for the location this
       // DIExpression is attached to, or else pass the number of implicit stack
       // elements into isValid.
       if (getNumElements() == 1)
         return false;
       break;
     }
     case dwarf::DW_OP_LLVM_entry_value: {
-      // An entry value operator must appear at the beginning and the number of
-      // operations it cover can currently only be 1, because we support only
-      // entry values of a simple register location. One reason for this is that
-      // we currently can't calculate the size of the resulting DWARF block for
-      // other expressions.
-      return I->get() == expr_op_begin()->get() && I->getArg(0) == 1;
+      // The number of operations an entry value operator covers can currently
+      // only be 1, because we support only entry values of a simple register
+      // location. One reason for this is that we currently can't calculate the
+      // size of the resulting DWARF block for other expressions.
+      return I->getArg(0) == 1;
     }
     case dwarf::DW_OP_LLVM_implicit_pointer:
     case dwarf::DW_OP_LLVM_convert:
     case dwarf::DW_OP_LLVM_arg:
     case dwarf::DW_OP_LLVM_tag_offset:
     case dwarf::DW_OP_constu:
     case dwarf::DW_OP_plus_uconst:
     case dwarf::DW_OP_plus:

llvm/lib/IR/Verifier.cpp

#include "llvm/IR/Metadata.def"
   void verifySiblingFuncletUnwinds();
 
   void verifyFragmentExpression(const DbgVariableIntrinsic &I);
   template <typename ValueOrMetadata>
   void verifyFragmentExpression(const DIVariable &V,
                                 DIExpression::FragmentInfo Fragment,
                                 ValueOrMetadata *Desc);
   void verifyFnArgs(const DbgVariableIntrinsic &I);
-  void verifyNotEntryValue(const DbgVariableIntrinsic &I);
 
   /// Module-level debug info verification...
   void verifyCompileUnits();
 
   /// Module-level verification that all @llvm.experimental.deoptimize
   /// declarations share the same calling convention.
   void verifyDeoptimizeCallingConvs();
 
void Verifier::visitInstruction(Instruction &I) {
 
   if (MDNode *N = I.getDebugLoc().getAsMDNode()) {
     AssertDI(isa<DILocation>(N), "invalid !dbg metadata attachment", &I, N);
     visitMDNode(*N, AreDebugLocsAllowed::Yes);
   }
 
   if (auto *DII = dyn_cast<DbgVariableIntrinsic>(&I)) {
     verifyFragmentExpression(*DII);
-    verifyNotEntryValue(*DII);
   }
 
   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
   I.getAllMetadata(MDs);
   for (auto Attachment : MDs) {
     unsigned Kind = Attachment.first;
     auto AllowLocs =
         (Kind == LLVMContext::MD_dbg || Kind == LLVMContext::MD_loop)
if (DebugFnArgs.size() < ArgNo)
     DebugFnArgs.resize(ArgNo, nullptr);
 
   auto *Prev = DebugFnArgs[ArgNo - 1];
   DebugFnArgs[ArgNo - 1] = Var;
   AssertDI(!Prev || (Prev == Var), "conflicting debug info for argument", &I,
            Prev, Var);
 }
 
-void Verifier::verifyNotEntryValue(const DbgVariableIntrinsic &I) {
-  DIExpression *E = dyn_cast_or_null<DIExpression>(I.getRawExpression());
-
-  // We don't know whether this intrinsic verified correctly.
-  if (!E || !E->isValid())
-    return;
-
-  AssertDI(!E->isEntryValue(), "Entry values are only allowed in MIR", &I);
-}
-
 void Verifier::verifyCompileUnits() {
   // When more than one Module is imported into the same context, such as during
   // an LTO build before linking the modules, ODR type uniquing may cause types
   // to point to a different CU. This check does not make sense in this case.
   if (M.getContext().isODRUniquingDebugTypes())
     return;
   auto *CUs = M.getNamedMetadata("llvm.dbg.cu");
   SmallPtrSet<const Metadata *, 2> Listed;

llvm/lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/Scalar/StructurizeCFG.h"
 #include "llvm/Transforms/Scalar/TailRecursionElimination.h"
 #include "llvm/Transforms/Scalar/WarnMissedTransforms.h"
 #include "llvm/Transforms/Utils/AddDiscriminators.h"
 #include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
 #include "llvm/Transforms/Utils/BreakCriticalEdges.h"
 #include "llvm/Transforms/Utils/CanonicalizeAliases.h"
 #include "llvm/Transforms/Utils/CanonicalizeFreezeInLoops.h"
+#include "llvm/Transforms/Utils/DebugEntryValues.h"
 #include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
 #include "llvm/Transforms/Utils/FixIrreducible.h"
 #include "llvm/Transforms/Utils/HelloWorld.h"
 #include "llvm/Transforms/Utils/InjectTLIMappings.h"
 #include "llvm/Transforms/Utils/InstructionNamer.h"
 #include "llvm/Transforms/Utils/LCSSA.h"
 #include "llvm/Transforms/Utils/LibCallsShrinkWrap.h"
 #include "llvm/Transforms/Utils/LoopSimplify.h"

llvm/lib/Passes/PassBuilderPipelines.cpp

 #include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
 #include "llvm/Transforms/Scalar/SimplifyCFG.h"
 #include "llvm/Transforms/Scalar/SpeculativeExecution.h"
 #include "llvm/Transforms/Scalar/TailRecursionElimination.h"
 #include "llvm/Transforms/Scalar/WarnMissedTransforms.h"
 #include "llvm/Transforms/Utils/AddDiscriminators.h"
 #include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
 #include "llvm/Transforms/Utils/CanonicalizeAliases.h"
+#include "llvm/Transforms/Utils/DebugEntryValues.h"
 #include "llvm/Transforms/Utils/InjectTLIMappings.h"
 #include "llvm/Transforms/Utils/LibCallsShrinkWrap.h"
 #include "llvm/Transforms/Utils/Mem2Reg.h"
 #include "llvm/Transforms/Utils/NameAnonGlobals.h"
 #include "llvm/Transforms/Utils/RelLookupTableConverter.h"
 #include "llvm/Transforms/Utils/SimplifyCFGOptions.h"
 #include "llvm/Transforms/Vectorize/LoopVectorize.h"
 #include "llvm/Transforms/Vectorize/SLPVectorizer.h"
PassBuilder::buildModuleSimplificationPipeline(OptimizationLevel Level,
   // delete control flows that are dead once globals have been folded to
   // constants.
   MPM.addPass(createModuleToFunctionPassAdaptor(PromotePass()));
 
   // Remove any dead arguments exposed by cleanups and constant folding
   // globals.
   MPM.addPass(DeadArgumentEliminationPass());
 
+  // Mark unmodified parameters as entry values.
+  MPM.addPass(createModuleToFunctionPassAdaptor(DebugEntryValues()));
+
   // Create a small function pass pipeline to cleanup after all the global
   // optimizations.
   FunctionPassManager GlobalCleanupPM;
   GlobalCleanupPM.addPass(InstCombinePass());
   invokePeepholeEPCallbacks(GlobalCleanupPM, Level);
 
   GlobalCleanupPM.addPass(SimplifyCFGPass());
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(GlobalCleanupPM),

llvm/lib/Passes/PassRegistry.def

 FUNCTION_PASS("consthoist", ConstantHoistingPass())
 FUNCTION_PASS("constraint-elimination", ConstraintEliminationPass())
 FUNCTION_PASS("chr", ControlHeightReductionPass())
 FUNCTION_PASS("coro-early", CoroEarlyPass())
 FUNCTION_PASS("coro-elide", CoroElidePass())
 FUNCTION_PASS("coro-cleanup", CoroCleanupPass())
 FUNCTION_PASS("correlated-propagation", CorrelatedValuePropagationPass())
 FUNCTION_PASS("dce", DCEPass())
+FUNCTION_PASS("dbg-entry-values", DebugEntryValues())
 FUNCTION_PASS("dfa-jump-threading", DFAJumpThreadingPass())
 FUNCTION_PASS("div-rem-pairs", DivRemPairsPass())
 FUNCTION_PASS("dse", DSEPass())
 FUNCTION_PASS("dot-cfg", CFGPrinterPass())
 FUNCTION_PASS("dot-cfg-only", CFGOnlyPrinterPass())
 FUNCTION_PASS("fix-irreducible", FixIrreduciblePass())
 FUNCTION_PASS("flattencfg", FlattenCFGPass())
 FUNCTION_PASS("make-guards-explicit", MakeGuardsExplicitPass())

llvm/lib/Transforms/Utils/CMakeLists.txt

add_llvm_component_library(LLVMTransformUtils
   CanonicalizeAliases.cpp
   CanonicalizeFreezeInLoops.cpp
   CloneFunction.cpp
   CloneModule.cpp
   CodeExtractor.cpp
   CodeLayout.cpp
   CodeMoverUtils.cpp
   CtorUtils.cpp
+  DebugEntryValues.cpp
   Debugify.cpp
   DemoteRegToStack.cpp
   EntryExitInstrumenter.cpp
   EscapeEnumerator.cpp
   Evaluator.cpp
   FixIrreducible.cpp
   FlattenCFG.cpp
   FunctionComparator.cpp

llvm/lib/Transforms/Utils/DebugEntryValues.cpp

+#include "llvm/Transforms/Utils/DebugEntryValues.h"
+#include "llvm/IR/DIBuilder.h"
+#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+void llvm::markEntryValues(Function &F) {
+  auto SP = F.getSubprogram();
+  if (!SP) {
+    return;
+  }
+
+  auto Nodes = SP->getRetainedNodes();
+  if (!Nodes) {
+    return;
+  }
+
+  DenseMap<DILocalVariable *, Value *> Parameters(F.arg_size());
+  std::vector<Value *> FArgs(F.arg_size(), nullptr);
+
+  for (auto it = F.arg_begin(); it != F.arg_end(); ++it) {
+    auto Arg = &(*it);
+    unsigned int idx = Arg->getArgNo();
+    FArgs[idx] = cast<Value>(&(*it));
+  }
+
+  for (auto *DN : Nodes) {
+    if (auto *DV = dyn_cast<DILocalVariable>(DN)) {
+      if (!DV->isParameter()) {
+        continue;
+      }
+      unsigned int idx = DV->getArg() - 1;
+
+      // FIXME: arg field in DILocalVariable.
+      if (F.arg_size() != 0 && idx < F.arg_size()) {
+        Parameters.insert({DV, FArgs[idx]});
+      }
+    }
+  }
+
+  if (Parameters.size() == 0) {
+    return;
+  }
+
+  // For modified parameters, there is a call to llvm.dbg.value
+  // instruction different than undef, so for those parameters we cannot use
+  // entry value as a backup location.
+  for (BasicBlock &B : F) {
+    for (Instruction &I : B) {
+      if (auto *DVI = dyn_cast<DbgVariableIntrinsic>(&I)) {
+        if (!isa<DbgValueInst>(I)) {
+          continue;
+        }
+
+        auto Var = DVI->getVariable();
+        if (Var->isParameter() && !DVI->isUndef()) {
+          Parameters.erase(Var);
+        }
+      }
+    }
+  }
+
+  // For unmodified parameters there is exactly one call to
+  // llvm.dbg.value instruction, with undef value. This is the
+  // situation when we can try to recover those values, so intrinsic
+  // is changed with an entry value expression, and variable's
+  // value as first operand.
+  for (BasicBlock &B : F) {
+    for (Instruction &I : B) {
+      if (auto *DVI = dyn_cast<DbgVariableIntrinsic>(&I)) {
+        auto Var = DVI->getVariable();
+        if (!isa<DbgValueInst>(I) || !Var->isParameter() || !DVI->isUndef()) {
+          continue;
+        }
+        auto it = Parameters.find(Var);
+        if (it == Parameters.end()) {
+          continue;
+        }
+        auto Val = Parameters[Var];
+        auto MetaVal =
+            MetadataAsValue::get(I.getContext(), ValueAsMetadata::get(Val));
+        DVI->Instruction::setOperand(0, MetaVal);
+        auto *DIExpr = DIExpression::get(DVI->getExpression()->getContext(),
+                                         {dwarf::DW_OP_LLVM_entry_value, 1});
+        DVI->setExpression(DIExpr);
+      }
+    }
+  }
+}
+
+PreservedAnalyses DebugEntryValues::run(Function &F,
+                                        FunctionAnalysisManager &AM) {
+  markEntryValues(F);
+  return PreservedAnalyses::all();
+}
+
+namespace {
+struct DebugEntryValuesLegacyPass : public FunctionPass {
+  static char ID;
+  DebugEntryValuesLegacyPass() : FunctionPass(ID) {}
+
+  bool runOnFunction(Function &F) override {
+    markEntryValues(F);
+    return false;
+  }
+
+}; // end of struct DebugEntryValuesLegacyPass
+} // end of anonymous namespace
+
+char DebugEntryValuesLegacyPass::ID = 0;
+
+static RegisterPass<DebugEntryValuesLegacyPass>
+    DEVCS("dbg-entry-values",
+          "Mark unmodified parameters' location as an entry value");

llvm/lib/Transforms/Utils/InlineFunction.cpp

if (InsertRetainCall) {
       Builder.SetInsertPoint(RI);
       Function *IFn = Intrinsic::getDeclaration(Mod, Intrinsic::objc_retain);
       Value *BC = Builder.CreateBitCast(RetOpnd, IFn->getArg(0)->getType());
       Builder.CreateCall(IFn, BC, "");
     }
   }
 }
 
+// When a function inlining happens, there is no typical
+// parameter passing. This situation is handled here
+// by deleting calls to llvm.dbg.value instructions which
+// describe the location of the variable as an entry value.
+static void invalidateEntryValues(Function *Fn, Function::iterator FI) {
+  std::vector<Instruction *> DbgValueToErase;
+  for (; FI != Fn->end(); ++FI)
+    for (BasicBlock::iterator BI = FI->begin(), BE = FI->end(); BI != BE;
+         ++BI) {
+      DbgValueInst *DVI = dyn_cast<DbgValueInst>(&(*BI));
+      if (!DVI)
+        continue;
+      if (DVI->getExpression()->isEntryValue()) {
+        UndefValue *U = UndefValue::get((&(*BI))->getType());
+        (&(*BI))->replaceAllUsesWith(U);
+        DbgValueToErase.push_back((&(*BI)));
+      }
+    }
+
+  for (Instruction *I : DbgValueToErase) {
+    I->dropAllReferences();
+    I->eraseFromParent();
+  }
+}
+
 /// This function inlines the called function into the basic block of the
 /// caller. This returns false if it is not possible to inline this call.
 /// The program is still in a well defined state if this occurs though.
 ///
 /// Note that this only does one level of inlining.  For example, if the
 /// instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now
 /// exists in the instruction stream.  Similarly this will inline a recursive
 /// function by one level.
Function::iterator FirstNewBlock;
     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 (CalledFunc->getSubprogram() != nullptr)
+      invalidateEntryValues(Caller, FirstNewBlock);
 
     // Now clone the inlined noalias scope metadata.
     SAMetadataCloner.clone();
     SAMetadataCloner.remap(FirstNewBlock, Caller->end());
 
     // Add noalias metadata if necessary.
     AddAliasScopeMetadata(CB, VMap, DL, CalleeAAR, InlinedFunctionInfo);
 

llvm/test/Other/new-pm-defaults.ll

 ; CHECK-O3-NEXT: Running pass: CallSiteSplittingPass
 ; CHECK-O-NEXT: Running pass: OpenMPOptPass
 ; CHECK-EP-PIPELINE-EARLY-SIMPLIFICATION-NEXT: Running pass: NoOpModulePass
 ; CHECK-O-NEXT: Running pass: IPSCCPPass
 ; CHECK-O-NEXT: Running pass: CalledValuePropagationPass
 ; CHECK-O-NEXT: Running pass: GlobalOptPass
 ; CHECK-O-NEXT: Running pass: PromotePass
 ; CHECK-O-NEXT: Running pass: DeadArgumentEliminationPass
+; CHECK-O-NEXT: Running pass: DebugEntryValues
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running analysis: OptimizationRemarkEmitterAnalysis
 ; CHECK-O-NEXT: Running analysis: AAManager
 ; CHECK-O-NEXT: Running analysis: BasicAA
 ; CHECK-O-NEXT: Running analysis: ScopedNoAliasAA
 ; CHECK-O-NEXT: Running analysis: TypeBasedAA
 ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy
 ; CHECK-EP-PEEPHOLE-NEXT: Running pass: NoOpFunctionPass

llvm/test/Other/new-pm-thinlto-defaults.ll

 ; CHECK-O3-NEXT: Running pass: CallSiteSplittingPass
 ; CHECK-O-NEXT: Running pass: OpenMPOptPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: LowerTypeTestsPass
 ; CHECK-O-NEXT: Running pass: IPSCCPPass
 ; CHECK-O-NEXT: Running pass: CalledValuePropagationPass
 ; CHECK-O-NEXT: Running pass: GlobalOptPass
 ; CHECK-O-NEXT: Running pass: PromotePass
 ; CHECK-O-NEXT: Running pass: DeadArgumentEliminationPass
+; CHECK-O-NEXT: Running pass: DebugEntryValues
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-PRELINK-O-NEXT: Running analysis: OptimizationRemarkEmitterAnalysis
 ; CHECK-O-NEXT: Running analysis: AAManager
 ; CHECK-O-NEXT: Running analysis: BasicAA
 ; CHECK-O-NEXT: Running analysis: ScopedNoAliasAA
 ; CHECK-O-NEXT: Running analysis: TypeBasedAA
 ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass

llvm/test/Other/new-pm-thinlto-postlink-pgo-defaults.ll

 ; CHECK-O3-NEXT: Running pass: CallSiteSplittingPass
 ; CHECK-O-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O-NEXT: Running pass: LowerTypeTestsPass
 ; CHECK-O-NEXT: Running pass: IPSCCPPass
 ; CHECK-O-NEXT: Running pass: CalledValuePropagationPass
 ; CHECK-O-NEXT: Running pass: GlobalOptPass
 ; CHECK-O-NEXT: Running pass: PromotePass
 ; CHECK-O-NEXT: Running pass: DeadArgumentEliminationPass
+; CHECK-O-NEXT: Running pass: DebugEntryValues
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running analysis: AAManager
 ; CHECK-O-NEXT: Running analysis: BasicAA
 ; CHECK-O-NEXT: Running analysis: ScopedNoAliasAA
 ; CHECK-O-NEXT: Running analysis: TypeBasedAA
 ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy
 ; CHECK-O-NEXT: Running analysis: BlockFrequencyAnalysis on foo
 ; These next two can appear in any order since they are accessed as parameters

llvm/test/Other/new-pm-thinlto-postlink-samplepgo-defaults.ll

 ; CHECK-O-NEXT: Running pass: PGOIndirectCallPromotion
 ; CHECK-O-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O-NEXT: Running pass: LowerTypeTestsPass
 ; CHECK-O-NEXT: Running pass: IPSCCPPass
 ; CHECK-O-NEXT: Running pass: CalledValuePropagationPass
 ; CHECK-O-NEXT: Running pass: GlobalOptPass
 ; CHECK-O-NEXT: Running pass: PromotePass
 ; CHECK-O-NEXT: Running pass: DeadArgumentEliminationPass
+; CHECK-O-NEXT: Running pass: DebugEntryValues
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running analysis: BlockFrequencyAnalysis on foo
 ; These next two can appear in any order since they are accessed as parameters
 ; on the same call to BlockFrequencyInfo::calculate.
 ; CHECK-O-DAG: Running analysis: LoopAnalysis on foo
 ; CHECK-O-DAG: Running analysis: BranchProbabilityAnalysis on foo
 ; CHECK-O-NEXT: Running analysis: PostDominatorTreeAnalysis on foo
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass on foo

llvm/test/Other/new-pm-thinlto-prelink-pgo-defaults.ll

 ; CHECK-O-NEXT: Running pass: CoroEarlyPass
 ; CHECK-O3-NEXT: Running pass: CallSiteSplittingPass
 ; CHECK-O-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O-NEXT: Running pass: IPSCCPPass
 ; CHECK-O-NEXT: Running pass: CalledValuePropagationPass
 ; CHECK-O-NEXT: Running pass: GlobalOptPass
 ; CHECK-O-NEXT: Running pass: PromotePass
 ; CHECK-O-NEXT: Running pass: DeadArgumentEliminationPass
+; CHECK-O-NEXT: Running pass: DebugEntryValues
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running analysis: OptimizationRemarkEmitterAnalysis
 ; CHECK-O-NEXT: Running analysis: AAManager
 ; CHECK-O-NEXT: Running analysis: BasicAA
 ; CHECK-O-NEXT: Running analysis: ScopedNoAliasAA
 ; CHECK-O-NEXT: Running analysis: TypeBasedAA
 ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass

llvm/test/Other/new-pm-thinlto-prelink-samplepgo-defaults.ll

 ; CHECK-O-NEXT: Running analysis: CallGraphAnalysis
 ; CHECK-O-NEXT: Running pass: RequireAnalysisPass<{{.*}}ProfileSummaryAnalysis
 ; CHECK-O-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O-NEXT: Running pass: IPSCCPPass
 ; CHECK-O-NEXT: Running pass: CalledValuePropagationPass
 ; CHECK-O-NEXT: Running pass: GlobalOptPass
 ; CHECK-O-NEXT: Running pass: PromotePass
 ; CHECK-O-NEXT: Running pass: DeadArgumentEliminationPass
+; CHECK-O-NEXT: Running pass: DebugEntryValues
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running analysis: BlockFrequencyAnalysis on foo
 ; These next two can appear in any order since they are accessed as parameters
 ; on the same call to BlockFrequencyInfo::calculate.
 ; CHECK-O-DAG: Running analysis: LoopAnalysis on foo
 ; CHECK-O-DAG: Running analysis: BranchProbabilityAnalysis on foo
 ; CHECK-O-NEXT: Running analysis: PostDominatorTreeAnalysis on foo
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass on foo

llvm/test/Transforms/DebugEntryValues/no-param-change.ll

+; RUN: opt -dbg-entry-values -S < %s | FileCheck %s
+
+; Function Attrs: noinline nounwind uwtable
+define dso_local i64 @fn2(i64 %0, i64 %1, i64 %2) local_unnamed_addr #0 !dbg !8 {
+  ; CHECK: call void @llvm.dbg.value(metadata i64 %0, metadata !13, metadata !DIExpression(DW_OP_LLVM_entry_value, 1)), !dbg !17
+  ; CHECK: call void @llvm.dbg.value(metadata i64 %1, metadata !14, metadata !DIExpression(DW_OP_LLVM_entry_value, 1)), !dbg !17
+  ; CHECK: call void @llvm.dbg.value(metadata i64 %2, metadata !15, metadata !DIExpression(DW_OP_LLVM_entry_value, 1)), !dbg !17
+  call void @llvm.dbg.value(metadata i64 undef, metadata !13, metadata !DIExpression()), !dbg !17
+  call void @llvm.dbg.value(metadata i64 undef, metadata !14, metadata !DIExpression()), !dbg !17
+  call void @llvm.dbg.value(metadata i64 undef, metadata !15, metadata !DIExpression()), !dbg !17
+  call void @llvm.dbg.value(metadata !DIArgList(i64 2, i64 undef), metadata !16, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_mul, DW_OP_stack_value)), !dbg !17
+  tail call void @fn1(i64 5, i64 6, i64 7) #3, !dbg !18
+  ret i64 0, !dbg !19
+}
+
+declare !dbg !20 dso_local void @fn1(i64, i64, i64) local_unnamed_addr #1
+
+; Function Attrs: noinline nounwind uwtable
+define dso_local i64 @fn3() local_unnamed_addr #0 !dbg !23 {
+  %1 = tail call i64 @fn2(i64 undef, i64 undef, i64 undef), !dbg !26
+  ret i64 0, !dbg !27
+}
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #2
+
+attributes #0 = { noinline nounwind uwtable "frame-pointer"="none" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+attributes #1 = { "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+attributes #2 = { nofree nosync nounwind readnone speculatable willreturn }
+attributes #3 = { nounwind }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0 (https://github.com/llvm/llvm-project.git c2574e63ff71c1d3caea48cb6200c2422bd8f33d)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "testOriginal.c", directory: "/home/syrmia/diplomski/testF")
+!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 7, !"uwtable", i32 1}
+!7 = !{!"clang version 14.0.0 (https://github.com/llvm/llvm-project.git c2574e63ff71c1d3caea48cb6200c2422bd8f33d)"}
+!8 = distinct !DISubprogram(name: "fn2", scope: !1, file: !1, line: 4, type: !9, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!11, !11, !11, !11}
+!11 = !DIBasicType(name: "long int", size: 64, encoding: DW_ATE_signed)
+!12 = !{!13, !14, !15, !16}
+!13 = !DILocalVariable(name: "a", arg: 1, scope: !8, file: !1, line: 4, type: !11)
+!14 = !DILocalVariable(name: "b", arg: 2, scope: !8, file: !1, line: 4, type: !11)
+!15 = !DILocalVariable(name: "c", arg: 3, scope: !8, file: !1, line: 4, type: !11)
+!16 = !DILocalVariable(name: "q", scope: !8, file: !1, line: 6, type: !11)
+!17 = !DILocation(line: 0, scope: !8)
+!18 = !DILocation(line: 7, column: 3, scope: !8)
+!19 = !DILocation(line: 8, column: 3, scope: !8)
+!20 = !DISubprogram(name: "fn1", scope: !1, file: !1, line: 1, type: !21, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!21 = !DISubroutineType(types: !22)
+!22 = !{null, !11, !11, !11}
+!23 = distinct !DISubprogram(name: "fn3", scope: !1, file: !1, line: 12, type: !24, scopeLine: 13, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)
+!24 = !DISubroutineType(types: !25)
+!25 = !{!11}
+!26 = !DILocation(line: 14, column: 10, scope: !23)
+!27 = !DILocation(line: 14, column: 3, scope: !23)

llvm/test/Transforms/DebugEntryValues/with-param-change.ll

+; RUN: opt -dbg-entry-values -S < %s | FileCheck %s
+
+; Function Attrs: noinline nounwind uwtable
+define dso_local i64 @fn2(i64 %0, i64 %1, i64 %2) local_unnamed_addr #0 !dbg !8 {
+  ; CHECK: call void @llvm.dbg.value(metadata i64 undef, metadata !13, metadata !DIExpression()), !dbg !16
+  ; CHECK: call void @llvm.dbg.value(metadata i64 undef, metadata !14, metadata !DIExpression()), !dbg !16
+  call void @llvm.dbg.value(metadata i64 undef, metadata !13, metadata !DIExpression()), !dbg !16
+  call void @llvm.dbg.value(metadata i64 undef, metadata !14, metadata !DIExpression()), !dbg !16
+  call void @llvm.dbg.value(metadata i64 undef, metadata !15, metadata !DIExpression()), !dbg !16
+  call void @llvm.dbg.value(metadata i64 2, metadata !13, metadata !DIExpression()), !dbg !16
+  call void @llvm.dbg.value(metadata i64 3, metadata !14, metadata !DIExpression()), !dbg !16
+  tail call void @fn1(i64 5, i64 6, i64 7) #3, !dbg !17
+  ret i64 0, !dbg !18
+}
+
+declare !dbg !19 dso_local void @fn1(i64, i64, i64) local_unnamed_addr #1
+
+; Function Attrs: noinline nounwind uwtable
+define dso_local i64 @fn3() local_unnamed_addr #0 !dbg !22 {
+  %1 = tail call i64 @fn2(i64 undef, i64 undef, i64 undef), !dbg !25
+  ret i64 0, !dbg !26
+}
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #2
+
+attributes #0 = { noinline nounwind uwtable "frame-pointer"="none" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+attributes #1 = { "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+attributes #2 = { nofree nosync nounwind readnone speculatable willreturn }
+attributes #3 = { nounwind }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0 (https://github.com/llvm/llvm-project.git c2574e63ff71c1d3caea48cb6200c2422bd8f33d)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "testOriginalChangedParams.c", directory: "/home/syrmia/diplomski/testF")
+!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 7, !"uwtable", i32 1}
+!7 = !{!"clang version 14.0.0 (https://github.com/llvm/llvm-project.git c2574e63ff71c1d3caea48cb6200c2422bd8f33d)"}
+!8 = distinct !DISubprogram(name: "fn2", scope: !1, file: !1, line: 4, type: !9, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!11, !11, !11, !11}
+!11 = !DIBasicType(name: "long int", size: 64, encoding: DW_ATE_signed)
+!12 = !{!13, !14, !15}
+!13 = !DILocalVariable(name: "a", arg: 1, scope: !8, file: !1, line: 4, type: !11)
+!14 = !DILocalVariable(name: "b", arg: 2, scope: !8, file: !1, line: 4, type: !11)
+!15 = !DILocalVariable(name: "c", arg: 3, scope: !8, file: !1, line: 4, type: !11)
+!16 = !DILocation(line: 0, scope: !8)
+!17 = !DILocation(line: 8, column: 3, scope: !8)
+!18 = !DILocation(line: 9, column: 3, scope: !8)
+!19 = !DISubprogram(name: "fn1", scope: !1, file: !1, line: 1, type: !20, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!20 = !DISubroutineType(types: !21)
+!21 = !{null, !11, !11, !11}
+!22 = distinct !DISubprogram(name: "fn3", scope: !1, file: !1, line: 13, type: !23, scopeLine: 14, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)
+!23 = !DISubroutineType(types: !24)
+!24 = !{!11}
+!25 = !DILocation(line: 15, column: 10, scope: !22)
+!26 = !DILocation(line: 15, column: 3, scope: !22)

llvm/test/Verifier/diexpression-entry-value-llvm-ir.ll

-; RUN: llvm-as -disable-output <%s 2>&1| FileCheck %s
-
-; The DW_OP_LLVM_entry_value operation can only be used in MIR.
-
-; CHECK: Entry values are only allowed in MIR
-; CHECK: call void @llvm.dbg.value(metadata i32 %param, metadata !{{.*}}, metadata !DIExpression(DW_OP_LLVM_entry_value, 1))
-; CHECK: warning: ignoring invalid debug info
-
-define void @foo(i32 %param) !dbg !4 {
-entry:
-  call void @llvm.dbg.value(metadata i32 %param, metadata !8, metadata !DIExpression(DW_OP_LLVM_entry_value, 1)), !dbg !9
-  ret void
-}
-
-declare void @llvm.dbg.value(metadata, metadata, metadata) #0
-
-attributes #0 = { nounwind readnone speculatable willreturn }
-
-!llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!2, !3}
-
-!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, emissionKind: FullDebug)
-!1 = !DIFile(filename: "a.c", directory: "/")
-!2 = !{i32 2, !"Dwarf Version", i32 4}
-!3 = !{i32 2, !"Debug Info Version", i32 3}
-!4 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, type: !5, unit: !0)
-!5 = !DISubroutineType(types: !6)
-!6 = !{null, !7}
-!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
-!8 = !DILocalVariable(name: "param", arg: 1, scope: !4, file: !1, type: !7)
-!9 = !DILocation(line: 0, scope: !4)

llvm/test/Verifier/diexpression-entry-value.ll

 ; RUN: not opt -S < %s 2>&1 | FileCheck %s
 
-!named = !{!0, !1, !2}
-; CHECK: invalid expression
-; CHECK-NEXT: !DIExpression
+!named = !{!0, !1}
 ; CHECK: invalid expression
 ; CHECK-NEXT: !DIExpression
 ; CHECK: invalid expression
 ; CHECK-NEXT: !DIExpression
 !0 = !DIExpression(DW_OP_LLVM_entry_value, 4, DW_OP_constu, 0, DW_OP_stack_value)
-!1 = !DIExpression(DW_OP_constu, 0, DW_OP_LLVM_entry_value, 1, DW_OP_constu, 0)
-!2 = !DIExpression(DW_OP_LLVM_entry_value, 100, DW_OP_constu, 0)
+!1 = !DIExpression(DW_OP_LLVM_entry_value, 100, DW_OP_constu, 0)