mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 19:12:56 +02:00
8dc80efd4f
Sometimes users do not specify data layout in LLVM assembly and let llc set the data layout by target triple after loading the LLVM assembly. Currently the parser checks alloca address space no matter whether the LLVM assembly contains data layout definition, which causes false alarm since the default data layout does not contain the correct alloca address space. The parser also calls verifier to check debug info and updating invalid debug info. Currently there is no way to let the verifier to check debug info only. If the verifier finds non-debug-info issues the parser will fail. For llc, the fix is to remove the check of alloca addr space in the parser and disable updating debug info, and defer the updating of debug info and verification to be after setting data layout of the IR by target. For other llvm tools, since they do not override data layout by target but instead can override data layout by a command line option, an argument for overriding data layout is added to the parser. In cases where data layout overriding is necessary for the parser, the data layout can be provided by command line. Differential Revision: https://reviews.llvm.org/D41832 llvm-svn: 323826
115 lines
4.2 KiB
C++
115 lines
4.2 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, bool UpgradeDebugInfo,
|
|
StringRef DataLayoutString) {
|
|
SourceMgr SM;
|
|
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(F);
|
|
SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
|
|
|
|
return LLParser(F.getBuffer(), SM, Err, &M, Slots, UpgradeDebugInfo,
|
|
DataLayoutString)
|
|
.Run();
|
|
}
|
|
|
|
std::unique_ptr<Module>
|
|
llvm::parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context,
|
|
SlotMapping *Slots, bool UpgradeDebugInfo,
|
|
StringRef DataLayoutString) {
|
|
std::unique_ptr<Module> M =
|
|
make_unique<Module>(F.getBufferIdentifier(), Context);
|
|
|
|
if (parseAssemblyInto(F, *M, Err, Slots, UpgradeDebugInfo, DataLayoutString))
|
|
return nullptr;
|
|
|
|
return M;
|
|
}
|
|
|
|
std::unique_ptr<Module>
|
|
llvm::parseAssemblyFile(StringRef Filename, SMDiagnostic &Err,
|
|
LLVMContext &Context, SlotMapping *Slots,
|
|
bool UpgradeDebugInfo, StringRef DataLayoutString) {
|
|
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,
|
|
UpgradeDebugInfo, DataLayoutString);
|
|
}
|
|
|
|
std::unique_ptr<Module>
|
|
llvm::parseAssemblyString(StringRef AsmString, SMDiagnostic &Err,
|
|
LLVMContext &Context, SlotMapping *Slots,
|
|
bool UpgradeDebugInfo, StringRef DataLayoutString) {
|
|
MemoryBufferRef F(AsmString, "<string>");
|
|
return parseAssembly(F, Err, Context, Slots, UpgradeDebugInfo,
|
|
DataLayoutString);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
Type *llvm::parseType(StringRef Asm, SMDiagnostic &Err, const Module &M,
|
|
const SlotMapping *Slots) {
|
|
unsigned Read;
|
|
Type *Ty = parseTypeAtBeginning(Asm, Read, Err, M, Slots);
|
|
if (!Ty)
|
|
return nullptr;
|
|
if (Read != Asm.size()) {
|
|
SourceMgr SM;
|
|
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
|
|
SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
|
|
Err = SM.GetMessage(SMLoc::getFromPointer(Asm.begin() + Read),
|
|
SourceMgr::DK_Error, "expected end of string");
|
|
return nullptr;
|
|
}
|
|
return Ty;
|
|
}
|
|
Type *llvm::parseTypeAtBeginning(StringRef Asm, unsigned &Read,
|
|
SMDiagnostic &Err, const Module &M,
|
|
const SlotMapping *Slots) {
|
|
SourceMgr SM;
|
|
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
|
|
SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
|
|
Type *Ty;
|
|
if (LLParser(Asm, SM, Err, const_cast<Module *>(&M))
|
|
.parseTypeAtBeginning(Ty, Read, Slots))
|
|
return nullptr;
|
|
return Ty;
|
|
}
|