[lldb][ObjectFileELF] Improve error output for unsupported arch/relocations

[sgraenitz]

Summary

ObjectFileELF::ApplyRelocations() considered all 32-bit input objects to be i386 and didn't provide good error messages for AArch32 objects. Please find an example in https://github.com/llvm/llvm-project/issues/61948
While we are here, let' improve the situation for unsupported architectures as well. I think we should report the error here too and not silently fail (or crash with assertions enabled).

[sgraenitz]

This would be good to land in preparation for D147642

[SixWeining]

LGTM. I think this is a requirement for adding other 32bit arch support.

[DavidSpickett]

Agreed.

The tangled web of switch statements makes my head spin so if you ever feel like tackling that please do :)

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2705

Should this report error also? Given that you want it to not crash.

Though it did that already, you must have had reason to change it.

[sgraenitz]

Include R_386_NONE for error reporting

[sgraenitz]

Thanks for your feedback

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2705

I think the relocation types that can occur in debug sections are considered an invariant. If we see other relocation types, we got on a wrong track long before. The relocation resolver that exists in LLVM nowadays follows a support/resolve approach, which gives it a cleaner structure, but it comes down to the same behavior eventually: https://github.com/llvm/llvm-project/blob/release/16.x/llvm/lib/Object/RelocationResolver.cpp#L287-L299

I think it's best to keep this as is: Bail out with the assertion in development builds and ignore it silently in release builds.

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

for (unsigned i = 0; i < num_relocations; ++i) {
     if (!rel.Parse(rel_data, &offset)) {
       GetModule()->ReportError(".rel{0}[{1:d}] failed to parse relocation",
                                rel_section->GetName().AsCString(), i);
       break;
     }
     Symbol *symbol = nullptr;
 
     if (hdr->Is32Bit()) {
+      switch (hdr->e_machine) {
+      case llvm::ELF::EM_386:
         switch (reloc_type(rel)) {
         case R_386_32:
           symbol = symtab->FindSymbolByID(reloc_symbol(rel));
           if (symbol) {
             addr_t f_offset =
                 rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel);
             DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
             // ObjectFileELF creates a WritableDataBuffer in CreateInstance.
             WritableDataBuffer *data_buffer =
                 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
             uint32_t *dst = reinterpret_cast<uint32_t *>(
                 data_buffer->GetBytes() + f_offset);
 
             addr_t value = symbol->GetAddressRef().GetFileAddress();
             if (rel.IsRela()) {
               value += ELFRelocation::RelocAddend32(rel);
             } else {
               value += *dst;
             }
             *dst = value;
           } else {
             GetModule()->ReportError(".rel{0}[{1}] unknown symbol id: {2:d}",
                                     rel_section->GetName().AsCString(), i,
                                     reloc_symbol(rel));
           }
           break;
+        case R_386_NONE:
         case R_386_PC32:
-      default:
-        GetModule()->ReportError("unsupported 32-bit relocation:"
+          GetModule()->ReportError("unsupported i386 relocation:"
                                    " .rel{0}[{1}], type {2}",
                                    rel_section->GetName().AsCString(), i,
                                    reloc_type(rel));
+          break;
+        default:
+          assert(false && "unexpected relocation type");
+          break;
+        }
+        break;
+      default:
+        GetModule()->ReportError("unsupported 32-bit ELF machine arch: {0}", hdr->e_machine);
+        break;
       }
     } else {
       switch (hdr->e_machine) {
       case llvm::ELF::EM_AARCH64:
         switch (reloc_type(rel)) {
         case R_AARCH64_ABS64:
           ApplyELF64ABS64Relocation(symtab, rel, debug_data, rel_section);
           break;
if (hdr->Is32Bit()) {
           ApplyELF64ABS32Relocation(symtab, rel, debug_data, rel_section, true);
           break;
         case R_X86_64_PC32:
         default:
           assert(false && "unexpected relocation type");
         }
         break;
       default:
-        assert(false && "unsupported machine");
+        GetModule()->ReportError("unsupported 64-bit ELF machine arch: {0}", hdr->e_machine);
+        break;
       }
     }
   }
 
   return 0;
 }
 
 unsigned ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr,