[COFF] Keep the underscore on exported decorated stdcall functions

[mstorsjo]

Summary

This (together with the corresponding LLD commit) fixes PR35733.

[mstorsjo]

The matching change to the update of D41632.

[mstorsjo]

@ruiu Is this associated patch ok as well?

[mstorsjo]

Ping @ruiu @rnk - the corresponding change for LLD was already OK'd by Rui in D41632, but these two need to go together.

[ruiu]

LGTM

include/llvm/Object/COFFImportFile.h

struct COFFShortExport {
 
   friend bool operator!=(const COFFShortExport &L, const COFFShortExport &R) {
     return !(L == R);
   }
 };
 
 Error writeImportLibrary(StringRef ImportName, StringRef Path,
                          ArrayRef<COFFShortExport> Exports,
-                         COFF::MachineTypes Machine, bool MakeWeakAliases);
+                         COFF::MachineTypes Machine, bool MakeWeakAliases,
+                         bool MinGW);
 
 } // namespace object
 } // namespace llvm
 
 #endif

lib/Object/COFFImportFile.cpp

static void writeStringTable(std::vector<uint8_t> &B,
   }
 
   // Backfill the length of the table now that it has been computed.
   support::ulittle32_t Length(B.size() - Offset);
   support::endian::write32le(&B[Offset], Length);
 }
 
 static ImportNameType getNameType(StringRef Sym, StringRef ExtName,
-                                  MachineTypes Machine) {
+                                  MachineTypes Machine, bool MinGW) {
+  // A decorated stdcall function in MSVC is exported with the
+  // type IMPORT_NAME, and the exported function name includes the
+  // the leading underscore. In MinGW on the other hand, a decorated
+  // stdcall function still omits the underscore (IMPORT_NAME_NOPREFIX).
+  // See the comment in isDecorated in COFFModuleDefinition.cpp for more
+  // details.
+  if (ExtName.startswith("_") && ExtName.contains('@') && !MinGW)
+    return IMPORT_NAME;
   if (Sym != ExtName)
     return IMPORT_NAME_UNDECORATE;
   if (Machine == IMAGE_FILE_MACHINE_I386 && Sym.startswith("_"))
     return IMPORT_NAME_NOPREFIX;
   return IMPORT_NAME;
 }
 
 static Expected<std::string> replace(StringRef S, StringRef From,
NewArchiveMember ObjectFactory::createWeakExternal(StringRef Sym,
   // Copied here so we can still use writeStringTable
   char *Buf = Alloc.Allocate<char>(Buffer.size());
   memcpy(Buf, Buffer.data(), Buffer.size());
   return {MemoryBufferRef(StringRef(Buf, Buffer.size()), ImportName)};
 }
 
 Error writeImportLibrary(StringRef ImportName, StringRef Path,
                          ArrayRef<COFFShortExport> Exports,
-                         MachineTypes Machine, bool MakeWeakAliases) {
+                         MachineTypes Machine, bool MakeWeakAliases,
+                         bool MinGW) {
 
   std::vector<NewArchiveMember> Members;
   ObjectFactory OF(llvm::sys::path::filename(ImportName), Machine);
 
   std::vector<uint8_t> ImportDescriptor;
   Members.push_back(OF.createImportDescriptor(ImportDescriptor));
 
   std::vector<uint8_t> NullImportDescriptor;
for (COFFShortExport E : Exports) {
 
     ImportType ImportType = IMPORT_CODE;
     if (E.Data)
       ImportType = IMPORT_DATA;
     if (E.Constant)
       ImportType = IMPORT_CONST;
 
     StringRef SymbolName = E.SymbolName.empty() ? E.Name : E.SymbolName;
-    ImportNameType NameType = getNameType(SymbolName, E.Name, Machine);
+    ImportNameType NameType = getNameType(SymbolName, E.Name, Machine, MinGW);
     Expected<std::string> Name = E.ExtName.empty()
                                      ? SymbolName
                                      : replace(SymbolName, E.Name, E.ExtName);
 
     if (!Name)
       return Name.takeError();
 
     Members.push_back(

lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp

for (COFFShortExport& E : Def->Exports) {
       // one char.
       E.Name = E.Name.substr(0, E.Name.find('@', 1));
       // By making sure E.SymbolName != E.Name for decorated symbols,
       // writeImportLibrary writes these symbols with the type
       // IMPORT_NAME_UNDECORATE.
     }
   }
 
-  if (writeImportLibrary(Def->OutputFile, Path, Def->Exports, Machine, true))
+  if (writeImportLibrary(Def->OutputFile, Path, Def->Exports, Machine, true, true))
     return 1;
   return 0;
 }