LLVM  13.0.0git
BasicBlockSections.cpp
Go to the documentation of this file.
1 //===-- BasicBlockSections.cpp ---=========--------------------------------===//
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 // BasicBlockSections implementation.
10 //
11 // The purpose of this pass is to assign sections to basic blocks when
12 // -fbasic-block-sections= option is used. Further, with profile information
13 // only the subset of basic blocks with profiles are placed in separate sections
14 // and the rest are grouped in a cold section. The exception handling blocks are
15 // treated specially to ensure they are all in one seciton.
16 //
17 // Basic Block Sections
18 // ====================
19 //
20 // With option, -fbasic-block-sections=list, every function may be split into
21 // clusters of basic blocks. Every cluster will be emitted into a separate
22 // section with its basic blocks sequenced in the given order. To get the
23 // optimized performance, the clusters must form an optimal BB layout for the
24 // function. Every cluster's section is labeled with a symbol to allow the
25 // linker to reorder the sections in any arbitrary sequence. A global order of
26 // these sections would encapsulate the function layout.
27 //
28 // There are a couple of challenges to be addressed:
29 //
30 // 1. The last basic block of every cluster should not have any implicit
31 // fallthrough to its next basic block, as it can be reordered by the linker.
32 // The compiler should make these fallthroughs explicit by adding
33 // unconditional jumps..
34 //
35 // 2. All inter-cluster branch targets would now need to be resolved by the
36 // linker as they cannot be calculated during compile time. This is done
37 // using static relocations. Further, the compiler tries to use short branch
38 // instructions on some ISAs for small branch offsets. This is not possible
39 // for inter-cluster branches as the offset is not determined at compile
40 // time, and therefore, long branch instructions have to be used for those.
41 //
42 // 3. Debug Information (DebugInfo) and Call Frame Information (CFI) emission
43 // needs special handling with basic block sections. DebugInfo needs to be
44 // emitted with more relocations as basic block sections can break a
45 // function into potentially several disjoint pieces, and CFI needs to be
46 // emitted per cluster. This also bloats the object file and binary sizes.
47 //
48 // Basic Block Labels
49 // ==================
50 //
51 // With -fbasic-block-sections=labels, we emit the offsets of BB addresses of
52 // every function into the .llvm_bb_addr_map section. Along with the function
53 // symbols, this allows for mapping of virtual addresses in PMU profiles back to
54 // the corresponding basic blocks. This logic is implemented in AsmPrinter. This
55 // pass only assigns the BBSectionType of every function to ``labels``.
56 //
57 //===----------------------------------------------------------------------===//
58 
59 #include "llvm/ADT/Optional.h"
60 #include "llvm/ADT/SmallSet.h"
61 #include "llvm/ADT/SmallVector.h"
62 #include "llvm/ADT/StringMap.h"
63 #include "llvm/ADT/StringRef.h"
68 #include "llvm/CodeGen/Passes.h"
70 #include "llvm/InitializePasses.h"
71 #include "llvm/Support/Error.h"
75 
76 using llvm::SmallSet;
77 using llvm::SmallVector;
78 using llvm::StringMap;
79 using llvm::StringRef;
80 using namespace llvm;
81 
82 // Placing the cold clusters in a separate section mitigates against poor
83 // profiles and allows optimizations such as hugepage mapping to be applied at a
84 // section granularity. Defaults to ".text.split." which is recognized by lld
85 // via the `-z keep-text-section-prefix` flag.
87  "bbsections-cold-text-prefix",
88  cl::desc("The text prefix to use for cold basic block clusters"),
89  cl::init(".text.split."), cl::Hidden);
90 
92  "bbsections-detect-source-drift",
93  cl::desc("This checks if there is a fdo instr. profile hash "
94  "mismatch for this function"),
95  cl::init(true), cl::Hidden);
96 
97 namespace {
98 
99 // This struct represents the cluster information for a machine basic block.
100 struct BBClusterInfo {
101  // MachineBasicBlock ID.
102  unsigned MBBNumber;
103  // Cluster ID this basic block belongs to.
104  unsigned ClusterID;
105  // Position of basic block within the cluster.
106  unsigned PositionInCluster;
107 };
108 
109 using ProgramBBClusterInfoMapTy = StringMap<SmallVector<BBClusterInfo, 4>>;
110 
111 class BasicBlockSections : public MachineFunctionPass {
112 public:
113  static char ID;
114 
115  // This contains the basic-block-sections profile.
116  const MemoryBuffer *MBuf = nullptr;
117 
118  // This encapsulates the BB cluster information for the whole program.
119  //
120  // For every function name, it contains the cluster information for (all or
121  // some of) its basic blocks. The cluster information for every basic block
122  // includes its cluster ID along with the position of the basic block in that
123  // cluster.
124  ProgramBBClusterInfoMapTy ProgramBBClusterInfo;
125 
126  // Some functions have alias names. We use this map to find the main alias
127  // name for which we have mapping in ProgramBBClusterInfo.
128  StringMap<StringRef> FuncAliasMap;
129 
130  BasicBlockSections(const MemoryBuffer *Buf)
131  : MachineFunctionPass(ID), MBuf(Buf) {
133  };
134 
135  BasicBlockSections() : MachineFunctionPass(ID) {
137  }
138 
139  StringRef getPassName() const override {
140  return "Basic Block Sections Analysis";
141  }
142 
143  void getAnalysisUsage(AnalysisUsage &AU) const override;
144 
145  /// Read profiles of basic blocks if available here.
146  bool doInitialization(Module &M) override;
147 
148  /// Identify basic blocks that need separate sections and prepare to emit them
149  /// accordingly.
150  bool runOnMachineFunction(MachineFunction &MF) override;
151 };
152 
153 } // end anonymous namespace
154 
155 char BasicBlockSections::ID = 0;
156 INITIALIZE_PASS(BasicBlockSections, "bbsections-prepare",
157  "Prepares for basic block sections, by splitting functions "
158  "into clusters of basic blocks.",
159  false, false)
160 
161 // This function updates and optimizes the branching instructions of every basic
162 // block in a given function to account for changes in the layout.
163 static void updateBranches(
164  MachineFunction &MF,
166  const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
168  for (auto &MBB : MF) {
169  auto NextMBBI = std::next(MBB.getIterator());
170  auto *FTMBB = PreLayoutFallThroughs[MBB.getNumber()];
171  // If this block had a fallthrough before we need an explicit unconditional
172  // branch to that block if either
173  // 1- the block ends a section, which means its next block may be
174  // reorderd by the linker, or
175  // 2- the fallthrough block is not adjacent to the block in the new
176  // order.
177  if (FTMBB && (MBB.isEndSection() || &*NextMBBI != FTMBB))
178  TII->insertUnconditionalBranch(MBB, FTMBB, MBB.findBranchDebugLoc());
179 
180  // We do not optimize branches for machine basic blocks ending sections, as
181  // their adjacent block might be reordered by the linker.
182  if (MBB.isEndSection())
183  continue;
184 
185  // It might be possible to optimize branches by flipping the branch
186  // condition.
187  Cond.clear();
188  MachineBasicBlock *TBB = nullptr, *FBB = nullptr; // For analyzeBranch.
189  if (TII->analyzeBranch(MBB, TBB, FBB, Cond))
190  continue;
191  MBB.updateTerminator(FTMBB);
192  }
193 }
194 
195 // This function provides the BBCluster information associated with a function.
196 // Returns true if a valid association exists and false otherwise.
198  const MachineFunction &MF, const StringMap<StringRef> FuncAliasMap,
199  const ProgramBBClusterInfoMapTy &ProgramBBClusterInfo,
201  // Get the main alias name for the function.
202  auto FuncName = MF.getName();
203  auto R = FuncAliasMap.find(FuncName);
204  StringRef AliasName = R == FuncAliasMap.end() ? FuncName : R->second;
205 
206  // Find the assoicated cluster information.
207  auto P = ProgramBBClusterInfo.find(AliasName);
208  if (P == ProgramBBClusterInfo.end())
209  return false;
210 
211  if (P->second.empty()) {
212  // This indicates that sections are desired for all basic blocks of this
213  // function. We clear the BBClusterInfo vector to denote this.
214  V.clear();
215  return true;
216  }
217 
218  V.resize(MF.getNumBlockIDs());
219  for (auto bbClusterInfo : P->second) {
220  // Bail out if the cluster information contains invalid MBB numbers.
221  if (bbClusterInfo.MBBNumber >= MF.getNumBlockIDs())
222  return false;
223  V[bbClusterInfo.MBBNumber] = bbClusterInfo;
224  }
225  return true;
226 }
227 
228 // This function sorts basic blocks according to the cluster's information.
229 // All explicitly specified clusters of basic blocks will be ordered
230 // accordingly. All non-specified BBs go into a separate "Cold" section.
231 // Additionally, if exception handling landing pads end up in more than one
232 // clusters, they are moved into a single "Exception" section. Eventually,
233 // clusters are ordered in increasing order of their IDs, with the "Exception"
234 // and "Cold" succeeding all other clusters.
235 // FuncBBClusterInfo represent the cluster information for basic blocks. If this
236 // is empty, it means unique sections for all basic blocks in the function.
237 static void
239  const std::vector<Optional<BBClusterInfo>> &FuncBBClusterInfo) {
240  assert(MF.hasBBSections() && "BB Sections is not set for function.");
241  // This variable stores the section ID of the cluster containing eh_pads (if
242  // all eh_pads are one cluster). If more than one cluster contain eh_pads, we
243  // set it equal to ExceptionSectionID.
244  Optional<MBBSectionID> EHPadsSectionID;
245 
246  for (auto &MBB : MF) {
247  // With the 'all' option, every basic block is placed in a unique section.
248  // With the 'list' option, every basic block is placed in a section
249  // associated with its cluster, unless we want individual unique sections
250  // for every basic block in this function (if FuncBBClusterInfo is empty).
251  if (MF.getTarget().getBBSectionsType() == llvm::BasicBlockSection::All ||
252  FuncBBClusterInfo.empty()) {
253  // If unique sections are desired for all basic blocks of the function, we
254  // set every basic block's section ID equal to its number (basic block
255  // id). This further ensures that basic blocks are ordered canonically.
256  MBB.setSectionID({static_cast<unsigned int>(MBB.getNumber())});
257  } else if (FuncBBClusterInfo[MBB.getNumber()].hasValue())
258  MBB.setSectionID(FuncBBClusterInfo[MBB.getNumber()]->ClusterID);
259  else {
260  // BB goes into the special cold section if it is not specified in the
261  // cluster info map.
263  }
264 
265  if (MBB.isEHPad() && EHPadsSectionID != MBB.getSectionID() &&
266  EHPadsSectionID != MBBSectionID::ExceptionSectionID) {
267  // If we already have one cluster containing eh_pads, this must be updated
268  // to ExceptionSectionID. Otherwise, we set it equal to the current
269  // section ID.
270  EHPadsSectionID = EHPadsSectionID.hasValue()
272  : MBB.getSectionID();
273  }
274  }
275 
276  // If EHPads are in more than one section, this places all of them in the
277  // special exception section.
278  if (EHPadsSectionID == MBBSectionID::ExceptionSectionID)
279  for (auto &MBB : MF)
280  if (MBB.isEHPad())
281  MBB.setSectionID(EHPadsSectionID.getValue());
282 }
283 
287  MF.getNumBlockIDs());
288  for (auto &MBB : MF)
290 
291  MF.sort(MBBCmp);
292 
293  // Set IsBeginSection and IsEndSection according to the assigned section IDs.
294  MF.assignBeginEndSections();
295 
296  // After reordering basic blocks, we must update basic block branches to
297  // insert explicit fallthrough branches when required and optimize branches
298  // when possible.
299  updateBranches(MF, PreLayoutFallThroughs);
300 }
301 
302 // If the exception section begins with a landing pad, that landing pad will
303 // assume a zero offset (relative to @LPStart) in the LSDA. However, a value of
304 // zero implies "no landing pad." This function inserts a NOP just before the EH
305 // pad label to ensure a nonzero offset. Returns true if padding is not needed.
307  for (auto &MBB : MF) {
308  if (MBB.isBeginSection() && MBB.isEHPad()) {
310  while (!MI->isEHLabel())
311  ++MI;
312  MCInst Noop;
313  MF.getSubtarget().getInstrInfo()->getNoop(Noop);
314  BuildMI(MBB, MI, DebugLoc(),
315  MF.getSubtarget().getInstrInfo()->get(Noop.getOpcode()));
316  return false;
317  }
318  }
319  return true;
320 }
321 
322 // This checks if the source of this function has drifted since this binary was
323 // profiled previously. For now, we are piggy backing on what PGO does to
324 // detect this with instrumented profiles. PGO emits an hash of the IR and
325 // checks if the hash has changed. Advanced basic block layout is usually done
326 // on top of PGO optimized binaries and hence this check works well in practice.
329  return false;
330 
331  const char MetadataName[] = "instr_prof_hash_mismatch";
332  auto *Existing = MF.getFunction().getMetadata(LLVMContext::MD_annotation);
333  if (Existing) {
334  MDTuple *Tuple = cast<MDTuple>(Existing);
335  for (auto &N : Tuple->operands())
336  if (cast<MDString>(N.get())->getString() == MetadataName)
337  return true;
338  }
339 
340  return false;
341 }
342 
343 bool BasicBlockSections::runOnMachineFunction(MachineFunction &MF) {
344  auto BBSectionsType = MF.getTarget().getBBSectionsType();
345  assert(BBSectionsType != BasicBlockSection::None &&
346  "BB Sections not enabled!");
347 
348  // Check for source drift. If the source has changed since the profiles
349  // were obtained, optimizing basic blocks might be sub-optimal.
350  // This only applies to BasicBlockSection::List as it creates
351  // clusters of basic blocks using basic block ids. Source drift can
352  // invalidate these groupings leading to sub-optimal code generation with
353  // regards to performance.
354  if (BBSectionsType == BasicBlockSection::List &&
356  return true;
357 
358  // Renumber blocks before sorting them for basic block sections. This is
359  // useful during sorting, basic blocks in the same section will retain the
360  // default order. This renumbering should also be done for basic block
361  // labels to match the profiles with the correct blocks.
362  MF.RenumberBlocks();
363 
364  if (BBSectionsType == BasicBlockSection::Labels) {
365  MF.setBBSectionsType(BBSectionsType);
366  return true;
367  }
368 
369  std::vector<Optional<BBClusterInfo>> FuncBBClusterInfo;
370  if (BBSectionsType == BasicBlockSection::List &&
371  !getBBClusterInfoForFunction(MF, FuncAliasMap, ProgramBBClusterInfo,
372  FuncBBClusterInfo))
373  return true;
374  MF.setBBSectionsType(BBSectionsType);
375  assignSections(MF, FuncBBClusterInfo);
376 
377  // We make sure that the cluster including the entry basic block precedes all
378  // other clusters.
379  auto EntryBBSectionID = MF.front().getSectionID();
380 
381  // Helper function for ordering BB sections as follows:
382  // * Entry section (section including the entry block).
383  // * Regular sections (in increasing order of their Number).
384  // ...
385  // * Exception section
386  // * Cold section
387  auto MBBSectionOrder = [EntryBBSectionID](const MBBSectionID &LHS,
388  const MBBSectionID &RHS) {
389  // We make sure that the section containing the entry block precedes all the
390  // other sections.
391  if (LHS == EntryBBSectionID || RHS == EntryBBSectionID)
392  return LHS == EntryBBSectionID;
393  return LHS.Type == RHS.Type ? LHS.Number < RHS.Number : LHS.Type < RHS.Type;
394  };
395 
396  // We sort all basic blocks to make sure the basic blocks of every cluster are
397  // contiguous and ordered accordingly. Furthermore, clusters are ordered in
398  // increasing order of their section IDs, with the exception and the
399  // cold section placed at the end of the function.
400  auto Comparator = [&](const MachineBasicBlock &X,
401  const MachineBasicBlock &Y) {
402  auto XSectionID = X.getSectionID();
403  auto YSectionID = Y.getSectionID();
404  if (XSectionID != YSectionID)
405  return MBBSectionOrder(XSectionID, YSectionID);
406  // If the two basic block are in the same section, the order is decided by
407  // their position within the section.
408  if (XSectionID.Type == MBBSectionID::SectionType::Default)
409  return FuncBBClusterInfo[X.getNumber()]->PositionInCluster <
410  FuncBBClusterInfo[Y.getNumber()]->PositionInCluster;
411  return X.getNumber() < Y.getNumber();
412  };
413 
414  sortBasicBlocksAndUpdateBranches(MF, Comparator);
416  return true;
417 }
418 
419 // Basic Block Sections can be enabled for a subset of machine basic blocks.
420 // This is done by passing a file containing names of functions for which basic
421 // block sections are desired. Additionally, machine basic block ids of the
422 // functions can also be specified for a finer granularity. Moreover, a cluster
423 // of basic blocks could be assigned to the same section.
424 // A file with basic block sections for all of function main and three blocks
425 // for function foo (of which 1 and 2 are placed in a cluster) looks like this:
426 // ----------------------------
427 // list.txt:
428 // !main
429 // !foo
430 // !!1 2
431 // !!4
433  ProgramBBClusterInfoMapTy &ProgramBBClusterInfo,
434  StringMap<StringRef> &FuncAliasMap) {
435  assert(MBuf);
436  line_iterator LineIt(*MBuf, /*SkipBlanks=*/true, /*CommentMarker=*/'#');
437 
438  auto invalidProfileError = [&](auto Message) {
439  return make_error<StringError>(
440  Twine("Invalid profile " + MBuf->getBufferIdentifier() + " at line " +
441  Twine(LineIt.line_number()) + ": " + Message),
443  };
444 
445  auto FI = ProgramBBClusterInfo.end();
446 
447  // Current cluster ID corresponding to this function.
448  unsigned CurrentCluster = 0;
449  // Current position in the current cluster.
450  unsigned CurrentPosition = 0;
451 
452  // Temporary set to ensure every basic block ID appears once in the clusters
453  // of a function.
454  SmallSet<unsigned, 4> FuncBBIDs;
455 
456  for (; !LineIt.is_at_eof(); ++LineIt) {
457  StringRef S(*LineIt);
458  if (S[0] == '@')
459  continue;
460  // Check for the leading "!"
461  if (!S.consume_front("!") || S.empty())
462  break;
463  // Check for second "!" which indicates a cluster of basic blocks.
464  if (S.consume_front("!")) {
465  if (FI == ProgramBBClusterInfo.end())
466  return invalidProfileError(
467  "Cluster list does not follow a function name specifier.");
468  SmallVector<StringRef, 4> BBIndexes;
469  S.split(BBIndexes, ' ');
470  // Reset current cluster position.
471  CurrentPosition = 0;
472  for (auto BBIndexStr : BBIndexes) {
473  unsigned long long BBIndex;
474  if (getAsUnsignedInteger(BBIndexStr, 10, BBIndex))
475  return invalidProfileError(Twine("Unsigned integer expected: '") +
476  BBIndexStr + "'.");
477  if (!FuncBBIDs.insert(BBIndex).second)
478  return invalidProfileError(Twine("Duplicate basic block id found '") +
479  BBIndexStr + "'.");
480  if (!BBIndex && CurrentPosition)
481  return invalidProfileError("Entry BB (0) does not begin a cluster.");
482 
483  FI->second.emplace_back(BBClusterInfo{
484  ((unsigned)BBIndex), CurrentCluster, CurrentPosition++});
485  }
486  CurrentCluster++;
487  } else { // This is a function name specifier.
488  // Function aliases are separated using '/'. We use the first function
489  // name for the cluster info mapping and delegate all other aliases to
490  // this one.
492  S.split(Aliases, '/');
493  for (size_t i = 1; i < Aliases.size(); ++i)
494  FuncAliasMap.try_emplace(Aliases[i], Aliases.front());
495 
496  // Prepare for parsing clusters of this function name.
497  // Start a new cluster map for this function name.
498  FI = ProgramBBClusterInfo.try_emplace(Aliases.front()).first;
499  CurrentCluster = 0;
500  FuncBBIDs.clear();
501  }
502  }
503  return Error::success();
504 }
505 
506 bool BasicBlockSections::doInitialization(Module &M) {
507  if (!MBuf)
508  return false;
509  if (auto Err = getBBClusterInfo(MBuf, ProgramBBClusterInfo, FuncAliasMap))
511  return false;
512 }
513 
514 void BasicBlockSections::getAnalysisUsage(AnalysisUsage &AU) const {
515  AU.setPreservesAll();
517 }
518 
521  return new BasicBlockSections(Buf);
522 }
i
i
Definition: README.txt:29
MemoryBuffer.h
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:100
llvm
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Optional.h
llvm::sortBasicBlocksAndUpdateBranches
void sortBasicBlocksAndUpdateBranches(MachineFunction &MF, MachineBasicBlockComparator MBBCmp)
Definition: BasicBlockSections.cpp:284
llvm::line_iterator
A forward iterator which reads text lines from a buffer.
Definition: LineIterator.h:33
llvm::BBSectionsColdTextPrefix
cl::opt< std::string > BBSectionsColdTextPrefix
StringRef.h
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::HexagonInstrInfo::analyzeBranch
bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB, SmallVectorImpl< MachineOperand > &Cond, bool AllowModify) const override
Analyze the branching code at the end of MBB, returning true if it cannot be understood (e....
Definition: HexagonInstrInfo.cpp:391
getBBClusterInfoForFunction
static bool getBBClusterInfoForFunction(const MachineFunction &MF, const StringMap< StringRef > FuncAliasMap, const ProgramBBClusterInfoMapTy &ProgramBBClusterInfo, std::vector< Optional< BBClusterInfo >> &V)
Definition: BasicBlockSections.cpp:197
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:332
llvm::GlobalObject::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Metadata.cpp:1191
llvm::MachineFunctionPass
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Definition: MachineFunctionPass.h:30
Error.h
avoidZeroOffsetLandingPad
static bool avoidZeroOffsetLandingPad(MachineFunction &MF)
Definition: BasicBlockSections.cpp:306
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:140
llvm::MachineFunction::getNumBlockIDs
unsigned getNumBlockIDs() const
getNumBlockIDs - Return the number of MBB ID's allocated.
Definition: MachineFunction.h:682
llvm::StringMap::end
iterator end()
Definition: StringMap.h:205
TargetInstrInfo.h
llvm::MBBSectionID::Number
unsigned Number
Definition: MachineBasicBlock.h:59
llvm::SmallSet
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:134
llvm::Optional
Definition: APInt.h:33
getBBClusterInfo
static Error getBBClusterInfo(const MemoryBuffer *MBuf, ProgramBBClusterInfoMapTy &ProgramBBClusterInfo, StringMap< StringRef > &FuncAliasMap)
Definition: BasicBlockSections.cpp:432
llvm::MCInst
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:194
llvm::StringMap::find
iterator find(StringRef Key)
Definition: StringMap.h:218
llvm::MBBSectionID
Definition: MachineBasicBlock.h:52
llvm::BasicBlockSection::List
@ List
llvm::BasicBlockSection::None
@ None
llvm::MemoryBuffer
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:50
llvm::MachineFunctionPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
Definition: MachineFunctionPass.cpp:102
llvm::MDNode::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1194
llvm::MDNode::operands
op_range operands() const
Definition: Metadata.h:1096
llvm::MachineBasicBlock::isBeginSection
bool isBeginSection() const
Returns true if this block begins any section.
Definition: MachineBasicBlock.h:473
llvm::Optional::hasValue
constexpr bool hasValue() const
Definition: Optional.h:286
llvm::MachineBasicBlock::setSectionID
void setSectionID(MBBSectionID V)
Sets the section ID for this basic block.
Definition: MachineBasicBlock.h:492
llvm::MachineFunction::front
const MachineBasicBlock & front() const
Definition: MachineFunction.h:749
llvm::SmallVector
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
Definition: SmallVector.h:1095
llvm::TargetInstrInfo
TargetInstrInfo - Interface to description of machine instruction set.
Definition: TargetInstrInfo.h:97
TargetMachine.h
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
llvm::getAsUnsignedInteger
bool getAsUnsignedInteger(StringRef Str, unsigned Radix, unsigned long long &Result)
Helper functions for StringRef::getAsInteger.
Definition: StringRef.cpp:488
Y
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::MDTuple
Tuple of metadata.
Definition: Metadata.h:1135
TII
const HexagonInstrInfo * TII
Definition: HexagonCopyToCombine.cpp:129
llvm::BasicBlockSection::Labels
@ Labels
INITIALIZE_PASS
INITIALIZE_PASS(BasicBlockSections, "bbsections-prepare", "Prepares for basic block sections, by splitting functions " "into clusters of basic blocks.", false, false) static void updateBranches(MachineFunction &MF
LineIterator.h
llvm::report_fatal_error
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:140
llvm::BasicBlockSection::All
@ All
StringMap.h
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:108
llvm::MemoryBuffer::getBufferIdentifier
virtual StringRef getBufferIdentifier() const
Return an identifier for this buffer, typically the filename it was read from.
Definition: MemoryBuffer.h:75
Passes.h
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:176
llvm::cl::opt
Definition: CommandLine.h:1419
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
BasicBlockSectionUtils.h
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:440
MachineFunctionPass.h
llvm::MachineFunction::getName
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
Definition: MachineFunction.cpp:522
llvm::MBBSectionID::ExceptionSectionID
const static MBBSectionID ExceptionSectionID
Definition: MachineBasicBlock.h:65
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:67
llvm::MachineFunction
Definition: MachineFunction.h:227
llvm::MachineBasicBlock::getNumber
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...
Definition: MachineBasicBlock.h:949
Cond
SmallVector< MachineOperand, 4 > Cond
Definition: BasicBlockSections.cpp:167
llvm::MachineBasicBlock::isEHPad
bool isEHPad() const
Returns true if the block is a landing pad.
Definition: MachineBasicBlock.h:435
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::MachineBasicBlock::findBranchDebugLoc
DebugLoc findBranchDebugLoc()
Find and return the merged DebugLoc of the branch instructions of the block.
Definition: MachineBasicBlock.cpp:1417
llvm::MBBSectionID::Type
enum llvm::MBBSectionID::SectionType Type
llvm::ilist_node_impl::getIterator
self_iterator getIterator()
Definition: ilist_node.h:81
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::MachineFunction::hasBBSections
bool hasBBSections() const
Returns true if this function has basic block sections enabled.
Definition: MachineFunction.h:533
llvm::initializeBasicBlockSectionsPass
void initializeBasicBlockSectionsPass(PassRegistry &)
llvm::SmallSet::insert
std::pair< NoneType, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition: SmallSet.h:180
llvm::MachineBasicBlock::getSectionID
MBBSectionID getSectionID() const
Returns the section ID of this basic block.
Definition: MachineBasicBlock.h:483
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
hasInstrProfHashMismatch
static bool hasInstrProfHashMismatch(MachineFunction &MF)
Definition: BasicBlockSections.cpp:327
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:521
llvm::inconvertibleErrorCode
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:77
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::MachineFunction::getTarget
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
Definition: MachineFunction.h:551
llvm::MachineBasicBlock::isEndSection
bool isEndSection() const
Returns true if this block ends any section.
Definition: MachineBasicBlock.h:476
llvm::MBBSectionID::ColdSectionID
const static MBBSectionID ColdSectionID
Definition: MachineBasicBlock.h:64
BBSectionsDetectSourceDrift
cl::opt< bool > BBSectionsDetectSourceDrift("bbsections-detect-source-drift", cl::desc("This checks if there is a fdo instr. profile hash " "mismatch for this function"), cl::init(true), cl::Hidden)
llvm::createBasicBlockSectionsPass
MachineFunctionPass * createBasicBlockSectionsPass(const MemoryBuffer *Buf)
createBasicBlockSections Pass - This pass assigns sections to machine basic blocks and is enabled wit...
Definition: BasicBlockSections.cpp:520
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::MCInst::getOpcode
unsigned getOpcode() const
Definition: MCInst.h:208
llvm::TargetStackID::Default
@ Default
Definition: TargetFrameLowering.h:28
llvm::line_iterator::is_at_eof
bool is_at_eof() const
Return true if we've reached EOF or are an "end" iterator.
Definition: LineIterator.h:55
llvm::MachineBasicBlock::getFallThrough
MachineBasicBlock * getFallThrough()
Return the fallthrough block if the block can implicitly transfer control to the block after it by fa...
Definition: MachineBasicBlock.cpp:940
llvm::line_iterator::line_number
int64_t line_number() const
Return the current line number. May return any number at EOF.
Definition: LineIterator.h:61
SmallVector.h
PreLayoutFallThroughs
const SmallVector< MachineBasicBlock *, 4 > & PreLayoutFallThroughs
Definition: BasicBlockSections.cpp:165
llvm::MachineBasicBlock::begin
iterator begin()
Definition: MachineBasicBlock.h:268
assignSections
static void assignSections(MachineFunction &MF, const std::vector< Optional< BBClusterInfo >> &FuncBBClusterInfo)
Definition: BasicBlockSections.cpp:238
llvm::BuildMI
MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
Definition: MachineInstrBuilder.h:329
N
#define N
llvm::SmallSet::clear
void clear()
Definition: SmallSet.h:218
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::cl::desc
Definition: CommandLine.h:411
llvm::MachineBasicBlock::updateTerminator
void updateTerminator(MachineBasicBlock *PreviousLayoutSuccessor)
Update the terminator instructions in block to account for changes to block layout which may have bee...
Definition: MachineBasicBlock.cpp:638
MachineFunction.h
llvm::MachineInstrBundleIterator< MachineInstr >
vector
DEBUG_TYPE to vector
Definition: AMDGPUPromoteAlloca.cpp:132
llvm::MachineFunction::setBBSectionsType
void setBBSectionsType(BasicBlockSection V)
Definition: MachineFunction.h:544
InitializePasses.h
llvm::MachineFunction::RenumberBlocks
void RenumberBlocks(MachineBasicBlock *MBBFrom=nullptr)
RenumberBlocks - This discards all of the MachineBasicBlock numbers and recomputes them.
Definition: MachineFunction.cpp:294
llvm::StringMap::try_emplace
std::pair< iterator, bool > try_emplace(StringRef Key, ArgsTy &&... Args)
Emplace a new element for the specified key into the map if the key isn't already in the map.
Definition: StringMap.h:315
llvm::Optional::getValue
constexpr const T & getValue() const LLVM_LVALUE_FUNCTION
Definition: Optional.h:280
llvm::TargetMachine::getBBSectionsType
llvm::BasicBlockSection getBBSectionsType() const
If basic blocks should be emitted into their own section, corresponding to -fbasic-block-sections.
Definition: TargetMachine.h:292
SmallSet.h
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37