llvm/bolt/lib/Core/BinaryBasicBlock.cpp

//===- bolt/Core/BinaryBasicBlock.cpp - Low-level basic block -------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file implements the BinaryBasicBlock class.
//
//===----------------------------------------------------------------------===//

#include "bolt/Core/BinaryBasicBlock.h"
#include "bolt/Core/BinaryContext.h"
#include "bolt/Core/BinaryFunction.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/MC/MCInst.h"
#include "llvm/Support/Errc.h"

#define DEBUG_TYPE …

namespace llvm {
namespace bolt {

constexpr uint32_t BinaryBasicBlock::INVALID_OFFSET;

bool operator<(const BinaryBasicBlock &LHS, const BinaryBasicBlock &RHS) { … }

bool BinaryBasicBlock::hasCFG() const { … }

bool BinaryBasicBlock::isEntryPoint() const { … }

bool BinaryBasicBlock::hasInstructions() const { … }

const JumpTable *BinaryBasicBlock::getJumpTable() const { … }

void BinaryBasicBlock::adjustNumPseudos(const MCInst &Inst, int Sign) { … }

BinaryBasicBlock::iterator BinaryBasicBlock::getFirstNonPseudo() { … }

BinaryBasicBlock::reverse_iterator BinaryBasicBlock::getLastNonPseudo() { … }

bool BinaryBasicBlock::validateSuccessorInvariants() { … }

BinaryBasicBlock *BinaryBasicBlock::getSuccessor(const MCSymbol *Label) const { … }

BinaryBasicBlock *BinaryBasicBlock::getSuccessor(const MCSymbol *Label,
                                                 BinaryBranchInfo &BI) const { … }

BinaryBasicBlock *BinaryBasicBlock::getLandingPad(const MCSymbol *Label) const { … }

int32_t BinaryBasicBlock::getCFIStateAtInstr(const MCInst *Instr) const { … }

void BinaryBasicBlock::addSuccessor(BinaryBasicBlock *Succ, uint64_t Count,
                                    uint64_t MispredictedCount) { … }

void BinaryBasicBlock::replaceSuccessor(BinaryBasicBlock *Succ,
                                        BinaryBasicBlock *NewSucc,
                                        uint64_t Count,
                                        uint64_t MispredictedCount) { … }

void BinaryBasicBlock::removeAllSuccessors() { … }

void BinaryBasicBlock::removeSuccessor(BinaryBasicBlock *Succ) { … }

void BinaryBasicBlock::addPredecessor(BinaryBasicBlock *Pred) { … }

void BinaryBasicBlock::removePredecessor(BinaryBasicBlock *Pred,
                                         bool Multiple) { … }

void BinaryBasicBlock::removeDuplicateConditionalSuccessor(MCInst *CondBranch) { … }

void BinaryBasicBlock::updateJumpTableSuccessors() { … }

void BinaryBasicBlock::adjustExecutionCount(double Ratio) { … }

bool BinaryBasicBlock::analyzeBranch(const MCSymbol *&TBB, const MCSymbol *&FBB,
                                     MCInst *&CondBranch,
                                     MCInst *&UncondBranch) { … }

MCInst *BinaryBasicBlock::getTerminatorBefore(MCInst *Pos) { … }

bool BinaryBasicBlock::hasTerminatorAfter(MCInst *Pos) { … }

bool BinaryBasicBlock::swapConditionalSuccessors() { … }

void BinaryBasicBlock::addBranchInstruction(const BinaryBasicBlock *Successor) { … }

void BinaryBasicBlock::addTailCallInstruction(const MCSymbol *Target) { … }

uint32_t BinaryBasicBlock::getNumCalls() const { … }

uint32_t BinaryBasicBlock::getNumPseudos() const { … }

ErrorOr<std::pair<double, double>>
BinaryBasicBlock::getBranchStats(const BinaryBasicBlock *Succ) const { … }

void BinaryBasicBlock::dump() const { … }

uint64_t BinaryBasicBlock::estimateSize(const MCCodeEmitter *Emitter) const { … }

BinaryBasicBlock::BinaryBranchInfo &
BinaryBasicBlock::getBranchInfo(const BinaryBasicBlock &Succ) { … }

const BinaryBasicBlock::BinaryBranchInfo &
BinaryBasicBlock::getBranchInfo(const BinaryBasicBlock &Succ) const { … }

BinaryBasicBlock *BinaryBasicBlock::splitAt(iterator II) { … }

} // namespace bolt
} // namespace llvm