[LLD] Support compressed input sections on big-endian targets

[atanasyan]

Summary

This patch enables compressed input sections on big-endian targets by checking the target endianness and selecting an appropriate Chdr structure.

Fixes PR51369

[emaste]

With this patch applied BE mips64 FreeBSD builds successfully for me

[dim]

This LGTM, but I'm not an approver. I'll probably import this into FreeBSD if it's committed, though.

[MaskRay]

Looks great!

[emaste]

LGTM

[atanasyan]

Thanks for review.

lld/ELF/InputSection.h

public:
 
   template <typename T> llvm::ArrayRef<T> getDataAs() const {
     size_t s = data().size();
     assert(s % sizeof(T) == 0);
     return llvm::makeArrayRef<T>((const T *)data().data(), s / sizeof(T));
   }
 
 protected:
+  template <typename ELFT>
   void parseCompressedHeader();
   void uncompress() const;
 
   mutable ArrayRef<uint8_t> rawData;
 
   // This field stores the uncompressed size of the compressed data in rawData,
   // or -1 if rawData is not compressed (either because the section wasn't
   // compressed in the first place, or because we ended up uncompressing it).

lld/ELF/InputSection.cpp

InputSectionBase::InputSectionBase(InputFile *file, uint64_t flags,
   // In ELF, each section can be compressed by zlib, and if compressed,
   // section name may be mangled by appending "z" (e.g. ".zdebug_info").
   // If that's the case, demangle section name so that we can handle a
   // section as if it weren't compressed.
   if ((flags & SHF_COMPRESSED) || name.startswith(".zdebug")) {
     if (!zlib::isAvailable())
       error(toString(file) + ": contains a compressed section, " +
             "but zlib is not available");
-    parseCompressedHeader();
+    switch (config->ekind) {
+    case ELF32LEKind:
+      parseCompressedHeader<ELF32LE>();
+      break;
+    case ELF32BEKind:
+      parseCompressedHeader<ELF32BE>();
+      break;
+    case ELF64LEKind:
+      parseCompressedHeader<ELF64LE>();
+      break;
+    case ELF64BEKind:
+      parseCompressedHeader<ELF64BE>();
+      break;
+    default:
+      llvm_unreachable("unknown ELFT");
+    }
   }
 }
 
 // Drop SHF_GROUP bit unless we are producing a re-linkable object file.
 // SHF_GROUP is a marker that a section belongs to some comdat group.
 // That flag doesn't make sense in an executable.
 static uint64_t getFlags(uint64_t flags) {
   flags &= ~(uint64_t)SHF_INFO_LINK;
OutputSection *SectionBase::getOutputSection() {
   else
     return cast<OutputSection>(this);
   return sec ? sec->getParent() : nullptr;
 }
 
 // When a section is compressed, `rawData` consists with a header followed
 // by zlib-compressed data. This function parses a header to initialize
 // `uncompressedSize` member and remove the header from `rawData`.
-void InputSectionBase::parseCompressedHeader() {
-  using Chdr64 = typename ELF64LE::Chdr;
-  using Chdr32 = typename ELF32LE::Chdr;
-
+template <typename ELFT> void InputSectionBase::parseCompressedHeader() {
   // Old-style header
   if (name.startswith(".zdebug")) {
     if (!toStringRef(rawData).startswith("ZLIB")) {
       error(toString(this) + ": corrupted compressed section header");
       return;
     }
     rawData = rawData.slice(4);
 
if (name.startswith(".zdebug")) {
     // (e.g. ".zdebug_info" -> ".debug_info")
     name = saver.save("." + name.substr(2));
     return;
   }
 
   assert(flags & SHF_COMPRESSED);
   flags &= ~(uint64_t)SHF_COMPRESSED;
 
-  // New-style 64-bit header
-  if (config->is64) {
-    if (rawData.size() < sizeof(Chdr64)) {
-      error(toString(this) + ": corrupted compressed section");
-      return;
-    }
-
-    auto *hdr = reinterpret_cast<const Chdr64 *>(rawData.data());
-    if (hdr->ch_type != ELFCOMPRESS_ZLIB) {
-      error(toString(this) + ": unsupported compression type");
-      return;
-    }
-
-    uncompressedSize = hdr->ch_size;
-    alignment = std::max<uint32_t>(hdr->ch_addralign, 1);
-    rawData = rawData.slice(sizeof(*hdr));
-    return;
-  }
-
-  // New-style 32-bit header
-  if (rawData.size() < sizeof(Chdr32)) {
+  // New-style header
+  if (rawData.size() < sizeof(typename ELFT::Chdr)) {
     error(toString(this) + ": corrupted compressed section");
     return;
   }
 
-  auto *hdr = reinterpret_cast<const Chdr32 *>(rawData.data());
+  auto *hdr = reinterpret_cast<const typename ELFT::Chdr *>(rawData.data());
   if (hdr->ch_type != ELFCOMPRESS_ZLIB) {
     error(toString(this) + ": unsupported compression type");
     return;
   }
 
   uncompressedSize = hdr->ch_size;
   alignment = std::max<uint32_t>(hdr->ch_addralign, 1);
   rawData = rawData.slice(sizeof(*hdr));

lld/test/ELF/compressed-debug-input-err.s

 # REQUIRES: zlib, x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: not ld.lld %t.o -o /dev/null -shared 2>&1 | FileCheck %s
 
+# RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-unknown %s -o %t-be.o
+# RUN: not ld.lld %t-be.o -o /dev/null -shared 2>&1 | FileCheck %s
+
 ## Check we are able to report zlib uncompress errors.
 # CHECK: error: {{.*}}.o:(.debug_str): uncompress failed: zlib error: Z_DATA_ERROR
 
 .section .zdebug_str,"MS",@progbits,1
  .ascii "ZLIB"
  .byte 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1

lld/test/ELF/compressed-debug-input.s

 # REQUIRES: zlib, x86
 
 # RUN: llvm-mc -compress-debug-sections=zlib -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: llvm-mc -compress-debug-sections=zlib -filetype=obj -triple=powerpc64-unknown-unknown %s -o %t-be
 # RUN: llvm-readobj --sections %t | FileCheck -check-prefix=ZLIB %s
+# RUN: llvm-readobj --sections %t-be | FileCheck -check-prefix=ZLIB %s
 # ZLIB:      Section {
 # ZLIB:        Index: 2
 # ZLIB:        Name: .debug_str
 # ZLIB-NEXT:   Type: SHT_PROGBITS
 # ZLIB-NEXT:   Flags [
 # ZLIB-NEXT:     SHF_COMPRESSED (0x800)
 # ZLIB-NEXT:     SHF_MERGE (0x10)
 # ZLIB-NEXT:     SHF_STRINGS (0x20)
 # ZLIB-NEXT:   ]
 # ZLIB-NEXT:   Address:
 # ZLIB-NEXT:   Offset:
 # ZLIB-NEXT:   Size:
 # ZLIB-NEXT:   Link:
 # ZLIB-NEXT:   Info:
 # ZLIB-NEXT:   AddressAlignment: 8
 # ZLIB-NEXT:   EntrySize: 1
 # ZLIB-NEXT: }
 
 # RUN: llvm-mc -compress-debug-sections=zlib-gnu -filetype=obj -triple=x86_64-unknown-linux %s -o %t2
+# RUN: llvm-mc -compress-debug-sections=zlib-gnu -filetype=obj -triple=powerpc64-unknown-unknown %s -o %t2-be
 # RUN: llvm-readobj --sections %t2 | FileCheck -check-prefix=GNU %s
+# RUN: llvm-readobj --sections %t2-be | FileCheck -check-prefix=GNU %s
 # GNU:      Section {
 # GNU:        Index: 2
 # GNU:        Name: .zdebug_str
 # GNU-NEXT:   Type: SHT_PROGBITS
 # GNU-NEXT:   Flags [
 # GNU-NEXT:     SHF_MERGE (0x10)
 # GNU-NEXT:     SHF_STRINGS (0x20)
 # GNU-NEXT:   ]
 # GNU-NEXT:   Address:
 # GNU-NEXT:   Offset:
 # GNU-NEXT:   Size:
 # GNU-NEXT:   Link:
 # GNU-NEXT:   Info:
 # GNU-NEXT:   AddressAlignment: 1
 # GNU-NEXT:   EntrySize: 1
 # GNU-NEXT: }
 
 # RUN: ld.lld --hash-style=sysv %t -o %t.so -shared
 # RUN: llvm-readobj --sections --section-data %t.so | FileCheck -check-prefix=DATA %s
+# RUN: ld.lld --hash-style=sysv %t-be -o %t-be.so -shared
+# RUN: llvm-readobj --sections --section-data %t-be.so | FileCheck -check-prefix=DATA %s
 
 # RUN: ld.lld --hash-style=sysv %t2 -o %t2.so -shared
 # RUN: llvm-readobj --sections --section-data %t2.so | FileCheck -check-prefix=DATA %s
+# RUN: ld.lld --hash-style=sysv %t2-be -o %t2-be.so -shared
+# RUN: llvm-readobj --sections --section-data %t2-be.so | FileCheck -check-prefix=DATA %s
 
 # DATA:      Section {
 # DATA:        Index: 6
 # DATA:        Name: .debug_str
 # DATA-NEXT:   Type: SHT_PROGBITS
 # DATA-NEXT:   Flags [
 # DATA-NEXT:     SHF_MERGE (0x10)
 # DATA-NEXT:     SHF_STRINGS (0x20)