1 //===-- llvm/Bitcode/NaCl/NaClReaderWriter.h - ------------------*- C++ -*-===// 2 // NaCl Bitcode reader/writer. 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is distributed under the University of Illinois Open Source 7 // License. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 // 11 // This header defines interfaces to read and write NaCl bitcode wire format 12 // files. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #ifndef LLVM_BITCODE_NACL_NACLREADERWRITER_H 17 #define LLVM_BITCODE_NACL_NACLREADERWRITER_H 18 19 #include "llvm/IR/DiagnosticInfo.h" 20 #include "llvm/Support/CommandLine.h" 21 #include "llvm/Support/ErrorOr.h" 22 #include "llvm/Support/MemoryBuffer.h" 23 24 #include <string> 25 26 namespace llvm { 27 class LLVMContext; 28 class Module; 29 class NaClBitcodeHeader; 30 class NaClBitstreamWriter; 31 class StreamingMemoryObject; 32 class raw_ostream; 33 34 /// Defines the data layout used for PNaCl bitcode files. We set the 35 /// data layout of the module in the bitcode readers rather than in 36 /// pnacl-llc so that 'opt' will also use the correct data layout if 37 /// it is run on a pexe. 38 extern const char *PNaClDataLayout; 39 40 /// Allows (function) local symbol tables (unsupported) in PNaCl bitcode 41 /// files. 42 extern cl::opt<bool> PNaClAllowLocalSymbolTables; 43 44 /// \brief Defines the integer bit size used to model pointers in PNaCl. 45 static const unsigned PNaClIntPtrTypeBitSize = 32; 46 47 /// Diagnostic handler that redirects error diagnostics to the given stream. 48 DiagnosticHandlerFunction redirectNaClDiagnosticToStream(raw_ostream &Out); 49 50 /// Read the header of the specified bitcode buffer and prepare for lazy 51 /// deserialization of function bodies. If successful, this takes ownership 52 /// of 'Buffer' (extending its lifetime). On error, this returns an error 53 /// code and deletes Buffer. 54 /// 55 /// The AcceptSupportedOnly argument is used to decide which PNaCl versions 56 /// of the PNaCl bitcode to accept. There are three forms: 57 /// 1) Readable and supported. 58 /// 2) Readable and unsupported. Allows testing of code before becoming 59 /// supported, as well as running experiments on the bitcode format. 60 /// 3) Unreadable. 61 /// When AcceptSupportedOnly is true, only form 1 is allowed. When 62 /// AcceptSupportedOnly is false, forms 1 and 2 are allowed. 63 ErrorOr<Module *> getNaClLazyBitcodeModule( 64 std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext &Context, 65 DiagnosticHandlerFunction DiagnosticHandler = nullptr, 66 bool AcceptSupportedOnly = true); 67 68 /// Read the header of the specified stream and prepare for lazy 69 /// deserialization and streaming of function bodies. On error, 70 /// this returns null, and fills in *ErrMsg with an error description 71 /// if ErrMsg is non-null. 72 /// 73 /// See getNaClLazyBitcodeModule for an explanation of argument 74 /// AcceptSupportedOnly. 75 /// TODO(kschimpf): Refactor this and getStreamedBitcodeModule to use 76 /// ErrorOr<Module *> API so that all methods have the same interface. 77 Module *getNaClStreamedBitcodeModule( 78 const std::string &name, StreamingMemoryObject *streamer, 79 LLVMContext &Context, 80 DiagnosticHandlerFunction DiagnosticHandler = nullptr, 81 std::string *ErrMsg = nullptr, bool AcceptSupportedOnly = true); 82 83 /// Read the bitcode file from a buffer, returning the module. 84 /// 85 /// See getNaClLazyBitcodeModule for an explanation of argument 86 /// AcceptSupportedOnly. 87 ErrorOr<Module *> 88 NaClParseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, 89 DiagnosticHandlerFunction DiagnosticHandler = nullptr, 90 bool AcceptSupportedOnly = true); 91 92 /// Read the textual bitcode records in Filename, returning the module. 93 /// Note: If Filename is "-", stdin will be read. 94 /// 95 /// TODO(kschimpf) Replace Verbose argument with a DiagnosticHandlerFunction. 96 ErrorOr<Module *> parseNaClBitcodeText(const std::string &Filename, 97 LLVMContext &Context, 98 raw_ostream *Verbose = nullptr); 99 100 /// Write the specified module to the specified raw output stream, using 101 /// PNaCl wire format. For streams where it matters, the given stream 102 /// should be in "binary" mode. 103 /// 104 /// The AcceptSupportedOnly argument is used to decide which PNaCl versions 105 /// of the PNaCl bitcode to generate. There are two forms: 106 /// 1) Writable and supported. 107 /// 2) Writable and unsupported. Allows testing of code before becoming 108 /// supported, as well as running experiments on the bitcode format. 109 /// When AcceptSupportedOnly is true, only form 1 is allowed. When 110 /// AcceptSupportedOnly is false, forms 1 and 2 are allowed. 111 void NaClWriteBitcodeToFile(const Module *M, raw_ostream &Out, 112 bool AcceptSupportedOnly = true); 113 114 /// isNaClBitcode - Return true if the given bytes are the magic bytes for 115 /// PNaCl bitcode wire format. 116 /// 117 inline bool isNaClBitcode(const unsigned char *BufPtr, 118 const unsigned char *BufEnd) { 119 return BufPtr+4 <= BufEnd && 120 BufPtr[0] == 'P' && 121 BufPtr[1] == 'E' && 122 BufPtr[2] == 'X' && 123 BufPtr[3] == 'E'; 124 } 125 126 /// NaClWriteHeader - Generate a default header (using the version 127 /// number defined by kPNaClVersion) and write to the corresponding 128 /// bitcode stream. 129 void NaClWriteHeader(NaClBitstreamWriter &Stream, bool AcceptSupportedOnly); 130 131 // NaClWriteHeader - Write the contents of the bitcode header to the 132 // corresponding bitcode stream. 133 void NaClWriteHeader(const NaClBitcodeHeader &Header, 134 NaClBitstreamWriter &Stream); 135 136 /// NaClObjDump - Read PNaCl bitcode file from input, and print a 137 /// textual representation of its contents. NoRecords and NoAssembly 138 /// define what should not be included in the dump. 139 bool NaClObjDump(MemoryBufferRef Input, raw_ostream &output, 140 bool NoRecords, bool NoAssembly); 141 142 } // end llvm namespace 143 #endif 144
