[lanai] Add ELF enum value and relocations

[jpienaar]

Summary

Add ELF enum value and relocations for Lanai backed.

General Lanai backend discussion on llvm-dev thread "[RFC] Lanai backend" (http://lists.llvm.org/pipermail/llvm-dev/2016-February/095118.html).

[jyknight]

include/llvm/MC/MCExpr.h

294 ↗

(On Diff #47270)

It looks like half the backends put target specific expr kinds in a subclass of MCTargetExpr, instead of in here. I'm not sure, but maybe that's the way you're supposed to do it now?

include/llvm/Object/RelocVisitor.h

324 ↗

(On Diff #47270)

No call to getELFAddend needed here?

lib/MC/MCExpr.cpp

316 ↗

(On Diff #47270)

This, in particular, seems an unfortunate consequence of not using a LanaiMCExpr: a very generic name, assigned a target-specific variant.

[jpienaar]

Moved MCExpr changes to subclass of MCTargetExpr and use that instead in the backend.

[jpienaar]

Good suggestion on subclassing instead.

[eliben]

include/llvm/Support/ELFRelocs/Lanai.def

6 ↗

(On Diff #47463)

Would this be a good place for a few lines of comments explaining each relocation type?

[jpienaar]

include/llvm/Support/ELFRelocs/Lanai.def

6 ↗

(On Diff #47463)

Looking at the other backends, the relocation types are not normally documented in ELFRelocs/X.def. Rather the explanation of relocation types is commonly done in lib/Target/X/MCTargetDesc/XFixupKinds.h.

[echristo]

One inline comment. Are there any more testcases to test RelocToApply, readobj, etc?

-eric

include/llvm/Support/ELF.h

322 ↗

(On Diff #47463)

Add the extra comma at the end here...

[t.p.northover]

include/llvm/Object/RelocVisitor.h

323 ↗

(On Diff #47463)

What's the user of this function? It appears to be untested.

include/llvm/Support/ELFRelocs/Lanai.def

6 ↗

(On Diff #47463)

Fixups aren't usually in 1-1 correspondence with relocations. Normally relocs are documented in a platform's ABI document, but I Lanai's intending to do it in-tree isn't it?

If so, this file looks like a reasonable place since they're all together here.

test/Object/Lanai/yaml2obj-elf-lanai-rel.yaml

6 ↗

(On Diff #47463)

The other relocs should probably be tested too. It'd be good to test the actual numbers as well, if Lanai has any ABI stability expectations.

[jpienaar]

Addressed comments, added readobj and dwarfdump tests.

[jpienaar]

Updated, thanks

include/llvm/Object/RelocVisitor.h

323 ↗

(On Diff #47463)

It is used by dwarfdump. Adding test for it.

[t.p.northover]

Thanks, this looks fine now.

Tim.

[jpienaar]

Thanks, if none of the other reviewers have an objection, I'll submit this tomorrow.

[echristo]

It's good. Go ahead. :)

llvm/trunk/include/llvm/Object/ELFObjectFile.h

case ELF::ELFCLASS32:
     case ELF::EM_X86_64:
       return "ELF32-x86-64";
     case ELF::EM_ARM:
       return (IsLittleEndian ? "ELF32-arm-little" : "ELF32-arm-big");
     case ELF::EM_AVR:
       return "ELF32-avr";
     case ELF::EM_HEXAGON:
       return "ELF32-hexagon";
+    case ELF::EM_LANAI:
+      return "ELF32-lanai";
     case ELF::EM_MIPS:
       return "ELF32-mips";
     case ELF::EM_PPC:
       return "ELF32-ppc";
     case ELF::EM_SPARC:
     case ELF::EM_SPARC32PLUS:
       return "ELF32-sparc";
     case ELF::EM_WEBASSEMBLY:
unsigned ELFObjectFile<ELFT>::getArch() const {
   case ELF::EM_AARCH64:
     return Triple::aarch64;
   case ELF::EM_ARM:
     return Triple::arm;
   case ELF::EM_AVR:
     return Triple::avr;
   case ELF::EM_HEXAGON:
     return Triple::hexagon;
+  case ELF::EM_LANAI:
+    return Triple::lanai;
   case ELF::EM_MIPS:
     switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
     case ELF::ELFCLASS32:
       return IsLittleEndian ? Triple::mipsel : Triple::mips;
     case ELF::ELFCLASS64:
       return IsLittleEndian ? Triple::mips64el : Triple::mips64;
     default:
       report_fatal_error("Invalid ELFCLASS!");

llvm/trunk/include/llvm/Object/RelocVisitor.h

if (ObjToVisit.getBytesInAddress() == 8) { // 64-bit object file
       case Triple::armeb:
         switch (RelocType) {
         default:
           HasError = true;
           return RelocToApply();
         case llvm::ELF::R_ARM_ABS32:
           return visitELF_ARM_ABS32(R, Value);
         }
+      case Triple::lanai:
+        switch (RelocType) {
+        case llvm::ELF::R_LANAI_32:
+          return visitELF_Lanai_32(R, Value);
+        default:
+          HasError = true;
+          return RelocToApply();
+        }
       case Triple::mipsel:
       case Triple::mips:
         switch (RelocType) {
         case llvm::ELF::R_MIPS_32:
           return visitELF_MIPS_32(R, Value);
         default:
           HasError = true;
           return RelocToApply();
private:
 
   /// PPC32 ELF
   RelocToApply visitELF_PPC_ADDR32(RelocationRef R, uint64_t Value) {
     int64_t Addend = getELFAddend(R);
     uint32_t Res = (Value + Addend) & 0xFFFFFFFF;
     return RelocToApply(Res, 4);
   }
 
+  /// Lanai ELF
+  RelocToApply visitELF_Lanai_32(RelocationRef R, uint64_t Value) {
+    int64_t Addend = getELFAddend(R);
+    uint32_t Res = (Value + Addend) & 0xFFFFFFFF;
+    return RelocToApply(Res, 4);
+  }
+
   /// MIPS ELF
   RelocToApply visitELF_MIPS_32(RelocationRef R, uint64_t Value) {
     uint32_t Res = Value & 0xFFFFFFFF;
     return RelocToApply(Res, 4);
   }
 
   /// MIPS64 ELF
   RelocToApply visitELF_MIPS64_32(RelocationRef R, uint64_t Value) {

llvm/trunk/include/llvm/Support/ELF.h

enum {
   EM_NORC          = 218, // Nanoradio Optimized RISC
   EM_CSR_KALIMBA   = 219, // CSR Kalimba architecture family
   EM_AMDGPU        = 224, // AMD GPU architecture
 
   // A request has been made to the maintainer of the official registry for
   // such numbers for an official value for WebAssembly. As soon as one is
   // allocated, this enum will be updated to use it.
   EM_WEBASSEMBLY   = 0x4157, // WebAssembly architecture
+
+  // A request has been made to the maintainer of the official registry for
+  // an official value for Lanai. As soon as one is allocated, this enum will be
+  // updated to use it.
+  EM_LANAI         = 0x8123, // Lanai 32-bit processor
 };
 
 // Object file classes.
 enum {
   ELFCLASSNONE = 0,
   ELFCLASS32 = 1, // 32-bit object file
   ELFCLASS64 = 2  // 64-bit object file
 };
enum {
   SHN_HEXAGON_SCOMMON_8   = 0xff04        // Double-word-size access
 };
 
 // ELF Relocation types for Hexagon
 enum {
 #include "ELFRelocs/Hexagon.def"
 };
 
+// ELF Relocation type for Lanai.
+enum {
+#include "ELFRelocs/Lanai.def"
+};
+
 // ELF Relocation types for S390/zSeries
 enum {
 #include "ELFRelocs/SystemZ.def"
 };
 
 // ELF Relocation type for Sparc.
 enum {
 #include "ELFRelocs/Sparc.def"

llvm/trunk/include/llvm/Support/ELFRelocs/Lanai.def

+
+#ifndef ELF_RELOC
+#error "ELF_RELOC must be defined"
+#endif
+
+// No relocation
+ELF_RELOC(R_LANAI_NONE,        0)
+// 21-bit symbol relocation
+ELF_RELOC(R_LANAI_21,          1)
+// 21-bit symbol relocation with last two bits masked to 0
+ELF_RELOC(R_LANAI_21_F,        2)
+// 25-bit branch targets
+ELF_RELOC(R_LANAI_25,          3)
+// General 32-bit relocation
+ELF_RELOC(R_LANAI_32,          4)
+// Upper 16-bits of a symbolic relocation
+ELF_RELOC(R_LANAI_HI16,        5)
+// Lower 16-bits of a symbolic relocation
+ELF_RELOC(R_LANAI_LO16,        6)

llvm/trunk/lib/MC/MCObjectFileInfo.cpp

if (RelocM == Reloc::PIC_) {
       TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
         dwarf::DW_EH_PE_sdata8;
     } else {
       PersonalityEncoding = dwarf::DW_EH_PE_absptr;
       LSDAEncoding = dwarf::DW_EH_PE_absptr;
       TTypeEncoding = dwarf::DW_EH_PE_absptr;
     }
     break;
+  case Triple::lanai:
+    LSDAEncoding = dwarf::DW_EH_PE_absptr;
+    PersonalityEncoding = dwarf::DW_EH_PE_absptr;
+    TTypeEncoding = dwarf::DW_EH_PE_absptr;
+    break;
   case Triple::mips:
   case Triple::mipsel:
   case Triple::mips64:
   case Triple::mips64el:
     // MIPS uses indirect pointer to refer personality functions and types, so
     // that the eh_frame section can be read-only. DW.ref.personality will be
     // generated for relocation.
     PersonalityEncoding = dwarf::DW_EH_PE_indirect;

llvm/trunk/lib/Object/ELF.cpp

#include "llvm/Support/ELFRelocs/ARM.def"
     break;
   case ELF::EM_HEXAGON:
     switch (Type) {
 #include "llvm/Support/ELFRelocs/Hexagon.def"
     default:
       break;
     }
     break;
+  case ELF::EM_LANAI:
+    switch (Type) {
+#include "llvm/Support/ELFRelocs/Lanai.def"
+    default:
+      break;
+    }
+    break;
   case ELF::EM_PPC:
     switch (Type) {
 #include "llvm/Support/ELFRelocs/PowerPC.def"
     default:
       break;
     }
     break;
   case ELF::EM_PPC64:

llvm/trunk/test/DebugInfo/Lanai/lit.local.cfg

+if not 'Lanai' in config.root.targets:
+    config.unsupported = True

llvm/trunk/test/DebugInfo/Lanai/processes-relocations.ll

+; RUN: llvm-dwarfdump %p/Inputs/lanai-processes-relocations.elf 2>&1 | FileCheck %s
+
+; FIXME: Use llc with this file as input instead of binary file.
+; NOTE: this test is currently not using llc, but using a binary input as the
+; rest of the backend is not yet in tree. Once the Lanai backend is in tree,
+; the binary file will be removed and this test will use llc.
+
+; CHECK-NOT: failed to compute relocation
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4}
+!llvm.ident = !{!5}
+
+!0 = !{i32 786449, !1, i32 12, !"clang version 3.6.0 ", i1 false, !"", i32 0, !2, !2, !2, !2, !2, !"", i32 1} ; [ DW_TAG_compile_unit ] [/a/empty.c] [DW_LANG_C99]
+!1 = !{!"empty.c", !"/a"}
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{!"clang version 3.6.0 "}

llvm/trunk/test/Object/Lanai/lit.local.cfg

+if not 'Lanai' in config.root.targets:
+    config.unsupported = True

llvm/trunk/test/Object/Lanai/yaml2obj-elf-lanai-rel.yaml

+# RUN: yaml2obj -format=elf %s > %t
+# RUN: llvm-readobj -r %t | FileCheck %s
+
+# CHECK     : Relocations [
+# CHECK-NEXT:   Section (2) .rel.text {
+# CHECK-NEXT:     0x0 R_LANAI_32 main 0x0
+# CHECK-NEXT:     0x4 R_LANAI_NONE - 0x0
+# CHECK-NEXT:     0x8 R_LANAI_21 - 0x0
+# CHECK-NEXT:     0xC R_LANAI_21_F - 0x0
+# CHECK-NEXT:     0x10 R_LANAI_25 - 0x0
+# CHECK-NEXT:     0x14 R_LANAI_HI16 - 0x0
+# CHECK-NEXT:     0x18 R_LANAI_LO16 - 0x0
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_LANAI
+Sections:
+  - Type:            SHT_PROGBITS
+    Name:            .text
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x04
+    Content:         0000000000000000
+  - Type:            SHT_REL
+    Name:            .rel.text
+    Link:            .symtab
+    Info:            .text
+    AddressAlign:    0x04
+    Relocations:
+      - Offset:          0x0
+        Symbol:          main
+        Type:            R_LANAI_32
+      - Offset:          0x4
+        Symbol:          a
+        Type:            R_LANAI_NONE
+      - Offset:          0x8
+        Symbol:          b
+        Type:            R_LANAI_21
+      - Offset:          0xC
+        Symbol:          c
+        Type:            R_LANAI_21_F
+      - Offset:          0x10
+        Symbol:          d
+        Type:            R_LANAI_25
+      - Offset:          0x14
+        Symbol:          e
+        Type:            R_LANAI_HI16
+      - Offset:          0x18
+        Symbol:          f
+        Type:            R_LANAI_LO16
+
+
+Symbols:
+  Local:
+    - Name:            .text
+      Type:            STT_SECTION
+      Section:         .text
+
+  Global:
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+      Size:            0x08

llvm/trunk/test/tools/llvm-readobj/Inputs/relocs.py

class Relocs_Elf_Hexagon(Enum):
   R_HEX_IE_16_X           =  79
   R_HEX_IE_GOT_32_6_X     =  80
   R_HEX_IE_GOT_16_X       =  81
   R_HEX_IE_GOT_11_X       =  82
   R_HEX_TPREL_32_6_X      =  83
   R_HEX_TPREL_16_X        =  84
   R_HEX_TPREL_11_X        =  85
 
+class Relocs_Elf_Lanai(Enum):
+  R_LANAI_NONE = 0
+  R_LANAI_21   = 1
+  R_LANAI_21_F = 2
+  R_LANAI_25   = 3
+  R_LANAI_32   = 4
+  R_LANAI_HI16 = 5
+  R_LANAI_LO16 = 6
 
 class Relocs_Coff_i386(Enum):
   IMAGE_REL_I386_ABSOLUTE = 0x0000
   IMAGE_REL_I386_DIR16    = 0x0001
   IMAGE_REL_I386_REL16    = 0x0002
   IMAGE_REL_I386_DIR32    = 0x0006
   IMAGE_REL_I386_DIR32NB  = 0x0007
   IMAGE_REL_I386_SEG12    = 0x0009

 #craftElf("relocs-elf-ppc32",   "powerpc-unknown-linux-gnu",   Relocs_Elf_PPC32.entries(), ...)
 craftElf("relocs.obj.elf-ppc64",   "powerpc64-unknown-linux-gnu", Relocs_Elf_PPC64.entries(),
          ("@t = thread_local global i32 0, align 4", "define i32* @f{0}() nounwind {{ ret i32* @t }}", 2))
 craftElf("relocs.obj.elf-aarch64",  "aarch64",                     Relocs_Elf_AArch64.entries(), "movz x0, #:abs_g0:sym")
 craftElf("relocs.obj.elf-arm",      "arm-unknown-unknown",         Relocs_Elf_ARM.entries(), "b sym")
 craftElf("relocs.obj.elf-mips",     "mips-unknown-linux",          Relocs_Elf_Mips.entries(), "lui $2, %hi(sym)")
 craftElf("relocs.obj.elf-mips64el", "mips64el-unknown-linux",        Relocs_Elf_Mips.entries(), "lui $2, %hi(sym)")
 #craftElf("relocs.obj.elf-hexagon",  "hexagon-unknown-unknown",     Relocs_Elf_Hexagon.entries(), ...)
+#craftElf("relocs.obj.elf-lanai",   "lanai-unknown-unknown",   Relocs_Elf_Lanai.entries(), "mov hi(x), %r4")
 
 craftCoff("relocs.obj.coff-i386",   "i386-pc-win32",   Relocs_Coff_i386.entries(),   "mov foo@imgrel(%ebx, %ecx, 4), %eax")
 craftCoff("relocs.obj.coff-x86_64", "x86_64-pc-win32", Relocs_Coff_X86_64.entries(), "mov foo@imgrel(%ebx, %ecx, 4), %eax")
 #craftCoff("relocs.obj.coff-arm",    "arm-pc-win32",    Relocs_Coff_ARM.entries(), "...")
 
 craftMacho("relocs.obj.macho-i386",   "i386-apple-darwin9", Relocs_Macho_i386.entries(),
           ("asm", ".subsections_via_symbols; .text; a: ; b:", "call a", 1))
 craftMacho("relocs.obj.macho-x86_64", "x86_64-apple-darwin9", Relocs_Macho_X86_64.entries(),
           ("asm", ".subsections_via_symbols; .text; a: ; b:", "call a", 1))
 craftMacho("relocs.obj.macho-arm",    "armv7-apple-darwin10", Relocs_Macho_ARM.entries(), "bl sym")
 #craftMacho("relocs.obj.macho-ppc",   "powerpc-apple-darwin10", Relocs_Macho_PPC.entries(), ...)

llvm/trunk/test/tools/llvm-readobj/file-headers.test

 RUN: llvm-readobj -h %p/Inputs/trivial.obj.macho-ppc64 \
 RUN:   | FileCheck %s -check-prefix MACHO-PPC64
 RUN: llvm-readobj -h %p/Inputs/trivial.obj.macho-arm \
 RUN:   | FileCheck %s -check-prefix MACHO-ARM
 RUN: llvm-readobj -h %p/Inputs/magic.coff-unknown \
 RUN:   | FileCheck %s -check-prefix COFF-UNKNOWN
 RUN: llvm-readobj -h %p/Inputs/magic.coff-importlib \
 RUN:   | FileCheck %s -check-prefix COFF-IMPORTLIB
+RUN: llvm-readobj -h %p/Inputs/trivial.obj.elf-lanai \
+RUN:   | FileCheck %s -check-prefix ELF-LANAI
 
 COFF-ARM:      File: {{(.*[/\\])?}}trivial.obj.coff-arm
 COFF-ARM-NEXT: Format: COFF-ARM
 COFF-ARM-NEXT: Arch: thumb
 COFF-ARM-NEXT: AddressSize: 32bit
 COFF-ARM-NEXT: ImageFileHeader {
 COFF-ARM-NEXT:   Machine: IMAGE_FILE_MACHINE_ARMNT (0x1C4)
 COFF-ARM-NEXT:   SectionCount: 2

 COFF-UNKNOWN-NEXT:   ]
 COFF-UNKNOWN-NEXT: }
 
 COFF-IMPORTLIB:      Format: COFF-import-file
 COFF-IMPORTLIB-NEXT: Type: code
 COFF-IMPORTLIB-NEXT: Name type: noprefix
 COFF-IMPORTLIB-NEXT: Symbol: __imp__func
 COFF-IMPORTLIB-NEXT: Symbol: _func
+
+ELF-LANAI:      Format: ELF32-lanai
+ELF-LANAI-NEXT: Arch: lanai
+ELF-LANAI-NEXT: AddressSize: 32bit
+ELF-LANAI-NEXT: LoadName:
+ELF-LANAI-NEXT: ElfHeader {
+ELF-LANAI-NEXT:   Ident {
+ELF-LANAI-NEXT:     Magic: (7F 45 4C 46)
+ELF-LANAI-NEXT:     Class: 32-bit (0x1)
+ELF-LANAI-NEXT:     DataEncoding: BigEndian (0x2)
+ELF-LANAI-NEXT:     FileVersion: 1
+ELF-LANAI-NEXT:     OS/ABI: SystemV (0x0)
+ELF-LANAI-NEXT:     ABIVersion: 0
+ELF-LANAI-NEXT:     Unused: (00 00 00 00 00 00 00)
+ELF-LANAI-NEXT:   }
+ELF-LANAI-NEXT:   Type: Relocatable (0x1)
+ELF-LANAI-NEXT:   Machine: EM_LANAI (0x8123)
+ELF-LANAI-NEXT:   Version: 1
+ELF-LANAI-NEXT:   Entry: 0x0
+ELF-LANAI-NEXT:   ProgramHeaderOffset: 0x0
+ELF-LANAI-NEXT:   SectionHeaderOffset: 0x1A0
+ELF-LANAI-NEXT:   Flags [ (0x0)
+ELF-LANAI-NEXT:   ]
+ELF-LANAI-NEXT:   HeaderSize: 52
+ELF-LANAI-NEXT:   ProgramHeaderEntrySize: 0
+ELF-LANAI-NEXT:   ProgramHeaderCount: 0
+ELF-LANAI-NEXT:   SectionHeaderEntrySize: 40
+ELF-LANAI-NEXT:   SectionHeaderCount: 8
+ELF-LANAI-NEXT:   StringTableSectionIndex: 1
+ELF-LANAI-NEXT: }

llvm/trunk/test/tools/llvm-readobj/reloc-types.test

 // Test that libObject and subsequently llvm-readobj shows proper relocation type
 // names and values.
 
 // Todo: ELF-PPC, ELF-HEXAGON
 
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.elf-i386     | FileCheck %s -check-prefix ELF-32
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.elf-x86_64   | FileCheck %s -check-prefix ELF-64
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.elf-aarch64  | FileCheck %s -check-prefix ELF-AARCH64
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.elf-arm      | FileCheck %s -check-prefix ELF-ARM
+RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.elf-lanai    | FileCheck %s -check-prefix ELF-LANAI
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.elf-mips     | FileCheck %s -check-prefix ELF-MIPS
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.elf-mips64el | FileCheck %s -check-prefix ELF-MIPS64EL
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.elf-ppc64    | FileCheck %s -check-prefix ELF-PPC64
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.coff-i386    | FileCheck %s -check-prefix COFF-32
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.coff-x86_64  | FileCheck %s -check-prefix COFF-64
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.macho-arm    | FileCheck %s -check-prefix MACHO-ARM
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.macho-i386   | FileCheck %s -check-prefix MACHO-32
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/relocs.obj.macho-x86_64 | FileCheck %s -check-prefix MACHO-64

 ELF-ARM: Type: R_ARM_PRIVATE_13 (125)
 ELF-ARM: Type: R_ARM_PRIVATE_14 (126)
 ELF-ARM: Type: R_ARM_PRIVATE_15 (127)
 ELF-ARM: Type: R_ARM_ME_TOO (128)
 ELF-ARM: Type: R_ARM_THM_TLS_DESCSEQ16 (129)
 ELF-ARM: Type: R_ARM_THM_TLS_DESCSEQ32 (130)
 ELF-ARM: Type: R_ARM_IRELATIVE (160)
 
+ELF-LANAI: Type: R_LANAI_NONE (0)
+ELF-LANAI: Type: R_LANAI_21 (1)
+ELF-LANAI: Type: R_LANAI_21_F (2)
+ELF-LANAI: Type: R_LANAI_25 (3)
+ELF-LANAI: Type: R_LANAI_32 (4)
+ELF-LANAI: Type: R_LANAI_HI16 (5)
+ELF-LANAI: Type: R_LANAI_LO16 (6)
+
 ELF-MIPS: Type: R_MIPS_NONE (0)
 ELF-MIPS: Type: R_MIPS_16 (1)
 ELF-MIPS: Type: R_MIPS_32 (2)
 ELF-MIPS: Type: R_MIPS_REL32 (3)
 ELF-MIPS: Type: R_MIPS_26 (4)
 ELF-MIPS: Type: R_MIPS_HI16 (5)
 ELF-MIPS: Type: R_MIPS_LO16 (6)
 ELF-MIPS: Type: R_MIPS_GPREL16 (7)

llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp

case ELF::R_X86_64_64: {
       fmt << Target << (addend < 0 ? "" : "+") << addend;
       fmt.flush();
       Result.append(fmtbuf.begin(), fmtbuf.end());
     } break;
     default:
       res = "Unknown";
     }
     break;
+  case ELF::EM_LANAI:
   case ELF::EM_AARCH64: {
     std::string fmtbuf;
     raw_string_ostream fmt(fmtbuf);
     fmt << Target;
     if (addend != 0)
       fmt << (addend < 0 ? "" : "+") << addend;
     fmt.flush();
     Result.append(fmtbuf.begin(), fmtbuf.end());

llvm/trunk/tools/llvm-readobj/ELFDumper.cpp

static const EnumEntry<unsigned> ElfMachineType[] = {
   ENUM_ENT(EM_COREA_2ND,     "EM_COREA_2ND"),
   ENUM_ENT(EM_ARC_COMPACT2,  "EM_ARC_COMPACT2"),
   ENUM_ENT(EM_OPEN8,         "EM_OPEN8"),
   ENUM_ENT(EM_RL78,          "Renesas RL78"),
   ENUM_ENT(EM_VIDEOCORE5,    "Broadcom VideoCore V processor"),
   ENUM_ENT(EM_78KOR,         "EM_78KOR"),
   ENUM_ENT(EM_56800EX,       "EM_56800EX"),
   ENUM_ENT(EM_AMDGPU,        "EM_AMDGPU"),
-  ENUM_ENT(EM_WEBASSEMBLY,   "EM_WEBASSEMBLY")
+  ENUM_ENT(EM_WEBASSEMBLY,   "EM_WEBASSEMBLY"),
+  ENUM_ENT(EM_LANAI,         "EM_LANAI"),
 };
 
 static const EnumEntry<unsigned> ElfSymbolBindings[] = {
     {"Local",  "LOCAL",  ELF::STB_LOCAL},
     {"Global", "GLOBAL", ELF::STB_GLOBAL},
     {"Weak",   "WEAK",   ELF::STB_WEAK},
     {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}};