LLVM  8.0.0svn
RegisterUsageInfo.cpp
Go to the documentation of this file.
1 //===- RegisterUsageInfo.cpp - Register Usage Information Storage ---------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// This pass is required to take advantage of the interprocedural register
11 /// allocation infrastructure.
12 ///
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/IR/Function.h"
21 #include "llvm/IR/Module.h"
22 #include "llvm/Pass.h"
26 #include <algorithm>
27 #include <cassert>
28 #include <cstdint>
29 #include <utility>
30 #include <vector>
31 
32 using namespace llvm;
33 
35  "print-regusage", cl::init(false), cl::Hidden,
36  cl::desc("print register usage details collected for analysis."));
37 
39  "Register Usage Information Storage", false, true)
40 
42 
43 void PhysicalRegisterUsageInfo::setTargetMachine(const LLVMTargetMachine &TM) {
44  this->TM = &TM;
45 }
46 
48  RegMasks.grow(M.size());
49  return false;
50 }
51 
53  if (DumpRegUsage)
54  print(errs());
55 
56  RegMasks.shrink_and_clear();
57  return false;
58 }
59 
61  const Function &FP, ArrayRef<uint32_t> RegMask) {
62  RegMasks[&FP] = RegMask;
63 }
64 
67  auto It = RegMasks.find(&FP);
68  if (It != RegMasks.end())
69  return makeArrayRef<uint32_t>(It->second);
70  return ArrayRef<uint32_t>();
71 }
72 
74  using FuncPtrRegMaskPair = std::pair<const Function *, std::vector<uint32_t>>;
75 
77 
78  // Create a vector of pointer to RegMasks entries
79  for (const auto &RegMask : RegMasks)
80  FPRMPairVector.push_back(&RegMask);
81 
82  // sort the vector to print analysis in alphabatic order of function name.
83  llvm::sort(
84  FPRMPairVector,
85  [](const FuncPtrRegMaskPair *A, const FuncPtrRegMaskPair *B) -> bool {
86  return A->first->getName() < B->first->getName();
87  });
88 
89  for (const FuncPtrRegMaskPair *FPRMPair : FPRMPairVector) {
90  OS << FPRMPair->first->getName() << " "
91  << "Clobbered Registers: ";
92  const TargetRegisterInfo *TRI
93  = TM->getSubtarget<TargetSubtargetInfo>(*(FPRMPair->first))
94  .getRegisterInfo();
95 
96  for (unsigned PReg = 1, PRegE = TRI->getNumRegs(); PReg < PRegE; ++PReg) {
97  if (MachineOperand::clobbersPhysReg(&(FPRMPair->second[0]), PReg))
98  OS << printReg(PReg, TRI) << " ";
99  }
100  OS << "\n";
101  }
102 }
ArrayRef< uint32_t > getRegUsageInfo(const Function &FP)
To query stored RegMask for given Function *, it will returns ane empty array if function is not know...
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
This class represents lattice values for constants.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
void print(raw_ostream &OS, const Module *M=nullptr) const override
print - Print out the internal state of the pass.
bool doInitialization(Module &M) override
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
unsigned const TargetRegisterInfo * TRI
Printable printReg(unsigned Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)
Prints virtual and physical registers with or without a TRI instance.
static cl::opt< bool > DumpRegUsage("print-regusage", cl::init(false), cl::Hidden, cl::desc("print register usage details collected for analysis."))
void storeUpdateRegUsageInfo(const Function &FP, ArrayRef< uint32_t > RegMask)
To store RegMask for given Function *.
unsigned getNumRegs() const
Return the number of registers this target has (useful for sizing arrays holding per register informa...
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:419
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This class describes a target machine that is implemented with the LLVM target-independent code gener...
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:34
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1110
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
Module.h This file contains the declarations for the Module class.
static bool clobbersPhysReg(const uint32_t *RegMask, unsigned PhysReg)
clobbersPhysReg - Returns true if this RegMask clobbers PhysReg.
TargetSubtargetInfo - Generic base class for all target subtargets.
size_t size() const
Definition: Module.h:593
This pass is required to take advantage of the interprocedural register allocation infrastructure...
aarch64 promote const
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
const STC & getSubtarget(const Function &F) const
This method returns a pointer to the specified type of TargetSubtargetInfo.