1//===---- llvm/Support/IRReader.h - Reader for LLVM IR files ----*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines functions for reading LLVM IR. They support both 11// Bitcode and Assembly, automatically detecting the input format. 12// 13// These functions must be defined in a header file in order to avoid 14// library dependencies, since they reference both Bitcode and Assembly 15// functions. 16// 17//===----------------------------------------------------------------------===// 18 19#ifndef LLVM_SUPPORT_IRREADER_H 20#define LLVM_SUPPORT_IRREADER_H 21 22#include "llvm/ADT/OwningPtr.h" 23#include "llvm/Assembly/Parser.h" 24#include "llvm/Bitcode/ReaderWriter.h" 25#include "llvm/Support/MemoryBuffer.h" 26#include "llvm/Support/SourceMgr.h" 27#include "llvm/Support/system_error.h" 28 29namespace llvm { 30 31 /// If the given MemoryBuffer holds a bitcode image, return a Module for it 32 /// which does lazy deserialization of function bodies. Otherwise, attempt to 33 /// parse it as LLVM Assembly and return a fully populated Module. This 34 /// function *always* takes ownership of the given MemoryBuffer. 35 inline Module *getLazyIRModule(MemoryBuffer *Buffer, 36 SMDiagnostic &Err, 37 LLVMContext &Context) { 38 if (isBitcode((const unsigned char *)Buffer->getBufferStart(), 39 (const unsigned char *)Buffer->getBufferEnd())) { 40 std::string ErrMsg; 41 Module *M = getLazyBitcodeModule(Buffer, Context, &ErrMsg); 42 if (M == 0) { 43 Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error, 44 ErrMsg); 45 // ParseBitcodeFile does not take ownership of the Buffer in the 46 // case of an error. 47 delete Buffer; 48 } 49 return M; 50 } 51 52 return ParseAssembly(Buffer, 0, Err, Context); 53 } 54 55 /// If the given file holds a bitcode image, return a Module 56 /// for it which does lazy deserialization of function bodies. Otherwise, 57 /// attempt to parse it as LLVM Assembly and return a fully populated 58 /// Module. 59 inline Module *getLazyIRFileModule(const std::string &Filename, 60 SMDiagnostic &Err, 61 LLVMContext &Context) { 62 OwningPtr<MemoryBuffer> File; 63 if (error_code ec = MemoryBuffer::getFileOrSTDIN(Filename.c_str(), File)) { 64 Err = SMDiagnostic(Filename, SourceMgr::DK_Error, 65 "Could not open input file: " + ec.message()); 66 return 0; 67 } 68 69 return getLazyIRModule(File.take(), Err, Context); 70 } 71 72 /// If the given MemoryBuffer holds a bitcode image, return a Module 73 /// for it. Otherwise, attempt to parse it as LLVM Assembly and return 74 /// a Module for it. This function *always* takes ownership of the given 75 /// MemoryBuffer. 76 inline Module *ParseIR(MemoryBuffer *Buffer, 77 SMDiagnostic &Err, 78 LLVMContext &Context) { 79 if (isBitcode((const unsigned char *)Buffer->getBufferStart(), 80 (const unsigned char *)Buffer->getBufferEnd())) { 81 std::string ErrMsg; 82 Module *M = ParseBitcodeFile(Buffer, Context, &ErrMsg); 83 if (M == 0) 84 Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error, 85 ErrMsg); 86 // ParseBitcodeFile does not take ownership of the Buffer. 87 delete Buffer; 88 return M; 89 } 90 91 return ParseAssembly(Buffer, 0, Err, Context); 92 } 93 94 /// If the given file holds a bitcode image, return a Module for it. 95 /// Otherwise, attempt to parse it as LLVM Assembly and return a Module 96 /// for it. 97 inline Module *ParseIRFile(const std::string &Filename, 98 SMDiagnostic &Err, 99 LLVMContext &Context) { 100 OwningPtr<MemoryBuffer> File; 101 if (error_code ec = MemoryBuffer::getFileOrSTDIN(Filename.c_str(), File)) { 102 Err = SMDiagnostic(Filename, SourceMgr::DK_Error, 103 "Could not open input file: " + ec.message()); 104 return 0; 105 } 106 107 return ParseIR(File.take(), Err, Context); 108 } 109 110} 111 112#endif 113