[Xtensa 2/10] Add Xtensa ELF definitions.

[andreisfr]

Summary

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

[appcs]

llvm/include/llvm/BinaryFormat/ELF.h

863

Typo? (Just making sure it isn't).

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

12

Just making sure a '7' RELOC is not missing.

[andreisfr]

llvm/include/llvm/BinaryFormat/ELF.h

863

I took as a basis naming conventions of the e_flags from binutils (binutils/include/elf/xtensa.h). There used similar names for the architecture mask and base machine architecture with only differenece in prefix (E_ or EF_).

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

12

It is missing also in binutils (binutils/include/elf/xtensa.h). So I left it as is.

[aykevl]

LGTM, but I know very little about the LLVM backend.
Also, I see that this patch lacks one change that are included by the very similar RISC-V patch: https://github.com/lowRISC/riscv-llvm/blob/master/0003-RISCV-Add-RISC-V-ELF-defines.patch, namely the equivalent of ElfHeaderRISCVFlags in ELFDumper.cpp. I don't know whether that has a reason but mentioning it just in case.

llvm/include/llvm/BinaryFormat/ELF.h

863

Looking at https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;a=blob;f=include/elf/msp430.h for comparison, they use EF_<arch>_MACH for the mask and E_<arch>_MACH_<sub> for what seems to be the sub-architecture. I see a very similar pattern for AVR. In both cases, LLVM still uses the EF_ prefix for the subarch.
For consistency with the other architectures in LLVM, it might be better to use something like EF_XTENSA_MACH_BASE. However, I have no idea why these constants are given these names in LLVM or binutils.

[MaskRay]

llvm/include/llvm/BinaryFormat/ELF.h

860

Use // as the rest of the file uses.

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

2

Add a test test/tools/llvm-readobj/reloc-types-elf-xtensa.test

llvm/test/Object/Xtensa/elf-flags.yaml

1 ↗

(On Diff #210194)

Delete this file. Add to test/Object/obj2yaml.test instead. You may follow the ELF-X86-64: yaml2obj+obj2yaml test.

llvm/test/Object/Xtensa/lit.local.cfg

3 ↗

(On Diff #210194)

Delete this file.

[andreisfr]

Patch is updated according to latest upstream version. The E_XTENSA_MACH_BASE symbol changed to EF_XTENSA_MACH_BASE.

[andreisfr]

Add Xtensa ELF relocations test. Move ELF flags test from "llvm/test/Object/Xtensa/" directory to test/Object/obj2yaml.test.

[andreisfr]

llvm/include/llvm/BinaryFormat/ELF.h

863

Changed E_XTENSA_MACH to EF_XTENSA_MACH_BASE

[jhenderson]

llvm/test/Object/obj2yaml.test

787

Rather than adding a pre-canned binary, use yaml2obj to generate a file.

llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-xtensa.test

1 ↗

(On Diff #243466)

No need for "elf" to be in the file name, since it's in the ELF subdirectory.

183 ↗

(On Diff #243466)

Delete extra blank line here.

[andreisfr]

Correction of the llvm/test/tools/ llvm-readobj/ELF/reloc-types-elf-xtensa.test file (renaming to reloc-types-xtensa.test, and also delete the empty line at the end of file).

[andreisfr]

llvm/test/Object/obj2yaml.test

787

You suggest to create separate obj2yaml test for Xtensa?
Or add Xtensa ELF header yaml description in current file? I'm bother that there is already X86 ELF yaml description in this file, so yaml2obj could produce wrong result while processing obj2yaml.test. As I'm understand that is a reason why tests foir all other architectures in this file use pre-canned binaries.

[jhenderson]

llvm/test/Object/obj2yaml.test

787

There is no risk in yaml2obj picking the wrong yaml block. You can use the --docnum=<index> switch to specify which one to use, where <index> indicates which doc to use (e.g. --docnum=1 for the first, --docnum=2 for the second etc). See various other examples in the llvm-readobj tests for how.

[andreisfr]

Correction of the llvm/test/Object/obj2yaml.test, now Xtensa test uses yaml2obj instead of pre-built binary trivial-object-test.elf-xtensa.

[andreisfr]

llvm/test/Object/obj2yaml.test

787

Now Xtensa test uses yaml2obj instead of pre-built binary

[jhenderson]

There should be an llvm-readobj test for the xtensa file header (machine type + flags).

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

2

(Not specific to your change, but I don't understand why .def files don't seem to have any licence information)

llvm/test/Object/obj2yaml.test

689

It looks weird to me seeing a difference in the inptut Flags and printed Flags. Is EF_XTENSA_MACH_BASE a marker (like SHT_LORESERVE etc) or an actual flag? If it's only a marker, we shouldn't dump it.

697

This should specify all EF_XTENSA flags, to show that they all work.

[andreisfr]

Change EF_XTENSA_MACH_BASE to EF_XTENSA_MACH_NONE, it seems this is closer to ELF flag naming style used for AMDGPU and MIPS.

[andreisfr]

Correct Xtensa ELF flag test

[andreisfr]

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

2

I also noticed that and I thought that this is some kind of coding style and decided to follow it.

llvm/test/Object/obj2yaml.test

689

The situation is that EF_XTENSA_MACH_NONE (EF_XTENSA_MACH_BASE) defines default architecture, this flag equals 0x00 and it printed even in case of empty input flags set. Similar situation can be observed in AMDGPU tests, for example in llvm\test\Object\AMDGPU\elf-header-flags-xnack.yaml flag EF_AMDGPU_MACH_NONE. But I added this flag for input flags in Xtensa test to avoid confusion.

697

Added rest Xtensa ELF flags

[jhenderson]

llvm/include/llvm/BinaryFormat/ELF.h

861

Just trying to understand this: is this a mask for some other information? Perhaps worth saying that in the comment above if so (e.g. "Four-bit Xtensa machine type mask").

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

12

Is there an xtensa specification anywhere?

llvm/test/Object/obj2yaml.test

689

it printed even in case of empty input flags set.

Is printed by what? GNU readelf?

I think not having it in the input flags would be fine, if this line is accompanied by a comment saying something like "As EF_XTENSA_MACH_NONE == 0, it is always printed."

[andreisfr]

Correction of comments and Xtensa ELF flags test.

[andreisfr]

llvm/include/llvm/BinaryFormat/ELF.h

861

Comment is corrected

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

12

There is some description of the Xtensa relocations in GNU Binutils ( in binutils/bfd/doc/bfd.info file and source code). As I understand most of ELF relocations for other architectures in LLVM are imported from binutils, so the same approach was used for Xtensa.

llvm/test/Object/obj2yaml.test

689

The EF_XTENSA_MACH_NONE removed from input flags and added comment which explains why EF_XTENSA_MACH_NONE is printed by obj2yaml.

[jhenderson]

llvm/test/Object/obj2yaml.test

689

You never answered this question:

Is printed by what? GNU readelf?

From what I piece together from the comments and flag names, EF_XTENSA_MACH_NONE is effectively saying "there are no other EF_XTENSA_MACH_* bits sets". Given that, I would expect to NOT see this flag in obj2yaml or llvm-readobj output, if any of the bits covered by the EF_XTENSA_MACH mask are set. This of course might require some extra logic.

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

3

for the Xtensa

6

Your comment says both llvm-readobj and llvm-readelf, but you only test one of those. As the code is generic, that's fine, but probably best to remove the llvm-readelf reference from the comment.

[andreisfr]

Correct relocations test for the Xtensa target

[andreisfr]

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

6

Corrected

[andreisfr]

llvm/test/Object/obj2yaml.test

689

The EF_XTENSA_MACH_NONE is printed only by obj2yaml and it is printed only in case when ((ELF_FLAGS & EF_XTENSA_MACH) == 0 ). I checked this situation using dummy architecture flag like (EF_XTENSA_ARCH_1 = 0x1) and verified that obj2yaml prints only EF_XTENSA_ARCH_1 without EF_XTENSA_MACH_NONE.

I'm not sure that we must add Xtensa ELF flags to llvm-readobj, because it seems that in ELFDumper.cpp only RISCV / AMDGPU / Mips ELF flags are processed.

[MaskRay]

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

6

Delete --expand-relocs and you will be able to use CHECK-NEXT: instead of CHECK:.

[jhenderson]

llvm/test/Object/obj2yaml.test

689

... and verified that obj2yaml prints only EF_XTENSA_ARCH_1 without EF_XTENSA_MACH_NONE.

Thanks.

I'm not sure that we must add Xtensa ELF flags to llvm-readobj, because it seems that in ELFDumper.cpp only RISCV / AMDGPU / Mips ELF flags are processed.

This seems like a circular argument to me. Surely it only supports those other flags, because Xtensa flags haven't been implemented in it yet?

FWIW, adding support should probably be a separate change, but please do implement that patch, as otherwise I consider this functionality incomplete.

[andreisfr]

Patch is updated according to latest upstream version. Added llvm-readobj test.

[andreisfr]

llvm/test/Object/obj2yaml.test

689

Added Xtensa ELF flags to llvm-readobj, also implemented test

llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-xtensa.test

183 ↗

(On Diff #243466)

Corrected

[andreisfr]

Patch is updated according to LLVM upstream version and latest Xtensa backend version.

[andreisfr]

llvm/test/Object/Xtensa/lit.local.cfg

3 ↗

(On Diff #210194)

I suggest to add llvm/test/Object/Xtensa/elf-header-flags.yaml and llvm/test/Object/Xtensa/li.local.cfg to test llvm-readobj. What is your opinion on this?

[jhenderson]

llvm/include/llvm/Object/ELFObjectFile.h

1204–1205

I don't see any testing for this here?

llvm/test/Object/Xtensa/elf-header-flags.yaml

1 ↗

(On Diff #328692)

Please add a comment to this file explaining what the test is testing.

4 ↗

(On Diff #329497)

You can avoid having a second YAML DOC by using yaml2obj's -D option, which allows you to define a variable. See other yaml2obj examples in various tests.

6 ↗

(On Diff #329497)

obj2yaml testing should be done in test\tools\obj2yaml. There's no need for it here too.

llvm/test/Object/Xtensa/lit.local.cfg

3 ↗

(On Diff #210194)

The ability to check the ELF flags does not require the Xtensa target to be enabled. You only need to mark such tests as unsupported if they actually do require the enabling of that target, otherwise more people won't run the tests and there's a higher chance they'll break due to somebody's change, without them noticing.

llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-xtensa.test

7 ↗

(On Diff #329497)

We normally add spaces to make the checked values line up neatly, as suggested inline.

1 ↗

(On Diff #243466)

"elf" is still in the file name. Please remove it.

[andreisfr]

Corrected according to review comments

[andreisfr]

llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-xtensa.test

1 ↗

(On Diff #243466)

I changed file name to reloc-types-xtensa.test

[andreisfr]

llvm/include/llvm/Object/ELFObjectFile.h

1204–1205

I added test to llvm/unittests/Object/ELFObjectFileTest.cpp

[andreisfr]

llvm/test/Object/Xtensa/elf-header-flags.yaml

6 ↗

(On Diff #329497)

I'm agree, probably obj2yaml testing of the ELF flags is even redundant because it already implemented in llvm/test/Object/obj2yaml.test.

@jhenderson I suggest to implement "llvm/test/tools/llvm-readobj/ELF/xtensa-elf-flags.test" test instead of "llvm/test/Object/Xtensa/elf-header-flags.yaml". What do you think about this?

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/xtensa-elf-flags.test

1 ↗

(On Diff #333474)

Rename this to xtensa-header-flags.test. This should hopefully make it clear that these are flags for the ELF header, without the redundant elf in the filename.

3–7 ↗

(On Diff #333474)

Use a different filename for the files. That way, if the test breaks, you can easily compare the two files. This is generally very useful for debugging.

I'd also drop ELF- from the prefixes, since they don't add any value.

I've suggested a possible name inline.

[andreisfr]

Corrected llvm-readobj test

[andreisfr]

llvm/test/tools/llvm-readobj/ELF/xtensa-elf-flags.test

1 ↗

(On Diff #333474)

File name is renamed to xtensa-header-flags.test.

3–7 ↗

(On Diff #333474)

Thank you for suggestions, I corrected this code in xtensa-header-flags.test

[jhenderson]

LGTM, with one test nit. You might want to give it a couple of days to see if any of the other reviewers have further comments to make.

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

10–13

No need for the extra indentation.

[MaskRay]

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

6

Don't use a space for macro calls.

[andreisfr]

Removed spaces in macro calls in Xtensa.def. Also removed extra indentation in xtensa-header-flags.test.

[andreisfr]

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

6

Corrected, also aligned right parentheses

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

10–13

Corrected

[jrtc27]

llvm/test/Object/obj2yaml.test

550

All other architectures put their input in a separate file to avoid this.

[jhenderson]

llvm/test/Object/obj2yaml.test

550

Are you referring to the yaml2obj line or the use of --docnum? All other files use pre-canned binaries, which are not ideal, as they are fixed and hard to inspect/understand/update. Using yaml2obj is generally preferable for creating objects at test time.

[jrtc27]

llvm/test/Object/obj2yaml.test

550

Oh you're right. Hm. --docnum=N for each architecture would start to get a bit silly though... I do wonder why we don't have one .test file for each architecture being tested, then you don't need to play --docnum or Inputs/foo.yaml games (and even for pre-canned binaries it keeps the tests nicely separated rather than having an 800-odd line file).

[andreisfr]

Patch is updated according to LLVM upstream version and latest Xtensa backend version.

[jhenderson]

Still looks good to me, but someone with Xtensa knowledge needs to approve to confirm the flags etc are correct.

llvm/test/Object/obj2yaml.test

550

That would be reasonable. I think it's a legacy of how this test was written. In fact, having an obj2yaml test inside the Object library tests is a bit weird - it should either be in ObjectYAML or more likely tools\obj2yaml. Feel free to tidy things up!

(Apologies, I wrote this commenet ages ago, but forgot to submit it).

[andreisfr]

Patch is updated according to LLVM upstream version

[saugustine]

OK with one minor change.

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

12

To the best of my knowledge Xtensa does not have a formal elf specification. They definitely didn't a in the years I worked there. The binutils implementation governed.

My recollection is very hazy almost twenty years later, but I believe 7 was used in some experiments during the original port and we later determined it wasn't useful. But by the time we removed it, the other assignments had already been made.

I think instead of leaving it unused and blank, we should use something like:

ELF_RELOC(R_XTENSA_RESERVED_7, 7)

which will better show that this isn't a mistake. and probably what we should have done originally.

[jrtc27]

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

12

I disagree, such constants achieve nothing, as nothing should be using them. Just put a comment if you want to make it clear it’s deliberately not assigned a name here.

[andreisfr]

Minor changes, added a comment to the Xtensa ELF relocations file.

[andreisfr]

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

12

Added comment about RELOC '7'

[jhenderson]

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

13

Nit: comments should end with full stops.

[andreisfr]

Corrected comment

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

13

Corrected

[sstefan1]

Hi everyone. Since this has been accepted for some time now, we're planning to commit this on Monday (December 16th). Please let us know if there is anything else we should address.

[andreisfr]

Updated according to latest changes in upstream source code

[MaskRay]

llvm/unittests/Object/ELFObjectFileTest.cpp

304

This can use llvm::enumerate, but it's ok to follow other tests.

[andreisfr]

Updated according to latest changes in upstream source code

llvm/include/llvm/BinaryFormat/ELF.h

 
 // ELF Relocation types for MSP430
 enum {
 #include "ELFRelocs/MSP430.def"
 };
 
 // ELF Relocation type for VE.
 enum {
 #include "ELFRelocs/VE.def"
 };
 
 
 // ELF Relocation types for CSKY
 enum {
 #include "ELFRelocs/CSKY.def"
 };
 
+// Xtensa specific e_flags
+enum : unsigned {
+  // Four-bit Xtensa machine type mask.
+  EF_XTENSA_MACH = 0x0000000f,
+  // Various CPU types.
+  EF_XTENSA_MACH_NONE = 0x00000000, // A base Xtensa implementation
+  EF_XTENSA_XT_INSN = 0x00000100,
+  EF_XTENSA_XT_LIT = 0x00000200,
+};
+
+// ELF Relocation types for Xtensa
+enum {
+#include "ELFRelocs/Xtensa.def"
+};
+
 #undef ELF_RELOC
 
 // Section header.
 struct Elf32_Shdr {
   Elf32_Word sh_name;      // Section name (index into string table)
   Elf32_Word sh_type;      // Section type (SHT_*)
   Elf32_Word sh_flags;     // Section flags (SHF_*)
   Elf32_Addr sh_addr;      // Address where section is to be loaded

llvm/include/llvm/BinaryFormat/ELFRelocs/Xtensa.def

+#ifndef ELF_RELOC
+#error "ELF_RELOC must be defined"
+#endif
+
+ELF_RELOC(R_XTENSA_NONE,              0)
+ELF_RELOC(R_XTENSA_32,                1)
+ELF_RELOC(R_XTENSA_RTLD,              2)
+ELF_RELOC(R_XTENSA_GLOB_DAT,          3)
+ELF_RELOC(R_XTENSA_JMP_SLOT,          4)
+ELF_RELOC(R_XTENSA_RELATIVE,          5)
+ELF_RELOC(R_XTENSA_PLT,               6)
+ELF_RELOC(R_XTENSA_OP0,               8)
+ELF_RELOC(R_XTENSA_OP1,               9)
+ELF_RELOC(R_XTENSA_OP2,              10)
+ELF_RELOC(R_XTENSA_ASM_EXPAND,       11)
+ELF_RELOC(R_XTENSA_ASM_SIMPLIFY,     12)
+ELF_RELOC(R_XTENSA_32_PCREL,         14)
+ELF_RELOC(R_XTENSA_GNU_VTINHERIT,    15)
+ELF_RELOC(R_XTENSA_GNU_VTENTRY,      16)
+ELF_RELOC(R_XTENSA_DIFF8,            17)
+ELF_RELOC(R_XTENSA_DIFF16,           18)
+ELF_RELOC(R_XTENSA_DIFF32,           19)
+ELF_RELOC(R_XTENSA_SLOT0_OP,         20)
+ELF_RELOC(R_XTENSA_SLOT1_OP,         21)
+ELF_RELOC(R_XTENSA_SLOT2_OP,         22)
+ELF_RELOC(R_XTENSA_SLOT3_OP,         23)
+ELF_RELOC(R_XTENSA_SLOT4_OP,         24)
+ELF_RELOC(R_XTENSA_SLOT5_OP,         25)
+ELF_RELOC(R_XTENSA_SLOT6_OP,         26)
+ELF_RELOC(R_XTENSA_SLOT7_OP,         27)
+ELF_RELOC(R_XTENSA_SLOT8_OP,         28)
+ELF_RELOC(R_XTENSA_SLOT9_OP,         29)
+ELF_RELOC(R_XTENSA_SLOT10_OP,        30)
+ELF_RELOC(R_XTENSA_SLOT11_OP,        31)
+ELF_RELOC(R_XTENSA_SLOT12_OP,        32)
+ELF_RELOC(R_XTENSA_SLOT13_OP,        33)
+ELF_RELOC(R_XTENSA_SLOT14_OP,        34)
+ELF_RELOC(R_XTENSA_SLOT0_ALT,        35)
+ELF_RELOC(R_XTENSA_SLOT1_ALT,        36)
+ELF_RELOC(R_XTENSA_SLOT2_ALT,        37)
+ELF_RELOC(R_XTENSA_SLOT3_ALT,        38)
+ELF_RELOC(R_XTENSA_SLOT4_ALT,        39)
+ELF_RELOC(R_XTENSA_SLOT5_ALT,        40)
+ELF_RELOC(R_XTENSA_SLOT6_ALT,        41)
+ELF_RELOC(R_XTENSA_SLOT7_ALT,        42)
+ELF_RELOC(R_XTENSA_SLOT8_ALT,        43)
+ELF_RELOC(R_XTENSA_SLOT9_ALT,        44)
+ELF_RELOC(R_XTENSA_SLOT10_ALT,       45)
+ELF_RELOC(R_XTENSA_SLOT11_ALT,       46)
+ELF_RELOC(R_XTENSA_SLOT12_ALT,       47)
+ELF_RELOC(R_XTENSA_SLOT13_ALT,       48)
+ELF_RELOC(R_XTENSA_SLOT14_ALT,       49)
+ELF_RELOC(R_XTENSA_TLSDESC_FN,       50)
+ELF_RELOC(R_XTENSA_TLSDESC_ARG,      51)
+ELF_RELOC(R_XTENSA_TLS_DTPOFF,       52)
+ELF_RELOC(R_XTENSA_TLS_TPOFF,        53)
+ELF_RELOC(R_XTENSA_TLS_FUNC,         54)
+ELF_RELOC(R_XTENSA_TLS_ARG,          55)
+ELF_RELOC(R_XTENSA_TLS_CALL,         56)

llvm/include/llvm/Object/ELFObjectFile.h

case ELF::EM_RISCV:
       return "elf32-littleriscv";
     case ELF::EM_CSKY:
       return "elf32-csky";
     case ELF::EM_SPARC:
     case ELF::EM_SPARC32PLUS:
       return "elf32-sparc";
     case ELF::EM_AMDGPU:
       return "elf32-amdgpu";
+    case ELF::EM_XTENSA:
+      return "elf32-xtensa";
     default:
       return "elf32-unknown";
     }
   case ELF::ELFCLASS64:
     switch (EF.getHeader().e_machine) {
     case ELF::EM_386:
       return "elf64-i386";
     case ELF::EM_X86_64:
template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
 
   case ELF::EM_BPF:
     return IsLittleEndian ? Triple::bpfel : Triple::bpfeb;
 
   case ELF::EM_VE:
     return Triple::ve;
   case ELF::EM_CSKY:
     return Triple::csky;
+  case ELF::EM_XTENSA:
+    return Triple::xtensa;
   default:
     return Triple::UnknownArch;
   }
 }
 
 template <class ELFT>
 Expected<uint64_t> ELFObjectFile<ELFT>::getStartAddress() const {
   return EF.getHeader().e_entry;

llvm/include/llvm/module.modulemap

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

llvm/lib/Object/ELF.cpp

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

llvm/lib/ObjectYAML/ELFYAML.cpp

#define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M)
   case ELF::EM_RISCV:
     BCase(EF_RISCV_RVC);
     BCaseMask(EF_RISCV_FLOAT_ABI_SOFT, EF_RISCV_FLOAT_ABI);
     BCaseMask(EF_RISCV_FLOAT_ABI_SINGLE, EF_RISCV_FLOAT_ABI);
     BCaseMask(EF_RISCV_FLOAT_ABI_DOUBLE, EF_RISCV_FLOAT_ABI);
     BCaseMask(EF_RISCV_FLOAT_ABI_QUAD, EF_RISCV_FLOAT_ABI);
     BCase(EF_RISCV_RVE);
     break;
+  case ELF::EM_XTENSA:
+    BCase(EF_XTENSA_XT_INSN);
+    BCaseMask(EF_XTENSA_MACH_NONE, EF_XTENSA_MACH);
+    BCase(EF_XTENSA_XT_LIT);
+    break;
   case ELF::EM_AMDGPU:
     BCaseMask(EF_AMDGPU_MACH_NONE, EF_AMDGPU_MACH);
     BCaseMask(EF_AMDGPU_MACH_R600_R600, EF_AMDGPU_MACH);
     BCaseMask(EF_AMDGPU_MACH_R600_R630, EF_AMDGPU_MACH);
     BCaseMask(EF_AMDGPU_MACH_R600_RS880, EF_AMDGPU_MACH);
     BCaseMask(EF_AMDGPU_MACH_R600_RV670, EF_AMDGPU_MACH);
     BCaseMask(EF_AMDGPU_MACH_R600_RV710, EF_AMDGPU_MACH);
     BCaseMask(EF_AMDGPU_MACH_R600_RV730, EF_AMDGPU_MACH);
case ELF::ELFABIVERSION_AMDGPU_HSA_V4:
       BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_ANY_V4,
                 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;
   default:
     break;
   }
 #undef BCase
 #undef BCaseMask
 }
 
 void ScalarEnumerationTraits<ELFYAML::ELF_SHT>::enumeration(

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

llvm/test/Object/obj2yaml.test

 # ELF-MIPS64EL-NEXT:       Section:         .MIPS.options
 # ELF-MIPS64EL-NEXT:     - Name:            .pdr
 # ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 # ELF-MIPS64EL-NEXT:       Section:         .pdr
 # ELF-MIPS64EL-NEXT:     - Name:            zed
 # ELF-MIPS64EL-NEXT:       Binding:         STB_GLOBAL
 # ELF-MIPS64EL-NEXT: ...
 
-# RUN: yaml2obj %s -o %t-x86-64
+# RUN: yaml2obj --docnum=1 %s -o %t-x86-64
 # RUN: obj2yaml %t-x86-64 | FileCheck %s --check-prefix ELF-X86-64
 
 # ELF-X86-64:      FileHeader:
 # ELF-X86-64-NEXT:   Class:           ELFCLASS64
 # ELF-X86-64-NEXT:   Data:            ELFDATA2LSB
 # ELF-X86-64-NEXT:   OSABI:           ELFOSABI_GNU
 # ELF-X86-64-NEXT:   Type:            ET_REL
 # ELF-X86-64-NEXT:   Machine:         EM_X86_64
- Name:    main
     Section: .text
     Binding: STB_GLOBAL
     Size:    0x26
   - Name:    SomeOtherFunction
     Binding: STB_GLOBAL
   - Name:    puts
     Binding: STB_GLOBAL
 
+# RUN: yaml2obj --docnum=2 %s -o %t-xtensa
+# RUN: obj2yaml %t-xtensa | FileCheck %s --check-prefix ELF-XTENSA
+
+# ELF-XTENSA:      FileHeader:
+# ELF-XTENSA-NEXT:   Class:           ELFCLASS32
+# ELF-XTENSA-NEXT:   Data:            ELFDATA2LSB
+# ELF-XTENSA-NEXT:   Type:            ET_EXEC
+# ELF-XTENSA-NEXT:   Machine:         EM_XTENSA
+## As EF_XTENSA_MACH_NONE == 0, it is always printed by obj2yaml.
+# ELF-XTENSA-NEXT:   Flags:           [ EF_XTENSA_XT_INSN, EF_XTENSA_MACH_NONE, EF_XTENSA_XT_LIT ]
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_XTENSA
+  Flags:           [ EF_XTENSA_XT_INSN, EF_XTENSA_XT_LIT ]
+
 # RUN: obj2yaml %p/Inputs/trivial-object-test.elf-avr | FileCheck %s --check-prefix ELF-AVR
 
 # ELF-AVR:      FileHeader:
 # ELF-AVR-NEXT:   Class:           ELFCLASS32
 # ELF-AVR-NEXT:   Data:            ELFDATA2LSB
 # ELF-AVR-NEXT:   Type:            ET_EXEC
 # ELF-AVR-NEXT:   Machine:         EM_AVR
 # ELF-AVR-NEXT:   Flags:           [ EF_AVR_ARCH_AVR2, EF_AVR_LINKRELAX_PREPARED ]

 # ELF-AVR-NEXT:       Section:         .data
 # ELF-AVR-NEXT:       Binding:         STB_GLOBAL
 # ELF-AVR-NEXT:       Value:           0x800060
 # ELF-AVR-NEXT:     - Name:            _end
 # ELF-AVR-NEXT:       Section:         .data
 # ELF-AVR-NEXT:       Binding:         STB_GLOBAL
 # ELF-AVR-NEXT:       Value:           0x800060
 
 # RUN: obj2yaml %p/Inputs/trivial-object-test.wasm | FileCheck %s --check-prefix WASM
 
 # WASM:      --- !WASM
 # WASM-NEXT: FileHeader:
 # WASM-NEXT:   Version:         0x1
 # WASM:        - Type:            CUSTOM
 # WASM-NEXT:     Name:            linking
 # WASM-NEXT:     Version:         2
 # WASM-NEXT:     SymbolTable:

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

+## Test that llvm-readobj shows proper relocation type
+## names and values for the Xtensa target.
+
+# RUN: yaml2obj %s -o %t-xtensa.o
+# RUN: llvm-readobj -r %t-xtensa.o | FileCheck %s
+
+# CHECK:      0x0 R_XTENSA_NONE - 0x0
+# CHECK-NEXT: 0x4 R_XTENSA_32 - 0x0
+# CHECK-NEXT: 0x8 R_XTENSA_RTLD - 0x0
+# CHECK-NEXT: 0xC R_XTENSA_GLOB_DAT - 0x0
+# CHECK-NEXT: 0x10 R_XTENSA_JMP_SLOT - 0x0
+# CHECK-NEXT: 0x14 R_XTENSA_RELATIVE - 0x0
+# CHECK-NEXT: 0x18 R_XTENSA_PLT - 0x0
+# CHECK-NEXT: 0x1C R_XTENSA_OP0 - 0x0
+# CHECK-NEXT: 0x20 R_XTENSA_OP1 - 0x0
+# CHECK-NEXT: 0x24 R_XTENSA_OP2 - 0x0
+# CHECK-NEXT: 0x28 R_XTENSA_ASM_EXPAND - 0x0
+# CHECK-NEXT: 0x2C R_XTENSA_ASM_SIMPLIFY - 0x0
+# CHECK-NEXT: 0x30 R_XTENSA_32_PCREL - 0x0
+# CHECK-NEXT: 0x34 R_XTENSA_GNU_VTINHERIT - 0x0
+# CHECK-NEXT: 0x38 R_XTENSA_GNU_VTENTRY - 0x0
+# CHECK-NEXT: 0x3C R_XTENSA_DIFF8 - 0x0
+# CHECK-NEXT: 0x40 R_XTENSA_DIFF16 - 0x0
+# CHECK-NEXT: 0x44 R_XTENSA_DIFF32 - 0x0
+# CHECK-NEXT: 0x48 R_XTENSA_SLOT0_OP - 0x0
+# CHECK-NEXT: 0x4C R_XTENSA_SLOT1_OP - 0x0
+# CHECK-NEXT: 0x50 R_XTENSA_SLOT2_OP - 0x0
+# CHECK-NEXT: 0x54 R_XTENSA_SLOT3_OP - 0x0
+# CHECK-NEXT: 0x58 R_XTENSA_SLOT4_OP - 0x0
+# CHECK-NEXT: 0x5C R_XTENSA_SLOT5_OP - 0x0
+# CHECK-NEXT: 0x60 R_XTENSA_SLOT6_OP - 0x0
+# CHECK-NEXT: 0x64 R_XTENSA_SLOT7_OP - 0x0
+# CHECK-NEXT: 0x68 R_XTENSA_SLOT8_OP - 0x0
+# CHECK-NEXT: 0x6C R_XTENSA_SLOT9_OP - 0x0
+# CHECK-NEXT: 0x70 R_XTENSA_SLOT10_OP - 0x0
+# CHECK-NEXT: 0x74 R_XTENSA_SLOT11_OP - 0x0
+# CHECK-NEXT: 0x78 R_XTENSA_SLOT12_OP - 0x0
+# CHECK-NEXT: 0x7C R_XTENSA_SLOT13_OP - 0x0
+# CHECK-NEXT: 0x80 R_XTENSA_SLOT14_OP - 0x0
+# CHECK-NEXT: 0x84 R_XTENSA_SLOT0_ALT - 0x0
+# CHECK-NEXT: 0x88 R_XTENSA_SLOT1_ALT - 0x0
+# CHECK-NEXT: 0x8C R_XTENSA_SLOT2_ALT - 0x0
+# CHECK-NEXT: 0x90 R_XTENSA_SLOT3_ALT - 0x0
+# CHECK-NEXT: 0x94 R_XTENSA_SLOT4_ALT - 0x0
+# CHECK-NEXT: 0x98 R_XTENSA_SLOT5_ALT - 0x0
+# CHECK-NEXT: 0x9C R_XTENSA_SLOT6_ALT - 0x0
+# CHECK-NEXT: 0xA0 R_XTENSA_SLOT7_ALT - 0x0
+# CHECK-NEXT: 0xA4 R_XTENSA_SLOT8_ALT - 0x0
+# CHECK-NEXT: 0xA8 R_XTENSA_SLOT9_ALT - 0x0
+# CHECK-NEXT: 0xAC R_XTENSA_SLOT10_ALT - 0x0
+# CHECK-NEXT: 0xB0 R_XTENSA_SLOT11_ALT - 0x0
+# CHECK-NEXT: 0xB4 R_XTENSA_SLOT12_ALT - 0x0
+# CHECK-NEXT: 0xB8 R_XTENSA_SLOT13_ALT - 0x0
+# CHECK-NEXT: 0xBC R_XTENSA_SLOT14_ALT - 0x0
+# CHECK-NEXT: 0xC0 R_XTENSA_TLSDESC_FN - 0x0
+# CHECK-NEXT: 0xC4 R_XTENSA_TLSDESC_ARG - 0x0
+# CHECK-NEXT: 0xC8 R_XTENSA_TLS_DTPOFF - 0x0
+# CHECK-NEXT: 0xCC R_XTENSA_TLS_TPOFF - 0x0
+# CHECK-NEXT: 0xD0 R_XTENSA_TLS_FUNC - 0x0
+# CHECK-NEXT: 0xD4 R_XTENSA_TLS_ARG - 0x0
+# CHECK-NEXT: 0xD8 R_XTENSA_TLS_CALL - 0x0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_XTENSA
+Sections:
+  - Name:         .rela.text
+    Type:         SHT_RELA
+    Relocations:
+       - Offset: 0x0000000000000000
+         Type:   R_XTENSA_NONE
+       - Offset: 0x0000000000000004
+         Type:   R_XTENSA_32
+       - Offset: 0x0000000000000008
+         Type:   R_XTENSA_RTLD
+       - Offset: 0x000000000000000C
+         Type:   R_XTENSA_GLOB_DAT
+       - Offset: 0x0000000000000010
+         Type:   R_XTENSA_JMP_SLOT
+       - Offset: 0x0000000000000014
+         Type:   R_XTENSA_RELATIVE
+       - Offset: 0x0000000000000018
+         Type:   R_XTENSA_PLT
+       - Offset: 0x000000000000001C
+         Type:   R_XTENSA_OP0
+       - Offset: 0x0000000000000020
+         Type:   R_XTENSA_OP1
+       - Offset: 0x0000000000000024
+         Type:   R_XTENSA_OP2
+       - Offset: 0x0000000000000028
+         Type:   R_XTENSA_ASM_EXPAND
+       - Offset: 0x000000000000002C
+         Type:   R_XTENSA_ASM_SIMPLIFY
+       - Offset: 0x0000000000000030
+         Type:   R_XTENSA_32_PCREL
+       - Offset: 0x0000000000000034
+         Type:   R_XTENSA_GNU_VTINHERIT
+       - Offset: 0x0000000000000038
+         Type:   R_XTENSA_GNU_VTENTRY
+       - Offset: 0x000000000000003C
+         Type:   R_XTENSA_DIFF8
+       - Offset: 0x0000000000000040
+         Type:   R_XTENSA_DIFF16
+       - Offset: 0x0000000000000044
+         Type:   R_XTENSA_DIFF32
+       - Offset: 0x0000000000000048
+         Type:   R_XTENSA_SLOT0_OP
+       - Offset: 0x000000000000004C
+         Type:   R_XTENSA_SLOT1_OP
+       - Offset: 0x0000000000000050
+         Type:   R_XTENSA_SLOT2_OP
+       - Offset: 0x0000000000000054
+         Type:   R_XTENSA_SLOT3_OP
+       - Offset: 0x0000000000000058
+         Type:   R_XTENSA_SLOT4_OP
+       - Offset: 0x000000000000005C
+         Type:   R_XTENSA_SLOT5_OP
+       - Offset: 0x0000000000000060
+         Type:   R_XTENSA_SLOT6_OP
+       - Offset: 0x0000000000000064
+         Type:   R_XTENSA_SLOT7_OP
+       - Offset: 0x0000000000000068
+         Type:   R_XTENSA_SLOT8_OP
+       - Offset: 0x000000000000006C
+         Type:   R_XTENSA_SLOT9_OP
+       - Offset: 0x0000000000000070
+         Type:   R_XTENSA_SLOT10_OP
+       - Offset: 0x0000000000000074
+         Type:   R_XTENSA_SLOT11_OP
+       - Offset: 0x0000000000000078
+         Type:   R_XTENSA_SLOT12_OP
+       - Offset: 0x000000000000007C
+         Type:   R_XTENSA_SLOT13_OP
+       - Offset: 0x0000000000000080
+         Type:   R_XTENSA_SLOT14_OP
+       - Offset: 0x0000000000000084
+         Type:   R_XTENSA_SLOT0_ALT
+       - Offset: 0x0000000000000088
+         Type:   R_XTENSA_SLOT1_ALT
+       - Offset: 0x000000000000008C
+         Type:   R_XTENSA_SLOT2_ALT
+       - Offset: 0x0000000000000090
+         Type:   R_XTENSA_SLOT3_ALT
+       - Offset: 0x0000000000000094
+         Type:   R_XTENSA_SLOT4_ALT
+       - Offset: 0x0000000000000098
+         Type:   R_XTENSA_SLOT5_ALT
+       - Offset: 0x000000000000009C
+         Type:   R_XTENSA_SLOT6_ALT
+       - Offset: 0x00000000000000A0
+         Type:   R_XTENSA_SLOT7_ALT
+       - Offset: 0x00000000000000A4
+         Type:   R_XTENSA_SLOT8_ALT
+       - Offset: 0x00000000000000A8
+         Type:   R_XTENSA_SLOT9_ALT
+       - Offset: 0x00000000000000AC
+         Type:   R_XTENSA_SLOT10_ALT
+       - Offset: 0x00000000000000B0
+         Type:   R_XTENSA_SLOT11_ALT
+       - Offset: 0x00000000000000B4
+         Type:   R_XTENSA_SLOT12_ALT
+       - Offset: 0x00000000000000B8
+         Type:   R_XTENSA_SLOT13_ALT
+       - Offset: 0x00000000000000BC
+         Type:   R_XTENSA_SLOT14_ALT
+       - Offset: 0x00000000000000C0
+         Type:   R_XTENSA_TLSDESC_FN
+       - Offset: 0x00000000000000C4
+         Type:   R_XTENSA_TLSDESC_ARG
+       - Offset: 0x00000000000000C8
+         Type:   R_XTENSA_TLS_DTPOFF
+       - Offset: 0x00000000000000CC
+         Type:   R_XTENSA_TLS_TPOFF
+       - Offset: 0x00000000000000D0
+         Type:   R_XTENSA_TLS_FUNC
+       - Offset: 0x00000000000000D4
+         Type:   R_XTENSA_TLS_ARG
+       - Offset: 0x00000000000000D8
+         Type:   R_XTENSA_TLS_CALL

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

+## Check that we are able to dump EF_XTENSA_XT_* flags correctly
+
+# RUN: yaml2obj %s -o %t.insn -DFLAG=INSN
+# RUN: llvm-readobj -S --file-headers %t.insn | FileCheck --check-prefixes=ALL,INSN %s
+
+# RUN: yaml2obj %s -o %t.lit -DFLAG=LIT
+# RUN: llvm-readobj -S --file-headers %t.lit | FileCheck --check-prefixes=ALL,LIT %s
+
+# ALL:  Flags [
+# INSN:   EF_XTENSA_XT_INSN (0x100)
+# LIT:    EF_XTENSA_XT_LIT  (0x200)
+# ALL:  ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_XTENSA
+  Flags:   [ EF_XTENSA_XT_[[FLAG]] ]

llvm/tools/llvm-readobj/ELFDumper.cpp

const EnumEntry<unsigned> ElfHeaderAVRFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA3),
   LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA4),
   LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA5),
   LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA6),
   LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA7),
   ENUM_ENT(EF_AVR_LINKRELAX_PREPARED, "relaxable"),
 };
 
+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> 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[] = {
ElfFlags =
         printFlags(e.e_flags, makeArrayRef(ElfHeaderMipsFlags),
                    unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
                    unsigned(ELF::EF_MIPS_MACH));
   else if (e.e_machine == EM_RISCV)
     ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderRISCVFlags));
   else if (e.e_machine == EM_AVR)
     ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderAVRFlags),
                           unsigned(ELF::EF_AVR_ARCH_MASK));
+  else if (e.e_machine == EM_XTENSA)
+    ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderXtensaFlags),
+                          unsigned(ELF::EF_XTENSA_MACH));
   Str = "0x" + to_hexString(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_AMDGPU) {
                      unsigned(ELF::EF_AMDGPU_FEATURE_SRAMECC_V4));
         break;
       }
     } else if (E.e_machine == EM_RISCV)
       W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderRISCVFlags));
     else if (E.e_machine == EM_AVR)
       W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderAVRFlags),
                    unsigned(ELF::EF_AVR_ARCH_MASK));
+    else if (E.e_machine == EM_XTENSA)
+      W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderXtensaFlags),
+                   unsigned(ELF::EF_XTENSA_MACH));
     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, MachineTestForCSKY) {
   std::array<StringRef, 4> Formats = {"elf32-csky", "elf32-csky",
                                       "elf64-unknown", "elf64-unknown"};
   size_t I = 0;
   for (const DataForTest &D : generateData(ELF::EM_CSKY))
     checkFormatAndArch(D, Formats[I++], Triple::csky);
 }
 
+TEST(ELFObjectFileTest, MachineTestForXtensa) {
+  std::array<StringRef, 4> Formats = {"elf32-xtensa", "elf32-xtensa",
+                                      "elf64-unknown", "elf64-unknown"};
+  size_t I = 0;
+  for (const DataForTest &D : generateData(ELF::EM_XTENSA))
+    checkFormatAndArch(D, Formats[I++], Triple::xtensa);
+}
+
 // 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) {