forked from OSchip/llvm-project
105 lines
3.5 KiB
C++
105 lines
3.5 KiB
C++
//===-- llvm/CodeGen/GlobalISel/MachineIRBuilder.cpp - MIBuilder--*- C++ -*-==//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
/// \file
|
|
/// This file implements the MachineIRBuidler class.
|
|
//===----------------------------------------------------------------------===//
|
|
#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
|
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
#include "llvm/CodeGen/MachineInstr.h"
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
#include "llvm/Target/TargetOpcodes.h"
|
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
|
|
|
using namespace llvm;
|
|
|
|
void MachineIRBuilder::setMF(MachineFunction &MF) {
|
|
this->MF = &MF;
|
|
this->MBB = nullptr;
|
|
this->TII = MF.getSubtarget().getInstrInfo();
|
|
this->DL = DebugLoc();
|
|
this->MI = nullptr;
|
|
}
|
|
|
|
void MachineIRBuilder::setMBB(MachineBasicBlock &MBB, bool Beginning) {
|
|
this->MBB = &MBB;
|
|
Before = Beginning;
|
|
assert(&getMF() == MBB.getParent() &&
|
|
"Basic block is in a different function");
|
|
}
|
|
|
|
void MachineIRBuilder::setInstr(MachineInstr &MI, bool Before) {
|
|
assert(MI.getParent() && "Instruction is not part of a basic block");
|
|
setMBB(*MI.getParent());
|
|
this->MI = &MI;
|
|
this->Before = Before;
|
|
}
|
|
|
|
MachineBasicBlock::iterator MachineIRBuilder::getInsertPt() {
|
|
if (MI) {
|
|
if (Before)
|
|
return MI;
|
|
if (!MI->getNextNode())
|
|
return getMBB().end();
|
|
return MI->getNextNode();
|
|
}
|
|
return Before ? getMBB().begin() : getMBB().end();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Build instruction variants.
|
|
//------------------------------------------------------------------------------
|
|
MachineInstr *MachineIRBuilder::buildInstr(unsigned Opcode, Type *Ty) {
|
|
MachineInstr *NewMI = BuildMI(getMF(), DL, getTII().get(Opcode));
|
|
if (Ty) {
|
|
assert(isPreISelGenericOpcode(Opcode) &&
|
|
"Only generic instruction can have a type");
|
|
NewMI->setType(Ty);
|
|
} else
|
|
assert(!isPreISelGenericOpcode(Opcode) &&
|
|
"Generic instruction must have a type");
|
|
getMBB().insert(getInsertPt(), NewMI);
|
|
return NewMI;
|
|
}
|
|
|
|
MachineInstr *MachineIRBuilder::buildInstr(unsigned Opcode, unsigned Res,
|
|
unsigned Op0, unsigned Op1) {
|
|
return buildInstr(Opcode, nullptr, Res, Op0, Op1);
|
|
}
|
|
|
|
MachineInstr *MachineIRBuilder::buildInstr(unsigned Opcode, Type *Ty,
|
|
unsigned Res, unsigned Op0,
|
|
unsigned Op1) {
|
|
MachineInstr *NewMI = buildInstr(Opcode, Ty);
|
|
MachineInstrBuilder(getMF(), NewMI)
|
|
.addReg(Res, RegState::Define)
|
|
.addReg(Op0)
|
|
.addReg(Op1);
|
|
return NewMI;
|
|
}
|
|
|
|
MachineInstr *MachineIRBuilder::buildInstr(unsigned Opcode, unsigned Res,
|
|
unsigned Op0) {
|
|
MachineInstr *NewMI = buildInstr(Opcode, nullptr);
|
|
MachineInstrBuilder(getMF(), NewMI).addReg(Res, RegState::Define).addReg(Op0);
|
|
return NewMI;
|
|
}
|
|
|
|
MachineInstr *MachineIRBuilder::buildInstr(unsigned Opcode) {
|
|
return buildInstr(Opcode, nullptr);
|
|
}
|
|
|
|
MachineInstr *MachineIRBuilder::buildInstr(unsigned Opcode, Type *Ty,
|
|
MachineBasicBlock &BB) {
|
|
MachineInstr *NewMI = buildInstr(Opcode, Ty);
|
|
MachineInstrBuilder(getMF(), NewMI).addMBB(&BB);
|
|
return NewMI;
|
|
}
|