LLVM  15.0.0git
MachineCheckDebugify.cpp
Go to the documentation of this file.
1 //===- MachineCheckDebugify.cpp - Check debug info ------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file This checks debug info after mir-debugify (+ pass-to-test). Currently
10 /// it simply checks the integrity of line info in DILocation and
11 /// DILocalVariable which mir-debugifiy generated before.
12 //===----------------------------------------------------------------------===//
13 
17 #include "llvm/CodeGen/Passes.h"
18 #include "llvm/IR/Constants.h"
20 #include "llvm/InitializePasses.h"
21 #include "llvm/Pass.h"
22 
23 #define DEBUG_TYPE "mir-check-debugify"
24 
25 using namespace llvm;
26 
27 namespace {
28 
29 struct CheckDebugMachineModule : public ModulePass {
30  bool runOnModule(Module &M) override {
31  NamedMDNode *NMD = M.getNamedMetadata("llvm.mir.debugify");
32  if (!NMD) {
33  errs() << "WARNING: Please run mir-debugify to generate "
34  "llvm.mir.debugify metadata first.\n";
35  return false;
36  }
37 
38  MachineModuleInfo &MMI =
39  getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
40 
41  auto getDebugifyOperand = [&](unsigned Idx) -> unsigned {
42  return mdconst::extract<ConstantInt>(NMD->getOperand(Idx)->getOperand(0))
43  ->getZExtValue();
44  };
45  assert(NMD->getNumOperands() == 2 &&
46  "llvm.mir.debugify should have exactly 2 operands!");
47  unsigned NumLines = getDebugifyOperand(0);
48  unsigned NumVars = getDebugifyOperand(1);
49  BitVector MissingLines{NumLines, true};
50  BitVector MissingVars{NumVars, true};
51 
52  for (Function &F : M.functions()) {
54  if (!MF)
55  continue;
56  for (MachineBasicBlock &MBB : *MF) {
57  // Find missing lines.
58  // TODO: Avoid meta instructions other than dbg_val.
59  for (MachineInstr &MI : MBB) {
60  if (MI.isDebugValue())
61  continue;
62  const DebugLoc DL = MI.getDebugLoc();
63  if (DL && DL.getLine() != 0) {
64  MissingLines.reset(DL.getLine() - 1);
65  continue;
66  }
67 
68  if (!DL) {
69  errs() << "WARNING: Instruction with empty DebugLoc in function ";
70  errs() << F.getName() << " --";
71  MI.print(errs());
72  }
73  }
74 
75  // Find missing variables.
76  // TODO: Handle DBG_INSTR_REF which is under an experimental option now.
77  for (MachineInstr &MI : MBB) {
78  if (!MI.isDebugValue())
79  continue;
80  const DILocalVariable *LocalVar = MI.getDebugVariable();
81  unsigned Var = ~0U;
82 
83  (void)to_integer(LocalVar->getName(), Var, 10);
84  assert(Var <= NumVars && "Unexpected name for DILocalVariable");
85  MissingVars.reset(Var - 1);
86  }
87  }
88  }
89 
90  bool Fail = false;
91  for (unsigned Idx : MissingLines.set_bits()) {
92  errs() << "WARNING: Missing line " << Idx + 1 << "\n";
93  Fail = true;
94  }
95 
96  for (unsigned Idx : MissingVars.set_bits()) {
97  errs() << "WARNING: Missing variable " << Idx + 1 << "\n";
98  Fail = true;
99  }
100  errs() << "Machine IR debug info check: ";
101  errs() << (Fail ? "FAIL" : "PASS") << "\n";
102 
103  return false;
104  }
105 
106  CheckDebugMachineModule() : ModulePass(ID) {}
107 
108  void getAnalysisUsage(AnalysisUsage &AU) const override {
110  AU.setPreservesAll();
111  }
112 
113  static char ID; // Pass identification.
114 };
116 
117 } // end anonymous namespace
118 
119 INITIALIZE_PASS_BEGIN(CheckDebugMachineModule, DEBUG_TYPE,
120  "Machine Check Debug Module", false, false)
121 INITIALIZE_PASS_END(CheckDebugMachineModule, DEBUG_TYPE,
123 
125  return new CheckDebugMachineModule();
126 }
llvm::createCheckDebugMachineModulePass
ModulePass * createCheckDebugMachineModulePass()
Creates MIR Check Debug pass.
Definition: MachineCheckDebugify.cpp:124
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:104
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::NamedMDNode
A tuple of MDNodes.
Definition: Metadata.h:1488
llvm::NamedMDNode::getNumOperands
unsigned getNumOperands() const
Definition: Metadata.cpp:1152
llvm::ModulePass
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:248
DebugInfoMetadata.h
llvm::Function
Definition: Function.h:60
Pass.h
llvm::lltok::LocalVar
@ LocalVar
Definition: LLToken.h:405
Fail
#define Fail
Definition: AArch64Disassembler.cpp:281
MachineBasicBlock.h
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(CheckDebugMachineModule, DEBUG_TYPE, "Machine Check Debug Module", false, false) INITIALIZE_PASS_END(CheckDebugMachineModule
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:893
F
#define F(x, y, z)
Definition: MD5.cpp:55
Constants.h
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3048
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
Check
#define Check(C,...)
Definition: Lint.cpp:170
false
Definition: StackSlotColoring.cpp:141
llvm::MachineModuleInfo
This class contains meta information specific to a module.
Definition: MachineModuleInfo.h:75
llvm::BitVector
Definition: BitVector.h:75
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:94
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
llvm::Pass::print
virtual void print(raw_ostream &OS, const Module *M) const
print - Print out the internal state of the pass.
Definition: Pass.cpp:129
Passes.h
llvm::MDNode::getOperand
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1204
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:66
llvm::MachineModuleInfoWrapperPass
Definition: MachineModuleInfo.h:215
llvm::NamedMDNode::getOperand
MDNode * getOperand(unsigned i) const
Definition: Metadata.cpp:1156
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
MachineModuleInfo.h
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::MachineFunction
Definition: MachineFunction.h:241
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::MachineModuleInfo::getMachineFunction
MachineFunction * getMachineFunction(const Function &F) const
Returns the MachineFunction associated to IR function F if there is one, otherwise nullptr.
Definition: MachineModuleInfo.cpp:103
DEBUG_TYPE
#define DEBUG_TYPE
Definition: MachineCheckDebugify.cpp:23
Machine
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:369
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
MachineFunction.h
InitializePasses.h
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37