lib/Bytecode/Reader/ReaderWrappers.cpp

   1 //===- ReaderWrappers.cpp - Parse bytecode from file or buffer  -----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   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.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements loading and parsing a bytecode file and parsing a
  11 // bytecode module from a given buffer.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/Bytecode/Analyzer.h"
  16 #include "llvm/Bytecode/Reader.h"
  17 #include "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"
  23 #include <cerrno>
  24 #include <memory>
  25 using namespace llvm;
  26
  27 //===----------------------------------------------------------------------===//
  28 // BytecodeFileReader - Read from an mmap'able file descriptor.
  29 //
  30
  31 namespace {
  32   /// BytecodeFileReader - parses a bytecode file from a file
  33   ///
  34   class BytecodeFileReader : public BytecodeReader {
  35   private:
  36     std::string fileName;
  37     BCDecompressor_t *Decompressor;
  38     sys::MappedFile mapFile;
  39
  40     BytecodeFileReader(const BytecodeFileReader&); // Do not implement
  41     void operator=(const BytecodeFileReader &BFR); // Do not implement
  42
  43   public:
  44     BytecodeFileReader(const std::string &Filename, BCDecompressor_t *BCDC,
  45                        llvm::BytecodeHandler* H=0);
  46     bool read(std::string* ErrMsg);
  47
  48     void freeState() {
  49       BytecodeReader::freeState();
  50       mapFile.close();
  51     }
  52   };
  53 }
  54
  55 BytecodeFileReader::BytecodeFileReader(const std::string &Filename,
  56                                        BCDecompressor_t *BCDC,
  57                                        llvm::BytecodeHandler* H)
  58   : BytecodeReader(H), fileName(Filename), Decompressor(BCDC) {
  59 }
  60
  61 bool BytecodeFileReader::read(std::string* ErrMsg) {
  62   if (mapFile.open(sys::Path(fileName), sys::MappedFile::READ_ACCESS, ErrMsg))
  63     return true;
  64   if (!mapFile.map(ErrMsg)) {
  65     mapFile.close();
  66     return true;
  67   }
  68   unsigned char* buffer = reinterpret_cast<unsigned char*>(mapFile.base());
  69   return ParseBytecode(buffer, mapFile.size(), fileName,
  70                        Decompressor, ErrMsg);
  71 }
  72
  73 //===----------------------------------------------------------------------===//
  74 // BytecodeBufferReader - Read from a memory buffer
  75 //
  76
  77 namespace {
  78   /// BytecodeBufferReader - parses a bytecode file from a buffer
  79   ///
  80   class BytecodeBufferReader : public BytecodeReader {
  81   private:
  82     const unsigned char *Buffer;
  83     const unsigned char *Buf;
  84     unsigned Length;
  85     std::string ModuleID;
  86     BCDecompressor_t *Decompressor;
  87     bool MustDelete;
  88
  89     BytecodeBufferReader(const BytecodeBufferReader&); // Do not implement
  90     void operator=(const BytecodeBufferReader &BFR);   // Do not implement
  91
  92   public:
  93     BytecodeBufferReader(const unsigned char *Buf, unsigned Length,
  94                          const std::string &ModuleID, BCDecompressor_t *BCDC,
  95                          llvm::BytecodeHandler* Handler = 0);
  96     ~BytecodeBufferReader();
  97
  98     bool read(std::string* ErrMsg);
  99
 100   };
 101 }
 102
 103 BytecodeBufferReader::BytecodeBufferReader(const unsigned char *buf,
 104                                            unsigned len,
 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) {
 110 }
 111
 112 BytecodeBufferReader::~BytecodeBufferReader() {
 113   if (MustDelete) delete [] Buffer;
 114 }
 115
 116 bool
 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
 125     MustDelete = true;
 126   } else {
 127     // If we don't need to copy it over, just use the caller's copy
 128     ParseBegin = Buffer = Buf;
 129     MustDelete = false;
 130   }
 131   if (ParseBytecode(ParseBegin, Length, ModuleID, Decompressor, ErrMsg)) {
 132     if (MustDelete) delete [] Buffer;
 133     return true;
 134   }
 135   return false;
 136 }
 137
 138 //===----------------------------------------------------------------------===//
 139 //  BytecodeStdinReader - Read bytecode from Standard Input
 140 //
 141
 142 namespace {
 143   /// BytecodeStdinReader - parses a bytecode file from stdin
 144   ///
 145   class BytecodeStdinReader : public BytecodeReader {
 146   private:
 147     std::vector<unsigned char> FileData;
 148     BCDecompressor_t *Decompressor;
 149     unsigned char *FileBuf;
 150
 151     BytecodeStdinReader(const BytecodeStdinReader&); // Do not implement
 152     void operator=(const BytecodeStdinReader &BFR);  // Do not implement
 153
 154   public:
 155     BytecodeStdinReader(BCDecompressor_t *BCDC, llvm::BytecodeHandler* H = 0);
 156     bool read(std::string* ErrMsg);
 157   };
 158 }
 159
 160 BytecodeStdinReader::BytecodeStdinReader(BCDecompressor_t *BCDC,
 161                                          BytecodeHandler* H)
 162   : BytecodeReader(H), Decompressor(BCDC) {
 163 }
 164
 165 bool BytecodeStdinReader::read(std::string* ErrMsg) {
 166   sys::Program::ChangeStdinToBinary();
 167   char Buffer[4096*4];
 168
 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();
 173     if (0 >= BlockSize)
 174       break;
 175     FileData.insert(FileData.end(), Buffer, Buffer+BlockSize);
 176   }
 177
 178   if (FileData.empty()) {
 179     if (ErrMsg)
 180       *ErrMsg = "Standard Input is empty!";
 181     return true;
 182   }
 183
 184   FileBuf = &FileData[0];
 185   if (ParseBytecode(FileBuf, FileData.size(), "<stdin>", Decompressor, ErrMsg))
 186     return true;
 187   return false;
 188 }
 189
 190 //===----------------------------------------------------------------------===//
 191 // Wrapper functions
 192 //===----------------------------------------------------------------------===//
 193
 194 /// getBytecodeBufferModuleProvider - lazy function-at-a-time loading from a
 195 /// buffer
 196 ModuleProvider*
 197 llvm::getBytecodeBufferModuleProvider(const unsigned char *Buffer,
 198                                       unsigned Length,
 199                                       const std::string &ModuleID,
 200                                       BCDecompressor_t *BCDC,
 201                                       std::string *ErrMsg,
 202                                       BytecodeHandler *H) {
 203   BytecodeBufferReader *rdr =
 204     new BytecodeBufferReader(Buffer, Length, ModuleID, BCDC, H);
 205   if (rdr->read(ErrMsg))
 206     return 0;
 207   return rdr;
 208 }
 209
 210 /// ParseBytecodeBuffer - Parse a given bytecode buffer
 211 ///
 212 Module *llvm::ParseBytecodeBuffer(const unsigned char *Buffer, unsigned Length,
 213                                   const std::string &ModuleID,
 214                                   BCDecompressor_t *BCDC,
 215                                   std::string *ErrMsg) {
 216   ModuleProvider *MP =
 217     getBytecodeBufferModuleProvider(Buffer, Length, ModuleID, BCDC, ErrMsg, 0);
 218   if (!MP) return 0;
 219   Module *M = MP->releaseModule(ErrMsg);
 220   delete MP;
 221   return M;
 222 }
 223
 224 /// getBytecodeModuleProvider - lazy function-at-a-time loading from a file
 225 ///
 226 ModuleProvider *
 227 llvm::getBytecodeModuleProvider(const std::string &Filename,
 228                                 BCDecompressor_t *BCDC,
 229                                 std::string* ErrMsg,
 230                                 BytecodeHandler* H) {
 231   // Read from a file
 232   if (Filename != std::string("-")) {
 233     BytecodeFileReader *rdr = new BytecodeFileReader(Filename, BCDC, H);
 234     if (rdr->read(ErrMsg))
 235       return 0;
 236     return rdr;
 237   }
 238
 239   // Read from stdin
 240   BytecodeStdinReader *rdr = new BytecodeStdinReader(BCDC, H);
 241   if (rdr->read(ErrMsg))
 242     return 0;
 243   return rdr;
 244 }
 245
 246 /// ParseBytecodeFile - Parse the given bytecode file
 247 ///
 248 Module *llvm::ParseBytecodeFile(const std::string &Filename,
 249                                 BCDecompressor_t *BCDC,
 250                                 std::string *ErrMsg) {
 251   ModuleProvider* MP = getBytecodeModuleProvider(Filename, BCDC, ErrMsg);
 252   if (!MP) return 0;
 253   Module *M = MP->releaseModule(ErrMsg);
 254   delete MP;
 255   return M;
 256 }
 257
 258 // AnalyzeBytecodeFile - analyze one file
 259 Module* llvm::AnalyzeBytecodeFile(
 260   const std::string &Filename,  ///< File to analyze
 261   BytecodeAnalysis& bca,        ///< Statistical output
 262   BCDecompressor_t *BCDC,
 263   std::string *ErrMsg,          ///< Error output
 264   std::ostream* output          ///< Dump output
 265 ) {
 266   BytecodeHandler* AH = createBytecodeAnalyzerHandler(bca,output);
 267   ModuleProvider* MP = getBytecodeModuleProvider(Filename, BCDC, ErrMsg, AH);
 268   if (!MP) return 0;
 269   Module *M = MP->releaseModule(ErrMsg);
 270   delete MP;
 271   return M;
 272 }
 273
 274 bool llvm::GetBytecodeDependentLibraries(const std::string &fname,
 275                                          Module::LibraryListType& deplibs,
 276                                          BCDecompressor_t *BCDC,
 277                                          std::string* ErrMsg) {
 278   ModuleProvider* MP = getBytecodeModuleProvider(fname, BCDC, ErrMsg);
 279   if (!MP) {
 280     deplibs.clear();
 281     return true;
 282   }
 283   Module* M = MP->releaseModule(ErrMsg);
 284   deplibs = M->getLibraries();
 285   delete M;
 286   delete MP;
 287   return false;
 288 }
 289
 290 static void getSymbols(Module*M, std::vector<std::string>& symbols) {
 291   // Loop over global variables
 292   for (Module::global_iterator GI = M->global_begin(), GE=M->global_end(); GI != GE; ++GI)
 293     if (!GI->isDeclaration() && !GI->hasInternalLinkage())
 294       if (!GI->getName().empty())
 295         symbols.push_back(GI->getName());
 296
 297   // Loop over functions.
 298   for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI)
 299     if (!FI->isDeclaration() && !FI->hasInternalLinkage())
 300       if (!FI->getName().empty())
 301         symbols.push_back(FI->getName());
 302 }
 303
 304 // Get just the externally visible defined symbols from the bytecode
 305 bool llvm::GetBytecodeSymbols(const sys::Path& fName,
 306                               std::vector<std::string>& symbols,
 307                                BCDecompressor_t *BCDC,
 308                               std::string* ErrMsg) {
 309   ModuleProvider *MP = getBytecodeModuleProvider(fName.toString(), BCDC,ErrMsg);
 310   if (!MP)
 311     return true;
 312
 313   // Get the module from the provider
 314   Module* M = MP->materializeModule();
 315   if (M == 0) {
 316     delete MP;
 317     return true;
 318   }
 319
 320   // Get the symbols
 321   getSymbols(M, symbols);
 322
 323   // Done with the module.
 324   delete MP;
 325   return true;
 326 }
 327
 328 ModuleProvider*
 329 llvm::GetBytecodeSymbols(const unsigned char*Buffer, unsigned Length,
 330                          const std::string& ModuleID,
 331                          std::vector<std::string>& symbols,
 332                           BCDecompressor_t *BCDC,
 333                          std::string* ErrMsg) {
 334   // Get the module provider
 335   ModuleProvider* MP =
 336     getBytecodeBufferModuleProvider(Buffer, Length, ModuleID, BCDC, ErrMsg, 0);
 337   if (!MP)
 338     return 0;
 339
 340   // Get the module from the provider
 341   Module* M = MP->materializeModule();
 342   if (M == 0) {
 343     delete MP;
 344     return 0;
 345   }
 346
 347   // Get the symbols
 348   getSymbols(M, symbols);
 349
 350   // Done with the module. Note that ModuleProvider will delete the
 351   // Module when it is deleted. Also note that its the caller's responsibility
 352   // to delete the ModuleProvider.
 353   return MP;
 354 }