Basic Block Sections support in LLVM.

class TargetRegisterClass;

class TargetRegisterInfo;

enum MachineBasicBlockSection : unsigned {

  ///  This is also the order of sections in a function.  Basic blocks that are

  ///  part of the original function section (entry block) come first, followed

  ///  by exception handling basic blocks, cold basic blocks and finally basic

  //   blocks that need unique sections.

  MBBS_Entry,

  MBBS_Exception,

  MBBS_Cold,

  MBBS_Unique,

  ///  None implies no sections for any basic block, the default.

  MBBS_None,

};

template <> struct ilist_traits<MachineInstr> {

private:

  friend class MachineBasicBlock; // Set by the owning MachineBasicBlock.

  /// Indicate that this basic block is the entry block of a cleanup funclet.

  bool IsCleanupFuncletEntry = false;

  /// Stores the Section type of the basic block with basic block sections.

  MachineBasicBlockSection SectionType = MBBS_None;

  /// Default target of the callbr of a basic block.

  bool InlineAsmBrDefaultTarget = false;

  /// is only computed once and is cached.

  mutable MCSymbol *CachedMCSymbol = nullptr;

  /// Used during basic block sections to mark the end of a basic block.

  MCSymbol *EndMCSymbol = nullptr;

  // Intrusive list support

  MachineBasicBlock() = default;

  /// Indicates if this is the entry block of a cleanup funclet.

  void setIsCleanupFuncletEntry(bool V = true) { IsCleanupFuncletEntry = V; }

  /// Returns true if this block begins any section.

  bool isBeginSection() const;

  /// Returns true if this block ends any section.

  bool isEndSection() const;

  /// Returns the type of section this basic block belongs to.

  MachineBasicBlockSection getSectionType() const { return SectionType; }

  /// Indicate that the basic block belongs to a Section Type.

  void setSectionType(MachineBasicBlockSection V) { SectionType = V; }

  /// Returns true if this is the indirect dest of an INLINEASM_BR.

  bool isInlineAsmBrIndirectTarget(const MachineBasicBlock *Tgt) const {

    return InlineAsmBrIndirectTargets.count(Tgt);

  void moveBefore(MachineBasicBlock *NewAfter);

  void moveAfter(MachineBasicBlock *NewBefore);

  /// Returns true if this and MBB belong to the same section.

  bool sameSection(const MachineBasicBlock *MBB) const;

  /// Returns the basic block that ends the section which contains this one.

  const MachineBasicBlock *getSectionEndMBB() const;

  /// Update the terminator instructions in block to account for changes to the

  /// layout. If the block previously used a fallthrough, it may now need a

  /// branch, and if it previously used branching it may now be able to use a

  /// Return the MCSymbol for this basic block.

  MCSymbol *getSymbol() const;

  /// Sets the MCSymbol corresponding to the end of this basic block.

  void setEndMCSymbol(MCSymbol *Sym) { EndMCSymbol = Sym; }

  /// Returns the MCSymbol corresponding to the end of this basic block.

  MCSymbol *getEndMCSymbol() const { return EndMCSymbol; }

  Optional<uint64_t> getIrrLoopHeaderWeight() const {

    return IrrLoopHeaderWeight;

  }

#include "llvm/Support/Compiler.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/Recycler.h"

#include "llvm/Target/TargetOptions.h"

#include <cassert>

#include <cstdint>

#include <memory>

class MCContext;

class MCInstrDesc;

class MCSymbol;

class MCSection;

class Pass;

class PseudoSourceValueManager;

class raw_ostream;

  // Keep track of jump tables for switch instructions

  MachineJumpTableInfo *JumpTableInfo;

  // Keep track of the function section.

  MCSection *Section = nullptr;

  // Keeps track of Wasm exception handling related data. This will be null for

  // functions that aren't using a wasm EH personality.

  WasmEHFuncInfo *WasmEHInfo = nullptr;

  // numbered and this vector keeps track of the mapping from ID's to MBB's.

  std::vector<MachineBasicBlock*> MBBNumbering;

  // Unary encoding of basic block symbols is used to reduce size of ".strtab".

  // Basic block number 'i' gets a prefix of length 'i'.  The ith character also

  // denotes the type of basic block number 'i'.  Return blocks are marked with

  // 'r', landing pads with 'l' and regular blocks with 'a'.

  std::vector<char> BBSectionsSymbolPrefix;

  // Pool-allocate MachineFunction-lifetime and IR objects.

  BumpPtrAllocator Allocator;

  bool HasEHScopes = false;

  bool HasEHFunclets = false;

  /// Section Type for basic blocks, only relevant with basic block sections.

  BasicBlockSection BBSectionsType = BasicBlockSection::None;

  /// With Basic Block Sections, this stores the bb ranges of cold and

  /// exception sections.

  std::pair<int, int> ColdSectionRange = {-1, -1};

  std::pair<int, int> ExceptionSectionRange = {-1, -1};

  /// List of C++ TypeInfo used.

  std::vector<const GlobalValue *> TypeInfos;

  MachineModuleInfo &getMMI() const { return MMI; }

  MCContext &getContext() const { return Ctx; }

  /// Returns the Section this function belongs to.

  MCSection *getSection() const { return Section; }

  /// Indicates the Section this function belongs to.

  void setSection(MCSection *S) { Section = S; }

  PseudoSourceValueManager &getPSVManager() const { return *PSVManager; }

  /// Return the DataLayout attached to the Module associated to this MF.

  /// getFunctionNumber - Return a unique ID for the current function.

  unsigned getFunctionNumber() const { return FunctionNumber; }

  /// Returns true if this function has basic block sections enabled.

  bool hasBBSections() const {

    return (BBSectionsType == BasicBlockSection::All ||

            BBSectionsType == BasicBlockSection::List);

  }

  /// Returns true if basic block labels are to be generated for this function.

  bool hasBBLabels() const {

    return BBSectionsType == BasicBlockSection::Labels;

  }

  void setBBSectionsType(BasicBlockSection V) { BBSectionsType = V; }

  void setSectionRange();

  /// Returns true if this basic block number starts a cold or exception

  /// section.

  bool isSectionStartMBB(int N) const {

    return (N == ColdSectionRange.first || N == ExceptionSectionRange.first);

  }

  /// Returns true if this basic block ends a cold or exception section.

  bool isSectionEndMBB(int N) const {

    return (N == ColdSectionRange.second || N == ExceptionSectionRange.second);

  }

  /// Creates basic block Labels for this function.

  void createBBLabels();

  /// getTarget - Return the target machine this machine code is compiled with

  const LLVMTargetMachine &getTarget() const { return Target; }

  /// of the instruction stream.

  void copyCallSiteInfo(const MachineInstr *Old,

                        const MachineInstr *New);

  const std::vector<char> &getBBSectionsSymbolPrefix() const {

    return BBSectionsSymbolPrefix;

  }

  /// Move the call site info from \p Old to \New call site info. This function

  /// is used when we are replacing one call instruction with another one to

  /// the same callee.

class FunctionPass;

class MachineFunction;

class MachineFunctionPass;

class MemoryBuffer;

class ModulePass;

class Pass;

class TargetMachine;

  /// the entry block.

  FunctionPass *createUnreachableBlockEliminationPass();

  /// createBBSectionsPrepare Pass - This pass assigns sections to machine basic

  /// blocks and is enabled with -fbasicblock-sections.

  /// Buf is a memory buffer that contains the list of functions and basic

  /// block ids to selectively enable basic block sections.

  MachineFunctionPass *createBBSectionsPreparePass(const MemoryBuffer *Buf);

  /// MachineFunctionPrinter pass - This pass prints out the machine function to

  /// the given stream as a debugging tool.

  MachineFunctionPass *

  MCSection *getSectionForJumpTable(const Function &F,

                                    const TargetMachine &TM) const override;

  MCSection *

  getSectionForMachineBasicBlock(const Function &F,

                                 const MachineBasicBlock &MBB,

                                 const TargetMachine &TM) const override;

  MCSection *getNamedSectionForMachineBasicBlock(

      const Function &F, const MachineBasicBlock &MBB, const TargetMachine &TM,

      const char *Suffix) const override;

  bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,

                                           const Function &F) const override;

void initializeAtomicExpandPass(PassRegistry&);

void initializeAttributorLegacyPassPass(PassRegistry&);

void initializeAttributorCGSCCLegacyPassPass(PassRegistry &);

void initializeBBSectionsPreparePass(PassRegistry &);

void initializeBDCELegacyPassPass(PassRegistry&);

void initializeBarrierNoopPass(PassRegistry&);

void initializeBasicAAWrapperPassPass(PassRegistry&);