Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- llvm/CodeGen/MachineBasicBlock.h -------------------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// Collect the sequence of machine instructions for a basic block.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CODEGEN_MACHINEBASICBLOCK_H

#define LLVM_CODEGEN_MACHINEBASICBLOCK_H

#include "llvm/ADT/GraphTraits.h"

#include "llvm/ADT/SparseBitVector.h"

#include "llvm/ADT/ilist.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/CodeGen/MachineInstr.h"

#include "llvm/CodeGen/MachineInstrBundleIterator.h"

#include "llvm/IR/DebugLoc.h"

#include "llvm/MC/LaneBitmask.h"

#include "llvm/Support/BranchProbability.h"

#include <cassert>

#include <cstdint>

#include <iterator>

#include <string>

#include <vector>

namespace llvm {

class BasicBlock;

class MachineFunction;

class MCSymbol;

class ModuleSlotTracker;

class Pass;

class Printable;

class SlotIndexes;

class StringRef;

class raw_ostream;

class LiveIntervals;

class TargetRegisterClass;

class TargetRegisterInfo;

// This structure uniquely identifies a basic block section.

// Possible values are

//  {Type: Default, Number: (unsigned)} (These are regular section IDs)

//  {Type: Exception, Number: 0}  (ExceptionSectionID)

//  {Type: Cold, Number: 0}  (ColdSectionID)

struct MBBSectionID {

  enum SectionType {

    Default = 0, // Regular section (these sections are distinguished by the

                 // Number field).

    Exception,   // Special section type for exception handling blocks

    Cold,        // Special section type for cold blocks

  } Type;

  unsigned Number;

  MBBSectionID(unsigned N) : Type(Default), Number(N) {}

  // Special unique sections for cold and exception blocks.

  const static MBBSectionID ColdSectionID;

  const static MBBSectionID ExceptionSectionID;

  bool operator==(const MBBSectionID &Other) const {

    return Type == Other.Type && Number == Other.Number;

  }

  bool operator!=(const MBBSectionID &Other) const { return !(*this == Other); }

private:

  // This is only used to construct the special cold and exception sections.

  MBBSectionID(SectionType T) : Type(T), Number(0) {}

};

template <> struct ilist_traits<MachineInstr> {

private:

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

  MachineBasicBlock *Parent;

  using instr_iterator =

      simple_ilist<MachineInstr, ilist_sentinel_tracking<true>>::iterator;

public:

  void addNodeToList(MachineInstr *N);

  void removeNodeFromList(MachineInstr *N);

  void transferNodesFromList(ilist_traits &FromList, instr_iterator First,

                             instr_iterator Last);

  void deleteNode(MachineInstr *MI);

};

class MachineBasicBlock

    : public ilist_node_with_parent<MachineBasicBlock, MachineFunction> {

public:

  /// Pair of physical register and lane mask.

  /// This is not simply a std::pair typedef because the members should be named

  /// clearly as they both have an integer type.

  struct RegisterMaskPair {

  public:

    MCPhysReg PhysReg;

    LaneBitmask LaneMask;

    RegisterMaskPair(MCPhysReg PhysReg, LaneBitmask LaneMask)

        : PhysReg(PhysReg), LaneMask(LaneMask) {}

  };

private:

  using Instructions = ilist<MachineInstr, ilist_sentinel_tracking<true>>;

  const BasicBlock *BB;

  int Number;

  MachineFunction *xParent;

  Instructions Insts;

  /// Keep track of the predecessor / successor basic blocks.

  std::vector<MachineBasicBlock *> Predecessors;

  std::vector<MachineBasicBlock *> Successors;

  /// Keep track of the probabilities to the successors. This vector has the

  /// same order as Successors, or it is empty if we don't use it (disable

  /// optimization).

  std::vector<BranchProbability> Probs;

  using probability_iterator = std::vector<BranchProbability>::iterator;

  using const_probability_iterator =

      std::vector<BranchProbability>::const_iterator;

  std::optional<uint64_t> IrrLoopHeaderWeight;

  /// Keep track of the physical registers that are livein of the basicblock.

  using LiveInVector = std::vector<RegisterMaskPair>;

  LiveInVector LiveIns;

  /// Alignment of the basic block. One if the basic block does not need to be

  /// aligned.

  Align Alignment;

  /// Maximum amount of bytes that can be added to align the basic block. If the

  /// alignment cannot be reached in this many bytes, no bytes are emitted.

  /// Zero to represent no maximum.

  unsigned MaxBytesForAlignment = 0;

  /// Indicate that this basic block is entered via an exception handler.

  bool IsEHPad = false;

  /// Indicate that this MachineBasicBlock is referenced somewhere other than

  /// as predecessor/successor, a terminator MachineInstr, or a jump table.

  bool MachineBlockAddressTaken = false;

  /// If this MachineBasicBlock corresponds to an IR-level "blockaddress"

  /// constant, this contains a pointer to that block.

  BasicBlock *AddressTakenIRBlock = nullptr;

  /// Indicate that this basic block needs its symbol be emitted regardless of

  /// whether the flow just falls-through to it.

  bool LabelMustBeEmitted = false;

  /// Indicate that this basic block is the entry block of an EH scope, i.e.,

  /// the block that used to have a catchpad or cleanuppad instruction in the

  /// LLVM IR.

  bool IsEHScopeEntry = false;

  /// Indicates if this is a target block of a catchret.

  bool IsEHCatchretTarget = false;

  /// Indicate that this basic block is the entry block of an EH funclet.

  bool IsEHFuncletEntry = false;

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

  bool IsCleanupFuncletEntry = false;

  /// Fixed unique ID assigned to this basic block upon creation. Used with

  /// basic block sections and basic block labels.

  std::optional<unsigned> BBID;

  /// With basic block sections, this stores the Section ID of the basic block.

  MBBSectionID SectionID{0};

  // Indicate that this basic block begins a section.

  bool IsBeginSection = false;

  // Indicate that this basic block ends a section.

  bool IsEndSection = false;

  /// Indicate that this basic block is the indirect dest of an INLINEASM_BR.

  bool IsInlineAsmBrIndirectTarget = false;

  /// since getSymbol is a relatively heavy-weight operation, the symbol

  /// is only computed once and is cached.

  mutable MCSymbol *CachedMCSymbol = nullptr;

  /// Cached MCSymbol for this block (used if IsEHCatchRetTarget).

  mutable MCSymbol *CachedEHCatchretMCSymbol = nullptr;

  /// Marks the end of the basic block. Used during basic block sections to

  /// calculate the size of the basic block, or the BB section ending with it.

  mutable MCSymbol *CachedEndMCSymbol = nullptr;

  // Intrusive list support

  MachineBasicBlock() = default;

  explicit MachineBasicBlock(MachineFunction &MF, const BasicBlock *BB);

  ~MachineBasicBlock();

  // MachineBasicBlocks are allocated and owned by MachineFunction.

  friend class MachineFunction;

public:

  /// Return the LLVM basic block that this instance corresponded to originally.

  /// Note that this may be NULL if this instance does not correspond directly

  /// to an LLVM basic block.

  const BasicBlock *getBasicBlock() const { return BB; }

  /// Remove the reference to the underlying IR BasicBlock. This is for

  /// reduction tools and should generally not be used.

  void clearBasicBlock() {

    BB = nullptr;

  }

  /// Return the name of the corresponding LLVM basic block, or an empty string.

  StringRef getName() const;

  /// Return a formatted string to identify this block and its parent function.

  std::string getFullName() const;

  /// Test whether this block is used as as something other than the target

  /// of a terminator, exception-handling target, or jump table. This is

  /// either the result of an IR-level "blockaddress", or some form

  /// of target-specific branch lowering.

  bool hasAddressTaken() const {

    return MachineBlockAddressTaken || AddressTakenIRBlock;

  }

  /// Test whether this block is used as something other than the target of a

  /// terminator, exception-handling target, jump table, or IR blockaddress.

  /// For example, its address might be loaded into a register, or

  /// stored in some branch table that isn't part of MachineJumpTableInfo.

  bool isMachineBlockAddressTaken() const { return MachineBlockAddressTaken; }

  /// Test whether this block is the target of an IR BlockAddress.  (There can

  /// more than one MBB associated with an IR BB where the address is taken.)

  bool isIRBlockAddressTaken() const { return AddressTakenIRBlock; }

  /// Retrieves the BasicBlock which corresponds to this MachineBasicBlock.

  BasicBlock *getAddressTakenIRBlock() const { return AddressTakenIRBlock; }

  /// Set this block to indicate that its address is used as something other

  /// than the target of a terminator, exception-handling target, jump table,

  /// or IR-level "blockaddress".

  void setMachineBlockAddressTaken() { MachineBlockAddressTaken = true; }

  /// Set this block to reflect that it corresponds to an IR-level basic block

  /// with a BlockAddress.

  void setAddressTakenIRBlock(BasicBlock *BB) { AddressTakenIRBlock = BB; }

  /// Test whether this block must have its label emitted.

  bool hasLabelMustBeEmitted() const { return LabelMustBeEmitted; }

  /// Set this block to reflect that, regardless how we flow to it, we need

  /// its label be emitted.

  void setLabelMustBeEmitted() { LabelMustBeEmitted = true; }

  /// Return the MachineFunction containing this basic block.

  const MachineFunction *getParent() const { return xParent; }

  MachineFunction *getParent() { return xParent; }

  using instr_iterator = Instructions::iterator;

  using const_instr_iterator = Instructions::const_iterator;

  using reverse_instr_iterator = Instructions::reverse_iterator;

  using const_reverse_instr_iterator = Instructions::const_reverse_iterator;

  using iterator = MachineInstrBundleIterator<MachineInstr>;

  using const_iterator = MachineInstrBundleIterator<const MachineInstr>;

  using reverse_iterator = MachineInstrBundleIterator<MachineInstr, true>;

  using const_reverse_iterator =

      MachineInstrBundleIterator<const MachineInstr, true>;

  unsigned size() const { return (unsigned)Insts.size(); }

  bool sizeWithoutDebugLargerThan(unsigned Limit) const;

  bool empty() const { return Insts.empty(); }

  MachineInstr       &instr_front()       { return Insts.front(); }

  MachineInstr       &instr_back()        { return Insts.back();  }

  const MachineInstr &instr_front() const { return Insts.front(); }

  const MachineInstr &instr_back()  const { return Insts.back();  }

  MachineInstr       &front()             { return Insts.front(); }

  MachineInstr       &back()              { return *--end();      }

  const MachineInstr &front()       const { return Insts.front(); }

  const MachineInstr &back()        const { return *--end();      }

  instr_iterator                instr_begin()       { return Insts.begin();  }

  const_instr_iterator          instr_begin() const { return Insts.begin();  }

  instr_iterator                  instr_end()       { return Insts.end();    }

  const_instr_iterator            instr_end() const { return Insts.end();    }

  reverse_instr_iterator       instr_rbegin()       { return Insts.rbegin(); }

  const_reverse_instr_iterator instr_rbegin() const { return Insts.rbegin(); }

  reverse_instr_iterator       instr_rend  ()       { return Insts.rend();   }

  const_reverse_instr_iterator instr_rend  () const { return Insts.rend();   }

  using instr_range = iterator_range<instr_iterator>;

  using const_instr_range = iterator_range<const_instr_iterator>;

  instr_range instrs() { return instr_range(instr_begin(), instr_end()); }

  const_instr_range instrs() const {

    return const_instr_range(instr_begin(), instr_end());

  }

  iterator                begin()       { return instr_begin();  }

  const_iterator          begin() const { return instr_begin();  }

  iterator                end  ()       { return instr_end();    }

  const_iterator          end  () const { return instr_end();    }

  reverse_iterator rbegin() {

    return reverse_iterator::getAtBundleBegin(instr_rbegin());

  }

  const_reverse_iterator rbegin() const {

    return const_reverse_iterator::getAtBundleBegin(instr_rbegin());

  }

  reverse_iterator rend() { return reverse_iterator(instr_rend()); }

  const_reverse_iterator rend() const {

    return const_reverse_iterator(instr_rend());

  }

  /// Support for MachineInstr::getNextNode().

  static Instructions MachineBasicBlock::*getSublistAccess(MachineInstr *) {

    return &MachineBasicBlock::Insts;

  }

  inline iterator_range<iterator> terminators() {

    return make_range(getFirstTerminator(), end());

  }

  inline iterator_range<const_iterator> terminators() const {

    return make_range(getFirstTerminator(), end());

  }

  /// Returns a range that iterates over the phis in the basic block.

  inline iterator_range<iterator> phis() {

    return make_range(begin(), getFirstNonPHI());

  }

  inline iterator_range<const_iterator> phis() const {

    return const_cast<MachineBasicBlock *>(this)->phis();

  }

  // Machine-CFG iterators

  using pred_iterator = std::vector<MachineBasicBlock *>::iterator;

  using const_pred_iterator = std::vector<MachineBasicBlock *>::const_iterator;

  using succ_iterator = std::vector<MachineBasicBlock *>::iterator;

  using const_succ_iterator = std::vector<MachineBasicBlock *>::const_iterator;

  using pred_reverse_iterator =

      std::vector<MachineBasicBlock *>::reverse_iterator;

  using const_pred_reverse_iterator =

      std::vector<MachineBasicBlock *>::const_reverse_iterator;

  using succ_reverse_iterator =

      std::vector<MachineBasicBlock *>::reverse_iterator;

  using const_succ_reverse_iterator =

      std::vector<MachineBasicBlock *>::const_reverse_iterator;

  pred_iterator        pred_begin()       { return Predecessors.begin(); }

  const_pred_iterator  pred_begin() const { return Predecessors.begin(); }

  pred_iterator        pred_end()         { return Predecessors.end();   }

  const_pred_iterator  pred_end()   const { return Predecessors.end();   }

  pred_reverse_iterator        pred_rbegin()

                                          { return Predecessors.rbegin();}

  const_pred_reverse_iterator  pred_rbegin() const

                                          { return Predecessors.rbegin();}

  pred_reverse_iterator        pred_rend()

                                          { return Predecessors.rend();  }

  const_pred_reverse_iterator  pred_rend()   const

                                          { return Predecessors.rend();  }

  unsigned             pred_size()  const {

    return (unsigned)Predecessors.size();

  }

  bool                 pred_empty() const { return Predecessors.empty(); }

  succ_iterator        succ_begin()       { return Successors.begin();   }

  const_succ_iterator  succ_begin() const { return Successors.begin();   }

  succ_iterator        succ_end()         { return Successors.end();     }

  const_succ_iterator  succ_end()   const { return Successors.end();     }

  succ_reverse_iterator        succ_rbegin()

                                          { return Successors.rbegin();  }

  const_succ_reverse_iterator  succ_rbegin() const

                                          { return Successors.rbegin();  }

  succ_reverse_iterator        succ_rend()

                                          { return Successors.rend();    }

  const_succ_reverse_iterator  succ_rend()   const

                                          { return Successors.rend();    }

  unsigned             succ_size()  const {

    return (unsigned)Successors.size();

  }

  bool                 succ_empty() const { return Successors.empty();   }

  inline iterator_range<pred_iterator> predecessors() {

    return make_range(pred_begin(), pred_end());

  }

  inline iterator_range<const_pred_iterator> predecessors() const {

    return make_range(pred_begin(), pred_end());

  }

  inline iterator_range<succ_iterator> successors() {

    return make_range(succ_begin(), succ_end());

  }

  inline iterator_range<const_succ_iterator> successors() const {

    return make_range(succ_begin(), succ_end());

  }

  // LiveIn management methods.

  /// Adds the specified register as a live in. Note that it is an error to add

  /// the same register to the same set more than once unless the intention is

  /// to call sortUniqueLiveIns after all registers are added.

  void addLiveIn(MCRegister PhysReg,

                 LaneBitmask LaneMask = LaneBitmask::getAll()) {

    LiveIns.push_back(RegisterMaskPair(PhysReg, LaneMask));

  }

  void addLiveIn(const RegisterMaskPair &RegMaskPair) {

    LiveIns.push_back(RegMaskPair);

  }

  /// Sorts and uniques the LiveIns vector. It can be significantly faster to do

  /// this than repeatedly calling isLiveIn before calling addLiveIn for every

  /// LiveIn insertion.

  void sortUniqueLiveIns();

  /// Clear live in list.

  void clearLiveIns();

  /// Add PhysReg as live in to this block, and ensure that there is a copy of

  /// PhysReg to a virtual register of class RC. Return the virtual register

  /// that is a copy of the live in PhysReg.

  Register addLiveIn(MCRegister PhysReg, const TargetRegisterClass *RC);

  /// Remove the specified register from the live in set.

  void removeLiveIn(MCPhysReg Reg,

                    LaneBitmask LaneMask = LaneBitmask::getAll());

  /// Return true if the specified register is in the live in set.

  bool isLiveIn(MCPhysReg Reg,

                LaneBitmask LaneMask = LaneBitmask::getAll()) const;

  // Iteration support for live in sets.  These sets are kept in sorted

  // order by their register number.

  using livein_iterator = LiveInVector::const_iterator;

  /// Unlike livein_begin, this method does not check that the liveness

  /// information is accurate. Still for debug purposes it may be useful

  /// to have iterators that won't assert if the liveness information

  /// is not current.

  livein_iterator livein_begin_dbg() const { return LiveIns.begin(); }

  iterator_range<livein_iterator> liveins_dbg() const {

    return make_range(livein_begin_dbg(), livein_end());

  }

  livein_iterator livein_begin() const;

  livein_iterator livein_end()   const { return LiveIns.end(); }

  bool            livein_empty() const { return LiveIns.empty(); }

  iterator_range<livein_iterator> liveins() const {

    return make_range(livein_begin(), livein_end());

  }

  /// Remove entry from the livein set and return iterator to the next.

  livein_iterator removeLiveIn(livein_iterator I);

  class liveout_iterator {

  public:

    using iterator_category = std::input_iterator_tag;

    using difference_type = std::ptrdiff_t;

    using value_type = RegisterMaskPair;

    using pointer = const RegisterMaskPair *;

    using reference = const RegisterMaskPair &;

    liveout_iterator(const MachineBasicBlock &MBB, MCPhysReg ExceptionPointer,

                     MCPhysReg ExceptionSelector, bool End)

        : ExceptionPointer(ExceptionPointer),

          ExceptionSelector(ExceptionSelector), BlockI(MBB.succ_begin()),

          BlockEnd(MBB.succ_end()) {

      if (End)

        BlockI = BlockEnd;

      else if (BlockI != BlockEnd) {

        LiveRegI = (*BlockI)->livein_begin();

        if (!advanceToValidPosition())

          return;

        if (LiveRegI->PhysReg == ExceptionPointer ||

            LiveRegI->PhysReg == ExceptionSelector)

          ++(*this);

      }

    }

    liveout_iterator &operator++() {

      do {

        ++LiveRegI;

        if (!advanceToValidPosition())

          return *this;

      } while ((*BlockI)->isEHPad() &&

               (LiveRegI->PhysReg == ExceptionPointer ||

                LiveRegI->PhysReg == ExceptionSelector));

      return *this;

    }

    liveout_iterator operator++(int) {

      liveout_iterator Tmp = *this;

      ++(*this);

      return Tmp;

    }

    reference operator*() const {

      return *LiveRegI;

    }

    pointer operator->() const {

      return &*LiveRegI;

    }

    bool operator==(const liveout_iterator &RHS) const {

      if (BlockI != BlockEnd)

        return BlockI == RHS.BlockI && LiveRegI == RHS.LiveRegI;

      return RHS.BlockI == BlockEnd;

    }

    bool operator!=(const liveout_iterator &RHS) const {

      return !(*this == RHS);

    }

  private:

    bool advanceToValidPosition() {

      if (LiveRegI != (*BlockI)->livein_end())

        return true;

      do {

        ++BlockI;

      } while (BlockI != BlockEnd && (*BlockI)->livein_empty());

      if (BlockI == BlockEnd)

        return false;

      LiveRegI = (*BlockI)->livein_begin();

      return true;

    }

    MCPhysReg ExceptionPointer, ExceptionSelector;

    const_succ_iterator BlockI;

    const_succ_iterator BlockEnd;

    livein_iterator LiveRegI;

  };

  /// Iterator scanning successor basic blocks' liveins to determine the

  /// registers potentially live at the end of this block. There may be

  /// duplicates or overlapping registers in the list returned.

  liveout_iterator liveout_begin() const;

  liveout_iterator liveout_end() const {

    return liveout_iterator(*this, 0, 0, true);

  }

  iterator_range<liveout_iterator> liveouts() const {

    return make_range(liveout_begin(), liveout_end());

  }

  /// Get the clobber mask for the start of this basic block. Funclets use this

  /// to prevent register allocation across funclet transitions.

  const uint32_t *getBeginClobberMask(const TargetRegisterInfo *TRI) const;

  /// Get the clobber mask for the end of the basic block.

  /// \see getBeginClobberMask()

  const uint32_t *getEndClobberMask(const TargetRegisterInfo *TRI) const;

  /// Return alignment of the basic block.

  Align getAlignment() const { return Alignment; }

  /// Set alignment of the basic block.

  void setAlignment(Align A) { Alignment = A; }

  void setAlignment(Align A, unsigned MaxBytes) {

    setAlignment(A);

    setMaxBytesForAlignment(MaxBytes);

  }

  /// Return the maximum amount of padding allowed for aligning the basic block.

  unsigned getMaxBytesForAlignment() const { return MaxBytesForAlignment; }

  /// Set the maximum amount of padding allowed for aligning the basic block

  void setMaxBytesForAlignment(unsigned MaxBytes) {

    MaxBytesForAlignment = MaxBytes;

  }

  /// Returns true if the block is a landing pad. That is this basic block is

  /// entered via an exception handler.

  bool isEHPad() const { return IsEHPad; }

  /// Indicates the block is a landing pad.  That is this basic block is entered

  /// via an exception handler.

  void setIsEHPad(bool V = true) { IsEHPad = V; }

  bool hasEHPadSuccessor() const;

  /// Returns true if this is the entry block of the function.

  bool isEntryBlock() const;

  /// Returns true if this is the entry block of an EH scope, i.e., the block

  /// that used to have a catchpad or cleanuppad instruction in the LLVM IR.

  bool isEHScopeEntry() const { return IsEHScopeEntry; }

  /// Indicates if this is the entry block of an EH scope, i.e., the block that

  /// that used to have a catchpad or cleanuppad instruction in the LLVM IR.

  void setIsEHScopeEntry(bool V = true) { IsEHScopeEntry = V; }

  /// Returns true if this is a target block of a catchret.

  bool isEHCatchretTarget() const { return IsEHCatchretTarget; }

  /// Indicates if this is a target block of a catchret.

  void setIsEHCatchretTarget(bool V = true) { IsEHCatchretTarget = V; }

  /// Returns true if this is the entry block of an EH funclet.

  bool isEHFuncletEntry() const { return IsEHFuncletEntry; }

  /// Indicates if this is the entry block of an EH funclet.

  void setIsEHFuncletEntry(bool V = true) { IsEHFuncletEntry = V; }

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

  bool isCleanupFuncletEntry() const { return IsCleanupFuncletEntry; }

  /// 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 { return IsBeginSection; }

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

  bool isEndSection() const { return IsEndSection; }

  void setIsBeginSection(bool V = true) { IsBeginSection = V; }

  void setIsEndSection(bool V = true) { IsEndSection = V; }

  std::optional<unsigned> getBBID() const { return BBID; }

  /// Returns the BBID of the block when BBAddrMapVersion >= 2, otherwise

  /// returns `MachineBasicBlock::Number`.

  /// TODO: Remove this function when version 1 is deprecated and replace its

  /// uses with `getBBID()`.

  unsigned getBBIDOrNumber() const;

  /// Returns the section ID of this basic block.

  MBBSectionID getSectionID() const { return SectionID; }

  /// Returns the unique section ID number of this basic block.

  unsigned getSectionIDNum() const {

    return ((unsigned)MBBSectionID::SectionType::Cold) -

           ((unsigned)SectionID.Type) + SectionID.Number;

  }

  /// Sets the fixed BBID of this basic block.

  void setBBID(unsigned V) {

    assert(!BBID.has_value() && "Cannot change BBID.");

    BBID = V;

  }

  /// Sets the section ID for this basic block.

  void setSectionID(MBBSectionID V) { SectionID = V; }

  /// Returns the MCSymbol marking the end of this basic block.

  MCSymbol *getEndSymbol() const;

  /// Returns true if this block may have an INLINEASM_BR (overestimate, by

  /// checking if any of the successors are indirect targets of any inlineasm_br

  /// in the function).

  bool mayHaveInlineAsmBr() const;

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

  bool isInlineAsmBrIndirectTarget() const {

    return IsInlineAsmBrIndirectTarget;

  }

  /// Indicates if this is the indirect dest of an INLINEASM_BR.

  void setIsInlineAsmBrIndirectTarget(bool V = true) {

    IsInlineAsmBrIndirectTarget = V;

  }

  /// Returns true if it is legal to hoist instructions into this block.

  bool isLegalToHoistInto() const;

  // Code Layout methods.

  /// Move 'this' block before or after the specified block.  This only moves

  /// the block, it does not modify the CFG or adjust potential fall-throughs at

  /// the end of the block.

  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 {

    return getSectionID() == MBB->getSectionID();

  }

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

  /// block layout which may have been made. PreviousLayoutSuccessor should be

  /// set to the block which may have been used as fallthrough before the block

  /// layout was modified.  If the block previously fell through to that block,

  /// it may now need a branch. If it previously branched to another block, it

  /// may now be able to fallthrough to the current layout successor.

  void updateTerminator(MachineBasicBlock *PreviousLayoutSuccessor);

  // Machine-CFG mutators

  /// Add Succ as a successor of this MachineBasicBlock.  The Predecessors list

  /// of Succ is automatically updated. PROB parameter is stored in

  /// Probabilities list. The default probability is set as unknown. Mixing

  /// known and unknown probabilities in successor list is not allowed. When all

  /// successors have unknown probabilities, 1 / N is returned as the

  /// probability for each successor, where N is the number of successors.

  ///

  /// Note that duplicate Machine CFG edges are not allowed.

  void addSuccessor(MachineBasicBlock *Succ,

                    BranchProbability Prob = BranchProbability::getUnknown());

  /// Add Succ as a successor of this MachineBasicBlock.  The Predecessors list

  /// of Succ is automatically updated. The probability is not provided because

  /// BPI is not available (e.g. -O0 is used), in which case edge probabilities

  /// won't be used. Using this interface can save some space.

  void addSuccessorWithoutProb(MachineBasicBlock *Succ);

  /// Set successor probability of a given iterator.

  void setSuccProbability(succ_iterator I, BranchProbability Prob);

  /// Normalize probabilities of all successors so that the sum of them becomes

  /// one. This is usually done when the current update on this MBB is done, and

  /// the sum of its successors' probabilities is not guaranteed to be one. The

  /// user is responsible for the correct use of this function.

  /// MBB::removeSuccessor() has an option to do this automatically.

  void normalizeSuccProbs() {

    BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());

  }

  /// Validate successors' probabilities and check if the sum of them is

  /// approximate one. This only works in DEBUG mode.

  void validateSuccProbs() const;

  /// Remove successor from the successors list of this MachineBasicBlock. The

  /// Predecessors list of Succ is automatically updated.

  /// If NormalizeSuccProbs is true, then normalize successors' probabilities

  /// after the successor is removed.

  void removeSuccessor(MachineBasicBlock *Succ,

                       bool NormalizeSuccProbs = false);

  /// Remove specified successor from the successors list of this

  /// MachineBasicBlock. The Predecessors list of Succ is automatically updated.

  /// If NormalizeSuccProbs is true, then normalize successors' probabilities

  /// after the successor is removed.

  /// Return the iterator to the element after the one removed.

  succ_iterator removeSuccessor(succ_iterator I,

                                bool NormalizeSuccProbs = false);

  /// Replace successor OLD with NEW and update probability info.

  void replaceSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New);

  /// Copy a successor (and any probability info) from original block to this

  /// block's. Uses an iterator into the original blocks successors.

  ///

  /// This is useful when doing a partial clone of successors. Afterward, the

  /// probabilities may need to be normalized.

  void copySuccessor(MachineBasicBlock *Orig, succ_iterator I);

  /// Split the old successor into old plus new and updates the probability

  /// info.

  void splitSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New,

                      bool NormalizeSuccProbs = false);

  /// Transfers all the successors from MBB to this machine basic block (i.e.,

  /// copies all the successors FromMBB and remove all the successors from

  /// FromMBB).

  void transferSuccessors(MachineBasicBlock *FromMBB);

  /// Transfers all the successors, as in transferSuccessors, and update PHI

  /// operands in the successor blocks which refer to FromMBB to refer to this.

  void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB);

  /// Return true if any of the successors have probabilities attached to them.

  bool hasSuccessorProbabilities() const { return !Probs.empty(); }

  /// Return true if the specified MBB is a predecessor of this block.

  bool isPredecessor(const MachineBasicBlock *MBB) const;

  /// Return true if the specified MBB is a successor of this block.

  bool isSuccessor(const MachineBasicBlock *MBB) const;

  /// Return true if the specified MBB will be emitted immediately after this

  /// block, such that if this block exits by falling through, control will

  /// transfer to the specified MBB. Note that MBB need not be a successor at

  /// all, for example if this block ends with an unconditional branch to some

  /// other block.

  bool isLayoutSuccessor(const MachineBasicBlock *MBB) const;

  /// Return the successor of this block if it has a single successor.

  /// Otherwise return a null pointer.

  ///

  const MachineBasicBlock *getSingleSuccessor() const;

  MachineBasicBlock *getSingleSuccessor() {

    return const_cast<MachineBasicBlock *>(

        static_cast<const MachineBasicBlock *>(this)->getSingleSuccessor());