mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-03 18:29:48 +00:00
There is a pretty staggering amount of this in LLVM's header files, this is not all of the instances I'm afraid. These include all of the functions that (in my build) are used by a non-static inline (or external) function. Specifically, these issues were caught by the new '-Winternal-linkage-in-inline' warning. I'll try to just clean up the remainder of the clearly redundant "static inline" cases on functions (not methods!) defined within headers if I can do so in a reliable way. There were even several cases of a missing 'inline' altogether, or my personal favorite "static bool inline". Go figure. ;] git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@158800 91177308-0d34-0410-b5e6-96231b3b80d8
204 lines
7.0 KiB
C++
204 lines
7.0 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->isInsideBundle())
|
|
--I;
|
|
return I;
|
|
}
|
|
|
|
inline const MachineInstr *getBundleStart(const MachineInstr *MI) {
|
|
MachineBasicBlock::const_instr_iterator I = MI;
|
|
while (I->isInsideBundle())
|
|
--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();
|
|
}
|
|
|
|
/// RegInfo - Information about a virtual register used by a set of operands.
|
|
///
|
|
struct RegInfo {
|
|
/// 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;
|
|
};
|
|
|
|
/// 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.
|
|
RegInfo analyzeVirtReg(unsigned Reg,
|
|
SmallVectorImpl<std::pair<MachineInstr*, unsigned> > *Ops = 0);
|
|
};
|
|
|
|
/// 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
|