Recognize FreeBSD specific BFD names in OUTPUT_FORMAT

[dim]

Summary

After rLLD344952 ("Add OUTPUT_FORMAT linker script directive support"),
using BFD names such as elf64-x86-64-freebsd the OUTPUT_FORMAT
linker script command does not work anymore, resulting in errors like:

ld: error: /home/dim/src/clang800-import/stand/efi/loader/arch/amd64/ldscript.amd64:2: unknown output format name: elf64-x86-64-freebsd
>>> OUTPUT_FORMAT("elf64-x86-64-freebsd", "elf64-x86-64-freebsd", "elf64-x86-64-freebsd")
>>>               ^

To fix this, add the following FreeBSD specific BFD names to
readBfdName:

• elf32-i386-freebsd
• elf64-aarch64-freebsd
• elf64-powerpc-freebsd
• elf64-x86-64-freebsd

and also set Configuration::OSABI to ELFOSABI_FREEBSD for those
cases.

Add and/or update several test cases to check for the correct results of
these new OUTPUT_FORMAT arguments.

Note that some more generic parsing could probably be implemented, but I
would like to get something accepted for merging into the 8.0 branch, so
we can ship it in FreeBSD.

[grimar]

ELF/ScriptParser.cpp

95–96

I think we want to start using a new struct instead of tuple then.

[dim]

ELF/ScriptParser.cpp

95–96

Yeah, this is the disadvantage of unnamed tuples. I'll make a it a struct.

[ruiu]

I think this part of code needs a little bit of refactoring. I'll submit it so that you can make your change on top of it.

ELF/ScriptParser.cpp

410–414

Instead of recognizing all the combinations of *-freebsd, check if -freebsd is a suffix of a given string, and set OSABI to FREEBSD and then trim the string.

[ruiu]

I submitted a cleanup patch to this code, so I think you can easily implement your feature. I'd think you want to use StringRef::consume_front.

[dim]

Updated to address comments:

• Replaced tuple with BfdDesc struct
• Parse -freebsd suffix to determine OSABI
• Add new case for elf-aarch64 (which used to be elf-aarch64-freebsd)

[grimar]

Please rebase.

ELF/ScriptParser.cpp

385–386

readBfdName was removed in r352407. (method was converted to a static helper)

So you can define BfdDesc in an anonymous namespace.

385–386

Then I think you can avoid adding a constructor in BfdDesc and can use:

return {ELF32LEKind, EM_386, OSABI, false};

[ruiu]

Yes, please rebase.

[dim]

Rebased.

[ruiu]

ELF/ScriptParser.cpp

404

Can you move this to readOutputFormat? Then you don't need to change this function at all.

Also you shouldn't change OSABI if it does not end with -freebsd, as we shouldn't add the assumption if not FreeBSD, it is always ELFOSABI_NONE.

[dim]

Updated as @ruiu suggested.

[ruiu]

LGTM

ELF/ScriptParser.cpp

private:
   std::vector<StringRef> readOutputSectionPhdrs();
   InputSectionDescription *readInputSectionDescription(StringRef Tok);
   StringMatcher readFilePatterns();
   std::vector<SectionPattern> readInputSectionsList();
   InputSectionDescription *readInputSectionRules(StringRef FilePattern);
   unsigned readPhdrType();
   SortSectionPolicy readSortKind();
   SymbolAssignment *readProvideHidden(bool Provide, bool Hidden);
   SymbolAssignment *readAssignment(StringRef Tok);
   void readSort();
   Expr readAssert();
   Expr readConstant();
   Expr getPageSize();
 
   uint64_t readMemoryAssignment(StringRef, StringRef, StringRef);
   std::pair<uint32_t, uint32_t> readMemoryAttributes();
 
   Expr combine(StringRef Op, Expr L, Expr R);

 }
 
 void ScriptParser::readOutputArch() {
   // OUTPUT_ARCH is ignored for now.
   expect("(");
   while (!errorCount() && !consume(")"))
     skip();
 }
 
 static std::pair<ELFKind, uint16_t> parseBfdName(StringRef S) {
   return StringSwitch<std::pair<ELFKind, uint16_t>>(S)
       .Case("elf32-i386", {ELF32LEKind, EM_386})
       .Case("elf32-iamcu", {ELF32LEKind, EM_IAMCU})
       .Case("elf32-littlearm", {ELF32LEKind, EM_ARM})
       .Case("elf32-x86-64", {ELF32LEKind, EM_X86_64})
+      .Case("elf64-aarch64", {ELF64LEKind, EM_AARCH64})
       .Case("elf64-littleaarch64", {ELF64LEKind, EM_AARCH64})
       .Case("elf64-powerpc", {ELF64BEKind, EM_PPC64})
       .Case("elf64-powerpcle", {ELF64LEKind, EM_PPC64})
       .Case("elf64-x86-64", {ELF64LEKind, EM_X86_64})
       .Case("elf32-tradbigmips", {ELF32BEKind, EM_MIPS})
       .Case("elf32-ntradbigmips", {ELF32BEKind, EM_MIPS})
       .Case("elf32-tradlittlemips", {ELF32LEKind, EM_MIPS})
       .Case("elf32-ntradlittlemips", {ELF32LEKind, EM_MIPS})
       .Case("elf64-tradbigmips", {ELF64BEKind, EM_MIPS})
       .Case("elf64-tradlittlemips", {ELF64LEKind, EM_MIPS})
       .Default({ELFNoneKind, EM_NONE});
 }
 
 // Parse OUTPUT_FORMAT(bfdname) or OUTPUT_FORMAT(bfdname, big, little).
 // Currently we ignore big and little parameters.
 void ScriptParser::readOutputFormat() {
   expect("(");
 
-  StringRef S = unquote(next());
+  StringRef Name = unquote(next());
+  StringRef S = Name;
+  if (S.consume_back("-freebsd"))
+    Config->OSABI = ELFOSABI_FREEBSD;
 
   std::tie(Config->EKind, Config->EMachine) = parseBfdName(S);
   if (Config->EMachine == EM_NONE)
-    setError("unknown output format name: " + S);
+    setError("unknown output format name: " + Name);
   if (S == "elf32-ntradlittlemips" || S == "elf32-ntradbigmips")
     Config->MipsN32Abi = true;
 
   if (consume(")"))
     return;
   expect(",");
   skip();
   expect(",");

test/ELF/emulation-aarch64.s

 # AARCH64-NEXT:   Machine: EM_AARCH64 (0xB7)
 # AARCH64-NEXT:   Version: 1
 # AARCH64-NEXT:   Entry:
 # AARCH64-NEXT:   ProgramHeaderOffset: 0x40
 # AARCH64-NEXT:   SectionHeaderOffset:
 # AARCH64-NEXT:   Flags [ (0x0)
 # AARCH64-NEXT:   ]
 
+# RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-freebsd %s -o %taarch64fbsd
+# RUN: echo 'OUTPUT_FORMAT(elf64-aarch64-freebsd)' > %taarch64fbsd.script
+# RUN: ld.lld %taarch64fbsd.script %taarch64fbsd -o %t2aarch64fbsd
+# RUN: llvm-readobj -file-headers %t2aarch64fbsd | FileCheck --check-prefix=AARCH64-FBSD %s
+# AARCH64-FBSD:      ElfHeader {
+# AARCH64-FBSD-NEXT:   Ident {
+# AARCH64-FBSD-NEXT:     Magic: (7F 45 4C 46)
+# AARCH64-FBSD-NEXT:     Class: 64-bit (0x2)
+# AARCH64-FBSD-NEXT:     DataEncoding: LittleEndian (0x1)
+# AARCH64-FBSD-NEXT:     FileVersion: 1
+# AARCH64-FBSD-NEXT:     OS/ABI: FreeBSD (0x9)
+# AARCH64-FBSD-NEXT:     ABIVersion: 0
+# AARCH64-FBSD-NEXT:     Unused: (00 00 00 00 00 00 00)
+# AARCH64-FBSD-NEXT:   }
+# AARCH64-FBSD-NEXT:   Type: Executable (0x2)
+# AARCH64-FBSD-NEXT:   Machine: EM_AARCH64 (0xB7)
+# AARCH64-FBSD-NEXT:   Version: 1
+# AARCH64-FBSD-NEXT:   Entry:
+# AARCH64-FBSD-NEXT:   ProgramHeaderOffset: 0x40
+# AARCH64-FBSD-NEXT:   SectionHeaderOffset:
+# AARCH64-FBSD-NEXT:   Flags [ (0x0)
+# AARCH64-FBSD-NEXT:   ]
+
 .globl _start
 _start:

test/ELF/emulation-ppc.s

 # PPC64-NEXT:   HeaderSize: 64
 # PPC64-NEXT:   ProgramHeaderEntrySize: 56
 # PPC64-NEXT:   ProgramHeaderCount:
 # PPC64-NEXT:   SectionHeaderEntrySize: 64
 # PPC64-NEXT:   SectionHeaderCount:
 # PPC64-NEXT:   StringTableSectionIndex:
 # PPC64-NEXT: }
 
+# RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-freebsd %s -o %tppc64fbsd
+# RUN: echo 'OUTPUT_FORMAT(elf64-powerpc-freebsd)' > %tppc64fbsd.script
+# RUN: ld.lld %tppc64fbsd.script  %tppc64fbsd -o %t2ppc64fbsd
+# RUN: llvm-readobj -file-headers %t2ppc64fbsd | FileCheck --check-prefix=PPC64-FBSD %s
+
+# PPC64-FBSD:      ElfHeader {
+# PPC64-FBSD-NEXT:   Ident {
+# PPC64-FBSD-NEXT:     Magic: (7F 45 4C 46)
+# PPC64-FBSD-NEXT:     Class: 64-bit (0x2)
+# PPC64-FBSD-NEXT:     DataEncoding: BigEndian (0x2)
+# PPC64-FBSD-NEXT:     FileVersion: 1
+# PPC64-FBSD-NEXT:     OS/ABI: FreeBSD (0x9)
+# PPC64-FBSD-NEXT:     ABIVersion: 0
+# PPC64-FBSD-NEXT:     Unused: (00 00 00 00 00 00 00)
+# PPC64-FBSD-NEXT:   }
+# PPC64-FBSD-NEXT:   Type: Executable (0x2)
+# PPC64-FBSD-NEXT:   Machine: EM_PPC64 (0x15)
+# PPC64-FBSD-NEXT:   Version: 1
+# PPC64-FBSD-NEXT:   Entry:
+# PPC64-FBSD-NEXT:   ProgramHeaderOffset: 0x40
+# PPC64-FBSD-NEXT:   SectionHeaderOffset:
+# PPC64-FBSD-NEXT:   Flags [ (0x2)
+# PPC64-FBSD-NEXT:     0x2
+# PPC64-FBSD-NEXT:   ]
+# PPC64-FBSD-NEXT:   HeaderSize: 64
+# PPC64-FBSD-NEXT:   ProgramHeaderEntrySize: 56
+# PPC64-FBSD-NEXT:   ProgramHeaderCount:
+# PPC64-FBSD-NEXT:   SectionHeaderEntrySize: 64
+# PPC64-FBSD-NEXT:   SectionHeaderCount:
+# PPC64-FBSD-NEXT:   StringTableSectionIndex:
+# PPC64-FBSD-NEXT: }
+
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %tppc64le
 # RUN: ld.lld -m elf64lppc %tppc64le -o %t2ppc64le
 # RUN: llvm-readobj -file-headers %t2ppc64le | FileCheck --check-prefix=PPC64LE %s
 # RUN: ld.lld %tppc64le -o %t3ppc64le
 # RUN: llvm-readobj -file-headers %t3ppc64le | FileCheck --check-prefix=PPC64LE %s
 # RUN: echo 'OUTPUT_FORMAT(elf64-powerpcle)' > %tppc64le.script
 # RUN: ld.lld %tppc64le.script  %tppc64le -o %t4ppc64le
 # RUN: llvm-readobj -file-headers %t4ppc64le | FileCheck --check-prefix=PPC64LE %s

test/ELF/emulation-x86.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-freebsd %s -o %tx64
 # RUN: ld.lld -m elf_amd64_fbsd %tx64 -o %t2x64
 # RUN: llvm-readobj -file-headers %t2x64 | FileCheck --check-prefix=AMD64 %s
 # RUN: ld.lld %tx64 -o %t3x64
 # RUN: llvm-readobj -file-headers %t3x64 | FileCheck --check-prefix=AMD64 %s
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.sysv
 # RUN: ld.lld -m elf_amd64_fbsd %t.sysv -o %t.freebsd
 # RUN: llvm-readobj -file-headers %t.freebsd | FileCheck --check-prefix=AMD64 %s
+# RUN: echo 'OUTPUT_FORMAT(elf64-x86-64-freebsd)' > %t4x64.script
+# RUN: ld.lld %t4x64.script %tx64 -o %t4x64
+# RUN: llvm-readobj -file-headers %t4x64 | FileCheck --check-prefix=AMD64 %s
 # AMD64:      ElfHeader {
 # AMD64-NEXT:   Ident {
 # AMD64-NEXT:     Magic: (7F 45 4C 46)
 # AMD64-NEXT:     Class: 64-bit (0x2)
 # AMD64-NEXT:     DataEncoding: LittleEndian (0x1)
 # AMD64-NEXT:     FileVersion: 1
 # AMD64-NEXT:     OS/ABI: FreeBSD (0x9)
 # AMD64-NEXT:     ABIVersion: 0

 # X86-NEXT:   ProgramHeaderEntrySize: 32
 # X86-NEXT:   ProgramHeaderCount:
 # X86-NEXT:   SectionHeaderEntrySize: 40
 # X86-NEXT:   SectionHeaderCount:
 # X86-NEXT:   StringTableSectionIndex:
 # X86-NEXT: }
 
 # RUN: llvm-mc -filetype=obj -triple=i686-unknown-freebsd %s -o %tx86fbsd
-# RUN: ld.lld -m elf_i386_fbsd %tx86fbsd -o %t2x86_fbsd
-# RUN: llvm-readobj -file-headers %t2x86_fbsd | FileCheck --check-prefix=X86FBSD %s
+# RUN: ld.lld -m elf_i386_fbsd %tx86fbsd -o %t2x86fbsd
+# RUN: llvm-readobj -file-headers %t2x86fbsd | FileCheck --check-prefix=X86FBSD %s
 # RUN: ld.lld %tx86fbsd -o %t3x86fbsd
 # RUN: llvm-readobj -file-headers %t3x86fbsd | FileCheck --check-prefix=X86FBSD %s
+# RUN: echo 'OUTPUT_FORMAT(elf32-i386-freebsd)' > %t4x86fbsd.script
+# RUN: ld.lld %t4x86fbsd.script %tx86fbsd -o %t4x86fbsd
+# RUN: llvm-readobj -file-headers %t4x86fbsd | FileCheck --check-prefix=X86FBSD %s
 # X86FBSD:      ElfHeader {
 # X86FBSD-NEXT:   Ident {
 # X86FBSD-NEXT:     Magic: (7F 45 4C 46)
 # X86FBSD-NEXT:     Class: 32-bit (0x1)
 # X86FBSD-NEXT:     DataEncoding: LittleEndian (0x1)
 # X86FBSD-NEXT:     FileVersion: 1
 # X86FBSD-NEXT:     OS/ABI: FreeBSD (0x9)
 # X86FBSD-NEXT:     ABIVersion: 0