From 1675cbbfacb4ecdcb259e17fad3d51cb63cfca50 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Storsj=C3=B6?= Date: Thu, 4 Jul 2024 14:14:23 +0300 Subject: [PATCH] WIP: build-llvm: Apply patches to be tested --- build-llvm.sh | 1 + ...ove-the-i386-underscore-prefix-from-.patch | 132 ++++++++ ...dle-import-renaming-using-other-name.patch | 150 +++++++++ ...-renamed-imports-without-a-separate-.patch | 308 ++++++++++++++++++ 4 files changed, 591 insertions(+) create mode 100644 patches/llvm-project/0001-llvm-dlltool-Remove-the-i386-underscore-prefix-from-.patch create mode 100644 patches/llvm-project/0002-llvm-dlltool-Handle-import-renaming-using-other-name.patch create mode 100644 patches/llvm-project/0003-llvm-dlltool-Fix-renamed-imports-without-a-separate-.patch diff --git a/build-llvm.sh b/build-llvm.sh index 6e96f3a0..f2e0c792 100755 --- a/build-llvm.sh +++ b/build-llvm.sh @@ -117,6 +117,7 @@ if [ -n "$SYNC" ] || [ -n "$CHECKOUT" ]; then ;; esac fi + git am -3 ../patches/llvm-project/*.patch cd .. fi diff --git a/patches/llvm-project/0001-llvm-dlltool-Remove-the-i386-underscore-prefix-from-.patch b/patches/llvm-project/0001-llvm-dlltool-Remove-the-i386-underscore-prefix-from-.patch new file mode 100644 index 00000000..59dd85f0 --- /dev/null +++ b/patches/llvm-project/0001-llvm-dlltool-Remove-the-i386-underscore-prefix-from-.patch @@ -0,0 +1,132 @@ +From 62bf9e01723478f11a9bded5940ab8410c5faa34 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Martin=20Storsj=C3=B6?= +Date: Tue, 16 Apr 2024 14:27:44 +0300 +Subject: [PATCH 1/3] [llvm-dlltool] Remove the i386 underscore prefix from + COFFImportFile::ImportName. NFC. + +On i386, regular C level symbols are given an underscore prefix +in the symbols on the object file level. However, the exported +names from DLLs usually don't have this leading underscore. + +When specified in a def file like "symbol == dllname", the "dllname" +is the name of the exported symbol from the DLL, which will be +linked against from an object file symbol named "_symbol" +(on i386). + +The mechanism where one symbol is redirected to another one in +an import library is implemented with weak aliases. In that case, +we need to have the object file symbol level name for the target +of the import, as we make one object file symbol point at another +one. Therefore, we added an underscore to the ImportName field. + +(This mechanism, with weak aliases, only works as long as the +target also is exported as is, in that form - this issue is +dealt with in a later commit.) + +For clarity, for potentially handling the import renaming in +other ways, store the ImportName field unprefixed, containing +the actual name to import from the DLL. + +When creating the aliases, add the prefix as needed. This requires +passing an extra AddUnderscores parameter to the writeImportLibrary +function; this is a temporary measure, until alias creation is +reworked in a later commit. + +This doesn't preserve the corner case of checking !isDecorated() +before adding the prefix. This corner case isn't tested by any +of our existing tests, and only would trigger for +fastcall/vectorcall/MS C++ functions - while these kinds of +renames primarily are used in mingw-w64-crt import libraries +(which primarily handle cdecl and stdcall functions). +--- + llvm/include/llvm/Object/COFFImportFile.h | 9 +++++---- + llvm/lib/Object/COFFImportFile.cpp | 14 ++++++++++---- + llvm/lib/Object/COFFModuleDefinition.cpp | 2 -- + .../lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp | 5 +++-- + 4 files changed, 18 insertions(+), 12 deletions(-) + +diff --git a/llvm/include/llvm/Object/COFFImportFile.h b/llvm/include/llvm/Object/COFFImportFile.h +index 649fb4930934..e91d5a9b3198 100644 +--- a/llvm/include/llvm/Object/COFFImportFile.h ++++ b/llvm/include/llvm/Object/COFFImportFile.h +@@ -135,10 +135,11 @@ struct COFFShortExport { + /// linking both ARM64EC and pure ARM64 objects, and the linker will pick only + /// the exports relevant to the target platform. For non-hybrid targets, + /// the NativeExports parameter should not be used. +-Error writeImportLibrary( +- StringRef ImportName, StringRef Path, ArrayRef Exports, +- COFF::MachineTypes Machine, bool MinGW, +- ArrayRef NativeExports = std::nullopt); ++Error writeImportLibrary(StringRef ImportName, StringRef Path, ++ ArrayRef Exports, ++ COFF::MachineTypes Machine, bool MinGW, ++ ArrayRef NativeExports = std::nullopt, ++ bool AddUnderscores = true); + + } // namespace object + } // namespace llvm +diff --git a/llvm/lib/Object/COFFImportFile.cpp b/llvm/lib/Object/COFFImportFile.cpp +index a9f150a965c3..03af4921ddbc 100644 +--- a/llvm/lib/Object/COFFImportFile.cpp ++++ b/llvm/lib/Object/COFFImportFile.cpp +@@ -645,7 +645,8 @@ NewArchiveMember ObjectFactory::createWeakExternal(StringRef Sym, + Error writeImportLibrary(StringRef ImportName, StringRef Path, + ArrayRef Exports, + MachineTypes Machine, bool MinGW, +- ArrayRef NativeExports) { ++ ArrayRef NativeExports, ++ bool AddUnderscores) { + + MachineTypes NativeMachine = Machine; + if (isArm64EC(Machine)) { +@@ -691,10 +692,15 @@ Error writeImportLibrary(StringRef ImportName, StringRef Path, + } + + if (!E.ImportName.empty() && Name != E.ImportName) { ++ StringRef Prefix = ""; ++ if (Machine == IMAGE_FILE_MACHINE_I386 && AddUnderscores) ++ Prefix = "_"; ++ + if (ImportType == IMPORT_CODE) +- Members.push_back( +- OF.createWeakExternal(E.ImportName, Name, false, M)); +- Members.push_back(OF.createWeakExternal(E.ImportName, Name, true, M)); ++ Members.push_back(OF.createWeakExternal((Prefix + E.ImportName).str(), ++ Name, false, M)); ++ Members.push_back(OF.createWeakExternal((Prefix + E.ImportName).str(), ++ Name, true, M)); + continue; + } + +diff --git a/llvm/lib/Object/COFFModuleDefinition.cpp b/llvm/lib/Object/COFFModuleDefinition.cpp +index 0c0bef1319e4..82c18539658e 100644 +--- a/llvm/lib/Object/COFFModuleDefinition.cpp ++++ b/llvm/lib/Object/COFFModuleDefinition.cpp +@@ -282,8 +282,6 @@ private: + if (Tok.K == EqualEqual) { + read(); + E.ImportName = std::string(Tok.Value); +- if (AddUnderscores && !isDecorated(E.ImportName, MingwDef)) +- E.ImportName = std::string("_").append(E.ImportName); + continue; + } + // EXPORTAS must be at the end of export definition +diff --git a/llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp b/llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp +index 15e4cac08cd4..012ad246888f 100644 +--- a/llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp ++++ b/llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp +@@ -243,8 +243,9 @@ int llvm::dlltoolDriverMain(llvm::ArrayRef ArgsArr) { + } + + std::string Path = std::string(Args.getLastArgValue(OPT_l)); +- if (!Path.empty() && writeImportLibrary(OutputFile, Path, Exports, Machine, +- /*MinGW=*/true, NativeExports)) ++ if (!Path.empty() && ++ writeImportLibrary(OutputFile, Path, Exports, Machine, ++ /*MinGW=*/true, NativeExports, AddUnderscores)) + return 1; + return 0; + } +-- +2.25.1 + diff --git a/patches/llvm-project/0002-llvm-dlltool-Handle-import-renaming-using-other-name.patch b/patches/llvm-project/0002-llvm-dlltool-Handle-import-renaming-using-other-name.patch new file mode 100644 index 00000000..72ffaafd --- /dev/null +++ b/patches/llvm-project/0002-llvm-dlltool-Handle-import-renaming-using-other-name.patch @@ -0,0 +1,150 @@ +From 0d6df46274e47fc6dfd2085deb68352faecd0fc7 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Martin=20Storsj=C3=B6?= +Date: Tue, 16 Apr 2024 15:22:37 +0300 +Subject: [PATCH 2/3] [llvm-dlltool] Handle import renaming using other name + types, when possible + +This avoids needing to use weak aliases for these cases. (Weak +aliases only work if there's another, regular import entry that +provide the desired symbol from the DLL.) +--- + llvm/lib/Object/COFFImportFile.cpp | 66 +++++++++++++------ + .../tools/llvm-dlltool/coff-decorated.def | 16 +++++ + 2 files changed, 61 insertions(+), 21 deletions(-) + +diff --git a/llvm/lib/Object/COFFImportFile.cpp b/llvm/lib/Object/COFFImportFile.cpp +index 03af4921ddbc..1ddc5d954de6 100644 +--- a/llvm/lib/Object/COFFImportFile.cpp ++++ b/llvm/lib/Object/COFFImportFile.cpp +@@ -52,18 +52,12 @@ StringRef COFFImportFile::getFileFormatName() const { + } + } + +-StringRef COFFImportFile::getExportName() const { +- const coff_import_header *hdr = getCOFFImportHeader(); +- StringRef name = Data.getBuffer().substr(sizeof(*hdr)).split('\0').first; +- ++static StringRef applyNameType(ImportNameType Type, StringRef name) { + auto ltrim1 = [](StringRef s, StringRef chars) { + return !s.empty() && chars.contains(s[0]) ? s.substr(1) : s; + }; + +- switch (hdr->getNameType()) { +- case IMPORT_ORDINAL: +- name = ""; +- break; ++ switch (Type) { + case IMPORT_NAME_NOPREFIX: + name = ltrim1(name, "?@_"); + break; +@@ -71,6 +65,24 @@ StringRef COFFImportFile::getExportName() const { + name = ltrim1(name, "?@_"); + name = name.substr(0, name.find('@')); + break; ++ default: ++ break; ++ } ++ return name; ++} ++ ++StringRef COFFImportFile::getExportName() const { ++ const coff_import_header *hdr = getCOFFImportHeader(); ++ StringRef name = Data.getBuffer().substr(sizeof(*hdr)).split('\0').first; ++ ++ switch (hdr->getNameType()) { ++ case IMPORT_ORDINAL: ++ name = ""; ++ break; ++ case IMPORT_NAME_NOPREFIX: ++ case IMPORT_NAME_UNDECORATE: ++ name = applyNameType(static_cast(hdr->getNameType()), name); ++ break; + case IMPORT_NAME_EXPORTAS: { + // Skip DLL name + name = Data.getBuffer().substr(sizeof(*hdr) + name.size() + 1); +@@ -691,19 +703,6 @@ Error writeImportLibrary(StringRef ImportName, StringRef Path, + Name.swap(*ReplacedName); + } + +- if (!E.ImportName.empty() && Name != E.ImportName) { +- StringRef Prefix = ""; +- if (Machine == IMAGE_FILE_MACHINE_I386 && AddUnderscores) +- Prefix = "_"; +- +- if (ImportType == IMPORT_CODE) +- Members.push_back(OF.createWeakExternal((Prefix + E.ImportName).str(), +- Name, false, M)); +- Members.push_back(OF.createWeakExternal((Prefix + E.ImportName).str(), +- Name, true, M)); +- continue; +- } +- + ImportNameType NameType; + std::string ExportName; + if (E.Noname) { +@@ -711,6 +710,31 @@ Error writeImportLibrary(StringRef ImportName, StringRef Path, + } else if (!E.ExportAs.empty()) { + NameType = IMPORT_NAME_EXPORTAS; + ExportName = E.ExportAs; ++ } else if (!E.ImportName.empty()) { ++ // If we need to import from a specific ImportName, we may need to use ++ // a weak alias (which needs another import to point at). But if we can ++ // express ImportName based on the symbol name and a specific NameType, ++ // prefer that over an alias. ++ if (Machine == IMAGE_FILE_MACHINE_I386 && ++ applyNameType(IMPORT_NAME_UNDECORATE, Name) == E.ImportName) ++ NameType = IMPORT_NAME_UNDECORATE; ++ else if (Machine == IMAGE_FILE_MACHINE_I386 && ++ applyNameType(IMPORT_NAME_NOPREFIX, Name) == E.ImportName) ++ NameType = IMPORT_NAME_NOPREFIX; ++ else if (Name == E.ImportName) ++ NameType = IMPORT_NAME; ++ else { ++ StringRef Prefix = ""; ++ if (Machine == IMAGE_FILE_MACHINE_I386 && AddUnderscores) ++ Prefix = "_"; ++ ++ if (ImportType == IMPORT_CODE) ++ Members.push_back(OF.createWeakExternal( ++ (Prefix + E.ImportName).str(), Name, false, M)); ++ Members.push_back(OF.createWeakExternal((Prefix + E.ImportName).str(), ++ Name, true, M)); ++ continue; ++ } + } else { + NameType = getNameType(SymbolName, E.Name, M, MinGW); + } +diff --git a/llvm/test/tools/llvm-dlltool/coff-decorated.def b/llvm/test/tools/llvm-dlltool/coff-decorated.def +index fc81f23d09d6..773e3762cc3d 100644 +--- a/llvm/test/tools/llvm-dlltool/coff-decorated.def ++++ b/llvm/test/tools/llvm-dlltool/coff-decorated.def +@@ -13,6 +13,10 @@ StdcallExportName@4=StdcallInternalFunction@4 + OtherStdcallExportName@4=CdeclInternalFunction + CdeclExportName=StdcallInternalFunction@4 + ++NoprefixStdcall@4 == NoprefixStdcall@4 ++DecoratedStdcall@4 == _DecoratedStdcall@4 ++UndecoratedStdcall@4 == UndecoratedStdcall ++ + ; CHECK: Name type: noprefix + ; CHECK-NEXT: Export name: CdeclFunction + ; CHECK-NEXT: Symbol: __imp__CdeclFunction +@@ -43,3 +47,15 @@ CdeclExportName=StdcallInternalFunction@4 + ; CHECK-NEXT: Export name: CdeclExportName + ; CHECK-NEXT: Symbol: __imp__CdeclExportName + ; CHECK-NEXT: Symbol: _CdeclExportName ++; CHECK: Name type: noprefix ++; CHECK-NEXT: Export name: NoprefixStdcall@4 ++; CHECK-NEXT: Symbol: __imp__NoprefixStdcall@4 ++; CHECK-NEXT: Symbol: _NoprefixStdcall@4 ++; CHECK: Name type: name ++; CHECK-NEXT: Export name: _DecoratedStdcall@4 ++; CHECK-NEXT: Symbol: __imp__DecoratedStdcall@4 ++; CHECK-NEXT: Symbol: _DecoratedStdcall@4 ++; CHECK: Name type: undecorate ++; CHECK-NEXT: Export name: UndecoratedStdcall ++; CHECK-NEXT: Symbol: __imp__UndecoratedStdcall@4 ++; CHECK-NEXT: Symbol: _UndecoratedStdcall@4 +-- +2.25.1 + diff --git a/patches/llvm-project/0003-llvm-dlltool-Fix-renamed-imports-without-a-separate-.patch b/patches/llvm-project/0003-llvm-dlltool-Fix-renamed-imports-without-a-separate-.patch new file mode 100644 index 00000000..9e3b6a80 --- /dev/null +++ b/patches/llvm-project/0003-llvm-dlltool-Fix-renamed-imports-without-a-separate-.patch @@ -0,0 +1,308 @@ +From e37376c4e8e2c77a2b98449a5b1aadfa5b6d675b Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Martin=20Storsj=C3=B6?= +Date: Tue, 9 Jul 2024 00:41:19 +0300 +Subject: [PATCH 3/3] [llvm-dlltool] Fix renamed imports without a separate + regular import entry + +Normally, when doing renamed imports, we do this by providing a +weak alias, towards another regular import, for the symbol we +want to actually import. In a def file, this looks like this: + + regularfunc + renamedfunc == regularfunc + +However, if we want to link against a function in a DLL, where we +(intentionally) don't provide a regular import for that symbol +with the name in its DLL, doing the renamed import with a weak +alias doesn't work, as there's no symbol that the weak alias can +point towards. + +We can't make up such an import either, as we may intentionally +not want to provide a regular import for that name. + +This situation can either be resolved by using the "long" import +library format (as e.g. produced by GNU dlltool), or by using the +new short import library name type "export as". + +This patch implements it by using the "export as" name type. + +When producing a renamed import, defer emitting it until all regular +imports have been produced. If the renamed import refers to a +symbol that does exist as a regular import entry, produce a +weak alias, just as before. (This implementation also avoids needing +to know whether the symbol that the alias points towards actually +is prefixed or not, too.) + +If the renamed import points at a symbol that isn't otherwise +available (or is available as a renamed symbol itself), generate +an "export as" import entry. + +This name type is new, and is normally used in ARM64EC import +libraries, but can also be used for other architectures. +--- + lld/test/COFF/lib.test | 16 +++---- + llvm/include/llvm/Object/COFFImportFile.h | 9 ++-- + llvm/lib/Object/COFFImportFile.cpp | 42 ++++++++++++++----- + .../llvm-dlltool/DlltoolDriver.cpp | 5 +-- + .../tools/llvm-dlltool/coff-decorated.def | 2 +- + .../tools/llvm-dlltool/coff-weak-exports.def | 15 +++++-- + llvm/test/tools/llvm-dlltool/renaming.def | 39 +++++++++++++++++ + 7 files changed, 96 insertions(+), 32 deletions(-) + create mode 100644 llvm/test/tools/llvm-dlltool/renaming.def + +diff --git a/lld/test/COFF/lib.test b/lld/test/COFF/lib.test +index 7525ef4226cd..82abca6ec930 100644 +--- a/lld/test/COFF/lib.test ++++ b/lld/test/COFF/lib.test +@@ -1,6 +1,14 @@ + # RUN: lld-link /machine:x64 /def:%S/Inputs/library.def /out:%t.lib + # RUN: llvm-nm %t.lib | FileCheck %s + ++CHECK: 00000000 R __imp_constant ++CHECK: 00000000 R constant ++ ++CHECK: 00000000 D __imp_data ++ ++CHECK: 00000000 T __imp_function ++CHECK: 00000000 T function ++ + CHECK: 00000000 a @comp.id + CHECK: 00000000 a @feat.00 + CHECK: 00000000 W alias +@@ -11,11 +19,3 @@ CHECK: 00000000 a @feat.00 + CHECK: 00000000 W __imp_alias + CHECK: U __imp_function + +-CHECK: 00000000 R __imp_constant +-CHECK: 00000000 R constant +- +-CHECK: 00000000 D __imp_data +- +-CHECK: 00000000 T __imp_function +-CHECK: 00000000 T function +- +diff --git a/llvm/include/llvm/Object/COFFImportFile.h b/llvm/include/llvm/Object/COFFImportFile.h +index e91d5a9b3198..649fb4930934 100644 +--- a/llvm/include/llvm/Object/COFFImportFile.h ++++ b/llvm/include/llvm/Object/COFFImportFile.h +@@ -135,11 +135,10 @@ struct COFFShortExport { + /// linking both ARM64EC and pure ARM64 objects, and the linker will pick only + /// the exports relevant to the target platform. For non-hybrid targets, + /// the NativeExports parameter should not be used. +-Error writeImportLibrary(StringRef ImportName, StringRef Path, +- ArrayRef Exports, +- COFF::MachineTypes Machine, bool MinGW, +- ArrayRef NativeExports = std::nullopt, +- bool AddUnderscores = true); ++Error writeImportLibrary( ++ StringRef ImportName, StringRef Path, ArrayRef Exports, ++ COFF::MachineTypes Machine, bool MinGW, ++ ArrayRef NativeExports = std::nullopt); + + } // namespace object + } // namespace llvm +diff --git a/llvm/lib/Object/COFFImportFile.cpp b/llvm/lib/Object/COFFImportFile.cpp +index 1ddc5d954de6..a44ff2d5a742 100644 +--- a/llvm/lib/Object/COFFImportFile.cpp ++++ b/llvm/lib/Object/COFFImportFile.cpp +@@ -12,6 +12,8 @@ + + #include "llvm/Object/COFFImportFile.h" + #include "llvm/ADT/ArrayRef.h" ++#include "llvm/ADT/SmallVector.h" ++#include "llvm/ADT/StringMap.h" + #include "llvm/ADT/Twine.h" + #include "llvm/Object/Archive.h" + #include "llvm/Object/ArchiveWriter.h" +@@ -657,8 +659,7 @@ NewArchiveMember ObjectFactory::createWeakExternal(StringRef Sym, + Error writeImportLibrary(StringRef ImportName, StringRef Path, + ArrayRef Exports, + MachineTypes Machine, bool MinGW, +- ArrayRef NativeExports, +- bool AddUnderscores) { ++ ArrayRef NativeExports) { + + MachineTypes NativeMachine = Machine; + if (isArm64EC(Machine)) { +@@ -680,6 +681,13 @@ Error writeImportLibrary(StringRef ImportName, StringRef Path, + + auto addExports = [&](ArrayRef Exp, + MachineTypes M) -> Error { ++ StringMap RegularImports; ++ struct Deferred { ++ std::string Name; ++ ImportType ImpType; ++ const COFFShortExport *Export; ++ }; ++ SmallVector Renames; + for (const COFFShortExport &E : Exp) { + if (E.Private) + continue; +@@ -724,15 +732,11 @@ Error writeImportLibrary(StringRef ImportName, StringRef Path, + else if (Name == E.ImportName) + NameType = IMPORT_NAME; + else { +- StringRef Prefix = ""; +- if (Machine == IMAGE_FILE_MACHINE_I386 && AddUnderscores) +- Prefix = "_"; +- +- if (ImportType == IMPORT_CODE) +- Members.push_back(OF.createWeakExternal( +- (Prefix + E.ImportName).str(), Name, false, M)); +- Members.push_back(OF.createWeakExternal((Prefix + E.ImportName).str(), +- Name, true, M)); ++ Deferred D; ++ D.Name = Name; ++ D.ImpType = ImportType; ++ D.Export = &E; ++ Renames.push_back(D); + continue; + } + } else { +@@ -754,9 +758,25 @@ Error writeImportLibrary(StringRef ImportName, StringRef Path, + } + } + ++ RegularImports[applyNameType(NameType, Name)] = Name; + Members.push_back(OF.createShortImport(Name, E.Ordinal, ImportType, + NameType, ExportName, M)); + } ++ for (const auto &D : Renames) { ++ auto It = RegularImports.find(D.Export->ImportName); ++ if (It != RegularImports.end()) { ++ // We have a regular import entry for a symbol with the name we ++ // want to reference; produce an alias pointing at that. ++ StringRef Symbol = It->second; ++ if (D.ImpType == IMPORT_CODE) ++ Members.push_back(OF.createWeakExternal(Symbol, D.Name, false, M)); ++ Members.push_back(OF.createWeakExternal(Symbol, D.Name, true, M)); ++ } else { ++ Members.push_back(OF.createShortImport( ++ D.Name, D.Export->Ordinal, D.ImpType, IMPORT_NAME_EXPORTAS, ++ D.Export->ImportName, M)); ++ } ++ } + return Error::success(); + }; + +diff --git a/llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp b/llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp +index 012ad246888f..15e4cac08cd4 100644 +--- a/llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp ++++ b/llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp +@@ -243,9 +243,8 @@ int llvm::dlltoolDriverMain(llvm::ArrayRef ArgsArr) { + } + + std::string Path = std::string(Args.getLastArgValue(OPT_l)); +- if (!Path.empty() && +- writeImportLibrary(OutputFile, Path, Exports, Machine, +- /*MinGW=*/true, NativeExports, AddUnderscores)) ++ if (!Path.empty() && writeImportLibrary(OutputFile, Path, Exports, Machine, ++ /*MinGW=*/true, NativeExports)) + return 1; + return 0; + } +diff --git a/llvm/test/tools/llvm-dlltool/coff-decorated.def b/llvm/test/tools/llvm-dlltool/coff-decorated.def +index 773e3762cc3d..f5685fb1cf0c 100644 +--- a/llvm/test/tools/llvm-dlltool/coff-decorated.def ++++ b/llvm/test/tools/llvm-dlltool/coff-decorated.def +@@ -7,7 +7,7 @@ EXPORTS + CdeclFunction + StdcallFunction@4 + @FastcallFunction@4 +-StdcallAlias@4==StdcallFunction@4 ++StdcallAlias@4==StdcallFunction + ??_7exception@@6B@ + StdcallExportName@4=StdcallInternalFunction@4 + OtherStdcallExportName@4=CdeclInternalFunction +diff --git a/llvm/test/tools/llvm-dlltool/coff-weak-exports.def b/llvm/test/tools/llvm-dlltool/coff-weak-exports.def +index 67f0013bf170..b08040e29fa4 100644 +--- a/llvm/test/tools/llvm-dlltool/coff-weak-exports.def ++++ b/llvm/test/tools/llvm-dlltool/coff-weak-exports.def +@@ -5,6 +5,9 @@ + + LIBRARY test.dll + EXPORTS ++AltTestFunction ++AltTestFunction2 ++AltTestData + TestFunction==AltTestFunction + TestData DATA == AltTestData + ; When creating an import library, the DLL internal function name of +@@ -17,6 +20,14 @@ ImpLibName2 = Implementation2 == AltTestFunction2 + ; matter for the import library + ImpLibName3 = kernel32.Sleep + ++; CHECK: T AltTestFunction ++; CHECK-NEXT: T __imp_AltTestFunction ++; CHECK: T AltTestFunction2 ++; CHECK-NEXT: T __imp_AltTestFunction2 ++; CHECK: T ImpLibName ++; CHECK-NEXT: T __imp_ImpLibName ++; CHECK: T ImpLibName3 ++; CHECK-NEXT: T __imp_ImpLibName3 + ; CHECK: U AltTestFunction + ; CHECK-NEXT: W TestFunction + ; CHECK: U __imp_AltTestFunction +@@ -24,14 +35,10 @@ ImpLibName3 = kernel32.Sleep + ; CHECK-NOT: W TestData + ; CHECK: U __imp_AltTestData + ; CHECK-NEXT: W __imp_TestData +-; CHECK: T ImpLibName +-; CHECK-NEXT: T __imp_ImpLibName + ; CHECK: U AltTestFunction2 + ; CHECK-NEXT: W ImpLibName2 + ; CHECK: U __imp_AltTestFunction2 + ; CHECK-NEXT: W __imp_ImpLibName2 +-; CHECK: T ImpLibName3 +-; CHECK-NEXT: T __imp_ImpLibName3 + + ; ARCH-NOT: unknown arch + +diff --git a/llvm/test/tools/llvm-dlltool/renaming.def b/llvm/test/tools/llvm-dlltool/renaming.def +new file mode 100644 +index 000000000000..57fd472aa37c +--- /dev/null ++++ b/llvm/test/tools/llvm-dlltool/renaming.def +@@ -0,0 +1,39 @@ ++; RUN: llvm-dlltool -k -m i386 --input-def %s --output-lib %t.a ++; RUN: llvm-readobj %t.a | FileCheck %s ++; RUN: llvm-nm %t.a | FileCheck %s -check-prefix=CHECK-NM ++ ++LIBRARY test.dll ++EXPORTS ++ ++symbolname == actualimport ++ ++dataname DATA == actualdata ++ ++_wcstok == wcstok ++wcstok == wcstok_s ++ ++; CHECK-NM-NOT: actualimport ++; CHECK-NM-NOT: actualdata ++ ++; CHECK: Type: code ++; CHECK-NEXT: Name type: export as ++; CHECK-NEXT: Export name: actualimport ++; CHECK-NEXT: Symbol: __imp__symbolname ++; CHECK-NEXT: Symbol: _symbolname ++ ++; CHECK: Type: data ++; CHECK-NEXT: Name type: export as ++; CHECK-NEXT: Export name: actualdata ++; CHECK-NEXT: Symbol: __imp__dataname ++ ++; CHECK: Type: code ++; CHECK-NEXT: Name type: export as ++; CHECK-NEXT: Export name: wcstok ++; CHECK-NEXT: Symbol: __imp___wcstok ++; CHECK-NEXT: Symbol: __wcstok ++ ++; CHECK: Type: code ++; CHECK-NEXT: Name type: export as ++; CHECK-NEXT: Export name: wcstok_s ++; CHECK-NEXT: Symbol: __imp__wcstok ++; CHECK-NEXT: Symbol: _wcstok +-- +2.25.1 +