1 //===- ReaderWrappers.cpp - Parse bytecode from file or buffer -----------===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements loading and parsing a bytecode file and parsing a
11 // bytecode module from a given buffer.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/Bytecode/Analyzer.h"
16 #include "llvm/Bytecode/Reader.h"
18 #include "llvm/Module.h"
19 #include "llvm/Instructions.h"
20 #include "llvm/ADT/StringExtras.h"
21 #include "llvm/System/MappedFile.h"
22 #include "llvm/System/Program.h"
27 //===----------------------------------------------------------------------===//
28 // BytecodeFileReader - Read from an mmap'able file descriptor.
32 /// BytecodeFileReader - parses a bytecode file from a file
34 class BytecodeFileReader : public BytecodeReader {
37 BCDecompressor_t *Decompressor;
38 sys::MappedFile mapFile;
40 BytecodeFileReader(const BytecodeFileReader&); // Do not implement
41 void operator=(const BytecodeFileReader &BFR); // Do not implement
44 BytecodeFileReader(const std::string &Filename, BCDecompressor_t *BCDC,
45 llvm::BytecodeHandler* H=0);
46 bool read(std::string* ErrMsg);
49 BytecodeReader::freeState();
55 BytecodeFileReader::BytecodeFileReader(const std::string &Filename,
56 BCDecompressor_t *BCDC,
57 llvm::BytecodeHandler* H)
58 : BytecodeReader(H), fileName(Filename), Decompressor(BCDC) {
61 bool BytecodeFileReader::read(std::string* ErrMsg) {
62 if (mapFile.open(sys::Path(fileName), sys::MappedFile::READ_ACCESS, ErrMsg))
64 if (!mapFile.map(ErrMsg)) {
68 unsigned char* buffer = reinterpret_cast<unsigned char*>(mapFile.base());
69 return ParseBytecode(buffer, mapFile.size(), fileName,
70 Decompressor, ErrMsg);
73 //===----------------------------------------------------------------------===//
74 // BytecodeBufferReader - Read from a memory buffer
78 /// BytecodeBufferReader - parses a bytecode file from a buffer
80 class BytecodeBufferReader : public BytecodeReader {
82 const unsigned char *Buffer;
83 const unsigned char *Buf;
86 BCDecompressor_t *Decompressor;
89 BytecodeBufferReader(const BytecodeBufferReader&); // Do not implement
90 void operator=(const BytecodeBufferReader &BFR); // Do not implement
93 BytecodeBufferReader(const unsigned char *Buf, unsigned Length,
94 const std::string &ModuleID, BCDecompressor_t *BCDC,
95 llvm::BytecodeHandler* Handler = 0);
96 ~BytecodeBufferReader();
98 bool read(std::string* ErrMsg);
103 BytecodeBufferReader::BytecodeBufferReader(const unsigned char *buf,
105 const std::string &modID,
106 BCDecompressor_t *BCDC,
107 llvm::BytecodeHandler *H)
108 : BytecodeReader(H), Buffer(0), Buf(buf), Length(len), ModuleID(modID)
109 , Decompressor(BCDC), MustDelete(false) {
112 BytecodeBufferReader::~BytecodeBufferReader() {
113 if (MustDelete) delete [] Buffer;
117 BytecodeBufferReader::read(std::string* ErrMsg) {
118 // If not aligned, allocate a new buffer to hold the bytecode...
119 const unsigned char *ParseBegin = 0;
120 if (reinterpret_cast<uint64_t>(Buf) & 3) {
121 Buffer = new unsigned char[Length+4];
122 unsigned Offset = 4 - ((intptr_t)Buffer & 3); // Make sure it's aligned
123 ParseBegin = Buffer + Offset;
124 memcpy((unsigned char*)ParseBegin, Buf, Length); // Copy it over
127 // If we don't need to copy it over, just use the caller's copy
128 ParseBegin = Buffer = Buf;
131 if (ParseBytecode(ParseBegin, Length, ModuleID, Decompressor, ErrMsg)) {
132 if (MustDelete) delete [] Buffer;
138 //===----------------------------------------------------------------------===//
139 // BytecodeStdinReader - Read bytecode from Standard Input
143 /// BytecodeStdinReader - parses a bytecode file from stdin
145 class BytecodeStdinReader : public BytecodeReader {
147 std::vector<unsigned char> FileData;
148 BCDecompressor_t *Decompressor;
149 unsigned char *FileBuf;
151 BytecodeStdinReader(const BytecodeStdinReader&); // Do not implement
152 void operator=(const BytecodeStdinReader &BFR); // Do not implement
155 BytecodeStdinReader(BCDecompressor_t *BCDC, llvm::BytecodeHandler* H = 0);
156 bool read(std::string* ErrMsg);
160 BytecodeStdinReader::BytecodeStdinReader(BCDecompressor_t *BCDC,
162 : BytecodeReader(H), Decompressor(BCDC) {
165 bool BytecodeStdinReader::read(std::string* ErrMsg) {
166 sys::Program::ChangeStdinToBinary();
169 // Read in all of the data from stdin, we cannot mmap stdin...
170 while (cin.stream()->good()) {
171 cin.stream()->read(Buffer, 4096*4);
172 int BlockSize = cin.stream()->gcount();
175 FileData.insert(FileData.end(), Buffer, Buffer+BlockSize);
178 if (FileData.empty()) {
180 *ErrMsg = "Standard Input is empty!";
184 FileBuf = &FileData[0];
185 if (ParseBytecode(FileBuf, FileData.size(), "<stdin>", Decompressor, ErrMsg))
190 //===----------------------------------------------------------------------===//
192 //===----------------------------------------------------------------------===//
194 /// getBytecodeBufferModuleProvider - lazy function-at-a-time loading from a
197 llvm::getBytecodeBufferModuleProvider(const unsigned char *Buffer,
199 const std::string &ModuleID,
200 BCDecompressor_t *BCDC,
202 BytecodeHandler *H) {
203 BytecodeBufferReader *rdr =
204 new BytecodeBufferReader(Buffer, Length, ModuleID, BCDC, H);
205 if (rdr->read(ErrMsg))
210 /// ParseBytecodeBuffer - Parse a given bytecode buffer
212 Module *llvm::ParseBytecodeBuffer(const unsigned char *Buffer, unsigned Length,
213 const std::string &ModuleID,
214 BCDecompressor_t *BCDC,
215 std::string *ErrMsg) {
217 getBytecodeBufferModuleProvider(Buffer, Length, ModuleID, BCDC, ErrMsg, 0);
219 Module *M = MP->releaseModule(ErrMsg);
224 /// getBytecodeModuleProvider - lazy function-at-a-time loading from a file
227 llvm::getBytecodeModuleProvider(const std::string &Filename,
228 BCDecompressor_t *BCDC,
230 BytecodeHandler* H) {
232 if (Filename != std::string("-")) {
233 BytecodeFileReader *rdr = new BytecodeFileReader(Filename, BCDC, H);
234 if (rdr->read(ErrMsg))
240 BytecodeStdinReader *rdr = new BytecodeStdinReader(BCDC, H);
241 if (rdr->read(ErrMsg))
246 /// ParseBytecodeFile - Parse the given bytecode file
248 Module *llvm::ParseBytecodeFile(const std::string &Filename,
249 BCDecompressor_t *BCDC,
250 std::string *ErrMsg) {
251 ModuleProvider* MP = getBytecodeModuleProvider(Filename, BCDC, ErrMsg);
253 Module *M = MP->releaseModule(ErrMsg);