1 //===- COFFImportFile.cpp - COFF short import file implementation ---------===//
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 // This file defines the writeImportLibrary function.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/Object/COFFImportFile.h"
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/Object/Archive.h"
17 #include "llvm/Object/ArchiveWriter.h"
18 #include "llvm/Object/COFF.h"
19 #include "llvm/Support/Error.h"
20 #include "llvm/Support/Path.h"
21 
22 #include <cstdint>
23 #include <string>
24 #include <vector>
25 
26 using namespace llvm::COFF;
27 using namespace llvm::object;
28 using namespace llvm;
29 
30 namespace llvm {
31 namespace object {
32 
33 static bool is32bit(MachineTypes Machine) {
34   switch (Machine) {
35   default:
36     llvm_unreachable("unsupported machine");
37   case IMAGE_FILE_MACHINE_ARM64:
38   case IMAGE_FILE_MACHINE_AMD64:
39     return false;
40   case IMAGE_FILE_MACHINE_ARMNT:
41   case IMAGE_FILE_MACHINE_I386:
42     return true;
43   }
44 }
45 
46 static uint16_t getImgRelRelocation(MachineTypes Machine) {
47   switch (Machine) {
48   default:
49     llvm_unreachable("unsupported machine");
50   case IMAGE_FILE_MACHINE_AMD64:
51     return IMAGE_REL_AMD64_ADDR32NB;
52   case IMAGE_FILE_MACHINE_ARMNT:
53     return IMAGE_REL_ARM_ADDR32NB;
54   case IMAGE_FILE_MACHINE_ARM64:
55     return IMAGE_REL_ARM64_ADDR32NB;
56   case IMAGE_FILE_MACHINE_I386:
57     return IMAGE_REL_I386_DIR32NB;
58   }
59 }
60 
61 template <class T> static void append(std::vector<uint8_t> &B, const T &Data) {
62   size_t S = B.size();
63   B.resize(S + sizeof(T));
64   memcpy(&B[S], &Data, sizeof(T));
65 }
66 
67 static void writeStringTable(std::vector<uint8_t> &B,
68                              ArrayRef<const std::string> Strings) {
69   // The COFF string table consists of a 4-byte value which is the size of the
70   // table, including the length field itself.  This value is followed by the
71   // string content itself, which is an array of null-terminated C-style
72   // strings.  The termination is important as they are referenced to by offset
73   // by the symbol entity in the file format.
74 
75   size_t Pos = B.size();
76   size_t Offset = B.size();
77 
78   // Skip over the length field, we will fill it in later as we will have
79   // computed the length while emitting the string content itself.
80   Pos += sizeof(uint32_t);
81 
82   for (const auto &S : Strings) {
83     B.resize(Pos + S.length() + 1);
84     strcpy(reinterpret_cast<char *>(&B[Pos]), S.c_str());
85     Pos += S.length() + 1;
86   }
87 
88   // Backfill the length of the table now that it has been computed.
89   support::ulittle32_t Length(B.size() - Offset);
90   support::endian::write32le(&B[Offset], Length);
91 }
92 
93 static ImportNameType getNameType(StringRef Sym, StringRef ExtName,
94                                   MachineTypes Machine, bool MinGW) {
95   // A decorated stdcall function in MSVC is exported with the
96   // type IMPORT_NAME, and the exported function name includes the
97   // the leading underscore. In MinGW on the other hand, a decorated
98   // stdcall function still omits the underscore (IMPORT_NAME_NOPREFIX).
99   // See the comment in isDecorated in COFFModuleDefinition.cpp for more
100   // details.
101   if (ExtName.startswith("_") && ExtName.contains('@') && !MinGW)
102     return IMPORT_NAME;
103   if (Sym != ExtName)
104     return IMPORT_NAME_UNDECORATE;
105   if (Machine == IMAGE_FILE_MACHINE_I386 && Sym.startswith("_"))
106     return IMPORT_NAME_NOPREFIX;
107   return IMPORT_NAME;
108 }
109 
110 static Expected<std::string> replace(StringRef S, StringRef From,
111                                      StringRef To) {
112   size_t Pos = S.find(From);
113 
114   // From and To may be mangled, but substrings in S may not.
115   if (Pos == StringRef::npos && From.startswith("_") && To.startswith("_")) {
116     From = From.substr(1);
117     To = To.substr(1);
118     Pos = S.find(From);
119   }
120 
121   if (Pos == StringRef::npos) {
122     return make_error<StringError>(
123       StringRef(Twine(S + ": replacing '" + From +
124         "' with '" + To + "' failed").str()), object_error::parse_failed);
125   }
126 
127   return (Twine(S.substr(0, Pos)) + To + S.substr(Pos + From.size())).str();
128 }
129 
130 static const std::string NullImportDescriptorSymbolName =
131     "__NULL_IMPORT_DESCRIPTOR";
132 
133 namespace {
134 // This class constructs various small object files necessary to support linking
135 // symbols imported from a DLL.  The contents are pretty strictly defined and
136 // nearly entirely static.  The details of the structures files are defined in
137 // WINNT.h and the PE/COFF specification.
138 class ObjectFactory {
139   using u16 = support::ulittle16_t;
140   using u32 = support::ulittle32_t;
141   MachineTypes Machine;
142   BumpPtrAllocator Alloc;
143   StringRef ImportName;
144   StringRef Library;
145   std::string ImportDescriptorSymbolName;
146   std::string NullThunkSymbolName;
147 
148 public:
149   ObjectFactory(StringRef S, MachineTypes M)
150       : Machine(M), ImportName(S), Library(S.drop_back(4)),
151         ImportDescriptorSymbolName(("__IMPORT_DESCRIPTOR_" + Library).str()),
152         NullThunkSymbolName(("\x7f" + Library + "_NULL_THUNK_DATA").str()) {}
153 
154   // Creates an Import Descriptor.  This is a small object file which contains a
155   // reference to the terminators and contains the library name (entry) for the
156   // import name table.  It will force the linker to construct the necessary
157   // structure to import symbols from the DLL.
158   NewArchiveMember createImportDescriptor(std::vector<uint8_t> &Buffer);
159 
160   // Creates a NULL import descriptor.  This is a small object file whcih
161   // contains a NULL import descriptor.  It is used to terminate the imports
162   // from a specific DLL.
163   NewArchiveMember createNullImportDescriptor(std::vector<uint8_t> &Buffer);
164 
165   // Create a NULL Thunk Entry.  This is a small object file which contains a
166   // NULL Import Address Table entry and a NULL Import Lookup Table Entry.  It
167   // is used to terminate the IAT and ILT.
168   NewArchiveMember createNullThunk(std::vector<uint8_t> &Buffer);
169 
170   // Create a short import file which is described in PE/COFF spec 7. Import
171   // Library Format.
172   NewArchiveMember createShortImport(StringRef Sym, uint16_t Ordinal,
173                                      ImportType Type, ImportNameType NameType);
174 
175   // Create a weak external file which is described in PE/COFF Aux Format 3.
176   NewArchiveMember createWeakExternal(StringRef Sym, StringRef Weak, bool Imp);
177 };
178 } // namespace
179 
180 NewArchiveMember
181 ObjectFactory::createImportDescriptor(std::vector<uint8_t> &Buffer) {
182   const uint32_t NumberOfSections = 2;
183   const uint32_t NumberOfSymbols = 7;
184   const uint32_t NumberOfRelocations = 3;
185 
186   // COFF Header
187   coff_file_header Header{
188       u16(Machine),
189       u16(NumberOfSections),
190       u32(0),
191       u32(sizeof(Header) + (NumberOfSections * sizeof(coff_section)) +
192           // .idata$2
193           sizeof(coff_import_directory_table_entry) +
194           NumberOfRelocations * sizeof(coff_relocation) +
195           // .idata$4
196           (ImportName.size() + 1)),
197       u32(NumberOfSymbols),
198       u16(0),
199       u16(is32bit(Machine) ? IMAGE_FILE_32BIT_MACHINE : C_Invalid),
200   };
201   append(Buffer, Header);
202 
203   // Section Header Table
204   const coff_section SectionTable[NumberOfSections] = {
205       {{'.', 'i', 'd', 'a', 't', 'a', '$', '2'},
206        u32(0),
207        u32(0),
208        u32(sizeof(coff_import_directory_table_entry)),
209        u32(sizeof(coff_file_header) + NumberOfSections * sizeof(coff_section)),
210        u32(sizeof(coff_file_header) + NumberOfSections * sizeof(coff_section) +
211            sizeof(coff_import_directory_table_entry)),
212        u32(0),
213        u16(NumberOfRelocations),
214        u16(0),
215        u32(IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_CNT_INITIALIZED_DATA |
216            IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE)},
217       {{'.', 'i', 'd', 'a', 't', 'a', '$', '6'},
218        u32(0),
219        u32(0),
220        u32(ImportName.size() + 1),
221        u32(sizeof(coff_file_header) + NumberOfSections * sizeof(coff_section) +
222            sizeof(coff_import_directory_table_entry) +
223            NumberOfRelocations * sizeof(coff_relocation)),
224        u32(0),
225        u32(0),
226        u16(0),
227        u16(0),
228        u32(IMAGE_SCN_ALIGN_2BYTES | IMAGE_SCN_CNT_INITIALIZED_DATA |
229            IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE)},
230   };
231   append(Buffer, SectionTable);
232 
233   // .idata$2
234   const coff_import_directory_table_entry ImportDescriptor{
235       u32(0), u32(0), u32(0), u32(0), u32(0),
236   };
237   append(Buffer, ImportDescriptor);
238 
239   const coff_relocation RelocationTable[NumberOfRelocations] = {
240       {u32(offsetof(coff_import_directory_table_entry, NameRVA)), u32(2),
241        u16(getImgRelRelocation(Machine))},
242       {u32(offsetof(coff_import_directory_table_entry, ImportLookupTableRVA)),
243        u32(3), u16(getImgRelRelocation(Machine))},
244       {u32(offsetof(coff_import_directory_table_entry, ImportAddressTableRVA)),
245        u32(4), u16(getImgRelRelocation(Machine))},
246   };
247   append(Buffer, RelocationTable);
248 
249   // .idata$6
250   auto S = Buffer.size();
251   Buffer.resize(S + ImportName.size() + 1);
252   memcpy(&Buffer[S], ImportName.data(), ImportName.size());
253   Buffer[S + ImportName.size()] = '\0';
254 
255   // Symbol Table
256   coff_symbol16 SymbolTable[NumberOfSymbols] = {
257       {{{0, 0, 0, 0, 0, 0, 0, 0}},
258        u32(0),
259        u16(1),
260        u16(0),
261        IMAGE_SYM_CLASS_EXTERNAL,
262        0},
263       {{{'.', 'i', 'd', 'a', 't', 'a', '$', '2'}},
264        u32(0),
265        u16(1),
266        u16(0),
267        IMAGE_SYM_CLASS_SECTION,
268        0},
269       {{{'.', 'i', 'd', 'a', 't', 'a', '$', '6'}},
270        u32(0),
271        u16(2),
272        u16(0),
273        IMAGE_SYM_CLASS_STATIC,
274        0},
275       {{{'.', 'i', 'd', 'a', 't', 'a', '$', '4'}},
276        u32(0),
277        u16(0),
278        u16(0),
279        IMAGE_SYM_CLASS_SECTION,
280        0},
281       {{{'.', 'i', 'd', 'a', 't', 'a', '$', '5'}},
282        u32(0),
283        u16(0),
284        u16(0),
285        IMAGE_SYM_CLASS_SECTION,
286        0},
287       {{{0, 0, 0, 0, 0, 0, 0, 0}},
288        u32(0),
289        u16(0),
290        u16(0),
291        IMAGE_SYM_CLASS_EXTERNAL,
292        0},
293       {{{0, 0, 0, 0, 0, 0, 0, 0}},
294        u32(0),
295        u16(0),
296        u16(0),
297        IMAGE_SYM_CLASS_EXTERNAL,
298        0},
299   };
300   // TODO: Name.Offset.Offset here and in the all similar places below
301   // suggests a names refactoring. Maybe StringTableOffset.Value?
302   SymbolTable[0].Name.Offset.Offset =
303       sizeof(uint32_t);
304   SymbolTable[5].Name.Offset.Offset =
305       sizeof(uint32_t) + ImportDescriptorSymbolName.length() + 1;
306   SymbolTable[6].Name.Offset.Offset =
307       sizeof(uint32_t) + ImportDescriptorSymbolName.length() + 1 +
308       NullImportDescriptorSymbolName.length() + 1;
309   append(Buffer, SymbolTable);
310 
311   // String Table
312   writeStringTable(Buffer,
313                    {ImportDescriptorSymbolName, NullImportDescriptorSymbolName,
314                     NullThunkSymbolName});
315 
316   StringRef F{reinterpret_cast<const char *>(Buffer.data()), Buffer.size()};
317   return {MemoryBufferRef(F, ImportName)};
318 }
319 
320 NewArchiveMember
321 ObjectFactory::createNullImportDescriptor(std::vector<uint8_t> &Buffer) {
322   const uint32_t NumberOfSections = 1;
323   const uint32_t NumberOfSymbols = 1;
324 
325   // COFF Header
326   coff_file_header Header{
327       u16(Machine),
328       u16(NumberOfSections),
329       u32(0),
330       u32(sizeof(Header) + (NumberOfSections * sizeof(coff_section)) +
331           // .idata$3
332           sizeof(coff_import_directory_table_entry)),
333       u32(NumberOfSymbols),
334       u16(0),
335       u16(is32bit(Machine) ? IMAGE_FILE_32BIT_MACHINE : C_Invalid),
336   };
337   append(Buffer, Header);
338 
339   // Section Header Table
340   const coff_section SectionTable[NumberOfSections] = {
341       {{'.', 'i', 'd', 'a', 't', 'a', '$', '3'},
342        u32(0),
343        u32(0),
344        u32(sizeof(coff_import_directory_table_entry)),
345        u32(sizeof(coff_file_header) +
346            (NumberOfSections * sizeof(coff_section))),
347        u32(0),
348        u32(0),
349        u16(0),
350        u16(0),
351        u32(IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_CNT_INITIALIZED_DATA |
352            IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE)},
353   };
354   append(Buffer, SectionTable);
355 
356   // .idata$3
357   const coff_import_directory_table_entry ImportDescriptor{
358       u32(0), u32(0), u32(0), u32(0), u32(0),
359   };
360   append(Buffer, ImportDescriptor);
361 
362   // Symbol Table
363   coff_symbol16 SymbolTable[NumberOfSymbols] = {
364       {{{0, 0, 0, 0, 0, 0, 0, 0}},
365        u32(0),
366        u16(1),
367        u16(0),
368        IMAGE_SYM_CLASS_EXTERNAL,
369        0},
370   };
371   SymbolTable[0].Name.Offset.Offset = sizeof(uint32_t);
372   append(Buffer, SymbolTable);
373 
374   // String Table
375   writeStringTable(Buffer, {NullImportDescriptorSymbolName});
376 
377   StringRef F{reinterpret_cast<const char *>(Buffer.data()), Buffer.size()};
378   return {MemoryBufferRef(F, ImportName)};
379 }
380 
381 NewArchiveMember ObjectFactory::createNullThunk(std::vector<uint8_t> &Buffer) {
382   const uint32_t NumberOfSections = 2;
383   const uint32_t NumberOfSymbols = 1;
384   uint32_t VASize = is32bit(Machine) ? 4 : 8;
385 
386   // COFF Header
387   coff_file_header Header{
388       u16(Machine),
389       u16(NumberOfSections),
390       u32(0),
391       u32(sizeof(Header) + (NumberOfSections * sizeof(coff_section)) +
392           // .idata$5
393           VASize +
394           // .idata$4
395           VASize),
396       u32(NumberOfSymbols),
397       u16(0),
398       u16(is32bit(Machine) ? IMAGE_FILE_32BIT_MACHINE : C_Invalid),
399   };
400   append(Buffer, Header);
401 
402   // Section Header Table
403   const coff_section SectionTable[NumberOfSections] = {
404       {{'.', 'i', 'd', 'a', 't', 'a', '$', '5'},
405        u32(0),
406        u32(0),
407        u32(VASize),
408        u32(sizeof(coff_file_header) + NumberOfSections * sizeof(coff_section)),
409        u32(0),
410        u32(0),
411        u16(0),
412        u16(0),
413        u32((is32bit(Machine) ? IMAGE_SCN_ALIGN_4BYTES
414                              : IMAGE_SCN_ALIGN_8BYTES) |
415            IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ |
416            IMAGE_SCN_MEM_WRITE)},
417       {{'.', 'i', 'd', 'a', 't', 'a', '$', '4'},
418        u32(0),
419        u32(0),
420        u32(VASize),
421        u32(sizeof(coff_file_header) + NumberOfSections * sizeof(coff_section) +
422            VASize),
423        u32(0),
424        u32(0),
425        u16(0),
426        u16(0),
427        u32((is32bit(Machine) ? IMAGE_SCN_ALIGN_4BYTES
428                              : IMAGE_SCN_ALIGN_8BYTES) |
429            IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ |
430            IMAGE_SCN_MEM_WRITE)},
431   };
432   append(Buffer, SectionTable);
433 
434   // .idata$5, ILT
435   append(Buffer, u32(0));
436   if (!is32bit(Machine))
437     append(Buffer, u32(0));
438 
439   // .idata$4, IAT
440   append(Buffer, u32(0));
441   if (!is32bit(Machine))
442     append(Buffer, u32(0));
443 
444   // Symbol Table
445   coff_symbol16 SymbolTable[NumberOfSymbols] = {
446       {{{0, 0, 0, 0, 0, 0, 0, 0}},
447        u32(0),
448        u16(1),
449        u16(0),
450        IMAGE_SYM_CLASS_EXTERNAL,
451        0},
452   };
453   SymbolTable[0].Name.Offset.Offset = sizeof(uint32_t);
454   append(Buffer, SymbolTable);
455 
456   // String Table
457   writeStringTable(Buffer, {NullThunkSymbolName});
458 
459   StringRef F{reinterpret_cast<const char *>(Buffer.data()), Buffer.size()};
460   return {MemoryBufferRef{F, ImportName}};
461 }
462 
463 NewArchiveMember ObjectFactory::createShortImport(StringRef Sym,
464                                                   uint16_t Ordinal,
465                                                   ImportType ImportType,
466                                                   ImportNameType NameType) {
467   size_t ImpSize = ImportName.size() + Sym.size() + 2; // +2 for NULs
468   size_t Size = sizeof(coff_import_header) + ImpSize;
469   char *Buf = Alloc.Allocate<char>(Size);
470   memset(Buf, 0, Size);
471   char *P = Buf;
472 
473   // Write short import library.
474   auto *Imp = reinterpret_cast<coff_import_header *>(P);
475   P += sizeof(*Imp);
476   Imp->Sig2 = 0xFFFF;
477   Imp->Machine = Machine;
478   Imp->SizeOfData = ImpSize;
479   if (Ordinal > 0)
480     Imp->OrdinalHint = Ordinal;
481   Imp->TypeInfo = (NameType << 2) | ImportType;
482 
483   // Write symbol name and DLL name.
484   memcpy(P, Sym.data(), Sym.size());
485   P += Sym.size() + 1;
486   memcpy(P, ImportName.data(), ImportName.size());
487 
488   return {MemoryBufferRef(StringRef(Buf, Size), ImportName)};
489 }
490 
491 NewArchiveMember ObjectFactory::createWeakExternal(StringRef Sym,
492                                                    StringRef Weak, bool Imp) {
493   std::vector<uint8_t> Buffer;
494   const uint32_t NumberOfSections = 1;
495   const uint32_t NumberOfSymbols = 5;
496 
497   // COFF Header
498   coff_file_header Header{
499       u16(0),
500       u16(NumberOfSections),
501       u32(0),
502       u32(sizeof(Header) + (NumberOfSections * sizeof(coff_section))),
503       u32(NumberOfSymbols),
504       u16(0),
505       u16(0),
506   };
507   append(Buffer, Header);
508 
509   // Section Header Table
510   const coff_section SectionTable[NumberOfSections] = {
511       {{'.', 'd', 'r', 'e', 'c', 't', 'v', 'e'},
512        u32(0),
513        u32(0),
514        u32(0),
515        u32(0),
516        u32(0),
517        u32(0),
518        u16(0),
519        u16(0),
520        u32(IMAGE_SCN_LNK_INFO | IMAGE_SCN_LNK_REMOVE)}};
521   append(Buffer, SectionTable);
522 
523   // Symbol Table
524   coff_symbol16 SymbolTable[NumberOfSymbols] = {
525       {{{'@', 'c', 'o', 'm', 'p', '.', 'i', 'd'}},
526        u32(0),
527        u16(0xFFFF),
528        u16(0),
529        IMAGE_SYM_CLASS_STATIC,
530        0},
531       {{{'@', 'f', 'e', 'a', 't', '.', '0', '0'}},
532        u32(0),
533        u16(0xFFFF),
534        u16(0),
535        IMAGE_SYM_CLASS_STATIC,
536        0},
537       {{{0, 0, 0, 0, 0, 0, 0, 0}},
538        u32(0),
539        u16(0),
540        u16(0),
541        IMAGE_SYM_CLASS_EXTERNAL,
542        0},
543       {{{0, 0, 0, 0, 0, 0, 0, 0}},
544        u32(0),
545        u16(0),
546        u16(0),
547        IMAGE_SYM_CLASS_WEAK_EXTERNAL,
548        1},
549       {{{2, 0, 0, 0, IMAGE_WEAK_EXTERN_SEARCH_ALIAS, 0, 0, 0}},
550        u32(0),
551        u16(0),
552        u16(0),
553        IMAGE_SYM_CLASS_NULL,
554        0},
555   };
556   SymbolTable[2].Name.Offset.Offset = sizeof(uint32_t);
557 
558   //__imp_ String Table
559   StringRef Prefix = Imp ? "__imp_" : "";
560   SymbolTable[3].Name.Offset.Offset =
561       sizeof(uint32_t) + Sym.size() + Prefix.size() + 1;
562   append(Buffer, SymbolTable);
563   writeStringTable(Buffer, {(Prefix + Sym).str(),
564                             (Prefix + Weak).str()});
565 
566   // Copied here so we can still use writeStringTable
567   char *Buf = Alloc.Allocate<char>(Buffer.size());
568   memcpy(Buf, Buffer.data(), Buffer.size());
569   return {MemoryBufferRef(StringRef(Buf, Buffer.size()), ImportName)};
570 }
571 
572 Error writeImportLibrary(StringRef ImportName, StringRef Path,
573                          ArrayRef<COFFShortExport> Exports,
574                          MachineTypes Machine, bool MinGW) {
575 
576   std::vector<NewArchiveMember> Members;
577   ObjectFactory OF(llvm::sys::path::filename(ImportName), Machine);
578 
579   std::vector<uint8_t> ImportDescriptor;
580   Members.push_back(OF.createImportDescriptor(ImportDescriptor));
581 
582   std::vector<uint8_t> NullImportDescriptor;
583   Members.push_back(OF.createNullImportDescriptor(NullImportDescriptor));
584 
585   std::vector<uint8_t> NullThunk;
586   Members.push_back(OF.createNullThunk(NullThunk));
587 
588   for (COFFShortExport E : Exports) {
589     if (E.Private)
590       continue;
591 
592     ImportType ImportType = IMPORT_CODE;
593     if (E.Data)
594       ImportType = IMPORT_DATA;
595     if (E.Constant)
596       ImportType = IMPORT_CONST;
597 
598     StringRef SymbolName = E.SymbolName.empty() ? E.Name : E.SymbolName;
599     ImportNameType NameType = getNameType(SymbolName, E.Name, Machine, MinGW);
600     Expected<std::string> Name = E.ExtName.empty()
601                                      ? SymbolName
602                                      : replace(SymbolName, E.Name, E.ExtName);
603 
604     if (!Name)
605       return Name.takeError();
606 
607     if (!E.AliasTarget.empty() && *Name != E.AliasTarget) {
608       Members.push_back(OF.createWeakExternal(E.AliasTarget, *Name, false));
609       Members.push_back(OF.createWeakExternal(E.AliasTarget, *Name, true));
610       continue;
611     }
612 
613     Members.push_back(
614         OF.createShortImport(*Name, E.Ordinal, ImportType, NameType));
615   }
616 
617   return writeArchive(Path, Members, /*WriteSymtab*/ true,
618                       object::Archive::K_GNU,
619                       /*Deterministic*/ true, /*Thin*/ false);
620 }
621 
622 } // namespace object
623 } // namespace llvm
624