namespace llvm {
class CallLowering;
class InstructionSelector;
-class MachineLegalizer;
+class LegalizerInfo;
class RegisterBankInfo;
/// The goal of this helper class is to gather the accessor to all
virtual const InstructionSelector *getInstructionSelector() const {
return nullptr;
}
- virtual const MachineLegalizer *getMachineLegalizer() const {
- return nullptr;
- }
+ virtual const LegalizerInfo *getLegalizerInfo() const { return nullptr; }
virtual const RegisterBankInfo *getRegBankInfo() const { return nullptr;}
};
} // End namespace llvm;
-//== llvm/CodeGen/GlobalISel/MachineLegalizePass.h ------------- -*- C++ -*-==//
+//== llvm/CodeGen/GlobalISel/LegalizePass.h ------------- -*- C++ -*-==//
//
// The LLVM Compiler Infrastructure
//
class MachineRegisterInfo;
-class MachineLegalizePass : public MachineFunctionPass {
+class Legalizer : public MachineFunctionPass {
public:
static char ID;
public:
// Ctor, nothing fancy.
- MachineLegalizePass();
+ Legalizer();
- StringRef getPassName() const override { return "MachineLegalizePass"; }
+ StringRef getPassName() const override { return "Legalizer"; }
void getAnalysisUsage(AnalysisUsage &AU) const override;
-//== llvm/CodeGen/GlobalISel/MachineLegalizeHelper.h ----------- -*- C++ -*-==//
+//== llvm/CodeGen/GlobalISel/LegalizerHelper.h ---------------- -*- C++ -*-==//
//
// The LLVM Compiler Infrastructure
//
/// occur in multiple phases, for example G_ADD <2 x i8> -> G_ADD <2 x i16> ->
/// G_ADD <4 x i16>.
///
-/// The MachineLegalizeHelper class is where most of the work happens, and is
+/// The LegalizerHelper class is where most of the work happens, and is
/// designed to be callable from other passes that find themselves with an
/// illegal instruction.
//
namespace llvm {
// Forward declarations.
-class MachineLegalizeInfo;
-class MachineLegalizer;
+class LegalizerInfo;
+class Legalizer;
class MachineRegisterInfo;
-class MachineLegalizeHelper {
+class LegalizerHelper {
public:
enum LegalizeResult {
/// Instruction was already legal and no change was made to the
UnableToLegalize,
};
- MachineLegalizeHelper(MachineFunction &MF);
+ LegalizerHelper(MachineFunction &MF);
/// Replace \p MI by a sequence of legal instructions that can implement the
/// same operation. Note that this means \p MI may be deleted, so any iterator
/// Considered as an opaque blob, the legal code will use and define the same
/// registers as \p MI.
LegalizeResult legalizeInstrStep(MachineInstr &MI,
- const MachineLegalizer &Legalizer);
+ const LegalizerInfo &LegalizerInfo);
LegalizeResult legalizeInstr(MachineInstr &MI,
- const MachineLegalizer &Legalizer);
+ const LegalizerInfo &LegalizerInfo);
/// Legalize an instruction by emiting a runtime library call instead.
LegalizeResult libcall(MachineInstr &MI);
-//==-- llvm/CodeGen/GlobalISel/MachineLegalizer.h ----------------*- C++ -*-==//
+//==-- llvm/CodeGen/GlobalISel/LegalizerInfo.h -------------------*- C++ -*-==//
//
// The LLVM Compiler Infrastructure
//
}
};
-class MachineLegalizer {
+class LegalizerInfo {
public:
enum LegalizeAction : std::uint8_t {
/// The operation is expected to be selectable directly by the target, and
NotFound,
};
- MachineLegalizer();
+ LegalizerInfo();
/// Compute any ancillary tables needed to quickly decide how an operation
/// should be handled. This must be called after all "set*Action"methods but
void initializeLazyBranchProbabilityInfoPassPass(PassRegistry&);
void initializeLazyBlockFrequencyInfoPassPass(PassRegistry&);
void initializeLazyValueInfoWrapperPassPass(PassRegistry&);
+void initializeLegalizerPass(PassRegistry&);
void initializeLintPass(PassRegistry&);
void initializeLiveDebugValuesPass(PassRegistry&);
void initializeLiveDebugVariablesPass(PassRegistry&);
void initializeMachineDominanceFrontierPass(PassRegistry&);
void initializeMachineDominatorTreePass(PassRegistry&);
void initializeMachineFunctionPrinterPassPass(PassRegistry&);
-void initializeMachineLegalizePassPass(PassRegistry&);
void initializeMachineLICMPass(PassRegistry&);
void initializeMachineLoopInfoPass(PassRegistry&);
void initializeMachineModuleInfoPass(PassRegistry&);
class CallLowering;
class DataLayout;
class InstructionSelector;
+class LegalizerInfo;
class MachineFunction;
class MachineInstr;
-class MachineLegalizer;
class RegisterBankInfo;
class SDep;
class SUnit;
return nullptr;
}
- virtual const MachineLegalizer *getMachineLegalizer() const {
- return nullptr;
- }
+ virtual const LegalizerInfo *getLegalizerInfo() const { return nullptr; }
/// getRegisterInfo - If register information is available, return it. If
/// not, return null.
InstructionSelect.cpp
InstructionSelector.cpp
MachineIRBuilder.cpp
- MachineLegalizeHelper.cpp
- MachineLegalizePass.cpp
- MachineLegalizer.cpp
+ LegalizerHelper.cpp
+ Legalizer.cpp
+ LegalizerInfo.cpp
RegBankSelect.cpp
RegisterBank.cpp
RegisterBankInfo.cpp
void llvm::initializeGlobalISel(PassRegistry &Registry) {
initializeIRTranslatorPass(Registry);
- initializeMachineLegalizePassPass(Registry);
+ initializeLegalizerPass(Registry);
initializeRegBankSelectPass(Registry);
initializeInstructionSelectPass(Registry);
}
#include "llvm/ADT/PostOrderIterator.h"
#include "llvm/ADT/Twine.h"
#include "llvm/CodeGen/GlobalISel/InstructionSelector.h"
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/TargetPassConfig.h"
#include "llvm/IR/Function.h"
// Check that our input is fully legal: we require the function to have the
// Legalized property, so it should be.
// FIXME: This should be in the MachineVerifier, but it can't use the
- // MachineLegalizer as it's currently in the separate GlobalISel library.
+ // LegalizerInfo as it's currently in the separate GlobalISel library.
// The RegBankSelected property is already checked in the verifier. Note
// that it has the same layering problem, but we only use inline methods so
// end up not needing to link against the GlobalISel library.
const MachineRegisterInfo &MRI = MF.getRegInfo();
- if (const MachineLegalizer *MLI = MF.getSubtarget().getMachineLegalizer())
+ if (const LegalizerInfo *MLI = MF.getSubtarget().getLegalizerInfo())
for (const MachineBasicBlock &MBB : MF)
for (const MachineInstr &MI : MBB)
if (isPreISelGenericOpcode(MI.getOpcode()) && !MLI->isLegal(MI, MRI))
-//===-- llvm/CodeGen/GlobalISel/MachineLegalizePass.cpp -------------------===//
+//===-- llvm/CodeGen/GlobalISel/Legalizer.cpp -----------------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-/// \file This file implements the LegalizeHelper class to legalize individual
-/// instructions and the MachineLegalizePass wrapper pass for the primary
+/// \file This file implements the LegalizerHelper class to legalize individual
+/// instructions and the LegalizePass wrapper pass for the primary
/// legalization.
//
//===----------------------------------------------------------------------===//
-#include "llvm/CodeGen/GlobalISel/MachineLegalizePass.h"
-#include "llvm/CodeGen/GlobalISel/MachineLegalizeHelper.h"
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
+#include "llvm/CodeGen/GlobalISel/Legalizer.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerHelper.h"
+#include "llvm/CodeGen/GlobalISel/Legalizer.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/TargetPassConfig.h"
#include "llvm/Support/Debug.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetSubtargetInfo.h"
-#define DEBUG_TYPE "legalize-mir"
+#define DEBUG_TYPE "legalizer"
using namespace llvm;
-char MachineLegalizePass::ID = 0;
-INITIALIZE_PASS_BEGIN(MachineLegalizePass, DEBUG_TYPE,
+char Legalizer::ID = 0;
+INITIALIZE_PASS_BEGIN(Legalizer, DEBUG_TYPE,
"Legalize the Machine IR a function's Machine IR", false,
false)
INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)
-INITIALIZE_PASS_END(MachineLegalizePass, DEBUG_TYPE,
+INITIALIZE_PASS_END(Legalizer, DEBUG_TYPE,
"Legalize the Machine IR a function's Machine IR", false,
false)
-MachineLegalizePass::MachineLegalizePass() : MachineFunctionPass(ID) {
- initializeMachineLegalizePassPass(*PassRegistry::getPassRegistry());
+Legalizer::Legalizer() : MachineFunctionPass(ID) {
+ initializeLegalizerPass(*PassRegistry::getPassRegistry());
}
-void MachineLegalizePass::getAnalysisUsage(AnalysisUsage &AU) const {
+void Legalizer::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<TargetPassConfig>();
MachineFunctionPass::getAnalysisUsage(AU);
}
-void MachineLegalizePass::init(MachineFunction &MF) {
+void Legalizer::init(MachineFunction &MF) {
}
-bool MachineLegalizePass::combineExtracts(MachineInstr &MI,
- MachineRegisterInfo &MRI,
- const TargetInstrInfo &TII) {
+bool Legalizer::combineExtracts(MachineInstr &MI, MachineRegisterInfo &MRI,
+ const TargetInstrInfo &TII) {
bool Changed = false;
if (MI.getOpcode() != TargetOpcode::G_EXTRACT)
return Changed;
return Changed;
}
-bool MachineLegalizePass::runOnMachineFunction(MachineFunction &MF) {
+bool Legalizer::runOnMachineFunction(MachineFunction &MF) {
// If the ISel pipeline failed, do not bother running that pass.
if (MF.getProperties().hasProperty(
MachineFunctionProperties::Property::FailedISel))
DEBUG(dbgs() << "Legalize Machine IR for: " << MF.getName() << '\n');
init(MF);
const TargetPassConfig &TPC = getAnalysis<TargetPassConfig>();
- const MachineLegalizer &Legalizer = *MF.getSubtarget().getMachineLegalizer();
- MachineLegalizeHelper Helper(MF);
+ const LegalizerInfo &LegalizerInfo = *MF.getSubtarget().getLegalizerInfo();
+ LegalizerHelper Helper(MF);
// FIXME: an instruction may need more than one pass before it is legal. For
// example on most architectures <3 x i3> is doubly-illegal. It would
if (!isPreISelGenericOpcode(MI->getOpcode()))
continue;
- auto Res = Helper.legalizeInstr(*MI, Legalizer);
+ auto Res = Helper.legalizeInstr(*MI, LegalizerInfo);
// Error out if we couldn't legalize this instruction. We may want to fall
// back to DAG ISel instead in the future.
- if (Res == MachineLegalizeHelper::UnableToLegalize) {
+ if (Res == LegalizerHelper::UnableToLegalize) {
if (!TPC.isGlobalISelAbortEnabled()) {
MF.getProperties().set(
MachineFunctionProperties::Property::FailedISel);
report_fatal_error(OS.str());
}
- Changed |= Res == MachineLegalizeHelper::Legalized;
+ Changed |= Res == LegalizerHelper::Legalized;
}
-//===-- llvm/CodeGen/GlobalISel/MachineLegalizeHelper.cpp -----------------===//
+//===-- llvm/CodeGen/GlobalISel/LegalizerHelper.cpp -----------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-/// \file This file implements the MachineLegalizeHelper class to legalize
+/// \file This file implements the LegalizerHelper class to legalize
/// individual instructions and the LegalizeMachineIR wrapper pass for the
/// primary legalization.
//
//===----------------------------------------------------------------------===//
-#include "llvm/CodeGen/GlobalISel/MachineLegalizeHelper.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerHelper.h"
#include "llvm/CodeGen/GlobalISel/CallLowering.h"
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
-MachineLegalizeHelper::MachineLegalizeHelper(MachineFunction &MF)
+LegalizerHelper::LegalizerHelper(MachineFunction &MF)
: MRI(MF.getRegInfo()) {
MIRBuilder.setMF(MF);
}
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::legalizeInstrStep(MachineInstr &MI,
- const MachineLegalizer &Legalizer) {
- auto Action = Legalizer.getAction(MI, MRI);
+LegalizerHelper::LegalizeResult
+LegalizerHelper::legalizeInstrStep(MachineInstr &MI,
+ const LegalizerInfo &LegalizerInfo) {
+ auto Action = LegalizerInfo.getAction(MI, MRI);
switch (std::get<0>(Action)) {
- case MachineLegalizer::Legal:
+ case LegalizerInfo::Legal:
return AlreadyLegal;
- case MachineLegalizer::Libcall:
+ case LegalizerInfo::Libcall:
return libcall(MI);
- case MachineLegalizer::NarrowScalar:
+ case LegalizerInfo::NarrowScalar:
return narrowScalar(MI, std::get<1>(Action), std::get<2>(Action));
- case MachineLegalizer::WidenScalar:
+ case LegalizerInfo::WidenScalar:
return widenScalar(MI, std::get<1>(Action), std::get<2>(Action));
- case MachineLegalizer::Lower:
+ case LegalizerInfo::Lower:
return lower(MI, std::get<1>(Action), std::get<2>(Action));
- case MachineLegalizer::FewerElements:
+ case LegalizerInfo::FewerElements:
return fewerElementsVector(MI, std::get<1>(Action), std::get<2>(Action));
default:
return UnableToLegalize;
}
}
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::legalizeInstr(MachineInstr &MI,
- const MachineLegalizer &Legalizer) {
+LegalizerHelper::LegalizeResult
+LegalizerHelper::legalizeInstr(MachineInstr &MI,
+ const LegalizerInfo &LegalizerInfo) {
SmallVector<MachineInstr *, 4> WorkList;
MIRBuilder.recordInsertions(
[&](MachineInstr *MI) { WorkList.push_back(MI); });
LegalizeResult Res;
unsigned Idx = 0;
do {
- Res = legalizeInstrStep(*WorkList[Idx], Legalizer);
+ Res = legalizeInstrStep(*WorkList[Idx], LegalizerInfo);
if (Res == UnableToLegalize) {
MIRBuilder.stopRecordingInsertions();
return UnableToLegalize;
return Changed ? Legalized : AlreadyLegal;
}
-void MachineLegalizeHelper::extractParts(unsigned Reg, LLT Ty, int NumParts,
- SmallVectorImpl<unsigned> &VRegs) {
+void LegalizerHelper::extractParts(unsigned Reg, LLT Ty, int NumParts,
+ SmallVectorImpl<unsigned> &VRegs) {
unsigned Size = Ty.getSizeInBits();
SmallVector<uint64_t, 4> Indexes;
for (int i = 0; i < NumParts; ++i) {
MIRBuilder.buildExtract(VRegs, Indexes, Reg);
}
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::libcall(MachineInstr &MI) {
+LegalizerHelper::LegalizeResult
+LegalizerHelper::libcall(MachineInstr &MI) {
LLT Ty = MRI.getType(MI.getOperand(0).getReg());
unsigned Size = Ty.getSizeInBits();
MIRBuilder.setInstr(MI);
}
}
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::narrowScalar(MachineInstr &MI, unsigned TypeIdx,
- LLT NarrowTy) {
+LegalizerHelper::LegalizeResult LegalizerHelper::narrowScalar(MachineInstr &MI,
+ unsigned TypeIdx,
+ LLT NarrowTy) {
// FIXME: Don't know how to handle secondary types yet.
if (TypeIdx != 0)
return UnableToLegalize;
}
}
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx,
- LLT WideTy) {
+LegalizerHelper::LegalizeResult
+LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
MIRBuilder.setInstr(MI);
switch (MI.getOpcode()) {
}
}
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::lower(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
+LegalizerHelper::LegalizeResult
+LegalizerHelper::lower(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
using namespace TargetOpcode;
MIRBuilder.setInstr(MI);
}
}
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::fewerElementsVector(MachineInstr &MI, unsigned TypeIdx,
- LLT NarrowTy) {
+LegalizerHelper::LegalizeResult
+LegalizerHelper::fewerElementsVector(MachineInstr &MI, unsigned TypeIdx,
+ LLT NarrowTy) {
// FIXME: Don't know how to handle secondary types yet.
if (TypeIdx != 0)
return UnableToLegalize;
-//===---- lib/CodeGen/GlobalISel/MachineLegalizer.cpp - IRTranslator -------==//
+//===---- lib/CodeGen/GlobalISel/LegalizerInfo.cpp - Legalizer -------==//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
#include "llvm/ADT/SmallBitVector.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/Target/TargetOpcodes.h"
using namespace llvm;
-MachineLegalizer::MachineLegalizer() : TablesInitialized(false) {
+LegalizerInfo::LegalizerInfo() : TablesInitialized(false) {
// FIXME: these two can be legalized to the fundamental load/store Jakob
// proposed. Once loads & stores are supported.
DefaultActions[TargetOpcode::G_ANYEXT] = Legal;
DefaultActions[TargetOpcode::G_BRCOND] = WidenScalar;
}
-void MachineLegalizer::computeTables() {
+void LegalizerInfo::computeTables() {
for (unsigned Opcode = 0; Opcode <= LastOp - FirstOp; ++Opcode) {
for (unsigned Idx = 0; Idx != Actions[Opcode].size(); ++Idx) {
for (auto &Action : Actions[Opcode][Idx]) {
// probably going to need specialized lookup structures for various types before
// we have any hope of doing well with something like <13 x i3>. Even the common
// cases should do better than what we have now.
-std::pair<MachineLegalizer::LegalizeAction, LLT>
-MachineLegalizer::getAction(const InstrAspect &Aspect) const {
+std::pair<LegalizerInfo::LegalizeAction, LLT>
+LegalizerInfo::getAction(const InstrAspect &Aspect) const {
assert(TablesInitialized && "backend forgot to call computeTables");
// These *have* to be implemented for now, they're the fundamental basis of
// how everything else is transformed.
return findLegalAction(Aspect, FewerElements);
}
-std::tuple<MachineLegalizer::LegalizeAction, unsigned, LLT>
-MachineLegalizer::getAction(const MachineInstr &MI,
- const MachineRegisterInfo &MRI) const {
+std::tuple<LegalizerInfo::LegalizeAction, unsigned, LLT>
+LegalizerInfo::getAction(const MachineInstr &MI,
+ const MachineRegisterInfo &MRI) const {
SmallBitVector SeenTypes(8);
const MCOperandInfo *OpInfo = MI.getDesc().OpInfo;
for (unsigned i = 0; i < MI.getDesc().getNumOperands(); ++i) {
return std::make_tuple(Legal, 0, LLT{});
}
-bool MachineLegalizer::isLegal(const MachineInstr &MI,
- const MachineRegisterInfo &MRI) const {
+bool LegalizerInfo::isLegal(const MachineInstr &MI,
+ const MachineRegisterInfo &MRI) const {
return std::get<0>(getAction(MI, MRI)) == Legal;
}
-LLT MachineLegalizer::findLegalType(const InstrAspect &Aspect,
- LegalizeAction Action) const {
+LLT LegalizerInfo::findLegalType(const InstrAspect &Aspect,
+ LegalizeAction Action) const {
switch(Action) {
default:
llvm_unreachable("Cannot find legal type");
#include "llvm/CodeGen/GlobalISel/RegBankSelect.h"
#include "llvm/ADT/PostOrderIterator.h"
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
#include "llvm/CodeGen/GlobalISel/RegisterBank.h"
#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
#include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
// Check that our input is fully legal: we require the function to have the
// Legalized property, so it should be.
// FIXME: This should be in the MachineVerifier, but it can't use the
- // MachineLegalizer as it's currently in the separate GlobalISel library.
+ // LegalizerInfo as it's currently in the separate GlobalISel library.
const MachineRegisterInfo &MRI = MF.getRegInfo();
- if (const MachineLegalizer *MLI = MF.getSubtarget().getMachineLegalizer()) {
+ if (const LegalizerInfo *MLI = MF.getSubtarget().getLegalizerInfo()) {
for (const MachineBasicBlock &MBB : MF) {
for (const MachineInstr &MI : MBB) {
if (isPreISelGenericOpcode(MI.getOpcode()) && !MLI->isLegal(MI, MRI)) {
-//===- AArch64MachineLegalizer.cpp -------------------------------*- C++ -*-==//
+//===- AArch64LegalizerInfo.cpp ----------------------------------*- C++ -*-==//
//
// The LLVM Compiler Infrastructure
//
/// \todo This should be generated by TableGen.
//===----------------------------------------------------------------------===//
-#include "AArch64MachineLegalizer.h"
+#include "AArch64LegalizerInfo.h"
#include "llvm/CodeGen/ValueTypes.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/DerivedTypes.h"
#error "You shouldn't build this"
#endif
-AArch64MachineLegalizer::AArch64MachineLegalizer() {
+AArch64LegalizerInfo::AArch64LegalizerInfo() {
using namespace TargetOpcode;
const LLT p0 = LLT::pointer(0, 64);
const LLT s1 = LLT::scalar(1);
-//===- AArch64Machinelegalizer --------------------------------*- C++ -*-==//
+//===- AArch64LegalizerInfo --------------------------------------*- C++ -*-==//
//
// The LLVM Compiler Infrastructure
//
#ifndef LLVM_LIB_TARGET_AARCH64_AARCH64MACHINELEGALIZER_H
#define LLVM_LIB_TARGET_AARCH64_AARCH64MACHINELEGALIZER_H
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
namespace llvm {
class LLVMContext;
/// This class provides the information for the target register banks.
-class AArch64MachineLegalizer : public MachineLegalizer {
+class AArch64LegalizerInfo : public LegalizerInfo {
public:
- AArch64MachineLegalizer();
+ AArch64LegalizerInfo();
};
} // End llvm namespace.
#endif
return GISel->getInstructionSelector();
}
-const MachineLegalizer *AArch64Subtarget::getMachineLegalizer() const {
+const LegalizerInfo *AArch64Subtarget::getLegalizerInfo() const {
assert(GISel && "Access to GlobalISel APIs not set");
- return GISel->getMachineLegalizer();
+ return GISel->getLegalizerInfo();
}
const RegisterBankInfo *AArch64Subtarget::getRegBankInfo() const {
}
const CallLowering *getCallLowering() const override;
const InstructionSelector *getInstructionSelector() const override;
- const MachineLegalizer *getMachineLegalizer() const override;
+ const LegalizerInfo *getLegalizerInfo() const override;
const RegisterBankInfo *getRegBankInfo() const override;
const Triple &getTargetTriple() const { return TargetTriple; }
bool enableMachineScheduler() const override { return true; }
#include "AArch64.h"
#include "AArch64CallLowering.h"
#include "AArch64InstructionSelector.h"
-#include "AArch64MachineLegalizer.h"
+#include "AArch64LegalizerInfo.h"
#include "AArch64RegisterBankInfo.h"
#include "AArch64TargetMachine.h"
#include "AArch64TargetObjectFile.h"
#include "AArch64TargetTransformInfo.h"
#include "llvm/CodeGen/GlobalISel/IRTranslator.h"
#include "llvm/CodeGen/GlobalISel/InstructionSelect.h"
-#include "llvm/CodeGen/GlobalISel/MachineLegalizePass.h"
+#include "llvm/CodeGen/GlobalISel/Legalizer.h"
#include "llvm/CodeGen/GlobalISel/RegBankSelect.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/CodeGen/RegAllocRegistry.h"
struct AArch64GISelActualAccessor : public GISelAccessor {
std::unique_ptr<CallLowering> CallLoweringInfo;
std::unique_ptr<InstructionSelector> InstSelector;
- std::unique_ptr<MachineLegalizer> Legalizer;
+ std::unique_ptr<LegalizerInfo> Legalizer;
std::unique_ptr<RegisterBankInfo> RegBankInfo;
const CallLowering *getCallLowering() const override {
return CallLoweringInfo.get();
const InstructionSelector *getInstructionSelector() const override {
return InstSelector.get();
}
- const class MachineLegalizer *getMachineLegalizer() const override {
+ const class LegalizerInfo *getLegalizerInfo() const override {
return Legalizer.get();
}
const RegisterBankInfo *getRegBankInfo() const override {
new AArch64GISelActualAccessor();
GISel->CallLoweringInfo.reset(
new AArch64CallLowering(*I->getTargetLowering()));
- GISel->Legalizer.reset(new AArch64MachineLegalizer());
+ GISel->Legalizer.reset(new AArch64LegalizerInfo());
auto *RBI = new AArch64RegisterBankInfo(*I->getRegisterInfo());
return false;
}
bool AArch64PassConfig::addLegalizeMachineIR() {
- addPass(new MachineLegalizePass());
+ addPass(new Legalizer());
return false;
}
bool AArch64PassConfig::addRegBankSelect() {
set(GLOBAL_ISEL_FILES
AArch64CallLowering.cpp
AArch64InstructionSelector.cpp
- AArch64MachineLegalizer.cpp
+ AArch64LegalizerInfo.cpp
AArch64RegisterBankInfo.cpp
)
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
%sext = shl <4 x i32> %mul.i, <i32 16, i32 16, i32 16, i32 16>
%vmovl.i.i = ashr <4 x i32> %sext, <i32 16, i32 16, i32 16, i32 16>
ret <4 x i32> %vmovl.i.i
-}
\ No newline at end of file
+}
%mul1 = fmul double %b, 0.000000e+00
%sub = fsub double %mul, %mul1
ret double %sub
-}
\ No newline at end of file
+}
; RUN: llc -mtriple=arm64-linux-gnu -o - %s | FileCheck %s --check-prefix=CHECK-ELF
; CHECK-MACHO: .subsections_via_symbols
-; CHECK-ELF-NOT: .subsections_via_symbols
\ No newline at end of file
+; CHECK-ELF-NOT: .subsections_via_symbols
ret i32 0
}
-attributes #0 = { nounwind }
\ No newline at end of file
+attributes #0 = { nounwind }
; CHECK-OBJ: 0: c0 03 5f d6 ret
ret void
-}
\ No newline at end of file
+}
if(LLVM_BUILD_GLOBAL_ISEL)
add_llvm_unittest(GlobalISelTests
- MachineLegalizerTest.cpp
+ LegalizerInfoTest.cpp
)
endif()
--- /dev/null
+//===- llvm/unittest/CodeGen/GlobalISel/LegalizerInfoTest.cpp -------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
+#include "llvm/Target/TargetOpcodes.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+// Define a couple of pretty printers to help debugging when things go wrong.
+namespace llvm {
+std::ostream &
+operator<<(std::ostream &OS, const llvm::LegalizerInfo::LegalizeAction Act) {
+ switch (Act) {
+ case LegalizerInfo::Lower: OS << "Lower"; break;
+ case LegalizerInfo::Legal: OS << "Legal"; break;
+ case LegalizerInfo::NarrowScalar: OS << "NarrowScalar"; break;
+ case LegalizerInfo::WidenScalar: OS << "WidenScalar"; break;
+ case LegalizerInfo::FewerElements: OS << "FewerElements"; break;
+ case LegalizerInfo::MoreElements: OS << "MoreElements"; break;
+ case LegalizerInfo::Libcall: OS << "Libcall"; break;
+ case LegalizerInfo::Custom: OS << "Custom"; break;
+ case LegalizerInfo::Unsupported: OS << "Unsupported"; break;
+ case LegalizerInfo::NotFound: OS << "NotFound";
+ }
+ return OS;
+}
+
+std::ostream &
+operator<<(std::ostream &OS, const llvm::LLT Ty) {
+ std::string Repr;
+ raw_string_ostream SS{Repr};
+ Ty.print(SS);
+ OS << SS.str();
+ return OS;
+}
+}
+
+namespace {
+
+
+TEST(LegalizerInfoTest, ScalarRISC) {
+ using namespace TargetOpcode;
+ LegalizerInfo L;
+ // Typical RISCy set of operations based on AArch64.
+ L.setAction({G_ADD, LLT::scalar(8)}, LegalizerInfo::WidenScalar);
+ L.setAction({G_ADD, LLT::scalar(16)}, LegalizerInfo::WidenScalar);
+ L.setAction({G_ADD, LLT::scalar(32)}, LegalizerInfo::Legal);
+ L.setAction({G_ADD, LLT::scalar(64)}, LegalizerInfo::Legal);
+ L.computeTables();
+
+ // Check we infer the correct types and actually do what we're told.
+ ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(8)}),
+ std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32)));
+ ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(16)}),
+ std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32)));
+ ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(32)}),
+ std::make_pair(LegalizerInfo::Legal, LLT::scalar(32)));
+ ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(64)}),
+ std::make_pair(LegalizerInfo::Legal, LLT::scalar(64)));
+
+ // Make sure the default for over-sized types applies.
+ ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(128)}),
+ std::make_pair(LegalizerInfo::NarrowScalar, LLT::scalar(64)));
+}
+
+TEST(LegalizerInfoTest, VectorRISC) {
+ using namespace TargetOpcode;
+ LegalizerInfo L;
+ // Typical RISCy set of operations based on ARM.
+ L.setScalarInVectorAction(G_ADD, LLT::scalar(8), LegalizerInfo::Legal);
+ L.setScalarInVectorAction(G_ADD, LLT::scalar(16), LegalizerInfo::Legal);
+ L.setScalarInVectorAction(G_ADD, LLT::scalar(32), LegalizerInfo::Legal);
+
+ L.setAction({G_ADD, LLT::vector(8, 8)}, LegalizerInfo::Legal);
+ L.setAction({G_ADD, LLT::vector(16, 8)}, LegalizerInfo::Legal);
+ L.setAction({G_ADD, LLT::vector(4, 16)}, LegalizerInfo::Legal);
+ L.setAction({G_ADD, LLT::vector(8, 16)}, LegalizerInfo::Legal);
+ L.setAction({G_ADD, LLT::vector(2, 32)}, LegalizerInfo::Legal);
+ L.setAction({G_ADD, LLT::vector(4, 32)}, LegalizerInfo::Legal);
+ L.computeTables();
+
+ // Check we infer the correct types and actually do what we're told for some
+ // simple cases.
+ ASSERT_EQ(L.getAction({G_ADD, LLT::vector(2, 8)}),
+ std::make_pair(LegalizerInfo::MoreElements, LLT::vector(8, 8)));
+ ASSERT_EQ(L.getAction({G_ADD, LLT::vector(8, 8)}),
+ std::make_pair(LegalizerInfo::Legal, LLT::vector(8, 8)));
+ ASSERT_EQ(
+ L.getAction({G_ADD, LLT::vector(8, 32)}),
+ std::make_pair(LegalizerInfo::FewerElements, LLT::vector(4, 32)));
+}
+
+TEST(LegalizerInfoTest, MultipleTypes) {
+ using namespace TargetOpcode;
+ LegalizerInfo L;
+ LLT p0 = LLT::pointer(0, 64);
+ LLT s32 = LLT::scalar(32);
+ LLT s64 = LLT::scalar(64);
+
+ // Typical RISCy set of operations based on AArch64.
+ L.setAction({G_PTRTOINT, 0, s64}, LegalizerInfo::Legal);
+ L.setAction({G_PTRTOINT, 1, p0}, LegalizerInfo::Legal);
+
+ L.setAction({G_PTRTOINT, 0, s32}, LegalizerInfo::WidenScalar);
+ L.computeTables();
+
+ // Check we infer the correct types and actually do what we're told.
+ ASSERT_EQ(L.getAction({G_PTRTOINT, 0, s64}),
+ std::make_pair(LegalizerInfo::Legal, s64));
+ ASSERT_EQ(L.getAction({G_PTRTOINT, 1, p0}),
+ std::make_pair(LegalizerInfo::Legal, p0));
+}
+}
+++ /dev/null
-//===- llvm/unittest/CodeGen/GlobalISel/MachineLegalizerTest.cpp ----------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
-#include "llvm/Target/TargetOpcodes.h"
-#include "gtest/gtest.h"
-
-using namespace llvm;
-
-// Define a couple of pretty printers to help debugging when things go wrong.
-namespace llvm {
-std::ostream &
-operator<<(std::ostream &OS, const llvm::MachineLegalizer::LegalizeAction Act) {
- switch (Act) {
- case MachineLegalizer::Lower: OS << "Lower"; break;
- case MachineLegalizer::Legal: OS << "Legal"; break;
- case MachineLegalizer::NarrowScalar: OS << "NarrowScalar"; break;
- case MachineLegalizer::WidenScalar: OS << "WidenScalar"; break;
- case MachineLegalizer::FewerElements: OS << "FewerElements"; break;
- case MachineLegalizer::MoreElements: OS << "MoreElements"; break;
- case MachineLegalizer::Libcall: OS << "Libcall"; break;
- case MachineLegalizer::Custom: OS << "Custom"; break;
- case MachineLegalizer::Unsupported: OS << "Unsupported"; break;
- case MachineLegalizer::NotFound: OS << "NotFound";
- }
- return OS;
-}
-
-std::ostream &
-operator<<(std::ostream &OS, const llvm::LLT Ty) {
- std::string Repr;
- raw_string_ostream SS{Repr};
- Ty.print(SS);
- OS << SS.str();
- return OS;
-}
-}
-
-namespace {
-
-
-TEST(MachineLegalizerTest, ScalarRISC) {
- using namespace TargetOpcode;
- MachineLegalizer L;
- // Typical RISCy set of operations based on AArch64.
- L.setAction({G_ADD, LLT::scalar(8)}, MachineLegalizer::WidenScalar);
- L.setAction({G_ADD, LLT::scalar(16)}, MachineLegalizer::WidenScalar);
- L.setAction({G_ADD, LLT::scalar(32)}, MachineLegalizer::Legal);
- L.setAction({G_ADD, LLT::scalar(64)}, MachineLegalizer::Legal);
- L.computeTables();
-
- // Check we infer the correct types and actually do what we're told.
- ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(8)}),
- std::make_pair(MachineLegalizer::WidenScalar, LLT::scalar(32)));
- ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(16)}),
- std::make_pair(MachineLegalizer::WidenScalar, LLT::scalar(32)));
- ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(32)}),
- std::make_pair(MachineLegalizer::Legal, LLT::scalar(32)));
- ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(64)}),
- std::make_pair(MachineLegalizer::Legal, LLT::scalar(64)));
-
- // Make sure the default for over-sized types applies.
- ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(128)}),
- std::make_pair(MachineLegalizer::NarrowScalar, LLT::scalar(64)));
-}
-
-TEST(MachineLegalizerTest, VectorRISC) {
- using namespace TargetOpcode;
- MachineLegalizer L;
- // Typical RISCy set of operations based on ARM.
- L.setScalarInVectorAction(G_ADD, LLT::scalar(8), MachineLegalizer::Legal);
- L.setScalarInVectorAction(G_ADD, LLT::scalar(16), MachineLegalizer::Legal);
- L.setScalarInVectorAction(G_ADD, LLT::scalar(32), MachineLegalizer::Legal);
-
- L.setAction({G_ADD, LLT::vector(8, 8)}, MachineLegalizer::Legal);
- L.setAction({G_ADD, LLT::vector(16, 8)}, MachineLegalizer::Legal);
- L.setAction({G_ADD, LLT::vector(4, 16)}, MachineLegalizer::Legal);
- L.setAction({G_ADD, LLT::vector(8, 16)}, MachineLegalizer::Legal);
- L.setAction({G_ADD, LLT::vector(2, 32)}, MachineLegalizer::Legal);
- L.setAction({G_ADD, LLT::vector(4, 32)}, MachineLegalizer::Legal);
- L.computeTables();
-
- // Check we infer the correct types and actually do what we're told for some
- // simple cases.
- ASSERT_EQ(L.getAction({G_ADD, LLT::vector(2, 8)}),
- std::make_pair(MachineLegalizer::MoreElements, LLT::vector(8, 8)));
- ASSERT_EQ(L.getAction({G_ADD, LLT::vector(8, 8)}),
- std::make_pair(MachineLegalizer::Legal, LLT::vector(8, 8)));
- ASSERT_EQ(
- L.getAction({G_ADD, LLT::vector(8, 32)}),
- std::make_pair(MachineLegalizer::FewerElements, LLT::vector(4, 32)));
-}
-
-TEST(MachineLegalizerTest, MultipleTypes) {
- using namespace TargetOpcode;
- MachineLegalizer L;
- LLT p0 = LLT::pointer(0, 64);
- LLT s32 = LLT::scalar(32);
- LLT s64 = LLT::scalar(64);
-
- // Typical RISCy set of operations based on AArch64.
- L.setAction({G_PTRTOINT, 0, s64}, MachineLegalizer::Legal);
- L.setAction({G_PTRTOINT, 1, p0}, MachineLegalizer::Legal);
-
- L.setAction({G_PTRTOINT, 0, s32}, MachineLegalizer::WidenScalar);
- L.computeTables();
-
- // Check we infer the correct types and actually do what we're told.
- ASSERT_EQ(L.getAction({G_PTRTOINT, 0, s64}),
- std::make_pair(MachineLegalizer::Legal, s64));
- ASSERT_EQ(L.getAction({G_PTRTOINT, 1, p0}),
- std::make_pair(MachineLegalizer::Legal, p0));
-}
-}
projects / platform / upstream / llvm.git / commitdiff