LLVM 19.0.0git
Go to the documentation of this file.
1//===-- StackMapLivenessAnalysis.cpp - StackMap live Out Analysis ----------===//
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
9// This file implements the StackMap Liveness analysis pass. The pass calculates
10// the liveness for each basic block in a function and attaches the register
11// live-out information to a stackmap or patchpoint intrinsic if present.
15#include "llvm/ADT/Statistic.h"
22#include "llvm/Pass.h"
24#include "llvm/Support/Debug.h"
27using namespace llvm;
29#define DEBUG_TYPE "stackmaps"
32 "enable-patchpoint-liveness", cl::Hidden, cl::init(true),
33 cl::desc("Enable PatchPoint Liveness Analysis Pass"));
35STATISTIC(NumStackMapFuncVisited, "Number of functions visited");
36STATISTIC(NumStackMapFuncSkipped, "Number of functions skipped");
37STATISTIC(NumBBsVisited, "Number of basic blocks visited");
38STATISTIC(NumBBsHaveNoStackmap, "Number of basic blocks with no stackmap");
39STATISTIC(NumStackMaps, "Number of StackMaps visited");
41namespace {
42/// This pass calculates the liveness information for each basic block in
43/// a function and attaches the register live-out information to a patchpoint
44/// intrinsic if present.
46/// This pass can be disabled via the -enable-patchpoint-liveness=false flag.
47/// The pass skips functions that don't have any patchpoint intrinsics. The
48/// information provided by this pass is optional and not required by the
49/// aformentioned intrinsic to function.
50class StackMapLiveness : public MachineFunctionPass {
51 const TargetRegisterInfo *TRI = nullptr;
52 LivePhysRegs LiveRegs;
55 static char ID;
57 /// Default construct and initialize the pass.
58 StackMapLiveness();
60 /// Tell the pass manager which passes we depend on and what
61 /// information we preserve.
62 void getAnalysisUsage(AnalysisUsage &AU) const override;
66 MachineFunctionProperties::Property::NoVRegs);
67 }
69 /// Calculate the liveness information for the given machine function.
70 bool runOnMachineFunction(MachineFunction &MF) override;
73 /// Performs the actual liveness calculation for the function.
74 bool calculateLiveness(MachineFunction &MF);
76 /// Add the current register live set to the instruction.
77 void addLiveOutSetToMI(MachineFunction &MF, MachineInstr &MI);
79 /// Create a register mask and initialize it with the registers from
80 /// the register live set.
81 uint32_t *createRegisterMask(MachineFunction &MF) const;
83} // namespace
85char StackMapLiveness::ID = 0;
86char &llvm::StackMapLivenessID = StackMapLiveness::ID;
87INITIALIZE_PASS(StackMapLiveness, "stackmap-liveness",
88 "StackMap Liveness Analysis", false, false)
90/// Default construct and initialize the pass.
91StackMapLiveness::StackMapLiveness() : MachineFunctionPass(ID) {
95/// Tell the pass manager which passes we depend on and what information we
96/// preserve.
97void StackMapLiveness::getAnalysisUsage(AnalysisUsage &AU) const {
98 // We preserve all information.
99 AU.setPreservesAll();
100 AU.setPreservesCFG();
104/// Calculate the liveness information for the given machine function.
105bool StackMapLiveness::runOnMachineFunction(MachineFunction &MF) {
107 return false;
110 << MF.getName() << " **********\n");
112 ++NumStackMapFuncVisited;
114 // Skip this function if there are no patchpoints to process.
115 if (!MF.getFrameInfo().hasPatchPoint()) {
116 ++NumStackMapFuncSkipped;
117 return false;
118 }
119 return calculateLiveness(MF);
122/// Performs the actual liveness calculation for the function.
123bool StackMapLiveness::calculateLiveness(MachineFunction &MF) {
124 bool HasChanged = false;
125 // For all basic blocks in the function.
126 for (auto &MBB : MF) {
127 LLVM_DEBUG(dbgs() << "****** BB " << MBB.getName() << " ******\n");
128 LiveRegs.init(*TRI);
129 LiveRegs.addLiveOuts(MBB);
130 bool HasStackMap = false;
131 // Reverse iterate over all instructions and add the current live register
132 // set to an instruction if we encounter a patchpoint instruction.
133 for (MachineInstr &MI : llvm::reverse(MBB)) {
134 if (MI.getOpcode() == TargetOpcode::PATCHPOINT) {
135 addLiveOutSetToMI(MF, MI);
136 HasChanged = true;
137 HasStackMap = true;
138 ++NumStackMaps;
139 }
140 LLVM_DEBUG(dbgs() << " " << LiveRegs << " " << MI);
141 LiveRegs.stepBackward(MI);
142 }
143 ++NumBBsVisited;
144 if (!HasStackMap)
145 ++NumBBsHaveNoStackmap;
146 }
147 return HasChanged;
150/// Add the current register live set to the instruction.
151void StackMapLiveness::addLiveOutSetToMI(MachineFunction &MF,
152 MachineInstr &MI) {
153 uint32_t *Mask = createRegisterMask(MF);
155 MI.addOperand(MF, MO);
158/// Create a register mask and initialize it with the registers from the
159/// register live set.
160uint32_t *StackMapLiveness::createRegisterMask(MachineFunction &MF) const {
161 // The mask is owned and cleaned up by the Machine Function.
163 for (auto Reg : LiveRegs)
164 Mask[Reg / 32] |= 1U << (Reg % 32);
166 // Give the target a chance to adjust the mask.
167 TRI->adjustStackMapLiveOutMask(Mask);
169 return Mask;
MachineBasicBlock & MBB
#define LLVM_DEBUG(X)
Definition: Debug.h:101
IRTranslator LLVM IR MI
This file implements the LivePhysRegs utility for tracking liveness of physical registers.
unsigned const TargetRegisterInfo * TRI
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:38
static cl::opt< bool > EnablePatchPointLiveness("enable-patchpoint-liveness", cl::Hidden, cl::init(true), cl::desc("Enable PatchPoint Liveness Analysis Pass"))
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
Definition: Statistic.h:167
Represent the analysis usage information of a pass.
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:269
void setPreservesAll()
Set by analyses that do not transform their input at all.
A set of physical registers with utility functions to track liveness when walking backward/forward th...
Definition: LivePhysRegs.h:52
StringRef getName() const
Return the name of the corresponding LLVM basic block, or an empty string.
bool hasPatchPoint() const
This method may be called any time after instruction selection is complete to determine if there is a...
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
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...
virtual MachineFunctionProperties getRequiredProperties() const
Properties which a MachineFunction may have at a given point in time.
MachineFunctionProperties & set(Property P)
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
uint32_t * allocateRegMask()
Allocate and initialize a register mask with NumRegister bits.
Representation of each machine instruction.
Definition: MachineInstr.h:69
MachineOperand class - Representation of each machine instruction operand.
static MachineOperand CreateRegLiveOut(const uint32_t *Mask)
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:121
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
All possible values of the reg field in the ModR/M byte.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:450
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void initializeStackMapLivenessPass(PassRegistry &)
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:419
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
char & StackMapLivenessID
StackMapLiveness - This pass analyses the register live-out set of stackmap/patchpoint intrinsics and...