fix extra bytes when compressing for 32bit objcopy

[ckissane]

Summary

fixes extra bytes that zlib is "ok" with but zstd detects and errors on when decompressing

[ckissane]

• fix extra bytes when compressing for 32bit objcopy
• fix lldb compressed section zstd test File Size

[ckissane]

• remove lldb changes

[phosek]

Would it be possible to write a test that covers this case?

[MaskRay]

See test/tools/llvm-objcopy/ELF/compress-debug-sections-zstd.test. Use a similar file for ELFCLASS32 which runs llvm-objcopy --compress-debug-sections=zstd then llvm-objcopy --decompress-debug-sections. Then compare the output with the original with just one llvm-objcopy run.

[MaskRay]

llvm/lib/ObjCopy/ELF/ELFObjcopy.cpp

509

This is incorrect. Config.OutputArch is usually unset (-O).

We need a field in Object and initialize it in llvm/lib/ObjCopy/ELF/ELFObject.cpp:1883

[MaskRay]

D134385 should fix the problem:)

llvm/lib/ObjCopy/ELF/ELFObjcopy.cpp

RemovePred = [&Obj, RemovePred](const SectionBase &Sec) {
         return false;
       return RemovePred(Sec);
     };
   }
 
   if (Error E = Obj.removeSections(ELFConfig.AllowBrokenLinks, RemovePred))
     return E;
 
+  const ElfType OutputElfType =
+      getOutputElfType(Config.OutputArch.value_or(MachineInfo()));
+  const bool Is64Bit =
+      OutputElfType == ELFT_ELF64LE || OutputElfType == ELFT_ELF64BE;
   if (Config.CompressionType != DebugCompressionType::None) {
     if (Error Err = replaceDebugSections(
             Obj, isCompressable,
-            [&Config, &Obj](const SectionBase *S) -> Expected<SectionBase *> {
+            [&Config, &Obj,
+             Is64Bit](const SectionBase *S) -> Expected<SectionBase *> {
               return &Obj.addSection<CompressedSection>(
-                  CompressedSection(*S, Config.CompressionType));
+                  CompressedSection(*S, Config.CompressionType, Is64Bit));
             }))
       return Err;
   } else if (Config.DecompressDebugSections) {
     if (Error Err = replaceDebugSections(
             Obj,
             [](const SectionBase &S) { return isa<CompressedSection>(&S); },
             [&Obj](const SectionBase *S) {
               const CompressedSection *CS = cast<CompressedSection>(S);

llvm/lib/ObjCopy/ELF/ELFObject.h

public:
   Error accept(MutableSectionVisitor &Visitor) override;
   bool hasContents() const override { return true; }
 };
 
 class CompressedSection : public SectionBase {
   MAKE_SEC_WRITER_FRIEND
 
   uint32_t ChType = 0;
+  bool Is64Bits;
   DebugCompressionType CompressionType;
   uint64_t DecompressedSize;
   uint64_t DecompressedAlign;
   SmallVector<uint8_t, 128> CompressedData;
 
 public:
   CompressedSection(const SectionBase &Sec,
-                    DebugCompressionType CompressionType);
+                    DebugCompressionType CompressionType, bool Is64Bits);
   CompressedSection(ArrayRef<uint8_t> CompressedData, uint32_t ChType,
-                    uint64_t DecompressedSize, uint64_t DecompressedAlign);
+                    uint64_t DecompressedSize, uint64_t DecompressedAlign,
+                    bool Is64Bits);
 
   uint64_t getDecompressedSize() const { return DecompressedSize; }
   uint64_t getDecompressedAlign() const { return DecompressedAlign; }
   uint64_t getChType() const { return ChType; }
 
   Error accept(SectionVisitor &Visitor) const override;
   Error accept(MutableSectionVisitor &Visitor) override;
 

llvm/lib/ObjCopy/ELF/ELFObject.cpp

Error ELFSectionWriter<ELFT>::visit(const CompressedSection &Sec) {
   memcpy(Buf, &Chdr, sizeof(Chdr));
   Buf += sizeof(Chdr);
 
   std::copy(Sec.CompressedData.begin(), Sec.CompressedData.end(), Buf);
   return Error::success();
 }
 
 CompressedSection::CompressedSection(const SectionBase &Sec,
-                                     DebugCompressionType CompressionType)
-    : SectionBase(Sec), CompressionType(CompressionType),
+                                     DebugCompressionType CompressionType,
+                                     bool Is64Bits)
+    : SectionBase(Sec), Is64Bits(Is64Bits), CompressionType(CompressionType),
       DecompressedSize(Sec.OriginalData.size()), DecompressedAlign(Sec.Align) {
   compression::compress(compression::Params(CompressionType), OriginalData,
                         CompressedData);
 
   Flags |= ELF::SHF_COMPRESSED;
   size_t ChdrSize =
-      std::max(std::max(sizeof(object::Elf_Chdr_Impl<object::ELF64LE>),
-                        sizeof(object::Elf_Chdr_Impl<object::ELF64BE>)),
-               std::max(sizeof(object::Elf_Chdr_Impl<object::ELF32LE>),
-                        sizeof(object::Elf_Chdr_Impl<object::ELF32BE>)));
+      Is64Bits ? std::max(sizeof(object::Elf_Chdr_Impl<object::ELF64LE>),
+                          sizeof(object::Elf_Chdr_Impl<object::ELF64BE>))
+               : std::max(sizeof(object::Elf_Chdr_Impl<object::ELF32LE>),
+                          sizeof(object::Elf_Chdr_Impl<object::ELF32BE>));
   Size = ChdrSize + CompressedData.size();
   Align = 8;
 }
 
 CompressedSection::CompressedSection(ArrayRef<uint8_t> CompressedData,
                                      uint32_t ChType, uint64_t DecompressedSize,
-                                     uint64_t DecompressedAlign)
-    : ChType(ChType), CompressionType(DebugCompressionType::None),
+                                     uint64_t DecompressedAlign, bool Is64Bits)
+    : ChType(ChType), Is64Bits(Is64Bits),
+      CompressionType(DebugCompressionType::None),
       DecompressedSize(DecompressedSize), DecompressedAlign(DecompressedAlign) {
   OriginalData = CompressedData;
 }
 
 Error CompressedSection::accept(SectionVisitor &Visitor) const {
   return Visitor.visit(*this);
 }
 
default: {
 
     Expected<StringRef> Name = ElfFile.getSectionName(Shdr);
     if (!Name)
       return Name.takeError();
 
     if (!(Shdr.sh_flags & ELF::SHF_COMPRESSED))
       return Obj.addSection<Section>(*Data);
     auto *Chdr = reinterpret_cast<const Elf_Chdr_Impl<ELFT> *>(Data->data());
-    return Obj.addSection<CompressedSection>(CompressedSection(
-        *Data, Chdr->ch_type, Chdr->ch_size, Chdr->ch_addralign));
+    return Obj.addSection<CompressedSection>(
+        CompressedSection(*Data, Chdr->ch_type, Chdr->ch_size,
+                          Chdr->ch_addralign, ELFT::Is64Bits));
   }
   }
 }
 
 template <class ELFT> Error ELFBuilder<ELFT>::readSectionHeaders() {
   uint32_t Index = 0;
   Expected<typename ELFFile<ELFT>::Elf_Shdr_Range> Sections =
       ElfFile.sections();