mirror of
https://github.com/RPCS3/llvm.git
synced 2026-01-31 01:25:19 +01:00
6b547686c5
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@351636 91177308-0d34-0410-b5e6-96231b3b80d8
118 lines
4.3 KiB
C++
118 lines
4.3 KiB
C++
//==--- llvm/CodeGen/ReachingDefAnalysis.h - Reaching Def Analysis -*- 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
/// \file Reaching Defs Analysis pass.
|
|
///
|
|
/// This pass tracks for each instruction what is the "closest" reaching def of
|
|
/// a given register. It is used by BreakFalseDeps (for clearance calculation)
|
|
/// and ExecutionDomainFix (for arbitrating conflicting domains).
|
|
///
|
|
/// Note that this is different from the usual definition notion of liveness.
|
|
/// The CPU doesn't care whether or not we consider a register killed.
|
|
///
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CODEGEN_REACHINGDEFSANALYSIS_H
|
|
#define LLVM_CODEGEN_REACHINGDEFSANALYSIS_H
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/CodeGen/LoopTraversal.h"
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
|
|
|
namespace llvm {
|
|
|
|
class MachineBasicBlock;
|
|
class MachineInstr;
|
|
|
|
/// This class provides the reaching def analysis.
|
|
class ReachingDefAnalysis : public MachineFunctionPass {
|
|
private:
|
|
MachineFunction *MF;
|
|
const TargetRegisterInfo *TRI;
|
|
unsigned NumRegUnits;
|
|
/// Instruction that defined each register, relative to the beginning of the
|
|
/// current basic block. When a LiveRegsDefInfo is used to represent a
|
|
/// live-out register, this value is relative to the end of the basic block,
|
|
/// so it will be a negative number.
|
|
using LiveRegsDefInfo = std::vector<int>;
|
|
LiveRegsDefInfo LiveRegs;
|
|
|
|
/// Keeps clearance information for all registers. Note that this
|
|
/// is different from the usual definition notion of liveness. The CPU
|
|
/// doesn't care whether or not we consider a register killed.
|
|
using OutRegsInfoMap = SmallVector<LiveRegsDefInfo, 4>;
|
|
OutRegsInfoMap MBBOutRegsInfos;
|
|
|
|
/// Current instruction number.
|
|
/// The first instruction in each basic block is 0.
|
|
int CurInstr;
|
|
|
|
/// Maps instructions to their instruction Ids, relative to the begining of
|
|
/// their basic blocks.
|
|
DenseMap<MachineInstr *, int> InstIds;
|
|
|
|
/// All reaching defs of a given RegUnit for a given MBB.
|
|
using MBBRegUnitDefs = SmallVector<int, 1>;
|
|
/// All reaching defs of all reg units for a given MBB
|
|
using MBBDefsInfo = std::vector<MBBRegUnitDefs>;
|
|
/// All reaching defs of all reg units for a all MBBs
|
|
using MBBReachingDefsInfo = SmallVector<MBBDefsInfo, 4>;
|
|
MBBReachingDefsInfo MBBReachingDefs;
|
|
|
|
/// Default values are 'nothing happened a long time ago'.
|
|
const int ReachingDefDefaultVal = -(1 << 20);
|
|
|
|
public:
|
|
static char ID; // Pass identification, replacement for typeid
|
|
|
|
ReachingDefAnalysis() : MachineFunctionPass(ID) {
|
|
initializeReachingDefAnalysisPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
void releaseMemory() override;
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
AU.setPreservesAll();
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
|
}
|
|
|
|
bool runOnMachineFunction(MachineFunction &MF) override;
|
|
|
|
MachineFunctionProperties getRequiredProperties() const override {
|
|
return MachineFunctionProperties().set(
|
|
MachineFunctionProperties::Property::NoVRegs);
|
|
}
|
|
|
|
/// Provides the instruction id of the closest reaching def instruction of
|
|
/// PhysReg that reaches MI, relative to the begining of MI's basic block.
|
|
int getReachingDef(MachineInstr *MI, int PhysReg);
|
|
|
|
/// Provides the clearance - the number of instructions since the closest
|
|
/// reaching def instuction of PhysReg that reaches MI.
|
|
int getClearance(MachineInstr *MI, MCPhysReg PhysReg);
|
|
|
|
private:
|
|
/// Set up LiveRegs by merging predecessor live-out values.
|
|
void enterBasicBlock(const LoopTraversal::TraversedMBBInfo &TraversedMBB);
|
|
|
|
/// Update live-out values.
|
|
void leaveBasicBlock(const LoopTraversal::TraversedMBBInfo &TraversedMBB);
|
|
|
|
/// Process he given basic block.
|
|
void processBasicBlock(const LoopTraversal::TraversedMBBInfo &TraversedMBB);
|
|
|
|
/// Update def-ages for registers defined by MI.
|
|
/// Also break dependencies on partial defs and undef uses.
|
|
void processDefs(MachineInstr *);
|
|
};
|
|
|
|
} // namespace llvm
|
|
|
|
#endif // LLVM_CODEGEN_REACHINGDEFSANALYSIS_H
|