6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-25 16:24:23 +00:00
Code Issues Projects Releases Wiki Activity

ParseIR: don't take ownership of the MemoryBuffer

Browse Source 
clang was needlessly duplicating whole memory buffer contents in an attempt to
satisfy unclear ownership semantics. Let's just hide internal LLVM quirks and
present a simple non-owning interface.

The public C API preserves previous behaviour for stability.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@211861 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Alp Toker
2014-06-27 04:33:58 +00:00
parent 493512898f
commit d0996e5b33
3 changed files with 14 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/llvm/IRReader/IRReader.h
View File

@ -40,9 +40,9 @@ Module *getLazyIRFileModule(const std::string &Filename, SMDiagnostic &Err,
/// If the given MemoryBuffer holds a bitcode image, return a Module /// If the given MemoryBuffer holds a bitcode image, return a Module
/// for it. Otherwise, attempt to parse it as LLVM Assembly and return /// for it. Otherwise, attempt to parse it as LLVM Assembly and return
/// a Module for it. This function *always* takes ownership of the given /// a Module for it. This function *never* takes ownership of Buffer.
/// MemoryBuffer. Module *ParseIR(const MemoryBuffer *Buffer, SMDiagnostic &Err,
Module *ParseIR(MemoryBuffer *Buffer, SMDiagnostic &Err, LLVMContext &Context); LLVMContext &Context);
/// If the given file holds a bitcode image, return a Module for it. /// If the given file holds a bitcode image, return a Module for it.
/// Otherwise, attempt to parse it as LLVM Assembly and return a Module /// Otherwise, attempt to parse it as LLVM Assembly and return a Module

3
lib/AsmParser/Parser.cpp
View File

@ -54,8 +54,7 @@ Module *llvm::ParseAssemblyFile(const std::string &Filename, SMDiagnostic &Err,
Module *llvm::ParseAssemblyString(const char *AsmString, Module *M, Module *llvm::ParseAssemblyString(const char *AsmString, Module *M,
SMDiagnostic &Err, LLVMContext &Context) { SMDiagnostic &Err, LLVMContext &Context) {
MemoryBuffer *F = MemoryBuffer *F =
MemoryBuffer::getMemBuffer(StringRef(AsmString, strlen(AsmString)), MemoryBuffer::getMemBuffer(StringRef(AsmString), "<string>");
"<string>");
return ParseAssembly(F, M, Err, Context); return ParseAssembly(F, M, Err, Context);
} }

17
lib/IRReader/IRReader.cpp
View File

@ -39,7 +39,7 @@ Module *llvm::getLazyIRModule(MemoryBuffer *Buffer, SMDiagnostic &Err,
if (std::error_code EC = ModuleOrErr.getError()) { if (std::error_code EC = ModuleOrErr.getError()) {
Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error, Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error,
EC.message()); EC.message());
// ParseBitcodeFile does not take ownership of the Buffer in the // getLazyBitcodeModule does not take ownership of the Buffer in the
// case of an error. // case of an error.
delete Buffer; delete Buffer;
return nullptr; return nullptr;
@ -62,13 +62,14 @@ Module *llvm::getLazyIRFileModule(const std::string &Filename, SMDiagnostic &Err
return getLazyIRModule(File.release(), Err, Context); return getLazyIRModule(File.release(), Err, Context);
} }
Module *llvm::ParseIR(MemoryBuffer *Buffer, SMDiagnostic &Err, Module *llvm::ParseIR(const MemoryBuffer *Buffer, SMDiagnostic &Err,
LLVMContext &Context) { LLVMContext &Context) {
NamedRegionTimer T(TimeIRParsingName, TimeIRParsingGroupName, NamedRegionTimer T(TimeIRParsingName, TimeIRParsingGroupName,
TimePassesIsEnabled); TimePassesIsEnabled);
if (isBitcode((const unsigned char *)Buffer->getBufferStart(), if (isBitcode((const unsigned char *)Buffer->getBufferStart(),
(const unsigned char *)Buffer->getBufferEnd())) { (const unsigned char *)Buffer->getBufferEnd())) {
ErrorOr<Module *> ModuleOrErr = parseBitcodeFile(Buffer, Context); ErrorOr<Module *> ModuleOrErr =
parseBitcodeFile(const_cast<MemoryBuffer *>(Buffer), Context);
Module *M = nullptr; Module *M = nullptr;
if (std::error_code EC = ModuleOrErr.getError()) if (std::error_code EC = ModuleOrErr.getError())
Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error, Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error,
@ -76,11 +77,12 @@ Module *llvm::ParseIR(MemoryBuffer *Buffer, SMDiagnostic &Err,
else else
M = ModuleOrErr.get(); M = ModuleOrErr.get();
// parseBitcodeFile does not take ownership of the Buffer. // parseBitcodeFile does not take ownership of the Buffer.
delete Buffer;
return M; return M;
} }
return ParseAssembly(Buffer, nullptr, Err, Context); return ParseAssembly(MemoryBuffer::getMemBuffer(
Buffer->getBuffer(), Buffer->getBufferIdentifier()),
nullptr, Err, Context);
} }
Module *llvm::ParseIRFile(const std::string &Filename, SMDiagnostic &Err, Module *llvm::ParseIRFile(const std::string &Filename, SMDiagnostic &Err,
@ -92,7 +94,7 @@ Module *llvm::ParseIRFile(const std::string &Filename, SMDiagnostic &Err,
return nullptr; return nullptr;
} }
return ParseIR(File.release(), Err, Context); return ParseIR(File.get(), Err, Context);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
@ -104,7 +106,8 @@ LLVMBool LLVMParseIRInContext(LLVMContextRef ContextRef,
char **OutMessage) { char **OutMessage) {
SMDiagnostic Diag; SMDiagnostic Diag;
*OutM = wrap(ParseIR(unwrap(MemBuf), Diag, *unwrap(ContextRef))); std::unique_ptr<MemoryBuffer> MB(unwrap(MemBuf));
*OutM = wrap(ParseIR(MB.get(), Diag, *unwrap(ContextRef)));
if(!*OutM) { if(!*OutM) {
if (OutMessage) { if (OutMessage) {