OLD | NEW |
(Empty) | |
| 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 |
OLD | NEW |