1 //===- COFFImportFile.h - COFF short import file implementation -*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // COFF short import file is a special kind of file which contains
10 // only symbol names for DLL-exported symbols. This class implements
11 // exporting of Symbols to create libraries and a SymbolicFile
12 // interface for the file type.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_OBJECT_COFFIMPORTFILE_H
17 #define LLVM_OBJECT_COFFIMPORTFILE_H
18 
19 #include "llvm/ADT/ArrayRef.h"
20 #include "llvm/Object/COFF.h"
21 #include "llvm/Object/ObjectFile.h"
22 #include "llvm/Object/SymbolicFile.h"
23 #include "llvm/Support/MemoryBufferRef.h"
24 #include "llvm/Support/raw_ostream.h"
25 
26 namespace llvm {
27 namespace object {
28 
29 constexpr std::string_view ImportDescriptorPrefix = "__IMPORT_DESCRIPTOR_";
30 constexpr std::string_view NullImportDescriptorSymbolName =
31     "__NULL_IMPORT_DESCRIPTOR";
32 constexpr std::string_view NullThunkDataPrefix = "\x7f";
33 constexpr std::string_view NullThunkDataSuffix = "_NULL_THUNK_DATA";
34 
35 class COFFImportFile : public SymbolicFile {
36 private:
37   enum SymbolIndex { ImpSymbol, ThunkSymbol, ECAuxSymbol, ECThunkSymbol };
38 
39 public:
COFFImportFile(MemoryBufferRef Source)40   COFFImportFile(MemoryBufferRef Source)
41       : SymbolicFile(ID_COFFImportFile, Source) {}
42 
classof(Binary const * V)43   static bool classof(Binary const *V) { return V->isCOFFImportFile(); }
44 
moveSymbolNext(DataRefImpl & Symb)45   void moveSymbolNext(DataRefImpl &Symb) const override { ++Symb.p; }
46 
printSymbolName(raw_ostream & OS,DataRefImpl Symb)47   Error printSymbolName(raw_ostream &OS, DataRefImpl Symb) const override {
48     switch (Symb.p) {
49     case ImpSymbol:
50       OS << "__imp_";
51       break;
52     case ECAuxSymbol:
53       OS << "__imp_aux_";
54       break;
55     }
56     const char *Name = Data.getBufferStart() + sizeof(coff_import_header);
57     if (Symb.p != ECThunkSymbol && COFF::isArm64EC(getMachine())) {
58       if (std::optional<std::string> DemangledName =
59               getArm64ECDemangledFunctionName(Name)) {
60         OS << StringRef(*DemangledName);
61         return Error::success();
62       }
63     }
64     OS << StringRef(Name);
65     return Error::success();
66   }
67 
getSymbolFlags(DataRefImpl Symb)68   Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override {
69     return SymbolRef::SF_Global;
70   }
71 
symbol_begin()72   basic_symbol_iterator symbol_begin() const override {
73     return BasicSymbolRef(DataRefImpl(), this);
74   }
75 
symbol_end()76   basic_symbol_iterator symbol_end() const override {
77     DataRefImpl Symb;
78     if (isData())
79       Symb.p = ImpSymbol + 1;
80     else if (COFF::isArm64EC(getMachine()))
81       Symb.p = ECThunkSymbol + 1;
82     else
83       Symb.p = ThunkSymbol + 1;
84     return BasicSymbolRef(Symb, this);
85   }
86 
is64Bit()87   bool is64Bit() const override { return false; }
88 
getCOFFImportHeader()89   const coff_import_header *getCOFFImportHeader() const {
90     return reinterpret_cast<const object::coff_import_header *>(
91         Data.getBufferStart());
92   }
93 
getMachine()94   uint16_t getMachine() const { return getCOFFImportHeader()->Machine; }
95 
96   StringRef getFileFormatName() const;
97   StringRef getExportName() const;
98 
99 private:
isData()100   bool isData() const {
101     return getCOFFImportHeader()->getType() == COFF::IMPORT_DATA;
102   }
103 };
104 
105 struct COFFShortExport {
106   /// The name of the export as specified in the .def file or on the command
107   /// line, i.e. "foo" in "/EXPORT:foo", and "bar" in "/EXPORT:foo=bar". This
108   /// may lack mangling, such as underscore prefixing and stdcall suffixing.
109   std::string Name;
110 
111   /// The external, exported name. Only non-empty when export renaming is in
112   /// effect, i.e. "foo" in "/EXPORT:foo=bar".
113   std::string ExtName;
114 
115   /// The real, mangled symbol name from the object file. Given
116   /// "/export:foo=bar", this could be "_bar@8" if bar is stdcall.
117   std::string SymbolName;
118 
119   /// Creates a weak alias. This is the name of the weak aliasee. In a .def
120   /// file, this is "baz" in "EXPORTS\nfoo = bar == baz".
121   std::string AliasTarget;
122 
123   uint16_t Ordinal = 0;
124   bool Noname = false;
125   bool Data = false;
126   bool Private = false;
127   bool Constant = false;
128 
129   friend bool operator==(const COFFShortExport &L, const COFFShortExport &R) {
130     return L.Name == R.Name && L.ExtName == R.ExtName &&
131             L.Ordinal == R.Ordinal && L.Noname == R.Noname &&
132             L.Data == R.Data && L.Private == R.Private;
133   }
134 
135   friend bool operator!=(const COFFShortExport &L, const COFFShortExport &R) {
136     return !(L == R);
137   }
138 };
139 
140 Error writeImportLibrary(StringRef ImportName, StringRef Path,
141                          ArrayRef<COFFShortExport> Exports,
142                          COFF::MachineTypes Machine, bool MinGW);
143 
144 } // namespace object
145 } // namespace llvm
146 
147 #endif
148