mirror of
https://github.com/RPCS3/llvm.git
synced 2024-11-29 06:30:30 +00:00
0e99876efe
This commit extends the 'SlotMapping' structure and includes mappings for named and numbered types in it. The LLParser is extended accordingly to fill out those mappings at the end of module parsing. This information is useful when we want to parse standalone constant values at a later stage using the 'parseConstantValue' method. The constant values can be constant expressions, which can contain references to types. In order to parse such constant values, we have to restore the internal named and numbered mappings for the types in LLParser, otherwise the parser will report a parsing error. Therefore, this commit also introduces a new method called 'restoreParsingState' to LLParser, which uses the slot mappings to restore some of its internal parsing state. This commit is required to serialize constant value pointers in the machine memory operands for the MIR format. Reviewers: Duncan P. N. Exon Smith git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@245740 91177308-0d34-0410-b5e6-96231b3b80d8
81 lines
3.0 KiB
C++
81 lines
3.0 KiB
C++
//===- Parser.cpp - Main dispatch module for the Parser library -----------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This library implements the functionality defined in llvm/AsmParser/Parser.h
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/AsmParser/Parser.h"
|
|
#include "LLParser.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/SourceMgr.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <cstring>
|
|
#include <system_error>
|
|
using namespace llvm;
|
|
|
|
bool llvm::parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err,
|
|
SlotMapping *Slots) {
|
|
SourceMgr SM;
|
|
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(F);
|
|
SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
|
|
|
|
return LLParser(F.getBuffer(), SM, Err, &M, Slots).Run();
|
|
}
|
|
|
|
std::unique_ptr<Module> llvm::parseAssembly(MemoryBufferRef F,
|
|
SMDiagnostic &Err,
|
|
LLVMContext &Context,
|
|
SlotMapping *Slots) {
|
|
std::unique_ptr<Module> M =
|
|
make_unique<Module>(F.getBufferIdentifier(), Context);
|
|
|
|
if (parseAssemblyInto(F, *M, Err, Slots))
|
|
return nullptr;
|
|
|
|
return M;
|
|
}
|
|
|
|
std::unique_ptr<Module> llvm::parseAssemblyFile(StringRef Filename,
|
|
SMDiagnostic &Err,
|
|
LLVMContext &Context,
|
|
SlotMapping *Slots) {
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
|
|
MemoryBuffer::getFileOrSTDIN(Filename);
|
|
if (std::error_code EC = FileOrErr.getError()) {
|
|
Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
|
|
"Could not open input file: " + EC.message());
|
|
return nullptr;
|
|
}
|
|
|
|
return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context, Slots);
|
|
}
|
|
|
|
std::unique_ptr<Module> llvm::parseAssemblyString(StringRef AsmString,
|
|
SMDiagnostic &Err,
|
|
LLVMContext &Context,
|
|
SlotMapping *Slots) {
|
|
MemoryBufferRef F(AsmString, "<string>");
|
|
return parseAssembly(F, Err, Context, Slots);
|
|
}
|
|
|
|
Constant *llvm::parseConstantValue(StringRef Asm, SMDiagnostic &Err,
|
|
const Module &M, const SlotMapping *Slots) {
|
|
SourceMgr SM;
|
|
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
|
|
SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
|
|
Constant *C;
|
|
if (LLParser(Asm, SM, Err, const_cast<Module *>(&M))
|
|
.parseStandaloneConstantValue(C, Slots))
|
|
return nullptr;
|
|
return C;
|
|
}
|