mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-02-25 19:29:53 +00:00
3682046086
This commit introduces a serializable structure called 'llvm::yaml::MachineFunction' that stores the machine function's name. This structure will mirror the machine function's state in the future. This commit prints machine functions as YAML documents containing a YAML mapping that stores the state of a machine function. This commit also parses the YAML documents that contain the machine functions. Reviewers: Duncan P. N. Exon Smith Differential Revision: http://reviews.llvm.org/D9841 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@238519 91177308-0d34-0410-b5e6-96231b3b80d8
133 lines
4.2 KiB
C++
133 lines
4.2 KiB
C++
//===- 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 "llvm/ADT/StringRef.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/AsmParser/Parser.h"
|
|
#include "llvm/CodeGen/MIRYamlMapping.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/Support/SMLoc.h"
|
|
#include "llvm/Support/SourceMgr.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/YAMLTraits.h"
|
|
#include <memory>
|
|
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
|
|
/// This class implements the parsing of LLVM IR that's embedded inside a MIR
|
|
/// file.
|
|
class MIRParserImpl {
|
|
SourceMgr SM;
|
|
StringRef Filename;
|
|
LLVMContext &Context;
|
|
|
|
public:
|
|
MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents, StringRef Filename,
|
|
LLVMContext &Context);
|
|
|
|
/// 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(SMDiagnostic &Error);
|
|
|
|
/// Parse the machine function in the current YAML document.
|
|
///
|
|
/// Return true if an error occurred.
|
|
bool parseMachineFunction(yaml::Input &In);
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
MIRParserImpl::MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
|
|
StringRef Filename, LLVMContext &Context)
|
|
: SM(), Filename(Filename), Context(Context) {
|
|
SM.AddNewSourceBuffer(std::move(Contents), SMLoc());
|
|
}
|
|
|
|
static void handleYAMLDiag(const SMDiagnostic &Diag, void *Context) {
|
|
*reinterpret_cast<SMDiagnostic *>(Context) = Diag;
|
|
}
|
|
|
|
std::unique_ptr<Module> MIRParserImpl::parse(SMDiagnostic &Error) {
|
|
yaml::Input In(SM.getMemoryBuffer(SM.getMainFileID())->getBuffer(),
|
|
/*Ctxt=*/nullptr, handleYAMLDiag, &Error);
|
|
|
|
if (!In.setCurrentDocument()) {
|
|
if (!Error.getMessage().empty())
|
|
return nullptr;
|
|
// Create an empty module when the MIR file is empty.
|
|
return llvm::make_unique<Module>(Filename, Context);
|
|
}
|
|
|
|
std::unique_ptr<Module> M;
|
|
// 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())) {
|
|
M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
|
|
Context);
|
|
if (!M)
|
|
return M;
|
|
In.nextDocument();
|
|
if (!In.setCurrentDocument())
|
|
return M;
|
|
} else {
|
|
// Create an new, empty module.
|
|
M = llvm::make_unique<Module>(Filename, Context);
|
|
}
|
|
|
|
// Parse the machine functions.
|
|
do {
|
|
if (parseMachineFunction(In))
|
|
return nullptr;
|
|
In.nextDocument();
|
|
} while (In.setCurrentDocument());
|
|
|
|
return M;
|
|
}
|
|
|
|
bool MIRParserImpl::parseMachineFunction(yaml::Input &In) {
|
|
yaml::MachineFunction MF;
|
|
yaml::yamlize(In, MF, false);
|
|
if (In.error())
|
|
return true;
|
|
// TODO: Initialize the real machine function with the state in the yaml
|
|
// machine function later on.
|
|
return false;
|
|
}
|
|
|
|
std::unique_ptr<Module> llvm::parseMIRFile(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 std::unique_ptr<Module>();
|
|
}
|
|
return parseMIR(std::move(FileOrErr.get()), Error, Context);
|
|
}
|
|
|
|
std::unique_ptr<Module> llvm::parseMIR(std::unique_ptr<MemoryBuffer> Contents,
|
|
SMDiagnostic &Error,
|
|
LLVMContext &Context) {
|
|
auto Filename = Contents->getBufferIdentifier();
|
|
MIRParserImpl Parser(std::move(Contents), Filename, Context);
|
|
return Parser.parse(Error);
|
|
}
|