Add OUTPUT_FORMAT linker script directive support.

[ruiu]

Summary

This patch adds a support for OUTPUT_FORMAT linker script directive.
Since I'm not 100% confident with BFD names you can use in the directive
for all architectures, I added only a few in this patch. We can add
other names for other archtiectures later.

We still do not support triple-style OUTPUT_FORMAT directive, namely,
OUTPUT_FORMAT(bfdname, big, little). If you pass -EL (little endian)
or -EB (big endian) to the linker, GNU linkers pick up big or little
as a BFD name, correspondingly, so that you can use a single linker
script for bi-endian processor. I'm not sure if we really need to
support that, so I'll leave it alone for now.

Note that -m takes precedence over OUTPUT_FORAMT, but we always parse
a BFD name given to OUTPUT_FORMAT for error checking. You cannot write
an invalid name in the OUTPUT_FORMAT directive.

[grimar]

lld/ELF/ScriptParser.cpp

97 ↗

(On Diff #170402)

It was confusing naming for me. Was not clear what is "bfd name".
Maybe readBfdArch or readBfdArchName?

394 ↗

(On Diff #170402)

An observation: bfd code contains both elf64-littleaarch64-cloudabi and elf64-littleaarch64 for example.
Should S == in this function be changed to S.startsWith maybe?

410 ↗

(On Diff #170402)

So I think this means LLD will error out when seeing the object file with incompatible architecture after parsing the script containing OUTPUT_FORMAT. Behavior is fine, but I think there is no test provided for that case?

lld/test/ELF/linkerscript/output-format.s

5 ↗

(On Diff #170402)

This tested we are ignoring the big and little parameters. I think the test was useful. Should it be moved to emulation.s?

[ruiu]

lld/ELF/ScriptParser.cpp

97 ↗

(On Diff #170402)

It seems "BFD name" is an established technical term. You can find "BFD name" in the BFD ld man page.

394 ↗

(On Diff #170402)

I'd like to address that in another patch, because I don't know what exactly we should do for these BFD names with extensions at the moment.

410 ↗

(On Diff #170402)

I don't think we need that test case.

lld/test/ELF/linkerscript/output-format.s

5 ↗

(On Diff #170402)

I don't think so -- I'm not too worried about them.

[grimar]

lld/ELF/ScriptParser.cpp

410 ↗

(On Diff #170402)

Then you should be able to simplify to

std::tie(Config->EKind, Config->EMachine) = readBfdName();

[ruiu]

lld/ELF/ScriptParser.cpp

410 ↗

(On Diff #170402)

I'm not too picky about aiming 100% test coverage, and I meant that we don't need a test case for that in that sense. I'll add a test for you but we don't need to test for all possible combinations of conditions.

[ruiu]

• add a test case

[grimar]

LGTM.

lld/ELF/ScriptParser.cpp

410 ↗

(On Diff #170402)

I meant the following scenario:

If we have file1_386.o (i386), script saying OUTPUT_FORMAT("elf64-x86-64") and file2_x64.o (x64).
And invocation: lld file1_386.o -script script.file file2_x64.o

Then having the if (Config->EKind == ELFNoneKind) line here allows us to the incompatible
architectures error properly. That what I suggested to test initially.

It's also a bit strange that we will accept
lld file1_386.o -script script.file
but will fail on
lld -script script.file file1_386.o

We could have a test explaining the behavior too.

Though I think it is acceptable for now. Let's go as is then.

lld/test/ELF/invalid-linkerscript.test

53 ↗

(On Diff #170426)

I agree that is not useful. See my comment.

[grimar]

lld/ELF/ScriptParser.cpp

410 ↗

(On Diff #170402)

allows us to the incompatible -> allows us to report the incompatible

ELF/ScriptParser.cpp

private:
   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);
+  std::pair<ELFKind, uint16_t> readBfdName();
   void readSort();
   Expr readAssert();
   Expr readConstant();
   Expr getPageSize();
 
   uint64_t readMemoryAssignment(StringRef, StringRef, StringRef);
   std::pair<uint32_t, uint32_t> readMemoryAttributes();
 

 
 void ScriptParser::readOutputArch() {
   // OUTPUT_ARCH is ignored for now.
   expect("(");
   while (!errorCount() && !consume(")"))
     skip();
 }
 
+std::pair<ELFKind, uint16_t> ScriptParser::readBfdName() {
+  StringRef S = next();
+  if (S == "elf32-i386")
+    return {ELF32LEKind, EM_386};
+  if (S == "elf32-iamcu")
+    return {ELF32LEKind, EM_IAMCU};
+  if (S == "elf32-x86-64")
+    return {ELF32LEKind, EM_X86_64};
+  if (S == "elf64-littleaarch64")
+    return {ELF64LEKind, EM_AARCH64};
+  if (S == "elf64-x86-64")
+    return {ELF64LEKind, EM_X86_64};
+
+  setError("unknown output format name: " + S);
+  return {ELFNoneKind, EM_NONE};
+}
+
+// Parse OUTPUT_FORMAT(bfdname) or OUTPUT_FORMAT(bfdname, big, little).
+// Currently we ignore big and little parameters.
 void ScriptParser::readOutputFormat() {
-  // Error checking only for now.
   expect("(");
-  skip();
+
+  std::pair<ELFKind, uint16_t> P = readBfdName();
+  if (Config->EKind == ELFNoneKind) {
+    Config->EKind = P.first;
+    Config->EMachine = P.second;
+  }
+
   if (consume(")"))
     return;
   expect(",");
   skip();
   expect(",");
   skip();
   expect(")");
 }

test/ELF/emulation.s

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

 # X86-64-NEXT:   StringTableSectionIndex:
 # X86-64-NEXT: }
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux-gnux32 %s -o %tx32
 # RUN: ld.lld -m elf32_x86_64 %tx32 -o %t2x32
 # RUN: llvm-readobj -file-headers %t2x32 | FileCheck --check-prefix=X32 %s
 # RUN: ld.lld %tx32 -o %t3x32
 # RUN: llvm-readobj -file-headers %t3x32 | FileCheck --check-prefix=X32 %s
+# RUN: echo 'OUTPUT_FORMAT(elf32-x86-64)' > %t4x32.script
+# RUN: ld.lld %t4x32.script %tx32 -o %t4x32
+# RUN: llvm-readobj -file-headers %t4x32 | FileCheck --check-prefix=X32 %s
 # X32:      ElfHeader {
 # X32-NEXT:   Ident {
 # X32-NEXT:     Magic: (7F 45 4C 46)
 # X32-NEXT:     Class: 32-bit (0x1)
 # X32-NEXT:     DataEncoding: LittleEndian (0x1)
 # X32-NEXT:     FileVersion: 1
 # X32-NEXT:     OS/ABI: SystemV (0x0)
 # X32-NEXT:     ABIVersion: 0

 # X32-NEXT:   StringTableSectionIndex:
 # X32-NEXT: }
 
 # RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %s -o %tx86
 # RUN: ld.lld -m elf_i386 %tx86 -o %t2x86
 # RUN: llvm-readobj -file-headers %t2x86 | FileCheck --check-prefix=X86 %s
 # RUN: ld.lld %tx86 -o %t3x86
 # RUN: llvm-readobj -file-headers %t3x86 | FileCheck --check-prefix=X86 %s
+# RUN: echo 'OUTPUT_FORMAT(elf32-i386)' > %t4x86.script
+# RUN: ld.lld %t4x86.script %tx86 -o %t4x86
+# RUN: llvm-readobj -file-headers %t4x86 | FileCheck --check-prefix=X86 %s
 # X86:      ElfHeader {
 # X86-NEXT:   Ident {
 # X86-NEXT:     Magic: (7F 45 4C 46)
 # X86-NEXT:     Class: 32-bit (0x1)
 # X86-NEXT:     DataEncoding: LittleEndian (0x1)
 # X86-NEXT:     FileVersion: 1
 # X86-NEXT:     OS/ABI: SystemV (0x0)
 # X86-NEXT:     ABIVersion: 0

 # X86FBSD-NEXT:   StringTableSectionIndex:
 # X86FBSD-NEXT: }
 
 # RUN: llvm-mc -filetype=obj -triple=i586-intel-elfiamcu %s -o %tiamcu
 # RUN: ld.lld -m elf_iamcu %tiamcu -o %t2iamcu
 # RUN: llvm-readobj -file-headers %t2iamcu | FileCheck --check-prefix=IAMCU %s
 # RUN: ld.lld %tiamcu -o %t3iamcu
 # RUN: llvm-readobj -file-headers %t3iamcu | FileCheck --check-prefix=IAMCU %s
+# RUN: echo 'OUTPUT_FORMAT(elf32-iamcu)' > %t4iamcu.script
+# RUN: ld.lld %t4iamcu.script %tiamcu -o %t4iamcu
+# RUN: llvm-readobj -file-headers %t4iamcu | FileCheck --check-prefix=IAMCU %s
 # IAMCU:      ElfHeader {
 # IAMCU-NEXT:   Ident {
 # IAMCU-NEXT:     Magic: (7F 45 4C 46)
 # IAMCU-NEXT:     Class: 32-bit (0x1)
 # IAMCU-NEXT:     DataEncoding: LittleEndian (0x1)
 # IAMCU-NEXT:     FileVersion: 1
 # IAMCU-NEXT:     OS/ABI: SystemV (0x0)
 # IAMCU-NEXT:     ABIVersion: 0

 # RUN: ld.lld -m aarch64linux %taarch64 -o %t2aarch64
 # RUN: llvm-readobj -file-headers %t2aarch64 | FileCheck --check-prefix=AARCH64 %s
 # RUN: ld.lld -m aarch64elf %taarch64 -o %t3aarch64
 # RUN: llvm-readobj -file-headers %t3aarch64 | FileCheck --check-prefix=AARCH64 %s
 # RUN: ld.lld -m aarch64_elf64_le_vec %taarch64 -o %t4aarch64
 # RUN: llvm-readobj -file-headers %t4aarch64 | FileCheck --check-prefix=AARCH64 %s
 # RUN: ld.lld %taarch64 -o %t5aarch64
 # RUN: llvm-readobj -file-headers %t5aarch64 | FileCheck --check-prefix=AARCH64 %s
+# RUN: echo 'OUTPUT_FORMAT(elf64-littleaarch64)' > %t4aarch64.script
+# RUN: ld.lld %t4aarch64.script %taarch64 -o %t4aarch64
+# RUN: llvm-readobj -file-headers %t4aarch64 | FileCheck --check-prefix=AARCH64 %s
 # AARCH64:      ElfHeader {
 # AARCH64-NEXT:   Ident {
 # AARCH64-NEXT:     Magic: (7F 45 4C 46)
 # AARCH64-NEXT:     Class: 64-bit (0x2)
 # AARCH64-NEXT:     DataEncoding: LittleEndian (0x1)
 # AARCH64-NEXT:     FileVersion: 1
 # AARCH64-NEXT:     OS/ABI: SystemV (0x0)
 # AARCH64-NEXT:     ABIVersion: 0

test/ELF/format-binary.test

 # CHECK-NEXT:     Name: _binary_{{[a-zA-Z0-9_]+}}test_ELF_Output_format_binary_test_tmp_binary_size
 # CHECK-NEXT:     Value: 0xC
 # CHECK-NEXT:     Size: 0
 # CHECK-NEXT:     Binding: Global
 # CHECK-NEXT:     Type: Object
 # CHECK-NEXT:     Other: 0
 # CHECK-NEXT:     Section: Absolute
 # CHECK-NEXT:   }
+
+# RUN: echo 'OUTPUT_FORMAT(elf64-x86-64)' > %t.script
+# RUN: ld.lld -b binary %t.binary -T %t.script -o %t.out
+# RUN: llvm-readobj %t.out -sections -section-data -symbols | FileCheck -check-prefix=X86-64 %s
+
+# X86-64: Format: ELF64-x86-64

test/ELF/invalid-linkerscript.test

 
 # RUN: echo "INCLUDE /no/such/file" > %t7
 # RUN: not ld.lld %t7 no-such-file 2>&1 | FileCheck -check-prefix=ERR7 %s
 # ERR7: cannot find linker script /no/such/file
 # ERR7: cannot open no-such-file:
 
 # RUN: echo "OUTPUT_FORMAT(x y z)" > %t8
 # RUN: not ld.lld %t8 no-such-file 2>&1 | FileCheck -check-prefix=ERR8 %s
-# ERR8: , expected, but got y
+# RUN: not ld.lld -m elf_amd64 %t8 no-such-file 2>&1 | FileCheck -check-prefix=ERR8 %s
+# ERR8: unknown output format name: x
 # ERR8: cannot open no-such-file:
+
+# RUN: echo "OUTPUT_FORMAT(elf64-x86-64 y z)" > %t9
+# RUN: not ld.lld %t9 no-such-file 2>&1 | FileCheck -check-prefix=ERR9 %s
+# ERR9: , expected, but got y
+# ERR9: cannot open no-such-file:

test/ELF/linkerscript/output-format.s

-# REQUIRES: x86
-# RUN: echo "OUTPUT_FORMAT(x, y, z)" > %t.script
-# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-freebsd %s -o %t1
-# RUN: ld.lld -shared -o %t2 %t1 %t.script
-# RUN: llvm-readobj %t2 > /dev/null
-
-# RUN: echo "OUTPUT_FORMAT(x, y)" > %t.script
-# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-freebsd %s -o %t1
-# RUN: not ld.lld -shared -o %t2 %t1 %t.script