llvm/llvm/lib/CodeGen/GlobalISel/CSEInfo.cpp

//===- CSEInfo.cpp ------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
//
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/GlobalISel/CSEInfo.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/InitializePasses.h"
#include "llvm/Support/Error.h"

#define DEBUG_TYPE …

usingnamespacellvm;
char llvm::GISelCSEAnalysisWrapperPass::ID = …;
GISelCSEAnalysisWrapperPass::GISelCSEAnalysisWrapperPass()
    : … { … }
INITIALIZE_PASS_BEGIN(GISelCSEAnalysisWrapperPass, DEBUG_TYPE,
                      "Analysis containing CSE Info", false, true)
INITIALIZE_PASS_END(GISelCSEAnalysisWrapperPass, DEBUG_TYPE,
                    "Analysis containing CSE Info", false, true)

/// -------- UniqueMachineInstr -------------//

void UniqueMachineInstr::Profile(FoldingSetNodeID &ID) { … }
/// -----------------------------------------

/// --------- CSEConfigFull ---------- ///
bool CSEConfigFull::shouldCSEOpc(unsigned Opc) { … }

bool CSEConfigConstantOnly::shouldCSEOpc(unsigned Opc) { … }

std::unique_ptr<CSEConfigBase>
llvm::getStandardCSEConfigForOpt(CodeGenOptLevel Level) { … }

/// -----------------------------------------

/// -------- GISelCSEInfo -------------//
void GISelCSEInfo::setMF(MachineFunction &MF) { … }

GISelCSEInfo::~GISelCSEInfo() = default;

bool GISelCSEInfo::isUniqueMachineInstValid(
    const UniqueMachineInstr &UMI) const { … }

void GISelCSEInfo::invalidateUniqueMachineInstr(UniqueMachineInstr *UMI) { … }

UniqueMachineInstr *GISelCSEInfo::getNodeIfExists(FoldingSetNodeID &ID,
                                                  MachineBasicBlock *MBB,
                                                  void *&InsertPos) { … }

void GISelCSEInfo::insertNode(UniqueMachineInstr *UMI, void *InsertPos) { … }

UniqueMachineInstr *GISelCSEInfo::getUniqueInstrForMI(const MachineInstr *MI) { … }

void GISelCSEInfo::insertInstr(MachineInstr *MI, void *InsertPos) { … }

MachineInstr *GISelCSEInfo::getMachineInstrIfExists(FoldingSetNodeID &ID,
                                                    MachineBasicBlock *MBB,
                                                    void *&InsertPos) { … }

void GISelCSEInfo::countOpcodeHit(unsigned Opc) { … }

void GISelCSEInfo::recordNewInstruction(MachineInstr *MI) { … }

void GISelCSEInfo::handleRecordedInst(MachineInstr *MI) { … }

void GISelCSEInfo::handleRemoveInst(MachineInstr *MI) { … }

void GISelCSEInfo::handleRecordedInsts() { … }

bool GISelCSEInfo::shouldCSE(unsigned Opc) const { … }

void GISelCSEInfo::erasingInstr(MachineInstr &MI) { … }
void GISelCSEInfo::createdInstr(MachineInstr &MI) { … }
void GISelCSEInfo::changingInstr(MachineInstr &MI) { … }
void GISelCSEInfo::changedInstr(MachineInstr &MI) { … }

void GISelCSEInfo::analyze(MachineFunction &MF) { … }

void GISelCSEInfo::releaseMemory() { … }

#ifndef NDEBUG
static const char *stringify(const MachineInstr *MI, std::string &S) {
  raw_string_ostream OS(S);
  OS << *MI;
  return OS.str().c_str();
}
#endif

Error GISelCSEInfo::verify() { … }

void GISelCSEInfo::print() { … }
/// -----------------------------------------
// ---- Profiling methods for FoldingSetNode --- //
const GISelInstProfileBuilder &
GISelInstProfileBuilder::addNodeID(const MachineInstr *MI) const { … }

const GISelInstProfileBuilder &
GISelInstProfileBuilder::addNodeIDOpcode(unsigned Opc) const { … }

const GISelInstProfileBuilder &
GISelInstProfileBuilder::addNodeIDRegType(const LLT Ty) const { … }

const GISelInstProfileBuilder &
GISelInstProfileBuilder::addNodeIDRegType(const TargetRegisterClass *RC) const { … }

const GISelInstProfileBuilder &
GISelInstProfileBuilder::addNodeIDRegType(const RegisterBank *RB) const { … }

const GISelInstProfileBuilder &
GISelInstProfileBuilder::addNodeIDImmediate(int64_t Imm) const { … }

const GISelInstProfileBuilder &
GISelInstProfileBuilder::addNodeIDRegNum(Register Reg) const { … }

const GISelInstProfileBuilder &
GISelInstProfileBuilder::addNodeIDRegType(const Register Reg) const { … }

const GISelInstProfileBuilder &
GISelInstProfileBuilder::addNodeIDMBB(const MachineBasicBlock *MBB) const { … }

const GISelInstProfileBuilder &
GISelInstProfileBuilder::addNodeIDFlag(unsigned Flag) const { … }

const GISelInstProfileBuilder &
GISelInstProfileBuilder::addNodeIDReg(Register Reg) const { … }

const GISelInstProfileBuilder &GISelInstProfileBuilder::addNodeIDMachineOperand(
    const MachineOperand &MO) const { … }

GISelCSEInfo &
GISelCSEAnalysisWrapper::get(std::unique_ptr<CSEConfigBase> CSEOpt,
                             bool Recompute) { … }
void GISelCSEAnalysisWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const { … }

bool GISelCSEAnalysisWrapperPass::runOnMachineFunction(MachineFunction &MF) { … }