[RL78 patch 1] Add RL78 ELF defintions

[SebastianPerta]

Summary

Add file with RL78 ELF relocations. Add RL78 support to ELF.h,
ELFObject.h and ELFYAML.cpp. Add simple test of RL78 ELF representation in YAML.

Please note this patch depends on the triple being defined which is done in first patch:
https://reviews.llvm.org/D150693

[MaskRay]

llvm/include/llvm/BinaryFormat/ELFRelocs/RL78.def

54

No newline at end of file. Please add one

llvm/test/tools/llvm-readobj/ELF/reloc-types-rl78.test

1

Seems to wrap too early.

llvm/test/tools/llvm-readobj/ELF/rl78-header-flags.test

1

Complete sentences in comments should end with a period. Fix this throughout.

[jhenderson]

llvm/include/llvm/BinaryFormat/ELF.h

919

Typo?

921

llvm/test/tools/llvm-readobj/ELF/rl78-header-flags.test

4

It seems to me like we should have at least a token llvm-readelf/--elf-output-style=GNU test case, as the two code paths start off separately. We need to show that they both recognise the new flags. It may not be necessary to check every single case though.

Up to you, but you could somewhat simplify this test by simply have yaml2obj create the input object with all the flags set at once. You then only need one yaml2obj and one llvm-readobj lines.

[• onesiesirate]

This comment was removed by mehdi_amini.

llvm/include/llvm/BinaryFormat/ELF.h

enum : unsigned {
   EF_CSKY_EFV3 = 0x3000000
 };
 
 // ELF Relocation types for CSKY
 enum {
 #include "ELFRelocs/CSKY.def"
 };
 
+// RL78 Specific e_flags.
+enum : unsigned {
+  // Functional unit.
+  EF_RL78_FU_EXIST = 0x01,
+  // Extension instructions#.
+  EF_RL78_EI_EXIST = 0x08,
+  // MAA mode
+  EF_RL78_MAA_0 = 0x40,
+  EF_RL78_MAA_1 = 0xc0,
+  // CPU.
+  EF_RL78_CPU_8BIT = 0x100,
+  EF_RL78_CPU_16BIT = 0x300,
+  // Size of double in bytes.
+  EF_RL78_DOUBLE_4 = 0x400,
+  EF_RL78_DOUBLE_8 = 0xc00,
+  // Default function pointer.
+  EF_RL78_TEXT_NEAR = 0x1000,
+  EF_RL78_TEXT_FAR = 0x3000,
+  // Default data pointer.
+  EF_RL78_DATA_NEAR = 0x4000,
+  EF_RL78_DATA_FAR = 0xc000,
+  // Default constant data pointer.
+  EF_RL78_RODATA_NEAR = 0x10000,
+  EF_RL78_RODATA_FAR = 0x30000,
+  // RL78 e_flags mask.
+  EF_RL78_MASK = 0x3FFFF
+};
+
+// ELF Relocation type for RL78.
+enum {
+#include "ELFRelocs/RL78.def"
+};
+
 // LoongArch Specific e_flags
 enum : unsigned {
   // Definitions from LoongArch ELF psABI v2.01.
   // Reference: https://github.com/loongson/LoongArch-Documentation
   // (commit hash 296de4def055c871809068e0816325a4ac04eb12)
 
   // Base ABI Modifiers
   EF_LOONGARCH_ABI_SOFT_FLOAT    = 0x1,

llvm/include/llvm/BinaryFormat/ELFRelocs/RL78.def

+#ifndef ELF_RELOC
+#error "ELF_RELOC must be defined"
+#endif
+
+ELF_RELOC(R_RL78_NONE,        0x00)
+ELF_RELOC(R_RL78_DIR3U,       0x01)
+ELF_RELOC(R_RL78_DIR8U,       0x02)
+ELF_RELOC(R_RL78_DIR16U,      0x04)
+ELF_RELOC(R_RL78_DIR20U,      0x06)
+ELF_RELOC(R_RL78_DIR20U_16,   0x07)
+ELF_RELOC(R_RL78_DIR20UW_16,  0x08)
+ELF_RELOC(R_RL78_DIR32U,      0x09)
+ELF_RELOC(R_RL78_DIR8U_MIR,   0x0a)
+ELF_RELOC(R_RL78_DIR16U_MIR,  0x0b)
+ELF_RELOC(R_RL78_DIR16UW_MIR, 0x0c)
+ELF_RELOC(R_RL78_DIR8U_SAD,   0x0e)
+ELF_RELOC(R_RL78_DIR8UW_SAD,  0x0f)
+ELF_RELOC(R_RL78_DIR16U_RAM,  0x10)
+ELF_RELOC(R_RL78_DIR16UW_RAM, 0x11)
+ELF_RELOC(R_RL78_DIR8S_PCREL, 0x12)
+ELF_RELOC(R_RL78_DIR16S_PCREL,0x13)
+ELF_RELOC(R_RL78_DIR_CALLT,   0x14)
+ELF_RELOC(R_RL78_ABS3U,       0x31)
+ELF_RELOC(R_RL78_ABS8U,       0x32)
+ELF_RELOC(R_RL78_ABS8UW,      0x33)
+ELF_RELOC(R_RL78_ABS16U,      0x34)
+ELF_RELOC(R_RL78_ABS16UW,     0x35)
+ELF_RELOC(R_RL78_ABS20U,      0x36)
+ELF_RELOC(R_RL78_ABS20U_16,   0x37)
+ELF_RELOC(R_RL78_ABS20UW_16,  0x38)
+ELF_RELOC(R_RL78_ABS32U,      0x39)
+ELF_RELOC(R_RL78_ABS8S_PCREL, 0x42)
+ELF_RELOC(R_RL78_ABS16S_PCREL,0x43)
+ELF_RELOC(R_RL78_ABS_CALLT,   0x44)
+ELF_RELOC(R_RL78_REF,         0x70)
+ELF_RELOC(R_RL78_SYM,         0x80)
+ELF_RELOC(R_RL78_SYM_MIR,     0x81)
+ELF_RELOC(R_RL78_OPadd,       0x82)
+ELF_RELOC(R_RL78_OPsub,       0x83)
+ELF_RELOC(R_RL78_OPsctsize,   0x84)
+ELF_RELOC(R_RL78_OPscttop,    0x85)
+ELF_RELOC(R_RL78_OPlowH,      0x86)
+ELF_RELOC(R_RL78_OPlowL,      0x87)
+ELF_RELOC(R_RL78_OPhighW,     0x88)
+ELF_RELOC(R_RL78_OPlowW,      0x89)
+ELF_RELOC(R_RL78_OPhighW_MIR, 0x8a)
+ELF_RELOC(R_RL78_OPlowW_MIR,  0x8b)
+ELF_RELOC(R_RL78_OPlowW_SMIR, 0x8c)
+ELF_RELOC(R_RL78_OPmir,       0x8d)
+ELF_RELOC(R_RL78_OPABSlowH,   0xa6)
+ELF_RELOC(R_RL78_OPABSlowL,   0xa7)
+ELF_RELOC(R_RL78_OPABShighW,  0xa8)
+ELF_RELOC(R_RL78_OPABSlowW,   0xa9)
 No newline at end of file

llvm/include/llvm/Object/ELFObjectFile.h

case ELF::ELFCLASS32:
     case ELF::EM_SPARC32PLUS:
       return "elf32-sparc";
     case ELF::EM_AMDGPU:
       return "elf32-amdgpu";
     case ELF::EM_LOONGARCH:
       return "elf32-loongarch";
     case ELF::EM_XTENSA:
       return "elf32-xtensa";
+    case ELF::EM_RL78:
+      return "elf32-rl78";
     default:
       return "elf32-unknown";
     }
   case ELF::ELFCLASS64:
     switch (EF.getHeader().e_machine) {
     case ELF::EM_386:
       return "elf64-i386";
     case ELF::EM_X86_64:
case ELF::ELFCLASS64:
       return Triple::loongarch64;
     default:
       report_fatal_error("Invalid ELFCLASS!");
     }
 
   case ELF::EM_XTENSA:
     return Triple::xtensa;
 
+  case ELF::EM_RL78:
+    return Triple::rl78;
+
   default:
     return Triple::UnknownArch;
   }
 }
 
 template <class ELFT>
 Expected<uint64_t> ELFObjectFile<ELFT>::getStartAddress() const {
   return EF.getHeader().e_entry;

llvm/include/module.modulemap

module LLVM_BinaryFormat {
     textual header "llvm/BinaryFormat/ELFRelocs/PowerPC64.def"
     textual header "llvm/BinaryFormat/ELFRelocs/PowerPC.def"
     textual header "llvm/BinaryFormat/ELFRelocs/RISCV.def"
     textual header "llvm/BinaryFormat/ELFRelocs/Sparc.def"
     textual header "llvm/BinaryFormat/ELFRelocs/SystemZ.def"
     textual header "llvm/BinaryFormat/ELFRelocs/VE.def"
     textual header "llvm/BinaryFormat/ELFRelocs/x86_64.def"
     textual header "llvm/BinaryFormat/ELFRelocs/Xtensa.def"
+    textual header "llvm/BinaryFormat/ELFRelocs/RL78.def"
     textual header "llvm/BinaryFormat/WasmRelocs.def"
     textual header "llvm/BinaryFormat/MsgPack.def"
 }
 
 module LLVM_Config {
   requires cplusplus
   umbrella "llvm/Config"
   extern module LLVM_Extern_Config_Def "module.extern.modulemap"

llvm/lib/Object/ELF.cpp

#include "llvm/BinaryFormat/ELFRelocs/LoongArch.def"
     break;
   case ELF::EM_XTENSA:
     switch (Type) {
 #include "llvm/BinaryFormat/ELFRelocs/Xtensa.def"
     default:
       break;
     }
     break;
+  case ELF::EM_RL78:
+    switch (Type) {
+#include "llvm/BinaryFormat/ELFRelocs/RL78.def"
+    default:
+      break;
+    }
   default:
     break;
   }
   return "Unknown";
 }
 
 #undef ELF_RELOC
 

llvm/lib/ObjectYAML/ELFYAML.cpp

case ELF::ELFABIVERSION_AMDGPU_HSA_V5:
                 EF_AMDGPU_FEATURE_SRAMECC_V4);
       BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_OFF_V4,
                 EF_AMDGPU_FEATURE_SRAMECC_V4);
       BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_ON_V4,
                 EF_AMDGPU_FEATURE_SRAMECC_V4);
       break;
     }
     break;
+  case ELF::EM_RL78:
+    BCase(EF_RL78_FU_EXIST);
+    BCase(EF_RL78_EI_EXIST);
+    BCaseMask(EF_RL78_MAA_0, EF_RL78_MAA_1);
+    BCaseMask(EF_RL78_MAA_1, EF_RL78_MAA_1);
+    BCaseMask(EF_RL78_CPU_8BIT, EF_RL78_CPU_16BIT);
+    BCaseMask(EF_RL78_CPU_16BIT, EF_RL78_CPU_16BIT);
+    BCaseMask(EF_RL78_DOUBLE_4, EF_RL78_DOUBLE_8);
+    BCaseMask(EF_RL78_DOUBLE_8, EF_RL78_DOUBLE_8);
+    BCaseMask(EF_RL78_TEXT_NEAR, EF_RL78_TEXT_FAR);
+    BCaseMask(EF_RL78_TEXT_FAR, EF_RL78_TEXT_FAR);
+    BCaseMask(EF_RL78_DATA_NEAR, EF_RL78_DATA_FAR);
+    BCaseMask(EF_RL78_DATA_FAR, EF_RL78_DATA_FAR);
+    BCaseMask(EF_RL78_RODATA_NEAR, EF_RL78_RODATA_FAR);
+    BCaseMask(EF_RL78_RODATA_FAR, EF_RL78_RODATA_FAR);
+    break;
   default:
     break;
   }
 #undef BCase
 #undef BCaseMask
 }
 
 void ScalarEnumerationTraits<ELFYAML::ELF_SHT>::enumeration(

 #include "llvm/BinaryFormat/ELFRelocs/M68k.def"
     break;
   case ELF::EM_LOONGARCH:
 #include "llvm/BinaryFormat/ELFRelocs/LoongArch.def"
     break;
   case ELF::EM_XTENSA:
 #include "llvm/BinaryFormat/ELFRelocs/Xtensa.def"
     break;
+  case ELF::EM_RL78:
+#include "llvm/BinaryFormat/ELFRelocs/RL78.def"
+    break;
   default:
     // Nothing to do.
     break;
   }
 #undef ELF_RELOC
   IO.enumFallback<Hex32>(Value);
 }
 

llvm/test/tools/llvm-readobj/ELF/reloc-types-rl78.test

+## Test that llvm-readobj shows proper relocation type
+## names and values for the RL78 target.
+
+# RUN: yaml2obj %s -o %t-rl78.o
+# RUN: llvm-readobj -r %t-rl78.o | FileCheck %s
+
+# CHECK:      0x0 R_RL78_NONE - 0x0
+# CHECK-NEXT: 0x4 R_RL78_DIR3U - 0x0
+# CHECK-NEXT: 0x8 R_RL78_DIR8U - 0x0
+# CHECK-NEXT: 0xC R_RL78_DIR16U - 0x0
+# CHECK-NEXT: 0x10 R_RL78_DIR20U - 0x0
+# CHECK-NEXT: 0x14 R_RL78_DIR20U_16 - 0x0
+# CHECK-NEXT: 0x18 R_RL78_DIR20UW_16 - 0x0
+# CHECK-NEXT: 0x1C R_RL78_DIR32U - 0x0
+# CHECK-NEXT: 0x20 R_RL78_DIR8U_MIR - 0x0
+# CHECK-NEXT: 0x24 R_RL78_DIR16U_MIR - 0x0
+# CHECK-NEXT: 0x28 R_RL78_DIR16UW_MIR - 0x0
+# CHECK-NEXT: 0x2C R_RL78_DIR8U_SAD - 0x0
+# CHECK-NEXT: 0x30 R_RL78_DIR8UW_SAD - 0x0
+# CHECK-NEXT: 0x34 R_RL78_DIR16U_RAM - 0x0
+# CHECK-NEXT: 0x38 R_RL78_DIR16UW_RAM - 0x0
+# CHECK-NEXT: 0x3C R_RL78_DIR8S_PCREL - 0x0
+# CHECK-NEXT: 0x40 R_RL78_DIR16S_PCREL - 0x0
+# CHECK-NEXT: 0x44 R_RL78_DIR_CALLT - 0x0
+# CHECK-NEXT: 0x48 R_RL78_ABS3U - 0x0
+# CHECK-NEXT: 0x4C R_RL78_ABS8U - 0x0
+# CHECK-NEXT: 0x50 R_RL78_ABS8UW - 0x0
+# CHECK-NEXT: 0x54 R_RL78_ABS16U - 0x0
+# CHECK-NEXT: 0x58 R_RL78_ABS16UW - 0x0
+# CHECK-NEXT: 0x5C R_RL78_ABS20U - 0x0
+# CHECK-NEXT: 0x60 R_RL78_ABS20U_16 - 0x0
+# CHECK-NEXT: 0x64 R_RL78_ABS20UW_16 - 0x0
+# CHECK-NEXT: 0x66 R_RL78_ABS32U - 0x0
+# CHECK-NEXT: 0x68 R_RL78_ABS8S_PCREL - 0x0
+# CHECK-NEXT: 0x6C R_RL78_ABS16S_PCREL - 0x0
+# CHECK-NEXT: 0x70 R_RL78_ABS_CALLT - 0x0
+# CHECK-NEXT: 0x74 R_RL78_REF - 0x0
+# CHECK-NEXT: 0x78 R_RL78_SYM - 0x0
+# CHECK-NEXT: 0x7C R_RL78_SYM_MIR - 0x0
+# CHECK-NEXT: 0x80 R_RL78_OPadd - 0x0
+# CHECK-NEXT: 0x84 R_RL78_OPsub - 0x0
+# CHECK-NEXT: 0x88 R_RL78_OPsctsize - 0x0
+# CHECK-NEXT: 0x8C R_RL78_OPscttop - 0x0
+# CHECK-NEXT: 0x90 R_RL78_OPlowH - 0x0
+# CHECK-NEXT: 0x94 R_RL78_OPlowL - 0x0
+# CHECK-NEXT: 0x95 R_RL78_OPhighW - 0x0
+# CHECK-NEXT: 0x96 R_RL78_OPlowW - 0x0
+# CHECK-NEXT: 0x98 R_RL78_OPhighW_MIR - 0x0
+# CHECK-NEXT: 0x9C R_RL78_OPlowW_MIR - 0x0
+# CHECK-NEXT: 0xA0 R_RL78_OPlowW_SMIR - 0x0
+# CHECK-NEXT: 0xA4 R_RL78_OPmir - 0x0
+# CHECK-NEXT: 0xA8 R_RL78_OPABSlowH - 0x0
+# CHECK-NEXT: 0xAC R_RL78_OPABSlowL - 0x0
+# CHECK-NEXT: 0xB0 R_RL78_OPABShighW - 0x0
+# CHECK-NEXT: 0xB4 R_RL78_OPABSlowW - 0x0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_RL78
+Sections:
+  - Name:         .rela.text
+    Type:         SHT_RELA
+    Relocations:
+       - Offset: 0x0000000000000000
+         Type:   R_RL78_NONE
+       - Offset: 0x0000000000000004
+         Type:   R_RL78_DIR3U
+       - Offset: 0x0000000000000008
+         Type:   R_RL78_DIR8U
+       - Offset: 0x000000000000000C
+         Type:   R_RL78_DIR16U
+       - Offset: 0x0000000000000010
+         Type:   R_RL78_DIR20U
+       - Offset: 0x0000000000000014
+         Type:   R_RL78_DIR20U_16
+       - Offset: 0x0000000000000018
+         Type:   R_RL78_DIR20UW_16
+       - Offset: 0x000000000000001C
+         Type:   R_RL78_DIR32U
+       - Offset: 0x0000000000000020
+         Type:   R_RL78_DIR8U_MIR
+       - Offset: 0x0000000000000024
+         Type:   R_RL78_DIR16U_MIR
+       - Offset: 0x0000000000000028
+         Type:   R_RL78_DIR16UW_MIR
+       - Offset: 0x000000000000002C
+         Type:   R_RL78_DIR8U_SAD
+       - Offset: 0x0000000000000030
+         Type:   R_RL78_DIR8UW_SAD
+       - Offset: 0x0000000000000034
+         Type:   R_RL78_DIR16U_RAM
+       - Offset: 0x0000000000000038
+         Type:   R_RL78_DIR16UW_RAM
+       - Offset: 0x000000000000003C
+         Type:   R_RL78_DIR8S_PCREL
+       - Offset: 0x0000000000000040
+         Type:   R_RL78_DIR16S_PCREL
+       - Offset: 0x0000000000000044
+         Type:   R_RL78_DIR_CALLT
+       - Offset: 0x0000000000000048
+         Type:   R_RL78_ABS3U
+       - Offset: 0x000000000000004C
+         Type:   R_RL78_ABS8U
+       - Offset: 0x0000000000000050
+         Type:   R_RL78_ABS8UW
+       - Offset: 0x0000000000000054
+         Type:   R_RL78_ABS16U
+       - Offset: 0x0000000000000058
+         Type:   R_RL78_ABS16UW
+       - Offset: 0x000000000000005C
+         Type:   R_RL78_ABS20U
+       - Offset: 0x0000000000000060
+         Type:   R_RL78_ABS20U_16
+       - Offset: 0x0000000000000064
+         Type:   R_RL78_ABS20UW_16
+       - Offset: 0x0000000000000066
+         Type:   R_RL78_ABS32U
+       - Offset: 0x0000000000000068
+         Type:   R_RL78_ABS8S_PCREL
+       - Offset: 0x000000000000006C
+         Type:   R_RL78_ABS16S_PCREL
+       - Offset: 0x0000000000000070
+         Type:   R_RL78_ABS_CALLT
+       - Offset: 0x0000000000000074
+         Type:   R_RL78_REF
+       - Offset: 0x0000000000000078
+         Type:   R_RL78_SYM
+       - Offset: 0x000000000000007C
+         Type:   R_RL78_SYM_MIR
+       - Offset: 0x0000000000000080
+         Type:   R_RL78_OPadd
+       - Offset: 0x0000000000000084
+         Type:   R_RL78_OPsub
+       - Offset: 0x0000000000000088
+         Type:   R_RL78_OPsctsize
+       - Offset: 0x000000000000008C
+         Type:   R_RL78_OPscttop
+       - Offset: 0x0000000000000090
+         Type:   R_RL78_OPlowH
+       - Offset: 0x0000000000000094
+         Type:   R_RL78_OPlowL
+       - Offset: 0x0000000000000095
+         Type:   R_RL78_OPhighW
+       - Offset: 0x0000000000000096
+         Type:   R_RL78_OPlowW
+       - Offset: 0x0000000000000098
+         Type:   R_RL78_OPhighW_MIR
+       - Offset: 0x000000000000009C
+         Type:   R_RL78_OPlowW_MIR
+       - Offset: 0x00000000000000A0
+         Type:   R_RL78_OPlowW_SMIR
+       - Offset: 0x00000000000000A4
+         Type:   R_RL78_OPmir
+       - Offset: 0x00000000000000A8
+         Type:   R_RL78_OPABSlowH
+       - Offset: 0x00000000000000AC
+         Type:   R_RL78_OPABSlowL
+       - Offset: 0x00000000000000B0
+         Type:   R_RL78_OPABShighW
+       - Offset: 0x00000000000000B4
+         Type:   R_RL78_OPABSlowW

llvm/test/tools/llvm-readobj/ELF/rl78-header-flags.test

+## Check that we are able to dump EF_RL78_* flags correctly
+
+# RUN: yaml2obj %s -o %t.fu_exist -DFLAG=FU_EXIST
+# RUN: llvm-readobj -S --file-headers %t.fu_exist | FileCheck --check-prefixes=ALL,FU_EXIST %s
+
+# RUN: yaml2obj %s -o %t.ei_exist -DFLAG=EI_EXIST
+# RUN: llvm-readobj -S --file-headers %t.ei_exist | FileCheck --check-prefixes=ALL,EI_EXIST %s
+
+# RUN: yaml2obj %s -o %t.maa_0 -DFLAG=MAA_0
+# RUN: llvm-readobj -S --file-headers %t.maa_0 | FileCheck --check-prefixes=ALL,MAA_0 %s
+
+# RUN: yaml2obj %s -o %t.maa_1 -DFLAG=MAA_1
+# RUN: llvm-readobj -S --file-headers %t.maa_1 | FileCheck --check-prefixes=ALL,MAA_1 %s
+
+# RUN: yaml2obj %s -o %t.cpu_8bit -DFLAG=CPU_8BIT
+# RUN: llvm-readobj -S --file-headers %t.cpu_8bit | FileCheck --check-prefixes=ALL,CPU_8BIT %s
+
+# RUN: yaml2obj %s -o %t.cpu_16bit -DFLAG=CPU_16BIT
+# RUN: llvm-readobj -S --file-headers %t.cpu_16bit | FileCheck --check-prefixes=ALL,CPU_16BIT %s
+
+# RUN: yaml2obj %s -o %t.double_4 -DFLAG=DOUBLE_4
+# RUN: llvm-readobj -S --file-headers %t.double_4 | FileCheck --check-prefixes=ALL,DOUBLE_4 %s
+
+# RUN: yaml2obj %s -o %t.double_8 -DFLAG=DOUBLE_8
+# RUN: llvm-readobj -S --file-headers %t.double_8 | FileCheck --check-prefixes=ALL,DOUBLE_8 %s
+
+# RUN: yaml2obj %s -o %t.text_near -DFLAG=TEXT_NEAR
+# RUN: llvm-readobj -S --file-headers %t.text_near | FileCheck --check-prefixes=ALL,TEXT_NEAR %s
+
+# RUN: yaml2obj %s -o %t.text_far -DFLAG=TEXT_FAR
+# RUN: llvm-readobj -S --file-headers %t.text_far | FileCheck --check-prefixes=ALL,TEXT_FAR %s
+
+# RUN: yaml2obj %s -o %t.data_near -DFLAG=DATA_NEAR
+# RUN: llvm-readobj -S --file-headers %t.data_near | FileCheck --check-prefixes=ALL,DATA_NEAR %s
+
+# RUN: yaml2obj %s -o %t.data_far -DFLAG=DATA_FAR
+# RUN: llvm-readobj -S --file-headers %t.data_far | FileCheck --check-prefixes=ALL,DATA_FAR %s
+
+# RUN: yaml2obj %s -o %t.rodata_near -DFLAG=RODATA_NEAR
+# RUN: llvm-readobj -S --file-headers %t.rodata_near | FileCheck --check-prefixes=ALL,RODATA_NEAR %s
+
+# RUN: yaml2obj %s -o %t.rodata_far -DFLAG=RODATA_FAR
+# RUN: llvm-readobj -S --file-headers %t.rodata_far | FileCheck --check-prefixes=ALL,RODATA_FAR %s
+
+# ALL:  Flags [
+# FU_EXIST:  EF_RL78_FU_EXIST (0x1)
+# EI_EXIST:  EF_RL78_EI_EXIST (0x8)
+# MAA_0:  EF_RL78_MAA_0 (0x40)
+# MAA_1:  EF_RL78_MAA_1 (0xC0)
+# CPU_8BIT:  EF_RL78_CPU_8BIT (0x100)
+# CPU_16BIT:  EF_RL78_CPU_16BIT (0x300)
+# DOUBLE_4:  EF_RL78_DOUBLE_4 (0x400)
+# DOUBLE_8:  EF_RL78_DOUBLE_8 (0xC00)
+# TEXT_NEAR:  EF_RL78_TEXT_NEAR (0x1000)
+# TEXT_FAR:  EF_RL78_TEXT_FAR (0x3000)
+# DATA_NEAR:  EF_RL78_DATA_NEAR (0x4000)
+# DATA_FAR:  EF_RL78_DATA_FAR (0xC000)
+# RODATA_NEAR:  EF_RL78_RODATA_NEAR (0x10000)
+# RODATA_FAR:  EF_RL78_RODATA_FAR (0x30000)
+# ALL:  ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_RL78
+  Flags:   [ EF_RL78_[[FLAG]] ]

llvm/tools/llvm-readobj/ELFDumper.cpp

 };
 
 static const EnumEntry<unsigned> ElfHeaderXtensaFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, EF_XTENSA_MACH_NONE),
   LLVM_READOBJ_ENUM_ENT(ELF, EF_XTENSA_XT_INSN),
   LLVM_READOBJ_ENUM_ENT(ELF, EF_XTENSA_XT_LIT)
 };
 
+const EnumEntry<unsigned> ElfHeaderRL78Flags[] = {
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_FU_EXIST),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_EI_EXIST),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_MAA_1),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_MAA_0),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_CPU_16BIT),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_CPU_8BIT),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_DOUBLE_8),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_DOUBLE_4),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_TEXT_FAR),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_TEXT_NEAR),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_DATA_FAR),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_DATA_NEAR),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_RODATA_FAR),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_RL78_RODATA_NEAR)
+};
+
 const EnumEntry<unsigned> ElfSymOtherFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, STV_INTERNAL),
   LLVM_READOBJ_ENUM_ENT(ELF, STV_HIDDEN),
   LLVM_READOBJ_ENUM_ENT(ELF, STV_PROTECTED)
 };
 
 const EnumEntry<unsigned> ElfMipsSymOtherFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL),
ElfFlags = printFlags(e.e_flags, ArrayRef(ElfHeaderAVRFlags),
                           unsigned(ELF::EF_AVR_ARCH_MASK));
   else if (e.e_machine == EM_LOONGARCH)
     ElfFlags = printFlags(e.e_flags, ArrayRef(ElfHeaderLoongArchFlags),
                           unsigned(ELF::EF_LOONGARCH_ABI_MODIFIER_MASK),
                           unsigned(ELF::EF_LOONGARCH_OBJABI_MASK));
   else if (e.e_machine == EM_XTENSA)
     ElfFlags = printFlags(e.e_flags, ArrayRef(ElfHeaderXtensaFlags),
                           unsigned(ELF::EF_XTENSA_MACH));
+  else if (e.e_machine == EM_RL78)
+    ElfFlags = printFlags(e.e_flags, ArrayRef(ElfHeaderRL78Flags),
+                          unsigned(ELF::EF_RL78_MASK));
   Str = "0x" + utohexstr(e.e_flags);
   if (!ElfFlags.empty())
     Str = Str + ", " + ElfFlags;
   printFields(OS, "Flags:", Str);
   Str = to_string(e.e_ehsize) + " (bytes)";
   printFields(OS, "Size of this header:", Str);
   Str = to_string(e.e_phentsize) + " (bytes)";
   printFields(OS, "Size of program headers:", Str);
else if (E.e_machine == EM_AVR)
                    unsigned(ELF::EF_AVR_ARCH_MASK));
     else if (E.e_machine == EM_LOONGARCH)
       W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderLoongArchFlags),
                    unsigned(ELF::EF_LOONGARCH_ABI_MODIFIER_MASK),
                    unsigned(ELF::EF_LOONGARCH_OBJABI_MASK));
     else if (E.e_machine == EM_XTENSA)
       W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderXtensaFlags),
                    unsigned(ELF::EF_XTENSA_MACH));
+    else if (E.e_machine == EM_RL78)
+      W.printFlags("Flags", E.e_flags, ArrayRef(ElfHeaderRL78Flags),
+                   unsigned(ELF::EF_RL78_MASK));
     else
       W.printFlags("Flags", E.e_flags);
     W.printNumber("HeaderSize", E.e_ehsize);
     W.printNumber("ProgramHeaderEntrySize", E.e_phentsize);
     W.printNumber("ProgramHeaderCount", E.e_phnum);
     W.printNumber("SectionHeaderEntrySize", E.e_shentsize);
     W.printString("SectionHeaderCount",
                   getSectionHeadersNumString(this->Obj, this->FileName));

llvm/unittests/Object/ELFObjectFileTest.cpp

 
 TEST(ELFObjectFileTest, MachineTestForXtensa) {
   std::array<StringRef, 4> Formats = {"elf32-xtensa", "elf32-xtensa",
                                       "elf64-unknown", "elf64-unknown"};
   for (auto [Idx, Data] : enumerate(generateData(ELF::EM_XTENSA)))
     checkFormatAndArch(Data, Formats[Idx], Triple::xtensa);
 }
 
+TEST(ELFObjectFileTest, MachineTestForRL78) {
+  std::array<StringRef, 4> Formats = {"elf32-rl78", "elf32-rl78",
+                                      "elf64-unknown", "elf64-unknown"};
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_RL78)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::rl78);
+}
+
 // ELF relative relocation type test.
 TEST(ELFObjectFileTest, RelativeRelocationTypeTest) {
   EXPECT_EQ(ELF::R_CKCORE_RELATIVE, getELFRelativeRelocationType(ELF::EM_CSKY));
 }
 
 template <class ELFT>
 static Expected<ELFObjectFile<ELFT>> toBinary(SmallVectorImpl<char> &Storage,
                                               StringRef Yaml) {