MipsOptimizePICCall.cpp | Explore in Territory

//===- MipsOptimizePICCall.cpp - Optimize PIC Calls -----------------------===//
//
// 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 pass eliminates unnecessary instructions that set up $gp and replace
// instructions that load target function addresses with copy instructions.
//
//===----------------------------------------------------------------------===//

#include "MCTargetDesc/MipsBaseInfo.h"
#include "Mips.h"
#include "MipsRegisterInfo.h"
#include "MipsSubtarget.h"
#include "llvm/ADT/PointerUnion.h"
#include "llvm/ADT/ScopedHashTable.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/CodeGen/MachineDominators.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineOperand.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/TargetInstrInfo.h"
#include "llvm/CodeGen/TargetOpcodes.h"
#include "llvm/CodeGen/TargetRegisterInfo.h"
#include "llvm/CodeGen/TargetSubtargetInfo.h"
#include "llvm/CodeGenTypes/MachineValueType.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/RecyclingAllocator.h"
#include <cassert>
#include <utility>

usingnamespacellvm;

#define DEBUG_TYPE …

static cl::opt<bool> LoadTargetFromGOT("mips-load-target-from-got",
                                       cl::init(true),
                                       cl::desc("Load target address from GOT"),
                                       cl::Hidden);

static cl::opt<bool> EraseGPOpnd("mips-erase-gp-opnd",
                                 cl::init(true), cl::desc("Erase GP Operand"),
                                 cl::Hidden);

namespace {

ValueType;
CntRegP;
AllocatorTy;
ScopedHTType;

class MBBInfo { … };

class OptimizePICCall : public MachineFunctionPass { … };

} // end of anonymous namespace

char OptimizePICCall::ID = …;

/// Return the first MachineOperand of MI if it is a used virtual register.
static MachineOperand *getCallTargetRegOpnd(MachineInstr &MI) { … }

/// Return type of register Reg.
static MVT::SimpleValueType getRegTy(unsigned Reg, MachineFunction &MF) { … }

/// Do the following transformation:
///
/// jalr $vreg
/// =>
/// copy $t9, $vreg
/// jalr $t9
static void setCallTargetReg(MachineBasicBlock *MBB,
                             MachineBasicBlock::iterator I) { … }

/// Search MI's operands for register GP and erase it.
static void eraseGPOpnd(MachineInstr &MI) { … }

MBBInfo::MBBInfo(MachineDomTreeNode *N) : … { … }

const MachineDomTreeNode *MBBInfo::getNode() const { … }

bool MBBInfo::isVisited() const { … }

void MBBInfo::preVisit(ScopedHTType &ScopedHT) { … }

void MBBInfo::postVisit() { … }

// OptimizePICCall methods.
bool OptimizePICCall::runOnMachineFunction(MachineFunction &F) { … }

bool OptimizePICCall::visitNode(MBBInfo &MBBI) { … }

bool OptimizePICCall::isCallViaRegister(MachineInstr &MI, unsigned &Reg,
                                        ValueType &Val) const { … }

unsigned OptimizePICCall::getCount(ValueType Entry) { … }

unsigned OptimizePICCall::getReg(ValueType Entry) { … }

void OptimizePICCall::incCntAndSetReg(ValueType Entry, unsigned Reg) { … }

/// Return an OptimizeCall object.
FunctionPass *llvm::createMipsOptimizePICCallPass() { … }
llvm/llvm/lib/Target/Mips/MipsOptimizePICCall.cpp
