lib/Bytecode/Reader/ReaderWrappers.cpp

   1 //===- ReaderWrappers.cpp - Parse bytecode from file or buffer  -----------===//
   2 //
   3 // This file implements loading and parsing a bytecode file and parsing a
   4 // bytecode module from a given buffer.
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8 #include "ReaderInternals.h"
   9 #include "Support/StringExtras.h"
  10 #include "Config/fcntl.h"
  11 #include "Config/unistd.h"
  12 #include "Config/sys/mman.h"
  13
  14 namespace {
  15   /// FDHandle - Simple handle class to make sure a file descriptor gets closed
  16   /// when the object is destroyed.
  17   ///
  18   class FDHandle {
  19     int FD;
  20   public:
  21     FDHandle(int fd) : FD(fd) {}
  22     operator int() const { return FD; }
  23     ~FDHandle() {
  24       if (FD != -1) close(FD);
  25     }
  26   };
  27
  28   /// BytecodeFileReader - parses a bytecode file from a file
  29   ///
  30   class BytecodeFileReader : public BytecodeParser {
  31   private:
  32     unsigned char *Buffer;
  33     int Length;
  34
  35     BytecodeFileReader(const BytecodeFileReader&); // Do not implement
  36     void operator=(const BytecodeFileReader &BFR); // Do not implement
  37
  38   public:
  39     BytecodeFileReader(const std::string &Filename);
  40     ~BytecodeFileReader();
  41
  42   };
  43 }
  44
  45 BytecodeFileReader::BytecodeFileReader(const std::string &Filename) {
  46   FDHandle FD = open(Filename.c_str(), O_RDONLY);
  47   if (FD == -1)
  48     throw std::string("Error opening file!");
  49
  50   // Stat the file to get its length...
  51   struct stat StatBuf;
  52   if (fstat(FD, &StatBuf) == -1 || StatBuf.st_size == 0)
  53     throw std::string("Error stat'ing file!");
  54
  55   // mmap in the file all at once...
  56   Length = StatBuf.st_size;
  57   unsigned char *Buffer = (unsigned char*)mmap(0, Length, PROT_READ,
  58                                                MAP_PRIVATE, FD, 0);
  59   if (Buffer == (unsigned char*)MAP_FAILED)
  60     throw std::string("Error mmapping file!");
  61
  62   // Parse the bytecode we mmapped in
  63   ParseBytecode(Buffer, Length, Filename);
  64 }
  65
  66 BytecodeFileReader::~BytecodeFileReader() {
  67   // Unmmap the bytecode...
  68   munmap((char*)Buffer, Length);
  69 }
  70
  71 ////////////////////////////////////////////////////////////////////////////
  72
  73 namespace {
  74   /// BytecodeBufferReader - parses a bytecode file from a buffer
  75   ///
  76   class BytecodeBufferReader : public BytecodeParser {
  77   private:
  78     const unsigned char *Buffer;
  79     bool MustDelete;
  80
  81     BytecodeBufferReader(const BytecodeBufferReader&); // Do not implement
  82     void operator=(const BytecodeBufferReader &BFR);   // Do not implement
  83
  84   public:
  85     BytecodeBufferReader(const unsigned char *Buf, unsigned Length,
  86                          const std::string &ModuleID);
  87     ~BytecodeBufferReader();
  88
  89   };
  90 }
  91
  92 BytecodeBufferReader::BytecodeBufferReader(const unsigned char *Buf,
  93                                            unsigned Length,
  94                                            const std::string &ModuleID)
  95 {
  96   // If not aligned, allocate a new buffer to hold the bytecode...
  97   const unsigned char *ParseBegin = 0;
  98   if ((intptr_t)Buf & 3) {
  99     Buffer = new unsigned char[Length+4];
 100     unsigned Offset = 4 - ((intptr_t)Buf & 3);   // Make sure it's aligned
 101     ParseBegin = Buffer + Offset;
 102     memcpy((unsigned char*)ParseBegin, Buf, Length);    // Copy it over
 103     MustDelete = true;
 104   } else {
 105     // If we don't need to copy it over, just use the caller's copy
 106     ParseBegin = Buffer = Buf;
 107     MustDelete = false;
 108   }
 109   ParseBytecode(ParseBegin, Length, ModuleID);
 110 }
 111
 112 BytecodeBufferReader::~BytecodeBufferReader() {
 113   if (MustDelete) delete [] Buffer;
 114 }
 115
 116
 117 namespace {
 118   /// BytecodeStdinReader - parses a bytecode file from stdin
 119   ///
 120   class BytecodeStdinReader : public BytecodeParser {
 121   private:
 122     std::vector<unsigned char> FileData;
 123     unsigned char *FileBuf;
 124
 125     BytecodeStdinReader(const BytecodeStdinReader&); // Do not implement
 126     void operator=(const BytecodeStdinReader &BFR);  // Do not implement
 127
 128   public:
 129     BytecodeStdinReader();
 130   };
 131 }
 132
 133 BytecodeStdinReader::BytecodeStdinReader() {
 134   int BlockSize;
 135   unsigned char Buffer[4096*4];
 136
 137   // Read in all of the data from stdin, we cannot mmap stdin...
 138   while ((BlockSize = read(0 /*stdin*/, Buffer, 4096*4))) {
 139     if (BlockSize == -1)
 140       throw std::string("Error reading from stdin!");
 141
 142     FileData.insert(FileData.end(), Buffer, Buffer+BlockSize);
 143   }
 144
 145   if (FileData.empty())
 146     throw std::string("Standard Input empty!");
 147
 148   FileBuf = &FileData[0];
 149   ParseBytecode(FileBuf, FileData.size(), "<stdin>");
 150 }
 151
 152 /////////////////////////////////////////////////////////////////////////////
 153 //
 154 // Wrapper functions
 155 //
 156 /////////////////////////////////////////////////////////////////////////////
 157
 158 /// getBytecodeBufferModuleProvider - lazy function-at-a-time loading from a
 159 /// buffer
 160 AbstractModuleProvider*
 161 getBytecodeBufferModuleProvider(const unsigned char *Buffer, unsigned Length,
 162                                 const std::string &ModuleID) {
 163   return new BytecodeBufferReader(Buffer, Length, ModuleID);
 164 }
 165
 166 /// ParseBytecodeBuffer - Parse a given bytecode buffer
 167 ///
 168 Module *ParseBytecodeBuffer(const unsigned char *Buffer, unsigned Length,
 169                             const std::string &ModuleID, std::string *ErrorStr){
 170   Module *M = 0;
 171   try {
 172     AbstractModuleProvider *AMP =
 173       getBytecodeBufferModuleProvider(Buffer, Length, ModuleID);
 174     M = AMP->releaseModule();
 175     delete AMP;
 176   } catch (std::string &err) {
 177     if (ErrorStr) ErrorStr = err;
 178     return 0;
 179   }
 180   return M;
 181 }
 182
 183 /// getBytecodeModuleProvider - lazy function-at-a-time loading from a file
 184 ///
 185 AbstractModuleProvider*
 186 getBytecodeModuleProvider(const std::string &Filename) {
 187   if (Filename != std::string("-"))        // Read from a file...
 188     return new BytecodeFileReader(Filename);
 189   else                                     // Read from stdin
 190     return new BytecodeStdinReader();
 191 }
 192
 193 /// ParseBytecodeFile - Parse the given bytecode file
 194 ///
 195 Module *ParseBytecodeFile(const std::string &Filename, std::string *ErrorStr) {
 196   Module *M = 0;
 197   try {
 198     AbstractModuleProvider *AMP = getBytecodeModuleProvider(Filename);
 199     M = AMP->releaseModule();
 200     delete AMP;
 201   } catch (std::string &err) {
 202     if (ErrorStr) ErrorStr = err;
 203     return 0;
 204   }
 205   return M;
 206 }