mirror of
https://github.com/RPCS3/llvm.git
synced 2025-04-15 12:30:22 +00:00
cca8dbee4e
Type specific declarations have been moved to Type.h and error handling routines have been moved to ErrorHandling.h. Both are included in Core.h so nothing should change for projects directly including the headers, but transitive dependencies may be affected. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@255965 91177308-0d34-0410-b5e6-96231b3b80d8
99 lines
3.5 KiB
C++
99 lines
3.5 KiB
C++
//===-- BitReader.cpp -----------------------------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm-c/BitReader.h"
|
|
#include "llvm-c/Core.h"
|
|
#include "llvm/Bitcode/ReaderWriter.h"
|
|
#include "llvm/IR/DiagnosticPrinter.h"
|
|
#include "llvm/IR/LLVMContext.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <cstring>
|
|
#include <string>
|
|
|
|
using namespace llvm;
|
|
|
|
/* Builds a module from the bitcode in the specified memory buffer, returning a
|
|
reference to the module via the OutModule parameter. Returns 0 on success.
|
|
Optionally returns a human-readable error message via OutMessage. */
|
|
LLVMBool LLVMParseBitcode(LLVMMemoryBufferRef MemBuf,
|
|
LLVMModuleRef *OutModule, char **OutMessage) {
|
|
return LLVMParseBitcodeInContext(wrap(&getGlobalContext()), MemBuf, OutModule,
|
|
OutMessage);
|
|
}
|
|
|
|
static void diagnosticHandler(const DiagnosticInfo &DI, void *C) {
|
|
auto *Message = reinterpret_cast<std::string *>(C);
|
|
raw_string_ostream Stream(*Message);
|
|
DiagnosticPrinterRawOStream DP(Stream);
|
|
DI.print(DP);
|
|
}
|
|
|
|
LLVMBool LLVMParseBitcodeInContext(LLVMContextRef ContextRef,
|
|
LLVMMemoryBufferRef MemBuf,
|
|
LLVMModuleRef *OutModule,
|
|
char **OutMessage) {
|
|
MemoryBufferRef Buf = unwrap(MemBuf)->getMemBufferRef();
|
|
LLVMContext &Ctx = *unwrap(ContextRef);
|
|
|
|
LLVMContext::DiagnosticHandlerTy OldDiagnosticHandler =
|
|
Ctx.getDiagnosticHandler();
|
|
void *OldDiagnosticContext = Ctx.getDiagnosticContext();
|
|
std::string Message;
|
|
Ctx.setDiagnosticHandler(diagnosticHandler, &Message, true);
|
|
|
|
ErrorOr<std::unique_ptr<Module>> ModuleOrErr = parseBitcodeFile(Buf, Ctx);
|
|
|
|
Ctx.setDiagnosticHandler(OldDiagnosticHandler, OldDiagnosticContext, true);
|
|
|
|
if (ModuleOrErr.getError()) {
|
|
if (OutMessage)
|
|
*OutMessage = strdup(Message.c_str());
|
|
*OutModule = wrap((Module*)nullptr);
|
|
return 1;
|
|
}
|
|
|
|
*OutModule = wrap(ModuleOrErr.get().release());
|
|
return 0;
|
|
}
|
|
|
|
/* Reads a module from the specified path, returning via the OutModule parameter
|
|
a module provider which performs lazy deserialization. Returns 0 on success.
|
|
Optionally returns a human-readable error message via OutMessage. */
|
|
LLVMBool LLVMGetBitcodeModuleInContext(LLVMContextRef ContextRef,
|
|
LLVMMemoryBufferRef MemBuf,
|
|
LLVMModuleRef *OutM,
|
|
char **OutMessage) {
|
|
std::string Message;
|
|
std::unique_ptr<MemoryBuffer> Owner(unwrap(MemBuf));
|
|
|
|
ErrorOr<std::unique_ptr<Module>> ModuleOrErr =
|
|
getLazyBitcodeModule(std::move(Owner), *unwrap(ContextRef));
|
|
Owner.release();
|
|
|
|
if (std::error_code EC = ModuleOrErr.getError()) {
|
|
*OutM = wrap((Module *)nullptr);
|
|
if (OutMessage)
|
|
*OutMessage = strdup(EC.message().c_str());
|
|
return 1;
|
|
}
|
|
|
|
*OutM = wrap(ModuleOrErr.get().release());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
LLVMBool LLVMGetBitcodeModule(LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM,
|
|
char **OutMessage) {
|
|
return LLVMGetBitcodeModuleInContext(LLVMGetGlobalContext(), MemBuf, OutM,
|
|
OutMessage);
|
|
}
|