You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
790 lines
29 KiB
790 lines
29 KiB
//===- MIRParser.cpp - MIR serialization format parser implementation -----===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the class that parses the optional LLVM IR and machine
|
|
// functions that are stored in MIR files.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/CodeGen/MIRParser/MIRParser.h"
|
|
#include "MIParser.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/ADT/StringMap.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/AsmParser/Parser.h"
|
|
#include "llvm/AsmParser/SlotMapping.h"
|
|
#include "llvm/CodeGen/GlobalISel/RegisterBank.h"
|
|
#include "llvm/CodeGen/GlobalISel/RegisterBankInfo.h"
|
|
#include "llvm/CodeGen/MIRYamlMapping.h"
|
|
#include "llvm/CodeGen/MachineConstantPool.h"
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
#include "llvm/CodeGen/MachineModuleInfo.h"
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
|
#include "llvm/IR/BasicBlock.h"
|
|
#include "llvm/IR/DebugInfo.h"
|
|
#include "llvm/IR/DiagnosticInfo.h"
|
|
#include "llvm/IR/Instructions.h"
|
|
#include "llvm/IR/LLVMContext.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/IR/ValueSymbolTable.h"
|
|
#include "llvm/Support/LineIterator.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/SMLoc.h"
|
|
#include "llvm/Support/SourceMgr.h"
|
|
#include "llvm/Support/YAMLTraits.h"
|
|
#include <memory>
|
|
|
|
using namespace llvm;
|
|
|
|
namespace llvm {
|
|
|
|
/// This class implements the parsing of LLVM IR that's embedded inside a MIR
|
|
/// file.
|
|
class MIRParserImpl {
|
|
SourceMgr SM;
|
|
StringRef Filename;
|
|
LLVMContext &Context;
|
|
StringMap<std::unique_ptr<yaml::MachineFunction>> Functions;
|
|
SlotMapping IRSlots;
|
|
/// Maps from register class names to register classes.
|
|
StringMap<const TargetRegisterClass *> Names2RegClasses;
|
|
/// Maps from register bank names to register banks.
|
|
StringMap<const RegisterBank *> Names2RegBanks;
|
|
|
|
public:
|
|
MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents, StringRef Filename,
|
|
LLVMContext &Context);
|
|
|
|
void reportDiagnostic(const SMDiagnostic &Diag);
|
|
|
|
/// Report an error with the given message at unknown location.
|
|
///
|
|
/// Always returns true.
|
|
bool error(const Twine &Message);
|
|
|
|
/// Report an error with the given message at the given location.
|
|
///
|
|
/// Always returns true.
|
|
bool error(SMLoc Loc, const Twine &Message);
|
|
|
|
/// Report a given error with the location translated from the location in an
|
|
/// embedded string literal to a location in the MIR file.
|
|
///
|
|
/// Always returns true.
|
|
bool error(const SMDiagnostic &Error, SMRange SourceRange);
|
|
|
|
/// Try to parse the optional LLVM module and the machine functions in the MIR
|
|
/// file.
|
|
///
|
|
/// Return null if an error occurred.
|
|
std::unique_ptr<Module> parse();
|
|
|
|
/// Parse the machine function in the current YAML document.
|
|
///
|
|
/// \param NoLLVMIR - set to true when the MIR file doesn't have LLVM IR.
|
|
/// A dummy IR function is created and inserted into the given module when
|
|
/// this parameter is true.
|
|
///
|
|
/// Return true if an error occurred.
|
|
bool parseMachineFunction(yaml::Input &In, Module &M, bool NoLLVMIR);
|
|
|
|
/// Initialize the machine function to the state that's described in the MIR
|
|
/// file.
|
|
///
|
|
/// Return true if error occurred.
|
|
bool initializeMachineFunction(MachineFunction &MF);
|
|
|
|
bool initializeRegisterInfo(PerFunctionMIParsingState &PFS,
|
|
const yaml::MachineFunction &YamlMF);
|
|
|
|
void inferRegisterInfo(const PerFunctionMIParsingState &PFS,
|
|
const yaml::MachineFunction &YamlMF);
|
|
|
|
bool initializeFrameInfo(PerFunctionMIParsingState &PFS,
|
|
const yaml::MachineFunction &YamlMF);
|
|
|
|
bool parseCalleeSavedRegister(PerFunctionMIParsingState &PFS,
|
|
std::vector<CalleeSavedInfo> &CSIInfo,
|
|
const yaml::StringValue &RegisterSource,
|
|
int FrameIdx);
|
|
|
|
bool parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
|
|
const yaml::MachineStackObject &Object,
|
|
int FrameIdx);
|
|
|
|
bool initializeConstantPool(PerFunctionMIParsingState &PFS,
|
|
MachineConstantPool &ConstantPool,
|
|
const yaml::MachineFunction &YamlMF);
|
|
|
|
bool initializeJumpTableInfo(PerFunctionMIParsingState &PFS,
|
|
const yaml::MachineJumpTable &YamlJTI);
|
|
|
|
private:
|
|
bool parseMDNode(const PerFunctionMIParsingState &PFS, MDNode *&Node,
|
|
const yaml::StringValue &Source);
|
|
|
|
bool parseMBBReference(const PerFunctionMIParsingState &PFS,
|
|
MachineBasicBlock *&MBB,
|
|
const yaml::StringValue &Source);
|
|
|
|
/// Return a MIR diagnostic converted from an MI string diagnostic.
|
|
SMDiagnostic diagFromMIStringDiag(const SMDiagnostic &Error,
|
|
SMRange SourceRange);
|
|
|
|
/// Return a MIR diagnostic converted from a diagnostic located in a YAML
|
|
/// block scalar string.
|
|
SMDiagnostic diagFromBlockStringDiag(const SMDiagnostic &Error,
|
|
SMRange SourceRange);
|
|
|
|
/// Create an empty function with the given name.
|
|
void createDummyFunction(StringRef Name, Module &M);
|
|
|
|
void initNames2RegClasses(const MachineFunction &MF);
|
|
void initNames2RegBanks(const MachineFunction &MF);
|
|
|
|
/// Check if the given identifier is a name of a register class.
|
|
///
|
|
/// Return null if the name isn't a register class.
|
|
const TargetRegisterClass *getRegClass(const MachineFunction &MF,
|
|
StringRef Name);
|
|
|
|
/// Check if the given identifier is a name of a register bank.
|
|
///
|
|
/// Return null if the name isn't a register bank.
|
|
const RegisterBank *getRegBank(const MachineFunction &MF, StringRef Name);
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
MIRParserImpl::MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
|
|
StringRef Filename, LLVMContext &Context)
|
|
: SM(), Filename(Filename), Context(Context) {
|
|
SM.AddNewSourceBuffer(std::move(Contents), SMLoc());
|
|
}
|
|
|
|
bool MIRParserImpl::error(const Twine &Message) {
|
|
Context.diagnose(DiagnosticInfoMIRParser(
|
|
DS_Error, SMDiagnostic(Filename, SourceMgr::DK_Error, Message.str())));
|
|
return true;
|
|
}
|
|
|
|
bool MIRParserImpl::error(SMLoc Loc, const Twine &Message) {
|
|
Context.diagnose(DiagnosticInfoMIRParser(
|
|
DS_Error, SM.GetMessage(Loc, SourceMgr::DK_Error, Message)));
|
|
return true;
|
|
}
|
|
|
|
bool MIRParserImpl::error(const SMDiagnostic &Error, SMRange SourceRange) {
|
|
assert(Error.getKind() == SourceMgr::DK_Error && "Expected an error");
|
|
reportDiagnostic(diagFromMIStringDiag(Error, SourceRange));
|
|
return true;
|
|
}
|
|
|
|
void MIRParserImpl::reportDiagnostic(const SMDiagnostic &Diag) {
|
|
DiagnosticSeverity Kind;
|
|
switch (Diag.getKind()) {
|
|
case SourceMgr::DK_Error:
|
|
Kind = DS_Error;
|
|
break;
|
|
case SourceMgr::DK_Warning:
|
|
Kind = DS_Warning;
|
|
break;
|
|
case SourceMgr::DK_Note:
|
|
Kind = DS_Note;
|
|
break;
|
|
}
|
|
Context.diagnose(DiagnosticInfoMIRParser(Kind, Diag));
|
|
}
|
|
|
|
static void handleYAMLDiag(const SMDiagnostic &Diag, void *Context) {
|
|
reinterpret_cast<MIRParserImpl *>(Context)->reportDiagnostic(Diag);
|
|
}
|
|
|
|
std::unique_ptr<Module> MIRParserImpl::parse() {
|
|
yaml::Input In(SM.getMemoryBuffer(SM.getMainFileID())->getBuffer(),
|
|
/*Ctxt=*/nullptr, handleYAMLDiag, this);
|
|
In.setContext(&In);
|
|
|
|
if (!In.setCurrentDocument()) {
|
|
if (In.error())
|
|
return nullptr;
|
|
// Create an empty module when the MIR file is empty.
|
|
return llvm::make_unique<Module>(Filename, Context);
|
|
}
|
|
|
|
std::unique_ptr<Module> M;
|
|
bool NoLLVMIR = false;
|
|
// Parse the block scalar manually so that we can return unique pointer
|
|
// without having to go trough YAML traits.
|
|
if (const auto *BSN =
|
|
dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
|
|
SMDiagnostic Error;
|
|
M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
|
|
Context, &IRSlots);
|
|
if (!M) {
|
|
reportDiagnostic(diagFromBlockStringDiag(Error, BSN->getSourceRange()));
|
|
return nullptr;
|
|
}
|
|
In.nextDocument();
|
|
if (!In.setCurrentDocument())
|
|
return M;
|
|
} else {
|
|
// Create an new, empty module.
|
|
M = llvm::make_unique<Module>(Filename, Context);
|
|
NoLLVMIR = true;
|
|
}
|
|
|
|
// Parse the machine functions.
|
|
do {
|
|
if (parseMachineFunction(In, *M, NoLLVMIR))
|
|
return nullptr;
|
|
In.nextDocument();
|
|
} while (In.setCurrentDocument());
|
|
|
|
return M;
|
|
}
|
|
|
|
bool MIRParserImpl::parseMachineFunction(yaml::Input &In, Module &M,
|
|
bool NoLLVMIR) {
|
|
auto MF = llvm::make_unique<yaml::MachineFunction>();
|
|
yaml::yamlize(In, *MF, false);
|
|
if (In.error())
|
|
return true;
|
|
auto FunctionName = MF->Name;
|
|
if (Functions.find(FunctionName) != Functions.end())
|
|
return error(Twine("redefinition of machine function '") + FunctionName +
|
|
"'");
|
|
Functions.insert(std::make_pair(FunctionName, std::move(MF)));
|
|
if (NoLLVMIR)
|
|
createDummyFunction(FunctionName, M);
|
|
else if (!M.getFunction(FunctionName))
|
|
return error(Twine("function '") + FunctionName +
|
|
"' isn't defined in the provided LLVM IR");
|
|
return false;
|
|
}
|
|
|
|
void MIRParserImpl::createDummyFunction(StringRef Name, Module &M) {
|
|
auto &Context = M.getContext();
|
|
Function *F = cast<Function>(M.getOrInsertFunction(
|
|
Name, FunctionType::get(Type::getVoidTy(Context), false)));
|
|
BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
|
|
new UnreachableInst(Context, BB);
|
|
}
|
|
|
|
bool MIRParserImpl::initializeMachineFunction(MachineFunction &MF) {
|
|
auto It = Functions.find(MF.getName());
|
|
if (It == Functions.end())
|
|
return error(Twine("no machine function information for function '") +
|
|
MF.getName() + "' in the MIR file");
|
|
// TODO: Recreate the machine function.
|
|
const yaml::MachineFunction &YamlMF = *It->getValue();
|
|
if (YamlMF.Alignment)
|
|
MF.setAlignment(YamlMF.Alignment);
|
|
MF.setExposesReturnsTwice(YamlMF.ExposesReturnsTwice);
|
|
MF.setHasInlineAsm(YamlMF.HasInlineAsm);
|
|
if (YamlMF.AllVRegsAllocated)
|
|
MF.getProperties().set(MachineFunctionProperties::Property::AllVRegsAllocated);
|
|
PerFunctionMIParsingState PFS(MF, SM, IRSlots);
|
|
if (initializeRegisterInfo(PFS, YamlMF))
|
|
return true;
|
|
if (!YamlMF.Constants.empty()) {
|
|
auto *ConstantPool = MF.getConstantPool();
|
|
assert(ConstantPool && "Constant pool must be created");
|
|
if (initializeConstantPool(PFS, *ConstantPool, YamlMF))
|
|
return true;
|
|
}
|
|
|
|
StringRef BlockStr = YamlMF.Body.Value.Value;
|
|
SMDiagnostic Error;
|
|
SourceMgr BlockSM;
|
|
BlockSM.AddNewSourceBuffer(
|
|
MemoryBuffer::getMemBuffer(BlockStr, "",/*RequiresNullTerminator=*/false),
|
|
SMLoc());
|
|
PFS.SM = &BlockSM;
|
|
if (parseMachineBasicBlockDefinitions(PFS, BlockStr, Error)) {
|
|
reportDiagnostic(
|
|
diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange));
|
|
return true;
|
|
}
|
|
PFS.SM = &SM;
|
|
|
|
if (MF.empty())
|
|
return error(Twine("machine function '") + Twine(MF.getName()) +
|
|
"' requires at least one machine basic block in its body");
|
|
// Initialize the frame information after creating all the MBBs so that the
|
|
// MBB references in the frame information can be resolved.
|
|
if (initializeFrameInfo(PFS, YamlMF))
|
|
return true;
|
|
// Initialize the jump table after creating all the MBBs so that the MBB
|
|
// references can be resolved.
|
|
if (!YamlMF.JumpTableInfo.Entries.empty() &&
|
|
initializeJumpTableInfo(PFS, YamlMF.JumpTableInfo))
|
|
return true;
|
|
// Parse the machine instructions after creating all of the MBBs so that the
|
|
// parser can resolve the MBB references.
|
|
StringRef InsnStr = YamlMF.Body.Value.Value;
|
|
SourceMgr InsnSM;
|
|
InsnSM.AddNewSourceBuffer(
|
|
MemoryBuffer::getMemBuffer(InsnStr, "", /*RequiresNullTerminator=*/false),
|
|
SMLoc());
|
|
PFS.SM = &InsnSM;
|
|
if (parseMachineInstructions(PFS, InsnStr, Error)) {
|
|
reportDiagnostic(
|
|
diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange));
|
|
return true;
|
|
}
|
|
PFS.SM = &SM;
|
|
|
|
inferRegisterInfo(PFS, YamlMF);
|
|
// FIXME: This is a temporary workaround until the reserved registers can be
|
|
// serialized.
|
|
MF.getRegInfo().freezeReservedRegs(MF);
|
|
MF.verify();
|
|
return false;
|
|
}
|
|
|
|
bool MIRParserImpl::initializeRegisterInfo(PerFunctionMIParsingState &PFS,
|
|
const yaml::MachineFunction &YamlMF) {
|
|
MachineFunction &MF = PFS.MF;
|
|
MachineRegisterInfo &RegInfo = MF.getRegInfo();
|
|
assert(RegInfo.isSSA());
|
|
if (!YamlMF.IsSSA)
|
|
RegInfo.leaveSSA();
|
|
assert(RegInfo.tracksLiveness());
|
|
if (!YamlMF.TracksRegLiveness)
|
|
RegInfo.invalidateLiveness();
|
|
RegInfo.enableSubRegLiveness(YamlMF.TracksSubRegLiveness);
|
|
|
|
SMDiagnostic Error;
|
|
// Parse the virtual register information.
|
|
for (const auto &VReg : YamlMF.VirtualRegisters) {
|
|
unsigned Reg;
|
|
if (StringRef(VReg.Class.Value).equals("_")) {
|
|
// This is a generic virtual register.
|
|
// The size will be set appropriately when we reach the definition.
|
|
Reg = RegInfo.createGenericVirtualRegister(/*Size*/ 1);
|
|
PFS.GenericVRegs.insert(Reg);
|
|
} else {
|
|
const auto *RC = getRegClass(MF, VReg.Class.Value);
|
|
if (RC) {
|
|
Reg = RegInfo.createVirtualRegister(RC);
|
|
} else {
|
|
const auto *RegBank = getRegBank(MF, VReg.Class.Value);
|
|
if (!RegBank)
|
|
return error(
|
|
VReg.Class.SourceRange.Start,
|
|
Twine("use of undefined register class or register bank '") +
|
|
VReg.Class.Value + "'");
|
|
Reg = RegInfo.createGenericVirtualRegister(/*Size*/ 1);
|
|
RegInfo.setRegBank(Reg, *RegBank);
|
|
PFS.GenericVRegs.insert(Reg);
|
|
}
|
|
}
|
|
if (!PFS.VirtualRegisterSlots.insert(std::make_pair(VReg.ID.Value, Reg))
|
|
.second)
|
|
return error(VReg.ID.SourceRange.Start,
|
|
Twine("redefinition of virtual register '%") +
|
|
Twine(VReg.ID.Value) + "'");
|
|
if (!VReg.PreferredRegister.Value.empty()) {
|
|
unsigned PreferredReg = 0;
|
|
if (parseNamedRegisterReference(PFS, PreferredReg,
|
|
VReg.PreferredRegister.Value, Error))
|
|
return error(Error, VReg.PreferredRegister.SourceRange);
|
|
RegInfo.setSimpleHint(Reg, PreferredReg);
|
|
}
|
|
}
|
|
|
|
// Parse the liveins.
|
|
for (const auto &LiveIn : YamlMF.LiveIns) {
|
|
unsigned Reg = 0;
|
|
if (parseNamedRegisterReference(PFS, Reg, LiveIn.Register.Value, Error))
|
|
return error(Error, LiveIn.Register.SourceRange);
|
|
unsigned VReg = 0;
|
|
if (!LiveIn.VirtualRegister.Value.empty()) {
|
|
if (parseVirtualRegisterReference(PFS, VReg, LiveIn.VirtualRegister.Value,
|
|
Error))
|
|
return error(Error, LiveIn.VirtualRegister.SourceRange);
|
|
}
|
|
RegInfo.addLiveIn(Reg, VReg);
|
|
}
|
|
|
|
// Parse the callee saved register mask.
|
|
BitVector CalleeSavedRegisterMask(RegInfo.getUsedPhysRegsMask().size());
|
|
if (!YamlMF.CalleeSavedRegisters)
|
|
return false;
|
|
for (const auto &RegSource : YamlMF.CalleeSavedRegisters.getValue()) {
|
|
unsigned Reg = 0;
|
|
if (parseNamedRegisterReference(PFS, Reg, RegSource.Value, Error))
|
|
return error(Error, RegSource.SourceRange);
|
|
CalleeSavedRegisterMask[Reg] = true;
|
|
}
|
|
RegInfo.setUsedPhysRegMask(CalleeSavedRegisterMask.flip());
|
|
return false;
|
|
}
|
|
|
|
void MIRParserImpl::inferRegisterInfo(const PerFunctionMIParsingState &PFS,
|
|
const yaml::MachineFunction &YamlMF) {
|
|
if (YamlMF.CalleeSavedRegisters)
|
|
return;
|
|
MachineRegisterInfo &MRI = PFS.MF.getRegInfo();
|
|
for (const MachineBasicBlock &MBB : PFS.MF) {
|
|
for (const MachineInstr &MI : MBB) {
|
|
for (const MachineOperand &MO : MI.operands()) {
|
|
if (!MO.isRegMask())
|
|
continue;
|
|
MRI.addPhysRegsUsedFromRegMask(MO.getRegMask());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool MIRParserImpl::initializeFrameInfo(PerFunctionMIParsingState &PFS,
|
|
const yaml::MachineFunction &YamlMF) {
|
|
MachineFunction &MF = PFS.MF;
|
|
MachineFrameInfo &MFI = *MF.getFrameInfo();
|
|
const Function &F = *MF.getFunction();
|
|
const yaml::MachineFrameInfo &YamlMFI = YamlMF.FrameInfo;
|
|
MFI.setFrameAddressIsTaken(YamlMFI.IsFrameAddressTaken);
|
|
MFI.setReturnAddressIsTaken(YamlMFI.IsReturnAddressTaken);
|
|
MFI.setHasStackMap(YamlMFI.HasStackMap);
|
|
MFI.setHasPatchPoint(YamlMFI.HasPatchPoint);
|
|
MFI.setStackSize(YamlMFI.StackSize);
|
|
MFI.setOffsetAdjustment(YamlMFI.OffsetAdjustment);
|
|
if (YamlMFI.MaxAlignment)
|
|
MFI.ensureMaxAlignment(YamlMFI.MaxAlignment);
|
|
MFI.setAdjustsStack(YamlMFI.AdjustsStack);
|
|
MFI.setHasCalls(YamlMFI.HasCalls);
|
|
MFI.setMaxCallFrameSize(YamlMFI.MaxCallFrameSize);
|
|
MFI.setHasOpaqueSPAdjustment(YamlMFI.HasOpaqueSPAdjustment);
|
|
MFI.setHasVAStart(YamlMFI.HasVAStart);
|
|
MFI.setHasMustTailInVarArgFunc(YamlMFI.HasMustTailInVarArgFunc);
|
|
if (!YamlMFI.SavePoint.Value.empty()) {
|
|
MachineBasicBlock *MBB = nullptr;
|
|
if (parseMBBReference(PFS, MBB, YamlMFI.SavePoint))
|
|
return true;
|
|
MFI.setSavePoint(MBB);
|
|
}
|
|
if (!YamlMFI.RestorePoint.Value.empty()) {
|
|
MachineBasicBlock *MBB = nullptr;
|
|
if (parseMBBReference(PFS, MBB, YamlMFI.RestorePoint))
|
|
return true;
|
|
MFI.setRestorePoint(MBB);
|
|
}
|
|
|
|
std::vector<CalleeSavedInfo> CSIInfo;
|
|
// Initialize the fixed frame objects.
|
|
for (const auto &Object : YamlMF.FixedStackObjects) {
|
|
int ObjectIdx;
|
|
if (Object.Type != yaml::FixedMachineStackObject::SpillSlot)
|
|
ObjectIdx = MFI.CreateFixedObject(Object.Size, Object.Offset,
|
|
Object.IsImmutable, Object.IsAliased);
|
|
else
|
|
ObjectIdx = MFI.CreateFixedSpillStackObject(Object.Size, Object.Offset);
|
|
MFI.setObjectAlignment(ObjectIdx, Object.Alignment);
|
|
if (!PFS.FixedStackObjectSlots.insert(std::make_pair(Object.ID.Value,
|
|
ObjectIdx))
|
|
.second)
|
|
return error(Object.ID.SourceRange.Start,
|
|
Twine("redefinition of fixed stack object '%fixed-stack.") +
|
|
Twine(Object.ID.Value) + "'");
|
|
if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister,
|
|
ObjectIdx))
|
|
return true;
|
|
}
|
|
|
|
// Initialize the ordinary frame objects.
|
|
for (const auto &Object : YamlMF.StackObjects) {
|
|
int ObjectIdx;
|
|
const AllocaInst *Alloca = nullptr;
|
|
const yaml::StringValue &Name = Object.Name;
|
|
if (!Name.Value.empty()) {
|
|
Alloca = dyn_cast_or_null<AllocaInst>(
|
|
F.getValueSymbolTable().lookup(Name.Value));
|
|
if (!Alloca)
|
|
return error(Name.SourceRange.Start,
|
|
"alloca instruction named '" + Name.Value +
|
|
"' isn't defined in the function '" + F.getName() +
|
|
"'");
|
|
}
|
|
if (Object.Type == yaml::MachineStackObject::VariableSized)
|
|
ObjectIdx = MFI.CreateVariableSizedObject(Object.Alignment, Alloca);
|
|
else
|
|
ObjectIdx = MFI.CreateStackObject(
|
|
Object.Size, Object.Alignment,
|
|
Object.Type == yaml::MachineStackObject::SpillSlot, Alloca);
|
|
MFI.setObjectOffset(ObjectIdx, Object.Offset);
|
|
if (!PFS.StackObjectSlots.insert(std::make_pair(Object.ID.Value, ObjectIdx))
|
|
.second)
|
|
return error(Object.ID.SourceRange.Start,
|
|
Twine("redefinition of stack object '%stack.") +
|
|
Twine(Object.ID.Value) + "'");
|
|
if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister,
|
|
ObjectIdx))
|
|
return true;
|
|
if (Object.LocalOffset)
|
|
MFI.mapLocalFrameObject(ObjectIdx, Object.LocalOffset.getValue());
|
|
if (parseStackObjectsDebugInfo(PFS, Object, ObjectIdx))
|
|
return true;
|
|
}
|
|
MFI.setCalleeSavedInfo(CSIInfo);
|
|
if (!CSIInfo.empty())
|
|
MFI.setCalleeSavedInfoValid(true);
|
|
|
|
// Initialize the various stack object references after initializing the
|
|
// stack objects.
|
|
if (!YamlMFI.StackProtector.Value.empty()) {
|
|
SMDiagnostic Error;
|
|
int FI;
|
|
if (parseStackObjectReference(PFS, FI, YamlMFI.StackProtector.Value, Error))
|
|
return error(Error, YamlMFI.StackProtector.SourceRange);
|
|
MFI.setStackProtectorIndex(FI);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool MIRParserImpl::parseCalleeSavedRegister(PerFunctionMIParsingState &PFS,
|
|
std::vector<CalleeSavedInfo> &CSIInfo,
|
|
const yaml::StringValue &RegisterSource, int FrameIdx) {
|
|
if (RegisterSource.Value.empty())
|
|
return false;
|
|
unsigned Reg = 0;
|
|
SMDiagnostic Error;
|
|
if (parseNamedRegisterReference(PFS, Reg, RegisterSource.Value, Error))
|
|
return error(Error, RegisterSource.SourceRange);
|
|
CSIInfo.push_back(CalleeSavedInfo(Reg, FrameIdx));
|
|
return false;
|
|
}
|
|
|
|
/// Verify that given node is of a certain type. Return true on error.
|
|
template <typename T>
|
|
static bool typecheckMDNode(T *&Result, MDNode *Node,
|
|
const yaml::StringValue &Source,
|
|
StringRef TypeString, MIRParserImpl &Parser) {
|
|
if (!Node)
|
|
return false;
|
|
Result = dyn_cast<T>(Node);
|
|
if (!Result)
|
|
return Parser.error(Source.SourceRange.Start,
|
|
"expected a reference to a '" + TypeString +
|
|
"' metadata node");
|
|
return false;
|
|
}
|
|
|
|
bool MIRParserImpl::parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
|
|
const yaml::MachineStackObject &Object, int FrameIdx) {
|
|
// Debug information can only be attached to stack objects; Fixed stack
|
|
// objects aren't supported.
|
|
assert(FrameIdx >= 0 && "Expected a stack object frame index");
|
|
MDNode *Var = nullptr, *Expr = nullptr, *Loc = nullptr;
|
|
if (parseMDNode(PFS, Var, Object.DebugVar) ||
|
|
parseMDNode(PFS, Expr, Object.DebugExpr) ||
|
|
parseMDNode(PFS, Loc, Object.DebugLoc))
|
|
return true;
|
|
if (!Var && !Expr && !Loc)
|
|
return false;
|
|
DILocalVariable *DIVar = nullptr;
|
|
DIExpression *DIExpr = nullptr;
|
|
DILocation *DILoc = nullptr;
|
|
if (typecheckMDNode(DIVar, Var, Object.DebugVar, "DILocalVariable", *this) ||
|
|
typecheckMDNode(DIExpr, Expr, Object.DebugExpr, "DIExpression", *this) ||
|
|
typecheckMDNode(DILoc, Loc, Object.DebugLoc, "DILocation", *this))
|
|
return true;
|
|
PFS.MF.getMMI().setVariableDbgInfo(DIVar, DIExpr, unsigned(FrameIdx), DILoc);
|
|
return false;
|
|
}
|
|
|
|
bool MIRParserImpl::parseMDNode(const PerFunctionMIParsingState &PFS,
|
|
MDNode *&Node, const yaml::StringValue &Source) {
|
|
if (Source.Value.empty())
|
|
return false;
|
|
SMDiagnostic Error;
|
|
if (llvm::parseMDNode(PFS, Node, Source.Value, Error))
|
|
return error(Error, Source.SourceRange);
|
|
return false;
|
|
}
|
|
|
|
bool MIRParserImpl::initializeConstantPool(PerFunctionMIParsingState &PFS,
|
|
MachineConstantPool &ConstantPool, const yaml::MachineFunction &YamlMF) {
|
|
DenseMap<unsigned, unsigned> &ConstantPoolSlots = PFS.ConstantPoolSlots;
|
|
const MachineFunction &MF = PFS.MF;
|
|
const auto &M = *MF.getFunction()->getParent();
|
|
SMDiagnostic Error;
|
|
for (const auto &YamlConstant : YamlMF.Constants) {
|
|
const Constant *Value = dyn_cast_or_null<Constant>(
|
|
parseConstantValue(YamlConstant.Value.Value, Error, M));
|
|
if (!Value)
|
|
return error(Error, YamlConstant.Value.SourceRange);
|
|
unsigned Alignment =
|
|
YamlConstant.Alignment
|
|
? YamlConstant.Alignment
|
|
: M.getDataLayout().getPrefTypeAlignment(Value->getType());
|
|
unsigned Index = ConstantPool.getConstantPoolIndex(Value, Alignment);
|
|
if (!ConstantPoolSlots.insert(std::make_pair(YamlConstant.ID.Value, Index))
|
|
.second)
|
|
return error(YamlConstant.ID.SourceRange.Start,
|
|
Twine("redefinition of constant pool item '%const.") +
|
|
Twine(YamlConstant.ID.Value) + "'");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool MIRParserImpl::initializeJumpTableInfo(PerFunctionMIParsingState &PFS,
|
|
const yaml::MachineJumpTable &YamlJTI) {
|
|
MachineJumpTableInfo *JTI = PFS.MF.getOrCreateJumpTableInfo(YamlJTI.Kind);
|
|
for (const auto &Entry : YamlJTI.Entries) {
|
|
std::vector<MachineBasicBlock *> Blocks;
|
|
for (const auto &MBBSource : Entry.Blocks) {
|
|
MachineBasicBlock *MBB = nullptr;
|
|
if (parseMBBReference(PFS, MBB, MBBSource.Value))
|
|
return true;
|
|
Blocks.push_back(MBB);
|
|
}
|
|
unsigned Index = JTI->createJumpTableIndex(Blocks);
|
|
if (!PFS.JumpTableSlots.insert(std::make_pair(Entry.ID.Value, Index))
|
|
.second)
|
|
return error(Entry.ID.SourceRange.Start,
|
|
Twine("redefinition of jump table entry '%jump-table.") +
|
|
Twine(Entry.ID.Value) + "'");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool MIRParserImpl::parseMBBReference(const PerFunctionMIParsingState &PFS,
|
|
MachineBasicBlock *&MBB,
|
|
const yaml::StringValue &Source) {
|
|
SMDiagnostic Error;
|
|
if (llvm::parseMBBReference(PFS, MBB, Source.Value, Error))
|
|
return error(Error, Source.SourceRange);
|
|
return false;
|
|
}
|
|
|
|
SMDiagnostic MIRParserImpl::diagFromMIStringDiag(const SMDiagnostic &Error,
|
|
SMRange SourceRange) {
|
|
assert(SourceRange.isValid() && "Invalid source range");
|
|
SMLoc Loc = SourceRange.Start;
|
|
bool HasQuote = Loc.getPointer() < SourceRange.End.getPointer() &&
|
|
*Loc.getPointer() == '\'';
|
|
// Translate the location of the error from the location in the MI string to
|
|
// the corresponding location in the MIR file.
|
|
Loc = Loc.getFromPointer(Loc.getPointer() + Error.getColumnNo() +
|
|
(HasQuote ? 1 : 0));
|
|
|
|
// TODO: Translate any source ranges as well.
|
|
return SM.GetMessage(Loc, Error.getKind(), Error.getMessage(), None,
|
|
Error.getFixIts());
|
|
}
|
|
|
|
SMDiagnostic MIRParserImpl::diagFromBlockStringDiag(const SMDiagnostic &Error,
|
|
SMRange SourceRange) {
|
|
assert(SourceRange.isValid());
|
|
|
|
// Translate the location of the error from the location in the llvm IR string
|
|
// to the corresponding location in the MIR file.
|
|
auto LineAndColumn = SM.getLineAndColumn(SourceRange.Start);
|
|
unsigned Line = LineAndColumn.first + Error.getLineNo() - 1;
|
|
unsigned Column = Error.getColumnNo();
|
|
StringRef LineStr = Error.getLineContents();
|
|
SMLoc Loc = Error.getLoc();
|
|
|
|
// Get the full line and adjust the column number by taking the indentation of
|
|
// LLVM IR into account.
|
|
for (line_iterator L(*SM.getMemoryBuffer(SM.getMainFileID()), false), E;
|
|
L != E; ++L) {
|
|
if (L.line_number() == Line) {
|
|
LineStr = *L;
|
|
Loc = SMLoc::getFromPointer(LineStr.data());
|
|
auto Indent = LineStr.find(Error.getLineContents());
|
|
if (Indent != StringRef::npos)
|
|
Column += Indent;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return SMDiagnostic(SM, Loc, Filename, Line, Column, Error.getKind(),
|
|
Error.getMessage(), LineStr, Error.getRanges(),
|
|
Error.getFixIts());
|
|
}
|
|
|
|
void MIRParserImpl::initNames2RegClasses(const MachineFunction &MF) {
|
|
if (!Names2RegClasses.empty())
|
|
return;
|
|
const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
|
|
for (unsigned I = 0, E = TRI->getNumRegClasses(); I < E; ++I) {
|
|
const auto *RC = TRI->getRegClass(I);
|
|
Names2RegClasses.insert(
|
|
std::make_pair(StringRef(TRI->getRegClassName(RC)).lower(), RC));
|
|
}
|
|
}
|
|
|
|
void MIRParserImpl::initNames2RegBanks(const MachineFunction &MF) {
|
|
if (!Names2RegBanks.empty())
|
|
return;
|
|
const RegisterBankInfo *RBI = MF.getSubtarget().getRegBankInfo();
|
|
// If the target does not support GlobalISel, we may not have a
|
|
// register bank info.
|
|
if (!RBI)
|
|
return;
|
|
for (unsigned I = 0, E = RBI->getNumRegBanks(); I < E; ++I) {
|
|
const auto &RegBank = RBI->getRegBank(I);
|
|
Names2RegBanks.insert(
|
|
std::make_pair(StringRef(RegBank.getName()).lower(), &RegBank));
|
|
}
|
|
}
|
|
|
|
const TargetRegisterClass *MIRParserImpl::getRegClass(const MachineFunction &MF,
|
|
StringRef Name) {
|
|
initNames2RegClasses(MF);
|
|
auto RegClassInfo = Names2RegClasses.find(Name);
|
|
if (RegClassInfo == Names2RegClasses.end())
|
|
return nullptr;
|
|
return RegClassInfo->getValue();
|
|
}
|
|
|
|
const RegisterBank *MIRParserImpl::getRegBank(const MachineFunction &MF,
|
|
StringRef Name) {
|
|
initNames2RegBanks(MF);
|
|
auto RegBankInfo = Names2RegBanks.find(Name);
|
|
if (RegBankInfo == Names2RegBanks.end())
|
|
return nullptr;
|
|
return RegBankInfo->getValue();
|
|
}
|
|
|
|
MIRParser::MIRParser(std::unique_ptr<MIRParserImpl> Impl)
|
|
: Impl(std::move(Impl)) {}
|
|
|
|
MIRParser::~MIRParser() {}
|
|
|
|
std::unique_ptr<Module> MIRParser::parseLLVMModule() { return Impl->parse(); }
|
|
|
|
bool MIRParser::initializeMachineFunction(MachineFunction &MF) {
|
|
return Impl->initializeMachineFunction(MF);
|
|
}
|
|
|
|
std::unique_ptr<MIRParser> llvm::createMIRParserFromFile(StringRef Filename,
|
|
SMDiagnostic &Error,
|
|
LLVMContext &Context) {
|
|
auto FileOrErr = MemoryBuffer::getFile(Filename);
|
|
if (std::error_code EC = FileOrErr.getError()) {
|
|
Error = SMDiagnostic(Filename, SourceMgr::DK_Error,
|
|
"Could not open input file: " + EC.message());
|
|
return nullptr;
|
|
}
|
|
return createMIRParser(std::move(FileOrErr.get()), Context);
|
|
}
|
|
|
|
std::unique_ptr<MIRParser>
|
|
llvm::createMIRParser(std::unique_ptr<MemoryBuffer> Contents,
|
|
LLVMContext &Context) {
|
|
auto Filename = Contents->getBufferIdentifier();
|
|
return llvm::make_unique<MIRParser>(
|
|
llvm::make_unique<MIRParserImpl>(std::move(Contents), Filename, Context));
|
|
}
|