mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-30 05:29:47 +00:00
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@206142 91177308-0d34-0410-b5e6-96231b3b80d8
253 lines
8.4 KiB
C++
253 lines
8.4 KiB
C++
//===-- CodeGen/MachineInstBundle.h - MI bundle utilities -------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file provide utility functions to manipulate machine instruction
|
|
// bundles.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CODEGEN_MACHINEINSTRBUNDLE_H
|
|
#define LLVM_CODEGEN_MACHINEINSTRBUNDLE_H
|
|
|
|
#include "llvm/CodeGen/MachineBasicBlock.h"
|
|
|
|
namespace llvm {
|
|
|
|
/// finalizeBundle - Finalize a machine instruction bundle which includes
|
|
/// a sequence of instructions starting from FirstMI to LastMI (exclusive).
|
|
/// This routine adds a BUNDLE instruction to represent the bundle, it adds
|
|
/// IsInternalRead markers to MachineOperands which are defined inside the
|
|
/// bundle, and it copies externally visible defs and uses to the BUNDLE
|
|
/// instruction.
|
|
void finalizeBundle(MachineBasicBlock &MBB,
|
|
MachineBasicBlock::instr_iterator FirstMI,
|
|
MachineBasicBlock::instr_iterator LastMI);
|
|
|
|
/// finalizeBundle - Same functionality as the previous finalizeBundle except
|
|
/// the last instruction in the bundle is not provided as an input. This is
|
|
/// used in cases where bundles are pre-determined by marking instructions
|
|
/// with 'InsideBundle' marker. It returns the MBB instruction iterator that
|
|
/// points to the end of the bundle.
|
|
MachineBasicBlock::instr_iterator finalizeBundle(MachineBasicBlock &MBB,
|
|
MachineBasicBlock::instr_iterator FirstMI);
|
|
|
|
/// finalizeBundles - Finalize instruction bundles in the specified
|
|
/// MachineFunction. Return true if any bundles are finalized.
|
|
bool finalizeBundles(MachineFunction &MF);
|
|
|
|
/// getBundleStart - Returns the first instruction in the bundle containing MI.
|
|
///
|
|
inline MachineInstr *getBundleStart(MachineInstr *MI) {
|
|
MachineBasicBlock::instr_iterator I = MI;
|
|
while (I->isBundledWithPred())
|
|
--I;
|
|
return I;
|
|
}
|
|
|
|
inline const MachineInstr *getBundleStart(const MachineInstr *MI) {
|
|
MachineBasicBlock::const_instr_iterator I = MI;
|
|
while (I->isBundledWithPred())
|
|
--I;
|
|
return I;
|
|
}
|
|
|
|
/// Return an iterator pointing beyond the bundle containing MI.
|
|
inline MachineBasicBlock::instr_iterator
|
|
getBundleEnd(MachineInstr *MI) {
|
|
MachineBasicBlock::instr_iterator I = MI;
|
|
while (I->isBundledWithSucc())
|
|
++I;
|
|
return ++I;
|
|
}
|
|
|
|
/// Return an iterator pointing beyond the bundle containing MI.
|
|
inline MachineBasicBlock::const_instr_iterator
|
|
getBundleEnd(const MachineInstr *MI) {
|
|
MachineBasicBlock::const_instr_iterator I = MI;
|
|
while (I->isBundledWithSucc())
|
|
++I;
|
|
return ++I;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// MachineOperand iterator
|
|
//
|
|
|
|
/// MachineOperandIteratorBase - Iterator that can visit all operands on a
|
|
/// MachineInstr, or all operands on a bundle of MachineInstrs. This class is
|
|
/// not intended to be used directly, use one of the sub-classes instead.
|
|
///
|
|
/// Intended use:
|
|
///
|
|
/// for (MIBundleOperands MIO(MI); MIO.isValid(); ++MIO) {
|
|
/// if (!MIO->isReg())
|
|
/// continue;
|
|
/// ...
|
|
/// }
|
|
///
|
|
class MachineOperandIteratorBase {
|
|
MachineBasicBlock::instr_iterator InstrI, InstrE;
|
|
MachineInstr::mop_iterator OpI, OpE;
|
|
|
|
// If the operands on InstrI are exhausted, advance InstrI to the next
|
|
// bundled instruction with operands.
|
|
void advance() {
|
|
while (OpI == OpE) {
|
|
// Don't advance off the basic block, or into a new bundle.
|
|
if (++InstrI == InstrE || !InstrI->isInsideBundle())
|
|
break;
|
|
OpI = InstrI->operands_begin();
|
|
OpE = InstrI->operands_end();
|
|
}
|
|
}
|
|
|
|
protected:
|
|
/// MachineOperandIteratorBase - Create an iterator that visits all operands
|
|
/// on MI, or all operands on every instruction in the bundle containing MI.
|
|
///
|
|
/// @param MI The instruction to examine.
|
|
/// @param WholeBundle When true, visit all operands on the entire bundle.
|
|
///
|
|
explicit MachineOperandIteratorBase(MachineInstr *MI, bool WholeBundle) {
|
|
if (WholeBundle) {
|
|
InstrI = getBundleStart(MI);
|
|
InstrE = MI->getParent()->instr_end();
|
|
} else {
|
|
InstrI = InstrE = MI;
|
|
++InstrE;
|
|
}
|
|
OpI = InstrI->operands_begin();
|
|
OpE = InstrI->operands_end();
|
|
if (WholeBundle)
|
|
advance();
|
|
}
|
|
|
|
MachineOperand &deref() const { return *OpI; }
|
|
|
|
public:
|
|
/// isValid - Returns true until all the operands have been visited.
|
|
bool isValid() const { return OpI != OpE; }
|
|
|
|
/// Preincrement. Move to the next operand.
|
|
void operator++() {
|
|
assert(isValid() && "Cannot advance MIOperands beyond the last operand");
|
|
++OpI;
|
|
advance();
|
|
}
|
|
|
|
/// getOperandNo - Returns the number of the current operand relative to its
|
|
/// instruction.
|
|
///
|
|
unsigned getOperandNo() const {
|
|
return OpI - InstrI->operands_begin();
|
|
}
|
|
|
|
/// VirtRegInfo - Information about a virtual register used by a set of operands.
|
|
///
|
|
struct VirtRegInfo {
|
|
/// Reads - One of the operands read the virtual register. This does not
|
|
/// include <undef> or <internal> use operands, see MO::readsReg().
|
|
bool Reads;
|
|
|
|
/// Writes - One of the operands writes the virtual register.
|
|
bool Writes;
|
|
|
|
/// Tied - Uses and defs must use the same register. This can be because of
|
|
/// a two-address constraint, or there may be a partial redefinition of a
|
|
/// sub-register.
|
|
bool Tied;
|
|
};
|
|
|
|
/// PhysRegInfo - Information about a physical register used by a set of
|
|
/// operands.
|
|
struct PhysRegInfo {
|
|
/// Clobbers - Reg or an overlapping register is defined, or a regmask
|
|
/// clobbers Reg.
|
|
bool Clobbers;
|
|
|
|
/// Defines - Reg or a super-register is defined.
|
|
bool Defines;
|
|
|
|
/// Reads - Read or a super-register is read.
|
|
bool Reads;
|
|
|
|
/// ReadsOverlap - Reg or an overlapping register is read.
|
|
bool ReadsOverlap;
|
|
|
|
/// DefinesDead - All defs of a Reg or a super-register are dead.
|
|
bool DefinesDead;
|
|
|
|
/// There is a kill of Reg or a super-register.
|
|
bool Kills;
|
|
};
|
|
|
|
/// analyzeVirtReg - Analyze how the current instruction or bundle uses a
|
|
/// virtual register. This function should not be called after operator++(),
|
|
/// it expects a fresh iterator.
|
|
///
|
|
/// @param Reg The virtual register to analyze.
|
|
/// @param Ops When set, this vector will receive an (MI, OpNum) entry for
|
|
/// each operand referring to Reg.
|
|
/// @returns A filled-in RegInfo struct.
|
|
VirtRegInfo analyzeVirtReg(unsigned Reg,
|
|
SmallVectorImpl<std::pair<MachineInstr*, unsigned> > *Ops = nullptr);
|
|
|
|
/// analyzePhysReg - Analyze how the current instruction or bundle uses a
|
|
/// physical register. This function should not be called after operator++(),
|
|
/// it expects a fresh iterator.
|
|
///
|
|
/// @param Reg The physical register to analyze.
|
|
/// @returns A filled-in PhysRegInfo struct.
|
|
PhysRegInfo analyzePhysReg(unsigned Reg, const TargetRegisterInfo *TRI);
|
|
};
|
|
|
|
/// MIOperands - Iterate over operands of a single instruction.
|
|
///
|
|
class MIOperands : public MachineOperandIteratorBase {
|
|
public:
|
|
MIOperands(MachineInstr *MI) : MachineOperandIteratorBase(MI, false) {}
|
|
MachineOperand &operator* () const { return deref(); }
|
|
MachineOperand *operator->() const { return &deref(); }
|
|
};
|
|
|
|
/// ConstMIOperands - Iterate over operands of a single const instruction.
|
|
///
|
|
class ConstMIOperands : public MachineOperandIteratorBase {
|
|
public:
|
|
ConstMIOperands(const MachineInstr *MI)
|
|
: MachineOperandIteratorBase(const_cast<MachineInstr*>(MI), false) {}
|
|
const MachineOperand &operator* () const { return deref(); }
|
|
const MachineOperand *operator->() const { return &deref(); }
|
|
};
|
|
|
|
/// MIBundleOperands - Iterate over all operands in a bundle of machine
|
|
/// instructions.
|
|
///
|
|
class MIBundleOperands : public MachineOperandIteratorBase {
|
|
public:
|
|
MIBundleOperands(MachineInstr *MI) : MachineOperandIteratorBase(MI, true) {}
|
|
MachineOperand &operator* () const { return deref(); }
|
|
MachineOperand *operator->() const { return &deref(); }
|
|
};
|
|
|
|
/// ConstMIBundleOperands - Iterate over all operands in a const bundle of
|
|
/// machine instructions.
|
|
///
|
|
class ConstMIBundleOperands : public MachineOperandIteratorBase {
|
|
public:
|
|
ConstMIBundleOperands(const MachineInstr *MI)
|
|
: MachineOperandIteratorBase(const_cast<MachineInstr*>(MI), true) {}
|
|
const MachineOperand &operator* () const { return deref(); }
|
|
const MachineOperand *operator->() const { return &deref(); }
|
|
};
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|