LLD: COFF: Infer machine type earlier than before.

[ruiu]

Summary

Previously, we infer machine type at the very end of linking after
all symbols are resolved. That's actually too late because machine
type affects how we mangle symbols (whether or not we need to
add "_").

For example, /entry:foo adds "_foo" to the symbol table if x86 but
"foo" if x64.

This patch moves the code to infer machine type, so that machine
type is inferred based on input files given via the command line
(but not based on .directives files).

[pcc]

COFF/Driver.cpp

211

You could add an assertion here that the machine type is known.

COFF/InputFiles.cpp

334–337

These don't look right. x86-32 and ARM both have a number of variants for the first part of the target triple. The llvm::Triple class can parse the triple for you.

[ruiu]

Address Peter's comments.

[pcc]

LGTM

[Eugene.Zelenko]

Committed in r241843.

COFF/Driver.cpp

 
 Undefined *LinkerDriver::addUndefined(StringRef Name) {
   Undefined *U = Symtab.addUndefined(Name);
   Config->GCRoot.insert(U);
   return U;
 }
 
 // Symbol names are mangled by appending "_" prefix on x86.
 StringRef LinkerDriver::mangle(StringRef Sym) {
   if (Config->MachineType == IMAGE_FILE_MACHINE_I386)
     return Alloc.save("_" + Sym);
   return Sym;
 }
 
 // Windows specific -- find default entry point name.
 StringRef LinkerDriver::findDefaultEntry() {
   // User-defined main functions and their corresponding entry points.
bool LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
   if (Args.hasArg(OPT_verbose))
     Config->Verbose = true;
 
   // Handle /force or /force:unresolved
   if (Args.hasArg(OPT_force) || Args.hasArg(OPT_force_unresolved))
     Config->Force = true;
 
   // Handle /entry
+  StringRef Entry;
   if (auto *Arg = Args.getLastArg(OPT_entry))
-    Config->Entry = addUndefined(mangle(Arg->getValue()));
+    Entry = Arg->getValue();
 
   // Handle /debug
   if (Args.hasArg(OPT_debug))
     Config->Debug = true;
 
   // Handle /noentry
   if (Args.hasArg(OPT_noentry)) {
     if (!Args.hasArg(OPT_dll)) {
       llvm::errs() << "/noentry must be specified with /dll\n";
       return false;
     }
     Config->NoEntry = true;
   }
 
   // Handle /dll
   if (Args.hasArg(OPT_dll)) {
     Config->DLL = true;
     Config->ImageBase = 0x180000000U;
     Config->ManifestID = 2;
-    if (Config->Entry == nullptr && !Config->NoEntry)
-      Config->Entry = addUndefined("_DllMainCRTStartup");
+    if (Entry.empty() && !Config->NoEntry)
+      Entry = "_DllMainCRTStartup";
   }
 
   // Handle /fixed
   if (Args.hasArg(OPT_fixed)) {
     if (Args.hasArg(OPT_dynamicbase)) {
       llvm::errs() << "/fixed must not be specified with /dynamicbase\n";
       return false;
     }
if (Args.hasArg(OPT_highentropyva_no))
     Config->HighEntropyVA = false;
   if (Args.hasArg(OPT_nxcompat_no))
     Config->NxCompat = false;
   if (Args.hasArg(OPT_tsaware_no))
     Config->TerminalServerAware = false;
 
   // Create a list of input files. Files can be given as arguments
   // for /defaultlib option.
-  std::vector<StringRef> InputPaths;
-  std::vector<MemoryBufferRef> Inputs;
+  std::vector<StringRef> Paths;
+  std::vector<MemoryBufferRef> MBs;
   for (auto *Arg : Args.filtered(OPT_INPUT))
     if (Optional<StringRef> Path = findFile(Arg->getValue()))
-      InputPaths.push_back(*Path);
+      Paths.push_back(*Path);
   for (auto *Arg : Args.filtered(OPT_defaultlib))
     if (Optional<StringRef> Path = findLib(Arg->getValue()))
-      InputPaths.push_back(*Path);
-  for (StringRef Path : InputPaths) {
+      Paths.push_back(*Path);
+  for (StringRef Path : Paths) {
     ErrorOr<MemoryBufferRef> MBOrErr = openFile(Path);
     if (auto EC = MBOrErr.getError()) {
       llvm::errs() << "cannot open " << Path << ": " << EC.message() << "\n";
       return false;
     }
-    Inputs.push_back(MBOrErr.get());
+    MBs.push_back(MBOrErr.get());
   }
 
   // Windows specific -- Create a resource file containing a manifest file.
   if (Config->Manifest == Configuration::Embed) {
     auto MBOrErr = createManifestRes();
     if (MBOrErr.getError())
       return false;
     std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
-    Inputs.push_back(MB->getMemBufferRef());
+    MBs.push_back(MB->getMemBufferRef());
     OwningMBs.push_back(std::move(MB)); // take ownership
   }
 
   // Windows specific -- Input files can be Windows resource files (.res files).
   // We invoke cvtres.exe to convert resource files to a regular COFF file
   // then link the result file normally.
+  std::vector<MemoryBufferRef> Resources;
   auto NotResource = [](MemoryBufferRef MB) {
     return identify_magic(MB.getBuffer()) != file_magic::windows_resource;
   };
-  auto It = std::stable_partition(Inputs.begin(), Inputs.end(), NotResource);
-  if (It != Inputs.end()) {
-    std::vector<MemoryBufferRef> Files(It, Inputs.end());
-    auto MBOrErr = convertResToCOFF(Files);
-    if (MBOrErr.getError())
-      return false;
-    std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
-    Inputs.erase(It, Inputs.end());
-    Inputs.push_back(MB->getMemBufferRef());
-    OwningMBs.push_back(std::move(MB)); // take ownership
+  auto It = std::stable_partition(MBs.begin(), MBs.end(), NotResource);
+  if (It != MBs.end()) {
+    Resources.insert(Resources.end(), It, MBs.end());
+    MBs.erase(It, MBs.end());
   }
 
-  Symtab.addAbsolute(mangle("__ImageBase"), Config->ImageBase);
-
   // Read all input files given via the command line. Note that step()
   // doesn't read files that are specified by directive sections.
-  for (MemoryBufferRef MB : Inputs)
+  for (MemoryBufferRef MB : MBs)
     Symtab.addFile(createFile(MB));
   if (auto EC = Symtab.step()) {
     llvm::errs() << EC.message() << "\n";
     return false;
   }
 
+  // Determine machine type and check if all object files are
+  // for the same CPU type. Note that this needs to be done before
+  // any call to mangle().
+  for (std::unique_ptr<InputFile> &File : Symtab.getFiles()) {
+    MachineTypes MT = File->getMachineType();
+    if (MT == IMAGE_FILE_MACHINE_UNKNOWN)
+      continue;
+    if (Config->MachineType == IMAGE_FILE_MACHINE_UNKNOWN) {
+      Config->MachineType = MT;
+      continue;
+    }
+    if (Config->MachineType != MT) {
+      llvm::errs() << File->getShortName() << ": machine type "
+                   << machineTypeToStr(MT) << " conflicts with "
+                   << machineTypeToStr(Config->MachineType) << "\n";
+      return false;
+    }
+  }
+  if (Config->MachineType == IMAGE_FILE_MACHINE_UNKNOWN) {
+    llvm::errs() << "warning: /machine is not specified. x64 is assumed.\n";
+    Config->MachineType = IMAGE_FILE_MACHINE_AMD64;
+  }
+
+  // Windows specific -- Convert Windows resource files to a COFF file.
+  if (!Resources.empty()) {
+    auto MBOrErr = convertResToCOFF(Resources);
+    if (MBOrErr.getError())
+      return false;
+    std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
+    Symtab.addFile(createFile(MB->getMemBufferRef()));
+    OwningMBs.push_back(std::move(MB)); // take ownership
+  }
+
+  if (!Entry.empty())
+    Config->Entry = addUndefined(mangle(Entry));
+  Symtab.addAbsolute(mangle("__ImageBase"), Config->ImageBase);
+
   // Windows specific -- If entry point name is not given, we need to
   // infer that from user-defined entry name.
-  if (Config->Entry == nullptr && !Config->NoEntry) {
+  if (Entry.empty() && !Config->NoEntry) {
     StringRef S = findDefaultEntry();
     if (S.empty()) {
       llvm::errs() << "entry point must be defined\n";
       return false;
     }
     Config->Entry = addUndefined(S);
     if (Config->Verbose)
       llvm::outs() << "Entry name inferred: " << S << "\n";
   }
 
-  // Read as much files as we can.
+  // Read as much files as we can from directives sections.
   if (auto EC = Symtab.run()) {
     llvm::errs() << EC.message() << "\n";
     return false;
   }
 
   // Resolve auxiliary symbols until we get a convergence.
   // (Trying to resolve a symbol may trigger a Lazy symbol to load a new file.
   // A new file may contain a directive section to add new command line options.
bool LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
   if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
     Config->Subsystem = inferSubsystem();
     if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
       llvm::errs() << "subsystem must be defined\n";
       return false;
     }
   }
 
-  // Check if all object files are for the same CPU type and
-  // compatible with /machine option (if given).
-  for (ObjectFile *File : Symtab.ObjectFiles) {
-    auto MT = static_cast<MachineTypes>(File->getCOFFObj()->getMachine());
-    if (MT == IMAGE_FILE_MACHINE_UNKNOWN)
-      continue;
-    if (Config->MachineType == IMAGE_FILE_MACHINE_UNKNOWN) {
-      Config->MachineType = MT;
-      continue;
-    }
-    if (Config->MachineType != MT) {
-      llvm::errs() << File->getShortName() << ": machine type "
-                   << machineTypeToStr(MT) << " conflicts with "
-                   << machineTypeToStr(Config->MachineType) << "\n";
-      return false;
-    }
-  }
-  if (Config->MachineType == IMAGE_FILE_MACHINE_UNKNOWN) {
-    llvm::errs() << "machine type must be specified\n";
-    return false;
-  }
-
   // Windows specific -- when we are creating a .dll file, we also
   // need to create a .lib file.
   if (!Config->Exports.empty())
     writeImportLibrary();
 
   // Windows specific -- fix up dllexported symbols.
   if (!Config->Exports.empty())
     if (fixupExports())

COFF/InputFiles.h

 #include <memory>
 #include <set>
 #include <vector>
 
 namespace lld {
 namespace coff {
 
 using llvm::LTOModule;
+using llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
+using llvm::COFF::MachineTypes;
 using llvm::object::Archive;
 using llvm::object::COFFObjectFile;
 using llvm::object::COFFSymbolRef;
 
 class Chunk;
 class Defined;
 class Lazy;
 class SymbolBody;
public:
 
   // Returns symbols defined by this file.
   virtual std::vector<SymbolBody *> &getSymbols() = 0;
 
   // Reads a file (constructors don't do that). Returns an error if a
   // file is broken.
   virtual std::error_code parse() = 0;
 
+  // Returns the CPU type this file was compiled to.
+  virtual MachineTypes getMachineType() { return IMAGE_FILE_MACHINE_UNKNOWN; }
+
   // Returns a short, human-friendly filename. If this is a member of
   // an archive file, a returned value includes parent's filename.
   // Used for logging or debugging.
   std::string getShortName();
 
   // Sets a parent filename if this file is created from an archive.
   void setParentName(StringRef N) { ParentName = N; }
 

 };
 
 // .obj or .o file. This may be a member of an archive file.
 class ObjectFile : public InputFile {
 public:
   explicit ObjectFile(MemoryBufferRef M) : InputFile(ObjectKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
   std::error_code parse() override;
+  MachineTypes getMachineType() override;
   std::vector<Chunk *> &getChunks() { return Chunks; }
   std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
 
   // Returns a SymbolBody object for the SymbolIndex'th symbol in the
   // underlying object file.
   SymbolBody *getSymbolBody(uint32_t SymbolIndex) {
     return SparseSymbolBodies[SymbolIndex];
   }

 };
 
 // Used for LTO.
 class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
   std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
+  MachineTypes getMachineType() override;
 
   LTOModule *getModule() const { return M.get(); }
   LTOModule *releaseModule() { return M.release(); }
 
 private:
   std::error_code parse() override;
 
   std::vector<SymbolBody *> SymbolBodies;
   llvm::BumpPtrAllocator Alloc;
   std::unique_ptr<LTOModule> M;
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

COFF/InputFiles.cpp

Defined *ObjectFile::createDefined(COFFSymbolRef Sym, const void *AuxP,
 
   auto *B = new (Alloc) DefinedRegular(this, Sym, SC);
   if (SC->isCOMDAT() && Sym.getValue() == 0 && !AuxP)
     SC->setSymbol(B);
 
   return B;
 }
 
+MachineTypes ObjectFile::getMachineType() {
+  if (COFFObj)
+    return static_cast<MachineTypes>(COFFObj->getMachine());
+  return IMAGE_FILE_MACHINE_UNKNOWN;
+}
+
 std::error_code ImportFile::parse() {
   const char *Buf = MB.getBufferStart();
   const char *End = MB.getBufferEnd();
   const auto *Hdr = reinterpret_cast<const coff_import_header *>(Buf);
 
   // Check if the total size is valid.
   if ((size_t)(End - Buf) != (sizeof(*Hdr) + Hdr->SizeOfData)) {
     llvm::errs() << "broken import library\n";
if (SymbolDef == LTO_SYMBOL_DEFINITION_UNDEFINED) {
                                                         Replaceable));
     }
   }
 
   Directives = M->getLinkerOpts();
   return std::error_code();
 }
 
+MachineTypes BitcodeFile::getMachineType() {
+  if (!M)
+    return IMAGE_FILE_MACHINE_UNKNOWN;
+  StringRef Triple = M->getTargetTriple();
+  if (Triple.startswith("x86_64-"))
+    return IMAGE_FILE_MACHINE_AMD64;
+  if (Triple.startswith("x86-"))
+    return IMAGE_FILE_MACHINE_I386;
+  if (Triple.startswith("arm-"))
+    return IMAGE_FILE_MACHINE_ARMNT;
+  return IMAGE_FILE_MACHINE_UNKNOWN;
+}
+
 } // namespace coff
 } // namespace lld

COFF/SymbolTable.h

 // SymbolTable selects the "best" symbols if there are name
 // conflicts. For example, obviously, a defined symbol is better than
 // an undefined symbol. Or, if there's a conflict between a lazy and a
 // undefined, it'll read an archive member to read a real definition
 // to replace the lazy symbol. The logic is implemented in resolve().
 class SymbolTable {
 public:
   void addFile(std::unique_ptr<InputFile> File);
+  std::vector<std::unique_ptr<InputFile>> &getFiles() { return Files; }
   std::error_code step();
   std::error_code run();
   bool queueEmpty();
 
   // Print an error message on undefined symbols. If Resolve is true, try to
   // resolve any undefined symbols and update the symbol table accordingly.
   bool reportRemainingUndefines(bool Resolve);
 

COFF/Writer.cpp

OutputSection *Writer::createSection(StringRef Name) {
   Sec->addPermissions(Perms);
   OutputSections.push_back(Sec);
   return Sec;
 }
 
 // Dest is .reloc section. Add contents to that section.
 void Writer::addBaserels(OutputSection *Dest) {
   std::vector<uint32_t> V;
-  Defined *ImageBase = cast<Defined>(Symtab->find("__ImageBase")->Body);
+  StringRef Name = Config->is64() ? "__ImageBase" : "___ImageBase";
+  Defined *ImageBase = cast<Defined>(Symtab->find(Name)->Body);
   for (OutputSection *Sec : OutputSections) {
     if (Sec == Dest)
       continue;
     // Collect all locations for base relocations.
     for (Chunk *C : Sec->getChunks())
       C->getBaserels(&V, ImageBase);
     // Add the addresses to .reloc section.
     if (!V.empty())

test/COFF/Inputs/machine-x64.yaml

+---
+header:
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: []
+sections:
+  - Name:            .text
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       4
+    SectionData:     000000000000
+symbols:
+  - Name:            .text
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          6
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          0
+  - Name:            main
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+...

test/COFF/Inputs/machine-x86.yaml

+---
+header:
+  Machine:         IMAGE_FILE_MACHINE_I386
+  Characteristics: []
+sections:
+  - Name:            .text
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       4
+    SectionData:     000000000000
+symbols:
+  - Name:            .text
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          6
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          0
+  - Name:            _main
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+...

test/COFF/hello32.test

 # RUN: yaml2obj < %p/Inputs/hello32.yaml > %t.obj
 # RUN: lld -flavor link2 %t.obj %p/Inputs/std32.lib /subsystem:console \
-# RUN:   /entry:_main@0 /out:%t.exe
+# RUN:   /entry:main@0 /out:%t.exe
 # RUN: llvm-readobj -file-headers %t.exe | FileCheck -check-prefix=HEADER %s
 # RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
 
 HEADER:      Format: COFF-i386
 HEADER-NEXT: Arch: i386
 HEADER-NEXT: AddressSize: 32bit
 HEADER-NEXT: ImageFileHeader {
 HEADER-NEXT:   Machine: IMAGE_FILE_MACHINE_I386 (0x14C)

test/COFF/machine.test

-# RUN: sed -e s/MACHINETYPE/IMAGE_FILE_MACHINE_AMD64/ %s | yaml2obj > %t.obj
+# RUN: yaml2obj %p/Inputs/machine-x64.yaml > %t.obj
 # RUN: lld -flavor link2 /entry:main /subsystem:console /out:%t.exe %t.obj
 # RUN: llvm-readobj -file-headers %t.exe | FileCheck -check-prefix=AMD64 %s
 # RUN: lld -flavor link2 /entry:main /subsystem:console /machine:x64 \
 # RUN:   /out:%t.exe %t.obj
 # RUN: llvm-readobj -file-headers %t.exe | FileCheck -check-prefix=AMD64 %s
 
-# AMD64: Machine: IMAGE_FILE_MACHINE_AMD64
+AMD64: Machine: IMAGE_FILE_MACHINE_AMD64
 
-# RUN: sed -e s/MACHINETYPE/IMAGE_FILE_MACHINE_I386/ %s | yaml2obj > %t.obj
+# RUN: yaml2obj %p/Inputs/machine-x86.yaml > %t.obj
 # RUN: lld -flavor link2 /entry:main /subsystem:console /out:%t.exe %t.obj
 # RUN: llvm-readobj -file-headers %t.exe | FileCheck -check-prefix=I386 %s
 # RUN: lld -flavor link2 /entry:main /subsystem:console /machine:x86 \
 # RUN:   /out:%t.exe %t.obj /fixed
 # RUN: llvm-readobj -file-headers %t.exe | FileCheck -check-prefix=I386 %s
 
-# I386: Machine: IMAGE_FILE_MACHINE_I386
+I386: Machine: IMAGE_FILE_MACHINE_I386
 
-# RUN: sed -e s/MACHINETYPE/IMAGE_FILE_MACHINE_AMD64/ %s | yaml2obj > %t.obj
+# RUN: yaml2obj %p/Inputs/machine-x64.yaml > %t.obj
 # RUN: not lld -flavor link2 /entry:main /subsystem:console /machine:x86 \
 # RUN:   /out:%t.exe %t.obj /fixed >& %t.log
 # RUN: FileCheck -check-prefix=INCOMPAT %s < %t.log
 
-# RUN: sed -e s/MACHINETYPE/IMAGE_FILE_MACHINE_I386/ %s | yaml2obj > %t1.obj
-# RUN: sed -e s/MACHINETYPE/IMAGE_FILE_MACHINE_AMD64/ %s | \
-# RUN:   sed -e s/main/foo/ | yaml2obj > %t2.obj
+# RUN: yaml2obj %p/Inputs/machine-x86.yaml > %t1.obj
+# RUN: sed -e s/main/foo/ %p/Inputs/machine-x64.yaml | yaml2obj > %t2.obj
 # RUN: not lld -flavor link2 /entry:main /subsystem:console /out:%t.exe \
 # RUN:   %t1.obj %t2.obj >& %t.log
 # RUN: FileCheck -check-prefix=INCOMPAT %s < %t.log
 
-# INCOMPAT: .obj: machine type x64 conflicts with x86
-
----
-header:
-  Machine:         MACHINETYPE
-  Characteristics: []
-sections:
-  - Name:            .text
-    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
-    Alignment:       4
-    SectionData:     000000000000
-symbols:
-  - Name:            .text
-    Value:           0
-    SectionNumber:   1
-    SimpleType:      IMAGE_SYM_TYPE_NULL
-    ComplexType:     IMAGE_SYM_DTYPE_NULL
-    StorageClass:    IMAGE_SYM_CLASS_STATIC
-    SectionDefinition:
-      Length:          6
-      NumberOfRelocations: 0
-      NumberOfLinenumbers: 0
-      CheckSum:        0
-      Number:          0
-  - Name:            main
-    Value:           0
-    SectionNumber:   1
-    SimpleType:      IMAGE_SYM_TYPE_NULL
-    ComplexType:     IMAGE_SYM_DTYPE_NULL
-    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
-...
+INCOMPAT: .obj: machine type x64 conflicts with x86

test/COFF/reloc-x86.test

header:
   Characteristics: []
 sections:
   - Name:            .text
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
     Alignment:       4096
     SectionData:     A100000000A100000000A100000000A100000000A100000000A100000000
     Relocations:
       - VirtualAddress:  1
-        SymbolName:      main
+        SymbolName:      _main
         Type:            IMAGE_REL_I386_ABSOLUTE
       - VirtualAddress:  6
-        SymbolName:      main
+        SymbolName:      _main
         Type:            IMAGE_REL_I386_DIR32
       - VirtualAddress:  11
-        SymbolName:      main
+        SymbolName:      _main
         Type:            IMAGE_REL_I386_DIR32NB
       - VirtualAddress:  16
-        SymbolName:      main
+        SymbolName:      _main
         Type:            IMAGE_REL_I386_REL32
       - VirtualAddress:  23
-        SymbolName:      main
+        SymbolName:      _main
         Type:            IMAGE_REL_I386_SECTION
       - VirtualAddress:  26
-        SymbolName:      main
+        SymbolName:      _main
         Type:            IMAGE_REL_I386_SECREL
 symbols:
   - Name:            .text
     Value:           0
     SectionNumber:   1
     SimpleType:      IMAGE_SYM_TYPE_NULL
     ComplexType:     IMAGE_SYM_DTYPE_NULL
     StorageClass:    IMAGE_SYM_CLASS_STATIC
     SectionDefinition:
       Length:          6
       NumberOfRelocations: 0
       NumberOfLinenumbers: 0
       CheckSum:        0
       Number:          0
-  - Name:            main
+  - Name:            _main
     Value:           0
     SectionNumber:   1
     SimpleType:      IMAGE_SYM_TYPE_NULL
     ComplexType:     IMAGE_SYM_DTYPE_NULL
     StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
 ...