LCOV - code coverage report
Current view: top level - include/llvm/Object - COFFImportFile.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 21 21 100.0 %
Date: 2017-09-14 15:23:50 Functions: 9 10 90.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- COFFImportFile.h - COFF short import file implementation -*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // COFF short import file is a special kind of file which contains
      11             : // only symbol names for DLL-exported symbols. This class implements
      12             : // exporting of Symbols to create libraries and a SymbolicFile
      13             : // interface for the file type.
      14             : //
      15             : //===----------------------------------------------------------------------===//
      16             : 
      17             : #ifndef LLVM_OBJECT_COFF_IMPORT_FILE_H
      18             : #define LLVM_OBJECT_COFF_IMPORT_FILE_H
      19             : 
      20             : #include "llvm/ADT/ArrayRef.h"
      21             : #include "llvm/Object/COFF.h"
      22             : #include "llvm/Object/IRObjectFile.h"
      23             : #include "llvm/Object/ObjectFile.h"
      24             : #include "llvm/Object/SymbolicFile.h"
      25             : #include "llvm/Support/MemoryBuffer.h"
      26             : #include "llvm/Support/raw_ostream.h"
      27             : 
      28             : namespace llvm {
      29             : namespace object {
      30             : 
      31         140 : class COFFImportFile : public SymbolicFile {
      32             : public:
      33             :   COFFImportFile(MemoryBufferRef Source)
      34         140 :       : SymbolicFile(ID_COFFImportFile, Source) {}
      35             : 
      36        1056 :   static bool classof(Binary const *V) { return V->isCOFFImportFile(); }
      37             : 
      38         266 :   void moveSymbolNext(DataRefImpl &Symb) const override { ++Symb.p; }
      39             : 
      40         266 :   std::error_code printSymbolName(raw_ostream &OS,
      41             :                                   DataRefImpl Symb) const override {
      42         266 :     if (Symb.p == 0)
      43         137 :       OS << "__imp_";
      44         798 :     OS << StringRef(Data.getBufferStart() + sizeof(coff_import_header));
      45         266 :     return std::error_code();
      46             :   }
      47             : 
      48         274 :   uint32_t getSymbolFlags(DataRefImpl Symb) const override {
      49         274 :     return SymbolRef::SF_Global;
      50             :   }
      51             : 
      52         137 :   basic_symbol_iterator symbol_begin() const override {
      53         548 :     return BasicSymbolRef(DataRefImpl(), this);
      54             :   }
      55             : 
      56         137 :   basic_symbol_iterator symbol_end() const override {
      57         137 :     DataRefImpl Symb;
      58         137 :     Symb.p = isData() ? 1 : 2;
      59         411 :     return BasicSymbolRef(Symb, this);
      60             :   }
      61             : 
      62             :   const coff_import_header *getCOFFImportHeader() const {
      63             :     return reinterpret_cast<const object::coff_import_header *>(
      64         382 :         Data.getBufferStart());
      65             :   }
      66             : 
      67             : private:
      68             :   bool isData() const {
      69         274 :     return getCOFFImportHeader()->getType() == COFF::IMPORT_DATA;
      70             :   }
      71             : };
      72             : 
      73        3544 : struct COFFShortExport {
      74             :   std::string Name;
      75             :   std::string ExtName;
      76             :   std::string SymbolName;
      77             : 
      78             :   uint16_t Ordinal = 0;
      79             :   bool Noname = false;
      80             :   bool Data = false;
      81             :   bool Private = false;
      82             :   bool Constant = false;
      83             : 
      84             :   bool isWeak() {
      85         132 :     return ExtName.size() && ExtName != Name;
      86             :   }
      87             : 
      88             :   friend bool operator==(const COFFShortExport &L, const COFFShortExport &R) {
      89             :     return L.Name == R.Name && L.ExtName == R.ExtName &&
      90             :             L.Ordinal == R.Ordinal && L.Noname == R.Noname &&
      91             :             L.Data == R.Data && L.Private == R.Private;
      92             :   }
      93             : 
      94             :   friend bool operator!=(const COFFShortExport &L, const COFFShortExport &R) {
      95             :     return !(L == R);
      96             :   }
      97             : };
      98             : 
      99             : std::error_code writeImportLibrary(StringRef ImportName,
     100             :                                    StringRef Path,
     101             :                                    ArrayRef<COFFShortExport> Exports,
     102             :                                    COFF::MachineTypes Machine,
     103             :                                    bool MakeWeakAliases);
     104             : 
     105             : } // namespace object
     106             : } // namespace llvm
     107             : 
     108             : #endif

Generated by: LCOV version 1.13