1 //===-- llvm/Bitcode/ReaderWriter.h - Bitcode reader/writers ----*- 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 header defines interfaces to read and write LLVM bitcode files/streams. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_BITCODE_READERWRITER_H 15 #define LLVM_BITCODE_READERWRITER_H 16 17 #include <string> 18 19 namespace llvm { 20 class BitstreamWriter; 21 class MemoryBuffer; 22 class DataStreamer; 23 class LLVMContext; 24 class Module; 25 class ModulePass; 26 class raw_ostream; 27 28 /// getLazyBitcodeModule - Read the header of the specified bitcode buffer 29 /// and prepare for lazy deserialization of function bodies. If successful, 30 /// this takes ownership of 'buffer' and returns a non-null pointer. On 31 /// error, this returns null, *does not* take ownership of Buffer, and fills 32 /// in *ErrMsg with an error description if ErrMsg is non-null. 33 Module *getLazyBitcodeModule(MemoryBuffer *Buffer, 34 LLVMContext &Context, 35 std::string *ErrMsg = 0); 36 37 /// getStreamedBitcodeModule - Read the header of the specified stream 38 /// and prepare for lazy deserialization and streaming of function bodies. 39 /// On error, this returns null, and fills in *ErrMsg with an error 40 /// description if ErrMsg is non-null. 41 Module *getStreamedBitcodeModule(const std::string &name, 42 DataStreamer *streamer, 43 LLVMContext &Context, 44 std::string *ErrMsg = 0); 45 46 /// getBitcodeTargetTriple - Read the header of the specified bitcode 47 /// buffer and extract just the triple information. If successful, 48 /// this returns a string and *does not* take ownership 49 /// of 'buffer'. On error, this returns "", and fills in *ErrMsg 50 /// if ErrMsg is non-null. 51 std::string getBitcodeTargetTriple(MemoryBuffer *Buffer, 52 LLVMContext &Context, 53 std::string *ErrMsg = 0); 54 55 /// ParseBitcodeFile - Read the specified bitcode file, returning the module. 56 /// If an error occurs, this returns null and fills in *ErrMsg if it is 57 /// non-null. This method *never* takes ownership of Buffer. 58 Module *ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext &Context, 59 std::string *ErrMsg = 0); 60 61 /// WriteBitcodeToFile - Write the specified module to the specified 62 /// raw output stream. For streams where it matters, the given stream 63 /// should be in "binary" mode. 64 void WriteBitcodeToFile(const Module *M, raw_ostream &Out); 65 66 /// createBitcodeWriterPass - Create and return a pass that writes the module 67 /// to the specified ostream. 68 ModulePass *createBitcodeWriterPass(raw_ostream &Str); 69 70 71 /// isBitcodeWrapper - Return true if the given bytes are the magic bytes 72 /// for an LLVM IR bitcode wrapper. 73 /// isBitcodeWrapper(const unsigned char * BufPtr,const unsigned char * BufEnd)74 inline bool isBitcodeWrapper(const unsigned char *BufPtr, 75 const unsigned char *BufEnd) { 76 // See if you can find the hidden message in the magic bytes :-). 77 // (Hint: it's a little-endian encoding.) 78 return BufPtr != BufEnd && 79 BufPtr[0] == 0xDE && 80 BufPtr[1] == 0xC0 && 81 BufPtr[2] == 0x17 && 82 BufPtr[3] == 0x0B; 83 } 84 85 /// isRawBitcode - Return true if the given bytes are the magic bytes for 86 /// raw LLVM IR bitcode (without a wrapper). 87 /// isRawBitcode(const unsigned char * BufPtr,const unsigned char * BufEnd)88 inline bool isRawBitcode(const unsigned char *BufPtr, 89 const unsigned char *BufEnd) { 90 // These bytes sort of have a hidden message, but it's not in 91 // little-endian this time, and it's a little redundant. 92 return BufPtr != BufEnd && 93 BufPtr[0] == 'B' && 94 BufPtr[1] == 'C' && 95 BufPtr[2] == 0xc0 && 96 BufPtr[3] == 0xde; 97 } 98 99 /// isBitcode - Return true if the given bytes are the magic bytes for 100 /// LLVM IR bitcode, either with or without a wrapper. 101 /// isBitcode(const unsigned char * BufPtr,const unsigned char * BufEnd)102 inline bool isBitcode(const unsigned char *BufPtr, 103 const unsigned char *BufEnd) { 104 return isBitcodeWrapper(BufPtr, BufEnd) || 105 isRawBitcode(BufPtr, BufEnd); 106 } 107 108 /// SkipBitcodeWrapperHeader - Some systems wrap bc files with a special 109 /// header for padding or other reasons. The format of this header is: 110 /// 111 /// struct bc_header { 112 /// uint32_t Magic; // 0x0B17C0DE 113 /// uint32_t Version; // Version, currently always 0. 114 /// uint32_t BitcodeOffset; // Offset to traditional bitcode file. 115 /// uint32_t BitcodeSize; // Size of traditional bitcode file. 116 /// ... potentially other gunk ... 117 /// }; 118 /// 119 /// This function is called when we find a file with a matching magic number. 120 /// In this case, skip down to the subsection of the file that is actually a 121 /// BC file. 122 /// If 'VerifyBufferSize' is true, check that the buffer is large enough to 123 /// contain the whole bitcode file. SkipBitcodeWrapperHeader(const unsigned char * & BufPtr,const unsigned char * & BufEnd,bool VerifyBufferSize)124 inline bool SkipBitcodeWrapperHeader(const unsigned char *&BufPtr, 125 const unsigned char *&BufEnd, 126 bool VerifyBufferSize) { 127 enum { 128 KnownHeaderSize = 4*4, // Size of header we read. 129 OffsetField = 2*4, // Offset in bytes to Offset field. 130 SizeField = 3*4 // Offset in bytes to Size field. 131 }; 132 133 // Must contain the header! 134 if (BufEnd-BufPtr < KnownHeaderSize) return true; 135 136 unsigned Offset = ( BufPtr[OffsetField ] | 137 (BufPtr[OffsetField+1] << 8) | 138 (BufPtr[OffsetField+2] << 16) | 139 (BufPtr[OffsetField+3] << 24)); 140 unsigned Size = ( BufPtr[SizeField ] | 141 (BufPtr[SizeField +1] << 8) | 142 (BufPtr[SizeField +2] << 16) | 143 (BufPtr[SizeField +3] << 24)); 144 145 // Verify that Offset+Size fits in the file. 146 if (VerifyBufferSize && Offset+Size > unsigned(BufEnd-BufPtr)) 147 return true; 148 BufPtr += Offset; 149 BufEnd = BufPtr+Size; 150 return false; 151 } 152 } // End llvm namespace 153 154 #endif 155