1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
//===- 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/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 in the MIR file.
///
/// Return null if an error occurred while parsing the LLVM module.
std::unique_ptr<Module> parseLLVMModule(SMDiagnostic &Error);
};
} // 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());
}
std::unique_ptr<Module> MIRParserImpl::parseLLVMModule(SMDiagnostic &Error) {
yaml::Input In(SM.getMemoryBuffer(SM.getMainFileID())->getBuffer());
// Parse the block scalar manually so that we can return unique pointer
// without having to go trough YAML traits.
if (In.setCurrentDocument()) {
if (const auto *BSN =
dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
return parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
Context);
}
}
// Create an new, empty module.
return llvm::make_unique<Module>(Filename, Context);
}
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.parseLLVMModule(Error);
}
|
