LLVM 19.0.0git
COFFImportFile.h
Go to the documentation of this file.
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"
25
26namespace llvm {
27namespace object {
28
29constexpr std::string_view ImportDescriptorPrefix = "__IMPORT_DESCRIPTOR_";
30constexpr std::string_view NullImportDescriptorSymbolName =
31 "__NULL_IMPORT_DESCRIPTOR";
32constexpr std::string_view NullThunkDataPrefix = "\x7f";
33constexpr std::string_view NullThunkDataSuffix = "_NULL_THUNK_DATA";
34
36private:
37 enum SymbolIndex { ImpSymbol, ThunkSymbol, ECAuxSymbol, ECThunkSymbol };
38
39public:
42
43 static bool classof(Binary const *V) { return V->isCOFFImportFile(); }
44
45 void moveSymbolNext(DataRefImpl &Symb) const override { ++Symb.p; }
46
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 =
60 OS << StringRef(*DemangledName);
61 return Error::success();
62 }
63 }
64 OS << StringRef(Name);
65 return Error::success();
66 }
67
70 }
71
73 return BasicSymbolRef(DataRefImpl(), this);
74 }
75
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
87 bool is64Bit() const override { return false; }
88
90 return reinterpret_cast<const object::coff_import_header *>(
92 }
93
95
98
99private:
100 bool isData() const {
102 }
103};
104
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 /// Specifies EXPORTAS name. In a .def file, this is "bar" in
124 /// "EXPORTS\nfoo EXPORTAS bar".
125 std::string ExportAs;
126
128 bool Noname = false;
129 bool Data = false;
130 bool Private = false;
131 bool Constant = false;
132
133 friend bool operator==(const COFFShortExport &L, const COFFShortExport &R) {
134 return L.Name == R.Name && L.ExtName == R.ExtName &&
135 L.Ordinal == R.Ordinal && L.Noname == R.Noname &&
136 L.Data == R.Data && L.Private == R.Private;
137 }
138
139 friend bool operator!=(const COFFShortExport &L, const COFFShortExport &R) {
140 return !(L == R);
141 }
142};
143
144/// Writes a COFF import library containing entries described by the Exports
145/// array.
146///
147/// For hybrid targets such as ARM64EC, additional native entry points can be
148/// exposed using the NativeExports parameter. When NativeExports is used, the
149/// output import library will expose these native ARM64 imports alongside the
150/// entries described in the Exports array. Such a library can be used for
151/// linking both ARM64EC and pure ARM64 objects, and the linker will pick only
152/// the exports relevant to the target platform. For non-hybrid targets,
153/// the NativeExports parameter should not be used.
155 StringRef ImportName, StringRef Path, ArrayRef<COFFShortExport> Exports,
156 COFF::MachineTypes Machine, bool MinGW,
157 ArrayRef<COFFShortExport> NativeExports = std::nullopt);
158
159} // namespace object
160} // namespace llvm
161
162#endif
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:371
std::string Name
raw_pwrite_stream & OS
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
This is an important base class in LLVM.
Definition: Constant.h:41
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Tagged union holding either a T or a Error.
Definition: Error.h:474
const char * getBufferStart() const
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
This is a value type class that represents a single symbol in the list of symbols in the object file.
Definition: SymbolicFile.h:103
MemoryBufferRef Data
Definition: Binary.h:37
const coff_import_header * getCOFFImportHeader() const
Expected< uint32_t > getSymbolFlags(DataRefImpl Symb) const override
bool is64Bit() const override
void moveSymbolNext(DataRefImpl &Symb) const override
StringRef getFileFormatName() const
COFFImportFile(MemoryBufferRef Source)
basic_symbol_iterator symbol_begin() const override
StringRef getExportName() const
Error printSymbolName(raw_ostream &OS, DataRefImpl Symb) const override
basic_symbol_iterator symbol_end() const override
static bool classof(Binary const *V)
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
MachineTypes
Definition: COFF.h:92
@ IMPORT_DATA
Definition: COFF.h:702
bool isArm64EC(T Machine)
Definition: COFF.h:124
constexpr std::string_view NullImportDescriptorSymbolName
Error writeImportLibrary(StringRef ImportName, StringRef Path, ArrayRef< COFFShortExport > Exports, COFF::MachineTypes Machine, bool MinGW, ArrayRef< COFFShortExport > NativeExports=std::nullopt)
Writes a COFF import library containing entries described by the Exports array.
std::optional< std::string > getArm64ECDemangledFunctionName(StringRef Name)
Definition: COFF.h:1394
constexpr std::string_view NullThunkDataPrefix
constexpr std::string_view NullThunkDataSuffix
constexpr std::string_view ImportDescriptorPrefix
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::string Name
The name of the export as specified in the .def file or on the command line, i.e.
std::string SymbolName
The real, mangled symbol name from the object file.
std::string ExportAs
Specifies EXPORTAS name.
friend bool operator!=(const COFFShortExport &L, const COFFShortExport &R)
std::string AliasTarget
Creates a weak alias.
std::string ExtName
The external, exported name.
friend bool operator==(const COFFShortExport &L, const COFFShortExport &R)
support::ulittle16_t Machine
Definition: COFF.h:545