LLVM 17.0.0git
PseudoProbeInserter.cpp
Go to the documentation of this file.
1//===- PseudoProbeInserter.cpp - Insert annotation for callsite profiling -===//
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// This file implements PseudoProbeInserter pass, which inserts pseudo probe
10// annotations for call instructions with a pseudo-probe-specific dwarf
11// discriminator. such discriminator indicates that the call instruction comes
12// with a pseudo probe, and the discriminator value holds information to
13// identify the corresponding counter.
14//===----------------------------------------------------------------------===//
15
21#include "llvm/IR/Module.h"
22#include "llvm/IR/PseudoProbe.h"
24
25#define DEBUG_TYPE "pseudo-probe-inserter"
26
27using namespace llvm;
28
29namespace {
30class PseudoProbeInserter : public MachineFunctionPass {
31public:
32 static char ID;
33
34 PseudoProbeInserter() : MachineFunctionPass(ID) {
36 }
37
38 StringRef getPassName() const override { return "Pseudo Probe Inserter"; }
39
40 void getAnalysisUsage(AnalysisUsage &AU) const override {
41 AU.setPreservesAll();
43 }
44
45 bool doInitialization(Module &M) override {
46 ShouldRun = M.getNamedMetadata(PseudoProbeDescMetadataName);
47 return false;
48 }
49
50 bool runOnMachineFunction(MachineFunction &MF) override {
51 if (!ShouldRun)
52 return false;
54 bool Changed = false;
55 for (MachineBasicBlock &MBB : MF) {
56 MachineInstr *FirstInstr = nullptr;
57 for (MachineInstr &MI : MBB) {
58 if (!MI.isPseudo())
59 FirstInstr = &MI;
60 if (MI.isCall()) {
61 if (DILocation *DL = MI.getDebugLoc()) {
62 auto Value = DL->getDiscriminator();
64 BuildMI(MBB, MI, DL, TII->get(TargetOpcode::PSEUDO_PROBE))
65 .addImm(getFuncGUID(MF.getFunction().getParent(), DL))
66 .addImm(
68 .addImm(
71 Value));
72 Changed = true;
73 }
74 }
75 }
76 }
77
78 // Walk the block backwards, move PSEUDO_PROBE before the first real
79 // instruction to fix out-of-order probes. There is a problem with probes
80 // as the terminator of the block. During the offline counts processing,
81 // the samples collected on the first physical instruction following a
82 // probe will be counted towards the probe. This logically equals to
83 // treating the instruction next to a probe as if it is from the same
84 // block of the probe. This is accurate most of the time unless the
85 // instruction can be reached from multiple flows, which means it actually
86 // starts a new block. Samples collected on such probes may cause
87 // imprecision with the counts inference algorithm. Fortunately, if
88 // there are still other native instructions preceding the probe we can
89 // use them as a place holder to collect samples for the probe.
90 if (FirstInstr) {
91 auto MII = MBB.rbegin();
92 while (MII != MBB.rend()) {
93 // Skip all pseudo probes followed by a real instruction since they
94 // are not dangling.
95 if (!MII->isPseudo())
96 break;
97 auto Cur = MII++;
98 if (Cur->getOpcode() != TargetOpcode::PSEUDO_PROBE)
99 continue;
100 // Move the dangling probe before FirstInstr.
101 auto *ProbeInstr = &*Cur;
102 MBB.remove(ProbeInstr);
103 MBB.insert(FirstInstr, ProbeInstr);
104 Changed = true;
105 }
106 } else {
107 // Probes not surrounded by any real instructions in the same block are
108 // called dangling probes. Since there's no good way to pick up a sample
109 // collection point for dangling probes at compile time, they are being
110 // removed so that the profile correlation tool will not report any
111 // samples collected for them and it's up to the counts inference tool
112 // to get them a reasonable count.
114 for (MachineInstr &MI : MBB) {
115 if (MI.isPseudoProbe())
116 ToBeRemoved.push_back(&MI);
117 }
118
119 for (auto *MI : ToBeRemoved)
120 MI->eraseFromParent();
121
122 Changed |= !ToBeRemoved.empty();
123 }
124 }
125
126 return Changed;
127 }
128
129private:
130 uint64_t getFuncGUID(Module *M, DILocation *DL) {
131 auto *SP = DL->getScope()->getSubprogram();
132 auto Name = SP->getLinkageName();
133 if (Name.empty())
134 Name = SP->getName();
135 return Function::getGUID(Name);
136 }
137
138 bool ShouldRun = false;
139};
140} // namespace
141
142char PseudoProbeInserter::ID = 0;
144 "Insert pseudo probe annotations for value profiling",
145 false, false)
147INITIALIZE_PASS_END(PseudoProbeInserter, DEBUG_TYPE,
148 "Insert pseudo probe annotations for value profiling",
150
152 return new PseudoProbeInserter();
153}
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
for(auto &MBB :MF)
Given that RA is a live value
std::string Name
const HexagonInstrInfo * TII
IRTranslator LLVM IR MI
Module.h This file contains the declarations for the Module class.
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:55
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:59
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:52
Insert pseudo probe annotations for value profiling
#define DEBUG_TYPE
riscv prera expand pseudo
Represent the analysis usage information of a pass.
void setPreservesAll()
Set by analyses that do not transform their input at all.
Debug location.
static bool isPseudoProbeDiscriminator(unsigned Discriminator)
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:308
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:591
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:652
reverse_iterator rend()
instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
MachineInstr * remove(MachineInstr *I)
Remove the unbundled instruction from the instruction list without deleting it.
reverse_iterator rbegin()
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
bool doInitialization(Module &) override
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
virtual bool runOnMachineFunction(MachineFunction &MF)=0
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Function & getFunction()
Return the LLVM function that this machine code represents.
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
Representation of each machine instruction.
Definition: MachineInstr.h:68
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:81
bool empty() const
Definition: SmallVector.h:94
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
TargetInstrInfo - Interface to description of machine instruction set.
Target-Independent Code Generator Pass Configuration Options.
virtual const TargetInstrInfo * getInstrInfo() const
LLVM Value Representation.
Definition: Value.h:74
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
FunctionPass * createPseudoProbeInserter()
This pass inserts pseudo probe annotation for callsite profiling.
void initializePseudoProbeInserterPass(PassRegistry &)
constexpr const char * PseudoProbeDescMetadataName
Definition: PseudoProbe.h:25
static uint32_t extractProbeIndex(uint32_t Value)
Definition: PseudoProbe.h:60
static uint32_t extractProbeAttributes(uint32_t Value)
Definition: PseudoProbe.h:68
static uint32_t extractProbeType(uint32_t Value)
Definition: PseudoProbe.h:64