LLVM  13.0.0git
MIRCanonicalizerPass.cpp
Go to the documentation of this file.
1 //===-------------- MIRCanonicalizer.cpp - MIR Canonicalizer --------------===//
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 // The purpose of this pass is to employ a canonical code transformation so
10 // that code compiled with slightly different IR passes can be diffed more
11 // effectively than otherwise. This is done by renaming vregs in a given
12 // LiveRange in a canonical way. This pass also does a pseudo-scheduling to
13 // move defs closer to their use inorder to reduce diffs caused by slightly
14 // different schedules.
15 //
16 // Basic Usage:
17 //
18 // llc -o - -run-pass mir-canonicalizer example.mir
19 //
20 // Reorders instructions canonically.
21 // Renames virtual register operands canonically.
22 // Strips certain MIR artifacts (optionally).
23 //
24 //===----------------------------------------------------------------------===//
25 
26 #include "MIRVRegNamerUtils.h"
28 #include "llvm/ADT/STLExtras.h"
32 #include "llvm/CodeGen/Passes.h"
33 #include "llvm/InitializePasses.h"
34 #include "llvm/Support/Debug.h"
36 
37 #include <queue>
38 
39 using namespace llvm;
40 
41 namespace llvm {
42 extern char &MIRCanonicalizerID;
43 } // namespace llvm
44 
45 #define DEBUG_TYPE "mir-canonicalizer"
46 
47 static cl::opt<unsigned>
48  CanonicalizeFunctionNumber("canon-nth-function", cl::Hidden, cl::init(~0u),
49  cl::value_desc("N"),
50  cl::desc("Function number to canonicalize."));
51 
52 namespace {
53 
54 class MIRCanonicalizer : public MachineFunctionPass {
55 public:
56  static char ID;
57  MIRCanonicalizer() : MachineFunctionPass(ID) {}
58 
59  StringRef getPassName() const override {
60  return "Rename register operands in a canonical ordering.";
61  }
62 
63  void getAnalysisUsage(AnalysisUsage &AU) const override {
64  AU.setPreservesCFG();
66  }
67 
68  bool runOnMachineFunction(MachineFunction &MF) override;
69 };
70 
71 } // end anonymous namespace
72 
74 
76 
77 INITIALIZE_PASS_BEGIN(MIRCanonicalizer, "mir-canonicalizer",
78  "Rename Register Operands Canonically", false, false)
79 
80 INITIALIZE_PASS_END(MIRCanonicalizer, "mir-canonicalizer",
82 
84  if (MF.empty())
85  return {};
87  std::vector<MachineBasicBlock *> RPOList;
88  append_range(RPOList, RPOT);
89 
90  return RPOList;
91 }
92 
93 static bool
94 rescheduleLexographically(std::vector<MachineInstr *> instructions,
97 
98  bool Changed = false;
99  using StringInstrPair = std::pair<std::string, MachineInstr *>;
100  std::vector<StringInstrPair> StringInstrMap;
101 
102  for (auto *II : instructions) {
103  std::string S;
104  raw_string_ostream OS(S);
105  II->print(OS);
106  OS.flush();
107 
108  // Trim the assignment, or start from the beginning in the case of a store.
109  const size_t i = S.find('=');
110  StringInstrMap.push_back({(i == std::string::npos) ? S : S.substr(i), II});
111  }
112 
113  llvm::sort(StringInstrMap,
114  [](const StringInstrPair &a, const StringInstrPair &b) -> bool {
115  return (a.first < b.first);
116  });
117 
118  for (auto &II : StringInstrMap) {
119 
120  LLVM_DEBUG({
121  dbgs() << "Splicing ";
122  II.second->dump();
123  dbgs() << " right before: ";
124  getPos()->dump();
125  });
126 
127  Changed = true;
128  MBB->splice(getPos(), MBB, II.second);
129  }
130 
131  return Changed;
132 }
133 
134 static bool rescheduleCanonically(unsigned &PseudoIdempotentInstCount,
136 
137  bool Changed = false;
138 
139  // Calculates the distance of MI from the beginning of its parent BB.
140  auto getInstrIdx = [](const MachineInstr &MI) {
141  unsigned i = 0;
142  for (auto &CurMI : *MI.getParent()) {
143  if (&CurMI == &MI)
144  return i;
145  i++;
146  }
147  return ~0U;
148  };
149 
150  // Pre-Populate vector of instructions to reschedule so that we don't
151  // clobber the iterator.
152  std::vector<MachineInstr *> Instructions;
153  for (auto &MI : *MBB) {
154  Instructions.push_back(&MI);
155  }
156 
157  std::map<MachineInstr *, std::vector<MachineInstr *>> MultiUsers;
158  std::map<unsigned, MachineInstr *> MultiUserLookup;
159  unsigned UseToBringDefCloserToCount = 0;
160  std::vector<MachineInstr *> PseudoIdempotentInstructions;
161  std::vector<unsigned> PhysRegDefs;
162  for (auto *II : Instructions) {
163  for (unsigned i = 1; i < II->getNumOperands(); i++) {
164  MachineOperand &MO = II->getOperand(i);
165  if (!MO.isReg())
166  continue;
167 
169  continue;
170 
171  if (!MO.isDef())
172  continue;
173 
174  PhysRegDefs.push_back(MO.getReg());
175  }
176  }
177 
178  for (auto *II : Instructions) {
179  if (II->getNumOperands() == 0)
180  continue;
181  if (II->mayLoadOrStore())
182  continue;
183 
184  MachineOperand &MO = II->getOperand(0);
185  if (!MO.isReg() || !Register::isVirtualRegister(MO.getReg()))
186  continue;
187  if (!MO.isDef())
188  continue;
189 
190  bool IsPseudoIdempotent = true;
191  for (unsigned i = 1; i < II->getNumOperands(); i++) {
192 
193  if (II->getOperand(i).isImm()) {
194  continue;
195  }
196 
197  if (II->getOperand(i).isReg()) {
198  if (!Register::isVirtualRegister(II->getOperand(i).getReg()))
199  if (!llvm::is_contained(PhysRegDefs, II->getOperand(i).getReg())) {
200  continue;
201  }
202  }
203 
204  IsPseudoIdempotent = false;
205  break;
206  }
207 
208  if (IsPseudoIdempotent) {
209  PseudoIdempotentInstructions.push_back(II);
210  continue;
211  }
212 
213  LLVM_DEBUG(dbgs() << "Operand " << 0 << " of "; II->dump(); MO.dump(););
214 
215  MachineInstr *Def = II;
216  unsigned Distance = ~0U;
217  MachineInstr *UseToBringDefCloserTo = nullptr;
219  for (auto &UO : MRI->use_nodbg_operands(MO.getReg())) {
220  MachineInstr *UseInst = UO.getParent();
221 
222  const unsigned DefLoc = getInstrIdx(*Def);
223  const unsigned UseLoc = getInstrIdx(*UseInst);
224  const unsigned Delta = (UseLoc - DefLoc);
225 
226  if (UseInst->getParent() != Def->getParent())
227  continue;
228  if (DefLoc >= UseLoc)
229  continue;
230 
231  if (Delta < Distance) {
232  Distance = Delta;
233  UseToBringDefCloserTo = UseInst;
234  MultiUserLookup[UseToBringDefCloserToCount++] = UseToBringDefCloserTo;
235  }
236  }
237 
238  const auto BBE = MBB->instr_end();
239  MachineBasicBlock::iterator DefI = BBE;
240  MachineBasicBlock::iterator UseI = BBE;
241 
242  for (auto BBI = MBB->instr_begin(); BBI != BBE; ++BBI) {
243 
244  if (DefI != BBE && UseI != BBE)
245  break;
246 
247  if (&*BBI == Def) {
248  DefI = BBI;
249  continue;
250  }
251 
252  if (&*BBI == UseToBringDefCloserTo) {
253  UseI = BBI;
254  continue;
255  }
256  }
257 
258  if (DefI == BBE || UseI == BBE)
259  continue;
260 
261  LLVM_DEBUG({
262  dbgs() << "Splicing ";
263  DefI->dump();
264  dbgs() << " right before: ";
265  UseI->dump();
266  });
267 
268  MultiUsers[UseToBringDefCloserTo].push_back(Def);
269  Changed = true;
270  MBB->splice(UseI, MBB, DefI);
271  }
272 
273  // Sort the defs for users of multiple defs lexographically.
274  for (const auto &E : MultiUserLookup) {
275 
276  auto UseI = llvm::find_if(MBB->instrs(), [&](MachineInstr &MI) -> bool {
277  return &MI == E.second;
278  });
279 
280  if (UseI == MBB->instr_end())
281  continue;
282 
283  LLVM_DEBUG(
284  dbgs() << "Rescheduling Multi-Use Instructions Lexographically.";);
285  Changed |= rescheduleLexographically(
286  MultiUsers[E.second], MBB,
287  [&]() -> MachineBasicBlock::iterator { return UseI; });
288  }
289 
290  PseudoIdempotentInstCount = PseudoIdempotentInstructions.size();
291  LLVM_DEBUG(
292  dbgs() << "Rescheduling Idempotent Instructions Lexographically.";);
293  Changed |= rescheduleLexographically(
294  PseudoIdempotentInstructions, MBB,
295  [&]() -> MachineBasicBlock::iterator { return MBB->begin(); });
296 
297  return Changed;
298 }
299 
301  bool Changed = false;
303 
304  std::vector<MachineInstr *> Copies;
305  for (MachineInstr &MI : MBB->instrs()) {
306  if (MI.isCopy())
307  Copies.push_back(&MI);
308  }
309 
310  for (MachineInstr *MI : Copies) {
311 
312  if (!MI->getOperand(0).isReg())
313  continue;
314  if (!MI->getOperand(1).isReg())
315  continue;
316 
317  const Register Dst = MI->getOperand(0).getReg();
318  const Register Src = MI->getOperand(1).getReg();
319 
320  if (!Register::isVirtualRegister(Dst))
321  continue;
322  if (!Register::isVirtualRegister(Src))
323  continue;
324  // Not folding COPY instructions if regbankselect has not set the RCs.
325  // Why are we only considering Register Classes? Because the verifier
326  // sometimes gets upset if the register classes don't match even if the
327  // types do. A future patch might add COPY folding for matching types in
328  // pre-registerbankselect code.
329  if (!MRI.getRegClassOrNull(Dst))
330  continue;
331  if (MRI.getRegClass(Dst) != MRI.getRegClass(Src))
332  continue;
333 
334  std::vector<MachineOperand *> Uses;
335  for (auto UI = MRI.use_begin(Dst); UI != MRI.use_end(); ++UI)
336  Uses.push_back(&*UI);
337  for (auto *MO : Uses)
338  MO->setReg(Src);
339 
340  Changed = true;
341  MI->eraseFromParent();
342  }
343 
344  return Changed;
345 }
346 
348  bool Changed = false;
349 
350  for (auto &MI : *MBB) {
351  for (auto &MO : MI.operands()) {
352  if (!MO.isReg())
353  continue;
354  if (!MO.isDef() && MO.isKill()) {
355  Changed = true;
356  MO.setIsKill(false);
357  }
358 
359  if (MO.isDef() && MO.isDead()) {
360  Changed = true;
361  MO.setIsDead(false);
362  }
363  }
364  }
365 
366  return Changed;
367 }
368 
370  unsigned BasicBlockNum, VRegRenamer &Renamer) {
371  LLVM_DEBUG({
372  dbgs() << "\n\n NEW BASIC BLOCK: " << MBB->getName() << " \n\n";
373  dbgs() << "\n\n================================================\n\n";
374  });
375 
376  bool Changed = false;
377 
378  LLVM_DEBUG(dbgs() << "\n\n NEW BASIC BLOCK: " << MBB->getName() << "\n\n";);
379 
380  LLVM_DEBUG(dbgs() << "MBB Before Canonical Copy Propagation:\n";
381  MBB->dump(););
382  Changed |= propagateLocalCopies(MBB);
383  LLVM_DEBUG(dbgs() << "MBB After Canonical Copy Propagation:\n"; MBB->dump(););
384 
385  LLVM_DEBUG(dbgs() << "MBB Before Scheduling:\n"; MBB->dump(););
386  unsigned IdempotentInstCount = 0;
387  Changed |= rescheduleCanonically(IdempotentInstCount, MBB);
388  LLVM_DEBUG(dbgs() << "MBB After Scheduling:\n"; MBB->dump(););
389 
390  Changed |= Renamer.renameVRegs(MBB, BasicBlockNum);
391 
392  // TODO: Consider dropping this. Dropping kill defs is probably not
393  // semantically sound.
394  Changed |= doDefKillClear(MBB);
395 
396  LLVM_DEBUG(dbgs() << "Updated MachineBasicBlock:\n"; MBB->dump();
397  dbgs() << "\n";);
398  LLVM_DEBUG(
399  dbgs() << "\n\n================================================\n\n");
400  return Changed;
401 }
402 
403 bool MIRCanonicalizer::runOnMachineFunction(MachineFunction &MF) {
404 
405  static unsigned functionNum = 0;
406  if (CanonicalizeFunctionNumber != ~0U) {
407  if (CanonicalizeFunctionNumber != functionNum++)
408  return false;
409  LLVM_DEBUG(dbgs() << "\n Canonicalizing Function " << MF.getName()
410  << "\n";);
411  }
412 
413  // we need a valid vreg to create a vreg type for skipping all those
414  // stray vreg numbers so reach alignment/canonical vreg values.
415  std::vector<MachineBasicBlock *> RPOList = GetRPOList(MF);
416 
417  LLVM_DEBUG(
418  dbgs() << "\n\n NEW MACHINE FUNCTION: " << MF.getName() << " \n\n";
419  dbgs() << "\n\n================================================\n\n";
420  dbgs() << "Total Basic Blocks: " << RPOList.size() << "\n";
421  for (auto MBB
422  : RPOList) { dbgs() << MBB->getName() << "\n"; } dbgs()
423  << "\n\n================================================\n\n";);
424 
425  unsigned BBNum = 0;
426  bool Changed = false;
428  VRegRenamer Renamer(MRI);
429  for (auto MBB : RPOList)
430  Changed |= runOnBasicBlock(MBB, BBNum++, Renamer);
431 
432  return Changed;
433 }
i
i
Definition: README.txt:29
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:100
llvm
Definition: AllocatorList.h:23
llvm::tgtok::Def
@ Def
Definition: TGLexer.h:50
runOnBasicBlock
static bool runOnBasicBlock(MachineBasicBlock *MBB, unsigned BasicBlockNum, VRegRenamer &Renamer)
Definition: MIRCanonicalizerPass.cpp:369
llvm::MachineRegisterInfo
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Definition: MachineRegisterInfo.h:52
llvm::MachineBasicBlock::instrs
instr_range instrs()
Definition: MachineBasicBlock.h:263
canonicalizer
mir canonicalizer
Definition: MIRCanonicalizerPass.cpp:80
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:614
MIRVRegNamerUtils.h
propagateLocalCopies
static bool propagateLocalCopies(MachineBasicBlock *MBB)
Definition: MIRCanonicalizerPass.cpp:300
llvm::MachineFunctionPass
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Definition: MachineFunctionPass.h:30
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:140
Canonically
mir Rename Register Operands Canonically
Definition: MIRCanonicalizerPass.cpp:81
rescheduleCanonically
static bool rescheduleCanonically(unsigned &PseudoIdempotentInstCount, MachineBasicBlock *MBB)
Definition: MIRCanonicalizerPass.cpp:134
Instructions
Code Generation Notes for reduce the size of the ISel and reduce repetition in the implementation In a small number of this can cause even when no optimisation has taken place Instructions
Definition: MSA.txt:11
STLExtras.h
llvm::MachineOperand::dump
void dump() const
Definition: MachineOperand.cpp:961
INITIALIZE_PASS_END
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
Definition: RegBankSelect.cpp:69
llvm::MachineFunctionPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
Definition: MachineFunctionPass.cpp:102
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:122
llvm::MIRCanonicalizerID
char & MIRCanonicalizerID
MIRCanonicalizer - This pass canonicalizes MIR by renaming vregs according to the semantics of the in...
Definition: MIRCanonicalizerPass.cpp:42
MachineRegisterInfo.h
Uses
SmallPtrSet< MachineInstr *, 2 > Uses
Definition: ARMLowOverheadLoops.cpp:583
a
=0.0 ? 0.0 :(a > 0.0 ? 1.0 :-1.0) a
Definition: README.txt:489
llvm::MachineBasicBlock::dump
void dump() const
Definition: MachineBasicBlock.cpp:292
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
llvm::MachineFunction::getRegInfo
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Definition: MachineFunction.h:565
llvm::MachineRegisterInfo::use_nodbg_operands
iterator_range< use_nodbg_iterator > use_nodbg_operands(Register Reg) const
Definition: MachineRegisterInfo.h:526
llvm::VRegRenamer::renameVRegs
bool renameVRegs(MachineBasicBlock *MBB, unsigned BBNum)
Same as the above, but sets a BBNum depending on BB traversal that will be used as prefix for the vre...
Definition: MIRVRegNamerUtils.h:89
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
b
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int b
Definition: README.txt:418
false
Definition: StackSlotColoring.cpp:142
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:49
llvm::raw_ostream::flush
void flush()
Definition: raw_ostream.h:183
Copies
SI Lower i1 Copies
Definition: SILowerI1Copies.cpp:406
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
Operands
mir Rename Register Operands
Definition: MIRNamerPass.cpp:78
llvm::MachineRegisterInfo::getRegClass
const TargetRegisterClass * getRegClass(Register Reg) const
Return the register class of the specified virtual register.
Definition: MachineRegisterInfo.h:634
Passes.h
llvm::cl::opt
Definition: CommandLine.h:1419
llvm::instructions
inst_range instructions(Function *F)
Definition: InstIterator.h:133
llvm::MachineOperand::isReg
bool isReg() const
isReg - Tests if this is a MO_Register operand.
Definition: MachineOperand.h:318
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:440
llvm::is_contained
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1570
MachineFunctionPass.h
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(MIRCanonicalizer, "mir-canonicalizer", "Rename Register Operands Canonically", false, false) INITIALIZE_PASS_END(MIRCanonicalizer
llvm::Register::isVirtualRegister
static bool isVirtualRegister(unsigned Reg)
Return true if the specified register number is in the virtual register namespace.
Definition: Register.h:71
llvm::MachineRegisterInfo::getRegClassOrNull
const TargetRegisterClass * getRegClassOrNull(Register Reg) const
Return the register class of Reg, or null if Reg has not been assigned a register class yet.
Definition: MachineRegisterInfo.h:651
llvm::MachineFunction::getName
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
Definition: MachineFunction.cpp:522
llvm::MachineBasicBlock::getParent
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
Definition: MachineBasicBlock.h:225
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:83
llvm::MachineOperand::getReg
Register getReg() const
getReg - Returns the register number.
Definition: MachineOperand.h:357
llvm::MachineBasicBlock::instr_begin
instr_iterator instr_begin()
Definition: MachineBasicBlock.h:252
llvm::MachineBasicBlock::instr_end
instr_iterator instr_end()
Definition: MachineBasicBlock.h:254
llvm::MachineFunction
Definition: MachineFunction.h:227
llvm::AnalysisUsage::setPreservesCFG
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:253
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::MachineBasicBlock::splice
void splice(iterator Where, MachineBasicBlock *Other, iterator From)
Take an instruction from MBB 'Other' at the position From, and insert it into this MBB right before '...
Definition: MachineBasicBlock.h:859
llvm::MachineRegisterInfo::use_begin
use_iterator use_begin(Register RegNo) const
Definition: MachineRegisterInfo.h:464
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1690
rescheduleLexographically
static bool rescheduleLexographically(std::vector< MachineInstr * > instructions, MachineBasicBlock *MBB, std::function< MachineBasicBlock::iterator()> getPos)
Definition: MIRCanonicalizerPass.cpp:94
llvm::MachineOperand::isDef
bool isDef() const
Definition: MachineOperand.h:372
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::MachineInstr::getParent
const MachineBasicBlock * getParent() const
Definition: MachineInstr.h:286
MRI
unsigned const MachineRegisterInfo * MRI
Definition: AArch64AdvSIMDScalarPass.cpp:105
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::find_if
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1532
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
std
Definition: BitVector.h:838
doDefKillClear
static bool doDefKillClear(MachineBasicBlock *MBB)
Definition: MIRCanonicalizerPass.cpp:347
GetRPOList
mir Rename Register Operands static false std::vector< MachineBasicBlock * > GetRPOList(MachineFunction &MF)
Definition: MIRCanonicalizerPass.cpp:83
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1446
llvm::VRegRenamer
VRegRenamer - This class is used for renaming vregs in a machine basic block according to semantics o...
Definition: MIRVRegNamerUtils.h:34
llvm::cl::value_desc
Definition: CommandLine.h:421
llvm::ReversePostOrderTraversal
Definition: PostOrderIterator.h:290
llvm::MachineRegisterInfo::use_end
static use_iterator use_end()
Definition: MachineRegisterInfo.h:467
PostOrderIterator.h
llvm::MachineBasicBlock::begin
iterator begin()
Definition: MachineBasicBlock.h:268
MachineInstrBuilder.h
llvm::cl::desc
Definition: CommandLine.h:411
raw_ostream.h
llvm::MachineInstrBundleIterator< MachineInstr >
InitializePasses.h
llvm::MachineBasicBlock::getName
StringRef getName() const
Return the name of the corresponding LLVM basic block, or an empty string.
Definition: MachineBasicBlock.cpp:311
Debug.h
CanonicalizeFunctionNumber
static cl::opt< unsigned > CanonicalizeFunctionNumber("canon-nth-function", cl::Hidden, cl::init(~0u), cl::value_desc("N"), cl::desc("Function number to canonicalize."))
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38