[VE] Implements minimum MC layer for VE (3/4)

[kaz7]

Summary

Define ELF binary code for VE and modify code where should use this new code.

Depends on D79544.

[jhenderson]

llvm/include/llvm/BinaryFormat/ELFRelocs/VE.def

37

Why are some commented out?

llvm/include/llvm/Object/ELFObjectFile.h

1142–1143

Test coverage?

1222–1223

Test coverage?

llvm/lib/Object/ELF.cpp

148–154

Please add an llvm-readobj test "reloc-types-elf-ve.test" to test/tools/llvm-readobj/ELF similar to the existing "reloc-types-elf-*.test" files for other machines.

201–202

Test coverage?

llvm/lib/ObjectYAML/ELFYAML.cpp

666–668

There should be some yaml2obj/obj2yaml testing to show that VE relocation enums are supported in those tools.

llvm/tools/llvm-readobj/ELFDumper.cpp

1474

It looks like this enum is currently essentially untested. Could you add a simple test case to llvm-readobj's tests to cover file header printing of the different machine types, please?

Here's a rough example of what I'm thinking of:

# RUN: yaml2obj %s -o %t.none -D MACHINE=EM_NONE
# RUN: llvm-readelf --file-headers %t.none | FileCheck %s -D MACHINE=None --check-prefix=GNU

# RUN: yaml2obj %s -o %t.m32 -D MACHINE=EM_M32
# RUN: llvm-readelf --file-headers %t.m32 | FileCheck %s -D MACHINE=WE32100

<repeat for each value>

# CHECK: Machine: [[MACHINE]]

--- !ELF
FileHeader:
  Class:   ELFCLASS32
  Data:    ELFDATA2LSB
  Type:    ET_REL
  Machine: [[MACHINE]]

[kaz7]

Thank you for your comments and examples for regression tests. I'll add them.

llvm/include/llvm/BinaryFormat/ELFRelocs/VE.def

37

I left them commented out because documents left them as commented out. This time, I put everything defined in manual. I can leave items what I use. In order to implement test for all of them, I have to do so...

https://www.hpc.nec/documents/guide/pdfs/VE-ABI_v2.1.pdf section 4.4.1
https://www.hpc.nec/documents/guide/pdfs/VE-tls_v1.2.pdf section 5.1

[kaz7]

Add some tests locally and found a problem need other's help. Please let me know how to fix EM_ECOG1X problem and how to check Tripe::ve. Thanks!

llvm/include/llvm/Object/ELFObjectFile.h

1142–1143

Add one.

1222–1223

Is there any idea how to test it? I've checked other tests and found llvm-ifs which I've never used. Using llvm-ifs is correct way to implement test for this? Thanks.

llvm/lib/Object/ELF.cpp

148–154

Thank you for examples. I'll add a test. Having unknown errors, ATM.

201–202

I will try it in above "reloc-types-elf-*.test".

llvm/lib/ObjectYAML/ELFYAML.cpp

666–668

Thanks. I'll try implement one.

llvm/tools/llvm-readobj/ELFDumper.cpp

1474

I've made a test and found a problem that EM_ECOG1 and EM_ECOG1X uses identical number 168. Let me know what I should do for this.

[kaz7]

llvm/include/llvm/Object/ELFObjectFile.h

1222–1223

Not sure about llvm-ifs. Please advise me. Thanks.

llvm/lib/Object/ELF.cpp

148–154

Add a test.

201–202

I'm going to remove this modifications since VE is not using SHT_RELR atm. Thank you very much for giving me opportunity to correct this.

llvm/lib/ObjectYAML/ELFYAML.cpp

666–668

Add a test.

[kaz7]

Add regression tests and update codes following jhenderson suggestions.
Thanks!

[jhenderson]

llvm/include/llvm/BinaryFormat/ELFRelocs/VE.def

37

That's a slightly weird (to me) way of omitting certain relocation types in the manual, but okay, that's fine. I'm happy that they remain commented out then.

llvm/include/llvm/Object/ELFObjectFile.h

1222–1223

I don't know anything about llvm-ifs, but it looks like llvm-objdump or llvm-readobj --file-headers will do the job for you (the "architecture" field is derived from the object file's architecture).

I would expect to see a corresponding change to Triple.cpp's getArchTypeName though.

llvm/test/Object/VE/elf64-unknown.yaml

1 ↗

(On Diff #262843)

Please explain (with a comment) what this test is trying to test. Why "unknown" in the title?

2 ↗

(On Diff #262843)

Why -S?

llvm/test/tools/llvm-readobj/ELF/machine-enum.test

1 ↗

(On Diff #262843)

Thanks for the test.

Please use '##' for comments, to help them stand out better. Also I'd rephrase this comment to be more grammatically correct:

## Show that all machine codes are correctly printed.

2 ↗

(On Diff #262843)

Delete the '#' from this line, please.

3–4 ↗

(On Diff #262843)

As a suggestion, it might be better to name each object differently, i.e. something like %tnone, %tm32 etc. That way it'll be easier to investigate a test failure.

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

53 ↗

(On Diff #262843)

You don't need this Content.

56–57 ↗

(On Diff #262843)

You don't need these two fields.

83 ↗

(On Diff #262843)

Rather than commenting these out, you might want to (if possible) use an explicit value for these ones, and then check that the value isn't interpreted, but rather treated as an unknown value. If you do that, I'd add a comment explaining what you are doing.

llvm/test/tools/obj2yaml/ELF/relocation-type-ve.yaml

1 ↗

(On Diff #262843)

I don't think copying the existing relocation-type.yaml test is particularly useful. That is more for generic handling of relocation types, whereas we want to explicitly show that the VE relocation types are understood by yaml2obj and obj2yaml. Instead, I'd just enumerate the relocation values as you have in the llvm-readobj test. It's okay to explicitly specify them, because we know from the llvm-readobj testing that their values are correct.

llvm/tools/llvm-readobj/ELFDumper.cpp

1474

Just test what is printed for one of them. It might be a bug in LLVM, or a gABI bug or something similar. Speaking of the gABI, have you been officially assigned a value for EM_VE using the ELF gABI mailing list?

[kaz7]

Thank you for kind suggestions.

llvm/include/llvm/Object/ELFObjectFile.h

1222–1223

Thanks. I could make a certain test for this using llvm-readobj.

llvm/test/Object/VE/elf64-unknown.yaml

1 ↗

(On Diff #262843)

Thank you for letting me correct it. I simply copied from others like ../AMDGPU/elf64-unknown.yaml. I renamed this to elf64-machine.yaml.

llvm/tools/llvm-readobj/ELFDumper.cpp

1474

Ok. I test onl EM_ECOG1. Tests for ECOG1X is commented out in above test with FIXME tag.

Regarding to gABI, I don't know. I guess EM_VE is officially assigned since EM_VE is used in NEC's official compiler systems like below. I tried to check it out, but I didn't find the way to do so unfortunately.

https://github.com/veos-sxarr-NEC/musl-libc-ve/blob/master/include/elf.h#L220

[kaz7]

I update following jhenderson's suggestions and also add a new test to
check triple for ve.

[kaz7]

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

83 ↗

(On Diff #262843)

I see. Listing commented out values here is strange as you explained. This time I removed those commented out values from tests.

llvm/test/tools/obj2yaml/ELF/relocation-type-ve.yaml

1 ↗

(On Diff #262843)

Thanks. I listed all types and test them using obj2yaml here similar to an above llvm-readobj test.

[jhenderson]

Having been looking at another piece of work in the Object library, rather than introducing lit tests for it to cover the specific behaviour, I think gtest unit tests should be introduced instead to cover the behaviour. For more thoughts on this, see D79612.

llvm/test/tools/llvm-readobj/ELF/machine-enum.test

378–379 ↗

(On Diff #263333)

I'd move this FIXME comment into the code, highlighting that it is dead code, due to the shared value, and then delete this case here, as it looks like it's meant to be a test, but isn't, which might confuse people in the future.

[kaz7]

Remove FIXME part from a test and put it to ELFDumper.cpp.

[kaz7]

In D79545#2033359, @jhenderson wrote:

Having been looking at another piece of work in the Object library, rather than introducing lit tests for it to cover the specific behaviour, I think gtest unit tests should be introduced instead to cover the behaviour. For more thoughts on this, see D79612.

You mean, for example, making "unittest/Object/ElfMachineTypeTest.cpp" instead of above "test/tools/llvm-readobj/ELF/machine-enum.test". That's make sense. Should I need to make them in this ticket?

[jhenderson]

In D79545#2033422, @kaz7 wrote:

In D79545#2033359, @jhenderson wrote:

Having been looking at another piece of work in the Object library, rather than introducing lit tests for it to cover the specific behaviour, I think gtest unit tests should be introduced instead to cover the behaviour. For more thoughts on this, see D79612.

You mean, for example, making "unittest/Object/ElfMachineTypeTest.cpp" instead of above "test/tools/llvm-readobj/ELF/machine-enum.test". That's make sense. Should I need to make them in this ticket?

Yes, if reasonable to do, since you are adding the new tests in this patch.

[kaz7]

I add several unit tests. I summarized modified files and tests for
each of them below. Please check them and let me know what you think.
Thanks.

• llvm/include/llvm/BinaryFormat/ELF.h
  • Add unittest/Object/ELFTest.cpp, but the test becomes something like an apple is an apple test. Maybe, it's Ok.
• llvm/include/llvm/BinaryFormat/ELFRelocs/VE.def
  • Add unittest/Object/ELFTest.cpp, but the test again becomes an apple is an apple test.
• llvm/include/llvm/Object/ELFObjectFile.h
  • Add unittest/Object/ELFObjectFileTest.cpp. This is a good example as a unit test.
  • Add test/Object/VE/elf64-arch.yaml and elf64-machine.yaml. We can remove them if we have above unit test.
• llvm/lib/Object/ELF.cpp
  • Add unittest/Object/ELFTest.cpp. The test is also an apple is an apple test, but it can examine getELFRelocationTypeName function, so not bad.
  • Add test/tools/llvm-readobj/ELF/reloc-types-elf-ve.test. We can remove this if we have above unit test.
• llvm/lib/ObjectYAML/ELFYAML.cpp
  • No idea how to make a unit test.
  • Add test/tools/obj2yaml/ELF/relocation-type-ve.yaml.
• llvm/tools/llvm-readobj/ELFDumper.cpp
  • Making a unit test requires refactoring of ELFDumper.cpp. It is out of my purpose.
  • Add test/tools/llvm-readobj/ELF/machine-enum.test.

If these modifications and tests are Ok, I'll remove following
duplicated tests.

• test/Object/VE/elf64-arch.yaml
• test/Object/VE/elf64-machine.yaml
• test/tools/llvm-readobj/ELF/reloc-types-elf-ve.test

[jhenderson]

Thanks @kaz7. I've run out of time to look at this today, but I'll try to get to it tomorrow, or Monday. I noticed you were looking to add unit tests to llvm-readobj, which I don't think you need to do. In general terms, I would suggest unit tests for things in the lib directory, and lit tests for things in the tools directory. Thus, if you've made a change to both code in the llvm-readobj directory and in the Object directory, you'd have unittests for the Object stuff and lit tests for the llvm-readobj stuff.

[kaz7]

Thank you @jhenderson too. Thanks for spending your time for this review and letting me know your situation. I misunderstood what you said about a unit test. Anyway, I've not made a unit test for tools this time. :)

Have a time and let me know your thought. Thanks!

[kaz7]

Update to correct filenames and to avoid warning messages.

[jhenderson]

Tests mostly look fine, thanks, but see inline comments.

llvm/lib/Object/ELF.cpp

201–202

Given you're no longer doing anything special here, perhaps it's okay to just let the EM_VE use default instead, by just deleting the case here. There are many other machines that are already in this position after all. If you go with that, I'd get rid of the corresponding unit test change from this patch. If you want to add unit tests for this function going forwards for it, it's perfectly fine to do so, but I'd add them in a separate patch and cover all the cases then.

What do you think?

llvm/test/Object/VE/elf64-arch.yaml

1 ↗

(On Diff #264123)

This and the other Object/VE tests can be deleted. I'm happy with the unit tests, and don't see a need for extra testing on top.

llvm/test/tools/llvm-readobj/ELF/machine-enum.test

1 ↗

(On Diff #264123)

I'd rename this file to file-header-machine-types.test to show it is specifically about that bit.

llvm/unittests/Object/ELFObjectFileTest.cpp

24

I'd rename this test to "VEMachineTest".

34

Two competing ideas:

1. It might be nice if this blob could be shared between the different machine types in the future, so that most of the testing can be avoided. There's a way to do this using TEST_P instead of TEST, which allows you to specify parameters for the test. In this case, it would be EM_VE and "elf64-ve". Take a look at some examples, e.g. in the DWARFDebugLineTest.cpp unit test file.
2. A way to reduce this down to YAML is by following a similar process to that used in the MinidumpYAMLTest.cpp unit test file (in the ObjectYAML directory). I think that would you to make this shorter and more focused on what is interesting. You'd need to use ELF-style YAML of course, like you already do in your lit tests.

I think both have merits. There may even be a way of combining the two, by somehow providing the YAML string for the machine at test run time via a parameter. I'd be happy with any of these approaches.

One suggestion: if you choose to stick with the byte array you already have, I'd replace 251 with EM_VE explicitly.

47

Nit: empty data -> no data

Also add the missing trailing full stop.

llvm/unittests/Object/ELFTest.cpp

17–18

These two TESTs are actually testing enum values from BinaryFormat/ELF.h and VE.def, if I'm not mistaken. I don't think there's much value in them - you're just as likely to make a mistake here in the test as you are in the enum, but also nobody's ever going to deliberately change this. Up to you though.

85

For readability, add a blank line after each individual TEST.

[kaz7]

Thanks for inspecting tests. I'll update them Monday again.

llvm/lib/Object/ELF.cpp

201–202

I'll remove EM_VE here, but leave getELFRelativeRelocationTypeTest. . Please add tests for other architectures from this patch in a separate patch at your side. I'd like to reduce the size of this patch.

llvm/test/Object/VE/elf64-arch.yaml

1 ↗

(On Diff #264123)

Thanks. I'll remove them.

llvm/test/tools/llvm-readobj/ELF/machine-enum.test

1 ↗

(On Diff #264123)

OK. Thank your for suggestion.

llvm/unittests/Object/ELFObjectFileTest.cpp

24

I'll rename that.

34

Thank you for suggestions. I'll take care them Monday.

47

Thanks for the correction. I'm not sure about "trailing full stop" since I've never tried to generate ELF data previously. I guess you are saying that above blob is not completed and need some trailing data. I appreciate if you advise me with some concrete examples or references.

llvm/unittests/Object/ELFTest.cpp

17–18

I agree with you. I'll remove them. Thanks.

[jhenderson]

llvm/unittests/Object/ELFObjectFileTest.cpp

47

If you look carefully in the Phabricator UI, I've only selected the comment line, because I'm referring to the comment with the "missing trailing full stop". In other words, the comment should be:

"A very simple ELF object file which contains no data."

[kaz7]

llvm/unittests/Object/ELFObjectFileTest.cpp

34

There is a problem to use TEST_P. TEST_P is for parameterize tests in my understanding. For example, it is useful to test something identical conditions for different parameters. However, we need different conditions for each parameter, e.g. name "elf64-ve" for EM_VE and name "elf64-x86-64" for EM_X86_64.

I tried TYPED_TEST_P, TEST_F, etc. All of them doesn't match our purpose, I think. This time, I only made a common class to obtain a buffer to create different ELFObjectFile.

I will also try to implement a yaml test. There is a problem to implement a method to traverse generated ELFObjectFile, though. I'll try it by reading tools/llvm-readobj/ELFDumper.cpp, but it takes for a while for me.

47

Haha. Thanks for correction.

[kaz7]

Update along to suggestions. Need to finish implementation of
unittests/ObjectYAML/ELFRelocationTypeTest.cpp which takes for a
while to learn how to traverse symbol information in ELFObjectFile.

[jhenderson]

I've run out of time, so will come back to looking at the rest of the updates tomorrow.

llvm/unittests/Object/ELFObjectFileTest.cpp

34

You can use std::tuple to create a parameterised test that has multiple properties. See for example MaxOpsPerInstFixture in DWARFDebugLineTest.cpp. In this case, you could have EM_VE and "elf64-ve" in one tuple, and EM_X86_64 and "elf64-x86-64" in another.

llvm/unittests/Object/MachineTest.cpp

1 ↗

(On Diff #264547)

When I said rename the TEST, I meant the TEST BasicTestForVE and not the test file name. The test file name should remain ELFObjectFileTest.cpp, to reflect that it is testing that file.

31 ↗

(On Diff #264547)

Use fixed width types throughout (uint8_t, uint32_t etc) that match the size that is allowed in the ELF spec. In this case, I think uint8_t is the right value in most, maybe all cases.

[kaz7]

I managed to implement test code for ELFYAML modifications. Now we can test relocation type info through unit tests. Therefore, I'll remove following lit tests.

• .../tools/llvm-readobj/ELF/reloc-types-elf-ve.test
• .../tools/obj2yaml/ELF/relocation-type-ve.yaml

llvm/unittests/Object/ELFObjectFileTest.cpp

34

Thank you for suggestions, but I have not enough time to do so. May I stop here to add test to support other architectures? I'm really exhausted by adding these unit tests.

[kaz7]

Add all necessary unit tests now.

[jhenderson]

Okay, I've had a bit more time to look at the tests. The logic generally looks fine, but there are a number of mostly stylistic issues that need addressing.

clang-format is complaining a lot on some of your new files. Please remember to run it to format them according to the LLVM coding standards.

llvm/unittests/Object/ELFObjectFileTest.cpp

2

Remove the "Machine field in" bit in the comment. It doesn't add anything, and will be incorrect in the future when we add more tests.

24–25

There is no need to mention the class name in this comment. It doesn't add anything to the comment, because the comment is already associated with the struct by its presence.

Also "to represent an ELF".

26–27

Rather than leave this FIXME here, just do it right the first time. You could use something similar to the fallible constructor pattern as described in the LLVM Programmer's Manual to have this object return a an ELFObjectFile instance. You could even consider instead doing the error handling inside the constructor using ASSERT_THAT_EXPECTED to create an ELFObjectFile instance stored in the struct and used by the test.

28

The name of the struct says ELF64, but you pass the Class into the code, implying it's able to work with ELF32. I don't think you can have both. Better would be to make this class able to work with both ELF32 and ELF64 and generate the data accordingly.

31

This is a struct. No need for public here.

33

I don't think there's any real benefit to pre-sizing this vector, but even if there is, you should use sizeof(Elf64_Ehdr) or equivalent for ELF32 rather than hard-coding in the number.

34–35

You allow passing in of the Encoding value, but are hard-coding here an assumption about it being little endian (or more specifically, the same as the host machine). You need to a) handle hosts being either little or big endian (using sys::isLittleEndian) and b) handle different Encoding values. There are already functions in LLVM for byte swapping. Consider using those instead, possibly in combination with reinterpret_cast<uint8_t *> to convert it to a sequence of bytes.

61

LLVM style doesn't allow names to have underscores in them. I'd also be even more generic with this name and just put something like ELFObjectFileTest. This will allow users to just run it specifically alongside other future ELFObjectFile tests.

llvm/unittests/ObjectYAML/ELFRelocationTypeTest.cpp

1 ↗

(On Diff #264569)

Similar to the ELFObjectFile test, this test file should be named after the source file it is testing, and the comment here needs updating.

36 ↗

(On Diff #264569)

Don't use auto where the type isn't obvious. Instead, please use the type explicitly.

82 ↗

(On Diff #264569)

I think SectionRef and RelocationRef below are intended to be like StringRef in that they don't need to be passed around as const & since they are lightweight.

130 ↗

(On Diff #264569)

Perhaps "Found unexpected relocation type: " + R.getType() would be a more useful error message.

[kaz7]

OK, I will run clang-format. It modifies ENUM_ENT definitions in ELFDumper.cpp, so that I was not running it in this patch since I feel modifying existing format is not good. Maybe I should think like this patch is a good practice to update existing format. Thanks.

llvm/unittests/Object/ELFObjectFileTest.cpp

26–27

Thanks for the link. I couldn't handle it correctly at first try. I would like to try it if I have time.

On the other hand, we don't need to hold ELFObjectFile in this structure since I'm not using test fixtures yet. I supported not only EM_VE but also X86_64, 385, all ELF64, ELF32, big endian, little endian MIPS cases in this test. I appreciate if I can stop extending and generalizing this test case here at least for this patch.

[kaz7]

Update regression tests.
Also rebase to the latest master.

[kaz7]

llvm/tools/llvm-readobj/ELFDumper.cpp

1474

FYI, I've checked registry status internally. And I heard that it is registered through [e-mail].

[jhenderson]

Sorry for the delay in responding - I ran out of time on Friday, and then it was a public holiday yesterday, so I wasn't working. Mostly, this looks fine. I just think the ELFObjectFIle unit tests still has some issues, which are described inline and below. Once you've resolve those, I think this is good to go.

I'm not a fan of writing out the ELF data byte-by-byte as you have done in the ELFObjectFile test - I think it can be simplified somewhat, and made more flexible/less prone to being broken by endianness issues etc. ELF already has the Ehdr structures, which you can use to populate the data below, rather than individually assigning each byte. Here's what I would recommend to solve these issues (note - code is untested, so don't blindly copy, but should give you a good indication of what I think you should do):

// You might want to cosider storing Encoding in the struct, to make using this function easier.
template <typename T> T swap(T Value, uint8_t Encoding) {
  assert(Encoding == ELF::ELFDATA2MSB || Encoding == ELF::ELFDATA2LSB);
  bool IsLittleEndian == ELF::ELFDATA2LSB;
  if (IsLittleEndianHost != IsLittleEndian)
    return sys::swapByteOrder(Value);
  return Value;
}

DataForTest(uint8_t Class, uint8_t Encoding, uint16_t Machine) {
  if (Class == ELF::ELFCLASS64)
    Data = makeElfData<ELF::Elf64_Ehdr>(Class, Encoding, Machine);
  else {
    assert(Class == ELF::ELFCLASS32);
    Data = makeElfData<ELF::Elf64_Ehdr>(Class, Encoding, Machine);
  }
}

template <typename T>
std::vector<uint8_t> makeElfData(uint8_t Class, uint8_t Encoding, uint16_t Machine) {
  T Ehdr {}; // Zero-initialise the header.
  Ehdr.e_ident[ELF::EI_MAG0] = 0x7f;
  Ehdr.e_ident[ELF::EI_MAG1] = 'E';
  Ehdr.e_ident[ELF::EI_MAG2] = 'L';
  Ehdr.e_ident[ELF::EI_MAG3] = 'F';
  Ehdr.e_ident[ELF::EI_CLASS] = Class;
  Ehdr.e_ident[ELF::EI_DATA] = Encoding;
  Ehdr.e_ident[ELF::EI_VERSION] = 1;
  Ehdr.e_type = swap(ELF::ET_REL, Encoding);
  Ehdr.e_machine = swap(Machine, Encoding);
  Ehdr.e_version = swap(uint16_t(1), Encoding);
  Ehdr.e_ehsize = swap(uint16_t(sizeof(T)), Encoding);
  uint8_t *EhdrBytes = reinterpret_cast<uint8_t *>(&Ehdr);
  std::vector<uint8_t> Bytes;
  std::copy(EhdrBytes, EhdrBytes + sizeof(Ehdr), std::back_inserter(Bytes));
  return Bytes;
}

llvm/tools/llvm-readobj/ELFDumper.cpp

1474

Great, good to hear. When I was referring to clang-formatting things, I was specifically referring to the new files you've added, rather than this enum, which I'm not convinced we should reformat. Could you undo the formatting changes to this bit, please?

llvm/unittests/Object/ELFObjectFileTest.cpp

28

No need to explicitly initialise Data.

31

If I'm reading the code correctly, this will unconditionally swap bytes for big endian inputs, regardless of the host endianness. If the host machine is big endian, you don't want to swap. There are build bots out there which are big endian, so you need to handle that case, or the test will fail on those.

See my out-of-line comment for a possible solution.

37

I don't think assigning each byte individually is a good way to go. See my out-of-line comment for an alternative.

llvm/unittests/Object/ELFTest.cpp

57

No need for an additional blank line here at the end of the file.

[kaz7]

No problem. Thank you for your time for reviewing. I also almost ran out my time this month to work on this. ;)

llvm/tools/llvm-readobj/ELFDumper.cpp

1474

Thanks. This clang-format thing is useful, but it becomes little annoying if I modifies code region which doesn't follow clang-format style. ;). Anyway, I'll revert this.

llvm/unittests/Object/ELFObjectFileTest.cpp

31

You are right. I didn't think about that scenario. And thank you for your example.

llvm/unittests/Object/ELFTest.cpp

57

Thank you for mentioning that. I also want to remove blank lines at the EOF and blanks at the EOL. But this time I cannot find blank line at the end of this file. Maybe smoking of glitches on the web? Please let me know if you find a blank like again.

[jhenderson]

llvm/unittests/Object/ELFTest.cpp

57

Looks like it. It's not the first time I've seen that happened.

[kaz7]

Update following jhenderson's suggestions. Also rebase to the latest.

[jhenderson]

Great work, LGTM. Thanks for persevering! The testing framework you've started should also prove very useful in the future, I think.

llvm/tools/llvm-readobj/ELFDumper.cpp

1474

Yeah, there might be a way to resolve that, but I'm not sure exactly how. I certainly think this format makes sense for the current context.

[kaz7]

Thank you. I appreciate your kind suggestions and examples too.

llvm/include/llvm/BinaryFormat/ELF.h

enum {
   EM_COGE = 216,          // Cognitive Smart Memory Processor
   EM_COOL = 217,          // iCelero CoolEngine
   EM_NORC = 218,          // Nanoradio Optimized RISC
   EM_CSR_KALIMBA = 219,   // CSR Kalimba architecture family
   EM_AMDGPU = 224,        // AMD GPU architecture
   EM_RISCV = 243,         // RISC-V
   EM_LANAI = 244,         // Lanai 32-bit processor
   EM_BPF = 247,           // Linux kernel bpf virtual machine
+  EM_VE = 251,            // NEC SX-Aurora VE
 };
 
 // Object file classes.
 enum {
   ELFCLASSNONE = 0,
   ELFCLASS32 = 1, // 32-bit object file
   ELFCLASS64 = 2  // 64-bit object file
 };
enum : unsigned {
   EF_MSP430_MACH_MSP430x54 = 54,
 };
 
 // ELF Relocation types for MSP430
 enum {
 #include "ELFRelocs/MSP430.def"
 };
 
+// ELF Relocation type for VE.
+enum {
+#include "ELFRelocs/VE.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/VE.def

+
+#ifndef ELF_RELOC
+#error "ELF_RELOC must be defined"
+#endif
+
+// Relocation types defined in following documents.
+//
+//  - System V Application Binary Interface - VE Architecture
+//    Processor Supplement
+//  - ELF Handling For Thread-Local Storage - VE Architecture
+//    Processor Supplement
+
+ELF_RELOC(R_VE_NONE,         0)
+ELF_RELOC(R_VE_REFLONG,      1)
+ELF_RELOC(R_VE_REFQUAD,      2)
+ELF_RELOC(R_VE_SREL32,       3)
+ELF_RELOC(R_VE_HI32,         4)
+ELF_RELOC(R_VE_LO32,         5)
+ELF_RELOC(R_VE_PC_HI32,      6)
+ELF_RELOC(R_VE_PC_LO32,      7)
+ELF_RELOC(R_VE_GOT32,        8)
+ELF_RELOC(R_VE_GOT_HI32,     9)
+ELF_RELOC(R_VE_GOT_LO32,     10)
+ELF_RELOC(R_VE_GOTOFF32,     11)
+ELF_RELOC(R_VE_GOTOFF_HI32,  12)
+ELF_RELOC(R_VE_GOTOFF_LO32,  13)
+ELF_RELOC(R_VE_PLT32,        14)
+ELF_RELOC(R_VE_PLT_HI32,     15)
+ELF_RELOC(R_VE_PLT_LO32,     16)
+ELF_RELOC(R_VE_RELATIVE,     17)
+ELF_RELOC(R_VE_GLOB_DAT,     18)
+ELF_RELOC(R_VE_JUMP_SLOT,    19)
+ELF_RELOC(R_VE_COPY,         20)
+ELF_RELOC(R_VE_DTPMOD64,     22)
+ELF_RELOC(R_VE_DTPOFF64,     23)
+// ELF_RELOC(R_VE_TPOFF64,     24)
+ELF_RELOC(R_VE_TLS_GD_HI32,  25)
+ELF_RELOC(R_VE_TLS_GD_LO32,  26)
+// ELF_RELOC(R_VE_TLS_LD_HI32,  27)
+// ELF_RELOC(R_VE_TLS_LD_LO32,  28)
+// ELF_RELOC(R_VE_DTPOFF32,     29)
+// ELF_RELOC(R_VE_TLS_IE_HI32,  30)
+// ELF_RELOC(R_VE_TLS_IE_LO32,  31)
+ELF_RELOC(R_VE_TPOFF_HI32,   32)
+ELF_RELOC(R_VE_TPOFF_LO32,   33)
+// ELF_RELOC(R_VE_TPOFF32,      34)
+ELF_RELOC(R_VE_CALL_HI32,    35)
+ELF_RELOC(R_VE_CALL_LO32,    36)

llvm/include/llvm/Object/ELFObjectFile.h

case ELF::ELFCLASS64:
     case ELF::EM_SPARCV9:
       return "elf64-sparc";
     case ELF::EM_MIPS:
       return "elf64-mips";
     case ELF::EM_AMDGPU:
       return "elf64-amdgpu";
     case ELF::EM_BPF:
       return "elf64-bpf";
+    case ELF::EM_VE:
+      return "elf64-ve";
     default:
       return "elf64-unknown";
     }
   default:
     // FIXME: Proper error handling.
     report_fatal_error("Invalid ELFCLASS!");
   }
 }
if (MACH >= ELF::EF_AMDGPU_MACH_AMDGCN_FIRST &&
       return Triple::amdgcn;
 
     return Triple::UnknownArch;
   }
 
   case ELF::EM_BPF:
     return IsLittleEndian ? Triple::bpfel : Triple::bpfeb;
 
+  case ELF::EM_VE:
+    return Triple::ve;
   default:
     return Triple::UnknownArch;
   }
 }
 
 template <class ELFT>
 Expected<uint64_t> ELFObjectFile<ELFT>::getStartAddress() const {
   return EF.getHeader()->e_entry;

llvm/lib/Object/ELF.cpp

#include "llvm/BinaryFormat/ELFRelocs/BPF.def"
     break;
   case ELF::EM_MSP430:
     switch (Type) {
 #include "llvm/BinaryFormat/ELFRelocs/MSP430.def"
     default:
       break;
     }
     break;
+  case ELF::EM_VE:
+    switch (Type) {
+#include "llvm/BinaryFormat/ELFRelocs/VE.def"
+    default:
+      break;
+    }
+    break;
   default:
     break;
   }
   return "Unknown";
 }
 
 #undef ELF_RELOC
 
uint32_t llvm::object::getELFRelativeRelocationType(uint32_t Machine) {
   case ELF::EM_SPARC:
   case ELF::EM_SPARC32PLUS:
   case ELF::EM_SPARCV9:
     return ELF::R_SPARC_RELATIVE;
   case ELF::EM_AMDGPU:
     break;
   case ELF::EM_BPF:
     break;
   default:
     break;
   }
   return 0;
 }
 
 StringRef llvm::object::getELFSectionTypeName(uint32_t Machine, unsigned Type) {
   switch (Machine) {
   case ELF::EM_ARM:
     switch (Type) {

llvm/lib/ObjectYAML/ELFYAML.cpp

#define ECase(X) IO.enumCase(Value, #X, ELF::X)
   ECase(EM_RL78);
   ECase(EM_VIDEOCORE5);
   ECase(EM_78KOR);
   ECase(EM_56800EX);
   ECase(EM_AMDGPU);
   ECase(EM_RISCV);
   ECase(EM_LANAI);
   ECase(EM_BPF);
+  ECase(EM_VE);
 #undef ECase
   IO.enumFallback<Hex16>(Value);
 }
 
 void ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS>::enumeration(
     IO &IO, ELFYAML::ELF_ELFCLASS &Value) {
 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
   // Since the semantics of ELFCLASSNONE is "invalid", just don't accept it

 #include "llvm/BinaryFormat/ELFRelocs/Lanai.def"
     break;
   case ELF::EM_AMDGPU:
 #include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"
     break;
   case ELF::EM_BPF:
 #include "llvm/BinaryFormat/ELFRelocs/BPF.def"
     break;
+  case ELF::EM_VE:
+#include "llvm/BinaryFormat/ELFRelocs/VE.def"
+    break;
   case ELF::EM_PPC64:
 #include "llvm/BinaryFormat/ELFRelocs/PowerPC64.def"
     break;
   default:
     // Nothing to do.
     break;
   }
 #undef ELF_RELOC

llvm/test/tools/llvm-readobj/ELF/file-header-machine-types.test

+## Show that all machine codes are correctly printed.
+
+# RUN: yaml2obj %s -o %t.none.o -D MACHINE=EM_NONE
+# RUN: llvm-readelf --file-headers %t.none.o | FileCheck %s -DMACHINE="None"
+
+# RUN: yaml2obj %s -o %t.m32.o -D MACHINE=EM_M32
+# RUN: llvm-readelf --file-headers %t.m32.o | FileCheck %s -DMACHINE="WE32100"
+
+# RUN: yaml2obj %s -o %t.sparc.o -D MACHINE=EM_SPARC
+# RUN: llvm-readelf --file-headers %t.sparc.o | FileCheck %s -DMACHINE="Sparc"
+
+# RUN: yaml2obj %s -o %t.386.o -D MACHINE=EM_386
+# RUN: llvm-readelf --file-headers %t.386.o | FileCheck %s -DMACHINE="Intel 80386"
+
+# RUN: yaml2obj %s -o %t.68k.o -D MACHINE=EM_68K
+# RUN: llvm-readelf --file-headers %t.68k.o | FileCheck %s -DMACHINE="MC68000"
+
+# RUN: yaml2obj %s -o %t.88k.o -D MACHINE=EM_88K
+# RUN: llvm-readelf --file-headers %t.88k.o | FileCheck %s -DMACHINE="MC88000"
+
+# RUN: yaml2obj %s -o %t.iamcu.o -D MACHINE=EM_IAMCU
+# RUN: llvm-readelf --file-headers %t.iamcu.o | FileCheck %s -DMACHINE="EM_IAMCU"
+
+# RUN: yaml2obj %s -o %t.860.o -D MACHINE=EM_860
+# RUN: llvm-readelf --file-headers %t.860.o | FileCheck %s -DMACHINE="Intel 80860"
+
+# RUN: yaml2obj %s -o %t.mips.o -D MACHINE=EM_MIPS
+# RUN: llvm-readelf --file-headers %t.mips.o | FileCheck %s -DMACHINE="MIPS R3000"
+
+# RUN: yaml2obj %s -o %t.s370.o -D MACHINE=EM_S370
+# RUN: llvm-readelf --file-headers %t.s370.o | FileCheck %s -DMACHINE="IBM System/370"
+
+# RUN: yaml2obj %s -o %t.mips_rs3_le.o -D MACHINE=EM_MIPS_RS3_LE
+# RUN: llvm-readelf --file-headers %t.mips_rs3_le.o | FileCheck %s -DMACHINE="MIPS R3000 little-endian"
+
+# RUN: yaml2obj %s -o %t.parisc.o -D MACHINE=EM_PARISC
+# RUN: llvm-readelf --file-headers %t.parisc.o | FileCheck %s -DMACHINE="HPPA"
+
+# RUN: yaml2obj %s -o %t.vpp500.o -D MACHINE=EM_VPP500
+# RUN: llvm-readelf --file-headers %t.vpp500.o | FileCheck %s -DMACHINE="Fujitsu VPP500"
+
+# RUN: yaml2obj %s -o %t.sparc32plus.o -D MACHINE=EM_SPARC32PLUS
+# RUN: llvm-readelf --file-headers %t.sparc32plus.o | FileCheck %s -DMACHINE="Sparc v8+"
+
+# RUN: yaml2obj %s -o %t.960.o -D MACHINE=EM_960
+# RUN: llvm-readelf --file-headers %t.960.o | FileCheck %s -DMACHINE="Intel 80960"
+
+# RUN: yaml2obj %s -o %t.ppc.o -D MACHINE=EM_PPC
+# RUN: llvm-readelf --file-headers %t.ppc.o | FileCheck %s -DMACHINE="PowerPC"
+
+# RUN: yaml2obj %s -o %t.ppc64.o -D MACHINE=EM_PPC64
+# RUN: llvm-readelf --file-headers %t.ppc64.o | FileCheck %s -DMACHINE="PowerPC64"
+
+# RUN: yaml2obj %s -o %t.s390.o -D MACHINE=EM_S390
+# RUN: llvm-readelf --file-headers %t.s390.o | FileCheck %s -DMACHINE="IBM S/390"
+
+# RUN: yaml2obj %s -o %t.spu.o -D MACHINE=EM_SPU
+# RUN: llvm-readelf --file-headers %t.spu.o | FileCheck %s -DMACHINE="SPU"
+
+# RUN: yaml2obj %s -o %t.v800.o -D MACHINE=EM_V800
+# RUN: llvm-readelf --file-headers %t.v800.o | FileCheck %s -DMACHINE="NEC V800 series"
+
+# RUN: yaml2obj %s -o %t.fr20.o -D MACHINE=EM_FR20
+# RUN: llvm-readelf --file-headers %t.fr20.o | FileCheck %s -DMACHINE="Fujistsu FR20"
+
+# RUN: yaml2obj %s -o %t.rh32.o -D MACHINE=EM_RH32
+# RUN: llvm-readelf --file-headers %t.rh32.o | FileCheck %s -DMACHINE="TRW RH-32"
+
+# RUN: yaml2obj %s -o %t.rce.o -D MACHINE=EM_RCE
+# RUN: llvm-readelf --file-headers %t.rce.o | FileCheck %s -DMACHINE="Motorola RCE"
+
+# RUN: yaml2obj %s -o %t.arm.o -D MACHINE=EM_ARM
+# RUN: llvm-readelf --file-headers %t.arm.o | FileCheck %s -DMACHINE="ARM"
+
+# RUN: yaml2obj %s -o %t.alpha.o -D MACHINE=EM_ALPHA
+# RUN: llvm-readelf --file-headers %t.alpha.o | FileCheck %s -DMACHINE="EM_ALPHA"
+
+# RUN: yaml2obj %s -o %t.sh.o -D MACHINE=EM_SH
+# RUN: llvm-readelf --file-headers %t.sh.o | FileCheck %s -DMACHINE="Hitachi SH"
+
+# RUN: yaml2obj %s -o %t.sparcv9.o -D MACHINE=EM_SPARCV9
+# RUN: llvm-readelf --file-headers %t.sparcv9.o | FileCheck %s -DMACHINE="Sparc v9"
+
+# RUN: yaml2obj %s -o %t.tricore.o -D MACHINE=EM_TRICORE
+# RUN: llvm-readelf --file-headers %t.tricore.o | FileCheck %s -DMACHINE="Siemens Tricore"
+
+# RUN: yaml2obj %s -o %t.arc.o -D MACHINE=EM_ARC
+# RUN: llvm-readelf --file-headers %t.arc.o | FileCheck %s -DMACHINE="ARC"
+
+# RUN: yaml2obj %s -o %t.h8_300.o -D MACHINE=EM_H8_300
+# RUN: llvm-readelf --file-headers %t.h8_300.o | FileCheck %s -DMACHINE="Hitachi H8/300"
+
+# RUN: yaml2obj %s -o %t.h8_300h.o -D MACHINE=EM_H8_300H
+# RUN: llvm-readelf --file-headers %t.h8_300h.o | FileCheck %s -DMACHINE="Hitachi H8/300H"
+
+# RUN: yaml2obj %s -o %t.h8s.o -D MACHINE=EM_H8S
+# RUN: llvm-readelf --file-headers %t.h8s.o | FileCheck %s -DMACHINE="Hitachi H8S"
+
+# RUN: yaml2obj %s -o %t.h8_500.o -D MACHINE=EM_H8_500
+# RUN: llvm-readelf --file-headers %t.h8_500.o | FileCheck %s -DMACHINE="Hitachi H8/500"
+
+# RUN: yaml2obj %s -o %t.ia_64.o -D MACHINE=EM_IA_64
+# RUN: llvm-readelf --file-headers %t.ia_64.o | FileCheck %s -DMACHINE="Intel IA-64"
+
+# RUN: yaml2obj %s -o %t.mips_x.o -D MACHINE=EM_MIPS_X
+# RUN: llvm-readelf --file-headers %t.mips_x.o | FileCheck %s -DMACHINE="Stanford MIPS-X"
+
+# RUN: yaml2obj %s -o %t.coldfire.o -D MACHINE=EM_COLDFIRE
+# RUN: llvm-readelf --file-headers %t.coldfire.o | FileCheck %s -DMACHINE="Motorola Coldfire"
+
+# RUN: yaml2obj %s -o %t.68hc12.o -D MACHINE=EM_68HC12
+# RUN: llvm-readelf --file-headers %t.68hc12.o | FileCheck %s -DMACHINE="Motorola MC68HC12 Microcontroller"
+
+# RUN: yaml2obj %s -o %t.mma.o -D MACHINE=EM_MMA
+# RUN: llvm-readelf --file-headers %t.mma.o | FileCheck %s -DMACHINE="Fujitsu Multimedia Accelerator"
+
+# RUN: yaml2obj %s -o %t.pcp.o -D MACHINE=EM_PCP
+# RUN: llvm-readelf --file-headers %t.pcp.o | FileCheck %s -DMACHINE="Siemens PCP"
+
+# RUN: yaml2obj %s -o %t.ncpu.o -D MACHINE=EM_NCPU
+# RUN: llvm-readelf --file-headers %t.ncpu.o | FileCheck %s -DMACHINE="Sony nCPU embedded RISC processor"
+
+# RUN: yaml2obj %s -o %t.ndri.o -D MACHINE=EM_NDR1
+# RUN: llvm-readelf --file-headers %t.ndri.o | FileCheck %s -DMACHINE="Denso NDR1 microprocesspr"
+
+# RUN: yaml2obj %s -o %t.starcore.o -D MACHINE=EM_STARCORE
+# RUN: llvm-readelf --file-headers %t.starcore.o | FileCheck %s -DMACHINE="Motorola Star*Core processor"
+
+# RUN: yaml2obj %s -o %t.me16.o -D MACHINE=EM_ME16
+# RUN: llvm-readelf --file-headers %t.me16.o | FileCheck %s -DMACHINE="Toyota ME16 processor"
+
+# RUN: yaml2obj %s -o %t.st100.o -D MACHINE=EM_ST100
+# RUN: llvm-readelf --file-headers %t.st100.o | FileCheck %s -DMACHINE="STMicroelectronics ST100 processor"
+
+# RUN: yaml2obj %s -o %t.tinyj.o -D MACHINE=EM_TINYJ
+# RUN: llvm-readelf --file-headers %t.tinyj.o | FileCheck %s -DMACHINE="Advanced Logic Corp. TinyJ embedded processor"
+
+# RUN: yaml2obj %s -o %t.x86_64.o -D MACHINE=EM_X86_64
+# RUN: llvm-readelf --file-headers %t.x86_64.o | FileCheck %s -DMACHINE="Advanced Micro Devices X86-64"
+
+# RUN: yaml2obj %s -o %t.pdsp.o -D MACHINE=EM_PDSP
+# RUN: llvm-readelf --file-headers %t.pdsp.o | FileCheck %s -DMACHINE="Sony DSP processor"
+
+# RUN: yaml2obj %s -o %t.pdp10.o -D MACHINE=EM_PDP10
+# RUN: llvm-readelf --file-headers %t.pdp10.o | FileCheck %s -DMACHINE="Digital Equipment Corp. PDP-10"
+
+# RUN: yaml2obj %s -o %t.pdp11.o -D MACHINE=EM_PDP11
+# RUN: llvm-readelf --file-headers %t.pdp11.o | FileCheck %s -DMACHINE="Digital Equipment Corp. PDP-11"
+
+# RUN: yaml2obj %s -o %t.fx66.o -D MACHINE=EM_FX66
+# RUN: llvm-readelf --file-headers %t.fx66.o | FileCheck %s -DMACHINE="Siemens FX66 microcontroller"
+
+# RUN: yaml2obj %s -o %t.st9plus.o -D MACHINE=EM_ST9PLUS
+# RUN: llvm-readelf --file-headers %t.st9plus.o | FileCheck %s -DMACHINE="STMicroelectronics ST9+ 8/16 bit microcontroller"
+
+# RUN: yaml2obj %s -o %t.st7.o -D MACHINE=EM_ST7
+# RUN: llvm-readelf --file-headers %t.st7.o | FileCheck %s -DMACHINE="STMicroelectronics ST7 8-bit microcontroller"
+
+# RUN: yaml2obj %s -o %t.68hc16.o -D MACHINE=EM_68HC16
+# RUN: llvm-readelf --file-headers %t.68hc16.o | FileCheck %s -DMACHINE="Motorola MC68HC16 Microcontroller"
+
+# RUN: yaml2obj %s -o %t.68hc11.o -D MACHINE=EM_68HC11
+# RUN: llvm-readelf --file-headers %t.68hc11.o | FileCheck %s -DMACHINE="Motorola MC68HC11 Microcontroller"
+
+# RUN: yaml2obj %s -o %t.68hc08.o -D MACHINE=EM_68HC08
+# RUN: llvm-readelf --file-headers %t.68hc08.o | FileCheck %s -DMACHINE="Motorola MC68HC08 Microcontroller"
+
+# RUN: yaml2obj %s -o %t.68hc05.o -D MACHINE=EM_68HC05
+# RUN: llvm-readelf --file-headers %t.68hc05.o | FileCheck %s -DMACHINE="Motorola MC68HC05 Microcontroller"
+
+# RUN: yaml2obj %s -o %t.svx.o -D MACHINE=EM_SVX
+# RUN: llvm-readelf --file-headers %t.svx.o | FileCheck %s -DMACHINE="Silicon Graphics SVx"
+
+# RUN: yaml2obj %s -o %t.st19.o -D MACHINE=EM_ST19
+# RUN: llvm-readelf --file-headers %t.st19.o | FileCheck %s -DMACHINE="STMicroelectronics ST19 8-bit microcontroller"
+
+# RUN: yaml2obj %s -o %t.vax.o -D MACHINE=EM_VAX
+# RUN: llvm-readelf --file-headers %t.vax.o | FileCheck %s -DMACHINE="Digital VAX"
+
+# RUN: yaml2obj %s -o %t.cris.o -D MACHINE=EM_CRIS
+# RUN: llvm-readelf --file-headers %t.cris.o | FileCheck %s -DMACHINE="Axis Communications 32-bit embedded processor"
+
+# RUN: yaml2obj %s -o %t.javelin.o -D MACHINE=EM_JAVELIN
+# RUN: llvm-readelf --file-headers %t.javelin.o | FileCheck %s -DMACHINE="Infineon Technologies 32-bit embedded cpu"
+
+# RUN: yaml2obj %s -o %t.firepath.o -D MACHINE=EM_FIREPATH
+# RUN: llvm-readelf --file-headers %t.firepath.o | FileCheck %s -DMACHINE="Element 14 64-bit DSP processor"
+
+# RUN: yaml2obj %s -o %t.zsp.o -D MACHINE=EM_ZSP
+# RUN: llvm-readelf --file-headers %t.zsp.o | FileCheck %s -DMACHINE="LSI Logic's 16-bit DSP processor"
+
+# RUN: yaml2obj %s -o %t.mmix.o -D MACHINE=EM_MMIX
+# RUN: llvm-readelf --file-headers %t.mmix.o | FileCheck %s -DMACHINE="Donald Knuth's educational 64-bit processor"
+
+# RUN: yaml2obj %s -o %t.huany.o -D MACHINE=EM_HUANY
+# RUN: llvm-readelf --file-headers %t.huany.o | FileCheck %s -DMACHINE="Harvard Universitys's machine-independent object format"
+
+# RUN: yaml2obj %s -o %t.prism.o -D MACHINE=EM_PRISM
+# RUN: llvm-readelf --file-headers %t.prism.o | FileCheck %s -DMACHINE="Vitesse Prism"
+
+# RUN: yaml2obj %s -o %t.avr.o -D MACHINE=EM_AVR
+# RUN: llvm-readelf --file-headers %t.avr.o | FileCheck %s -DMACHINE="Atmel AVR 8-bit microcontroller"
+
+# RUN: yaml2obj %s -o %t.fr30.o -D MACHINE=EM_FR30
+# RUN: llvm-readelf --file-headers %t.fr30.o | FileCheck %s -DMACHINE="Fujitsu FR30"
+
+# RUN: yaml2obj %s -o %t.d10v.o -D MACHINE=EM_D10V
+# RUN: llvm-readelf --file-headers %t.d10v.o | FileCheck %s -DMACHINE="Mitsubishi D10V"
+
+# RUN: yaml2obj %s -o %t.d30v.o -D MACHINE=EM_D30V
+# RUN: llvm-readelf --file-headers %t.d30v.o | FileCheck %s -DMACHINE="Mitsubishi D30V"
+
+# RUN: yaml2obj %s -o %t.v850.o -D MACHINE=EM_V850
+# RUN: llvm-readelf --file-headers %t.v850.o | FileCheck %s -DMACHINE="NEC v850"
+
+# RUN: yaml2obj %s -o %t.m32r.o -D MACHINE=EM_M32R
+# RUN: llvm-readelf --file-headers %t.m32r.o | FileCheck %s -DMACHINE="Renesas M32R (formerly Mitsubishi M32r)"
+
+# RUN: yaml2obj %s -o %t.mn10300.o -D MACHINE=EM_MN10300
+# RUN: llvm-readelf --file-headers %t.mn10300.o | FileCheck %s -DMACHINE="Matsushita MN10300"
+
+# RUN: yaml2obj %s -o %t.mn10200.o -D MACHINE=EM_MN10200
+# RUN: llvm-readelf --file-headers %t.mn10200.o | FileCheck %s -DMACHINE="Matsushita MN10200"
+
+# RUN: yaml2obj %s -o %t.pj.o -D MACHINE=EM_PJ
+# RUN: llvm-readelf --file-headers %t.pj.o | FileCheck %s -DMACHINE="picoJava"
+
+# RUN: yaml2obj %s -o %t.openrisc.o -D MACHINE=EM_OPENRISC
+# RUN: llvm-readelf --file-headers %t.openrisc.o | FileCheck %s -DMACHINE="OpenRISC 32-bit embedded processor"
+
+# RUN: yaml2obj %s -o %t.arc_compact.o -D MACHINE=EM_ARC_COMPACT
+# RUN: llvm-readelf --file-headers %t.arc_compact.o | FileCheck %s -DMACHINE="EM_ARC_COMPACT"
+
+# RUN: yaml2obj %s -o %t.xtensa.o -D MACHINE=EM_XTENSA
+# RUN: llvm-readelf --file-headers %t.xtensa.o | FileCheck %s -DMACHINE="Tensilica Xtensa Processor"
+
+# RUN: yaml2obj %s -o %t.videocore.o -D MACHINE=EM_VIDEOCORE
+# RUN: llvm-readelf --file-headers %t.videocore.o | FileCheck %s -DMACHINE="Alphamosaic VideoCore processor"
+
+# RUN: yaml2obj %s -o %t.tmm_gpp.o -D MACHINE=EM_TMM_GPP
+# RUN: llvm-readelf --file-headers %t.tmm_gpp.o | FileCheck %s -DMACHINE="Thompson Multimedia General Purpose Processor"
+
+# RUN: yaml2obj %s -o %t.ns32k.o -D MACHINE=EM_NS32K
+# RUN: llvm-readelf --file-headers %t.ns32k.o | FileCheck %s -DMACHINE="National Semiconductor 32000 series"
+
+# RUN: yaml2obj %s -o %t.tpc.o -D MACHINE=EM_TPC
+# RUN: llvm-readelf --file-headers %t.tpc.o | FileCheck %s -DMACHINE="Tenor Network TPC processor"
+
+# RUN: yaml2obj %s -o %t.snp1k.o -D MACHINE=EM_SNP1K
+# RUN: llvm-readelf --file-headers %t.snp1k.o | FileCheck %s -DMACHINE="EM_SNP1K"
+
+# RUN: yaml2obj %s -o %t.st200.o -D MACHINE=EM_ST200
+# RUN: llvm-readelf --file-headers %t.st200.o | FileCheck %s -DMACHINE="STMicroelectronics ST200 microcontroller"
+
+# RUN: yaml2obj %s -o %t.ip2k.o -D MACHINE=EM_IP2K
+# RUN: llvm-readelf --file-headers %t.ip2k.o | FileCheck %s -DMACHINE="Ubicom IP2xxx 8-bit microcontrollers"
+
+# RUN: yaml2obj %s -o %t.max.o -D MACHINE=EM_MAX
+# RUN: llvm-readelf --file-headers %t.max.o | FileCheck %s -DMACHINE="MAX Processor"
+
+# RUN: yaml2obj %s -o %t.cr.o -D MACHINE=EM_CR
+# RUN: llvm-readelf --file-headers %t.cr.o | FileCheck %s -DMACHINE="National Semiconductor CompactRISC"
+
+# RUN: yaml2obj %s -o %t.f2mc16.o -D MACHINE=EM_F2MC16
+# RUN: llvm-readelf --file-headers %t.f2mc16.o | FileCheck %s -DMACHINE="Fujitsu F2MC16"
+
+# RUN: yaml2obj %s -o %t.msp430.o -D MACHINE=EM_MSP430
+# RUN: llvm-readelf --file-headers %t.msp430.o | FileCheck %s -DMACHINE="Texas Instruments msp430 microcontroller"
+
+# RUN: yaml2obj %s -o %t.blackfin.o -D MACHINE=EM_BLACKFIN
+# RUN: llvm-readelf --file-headers %t.blackfin.o | FileCheck %s -DMACHINE="Analog Devices Blackfin"
+
+# RUN: yaml2obj %s -o %t.se_c33.o -D MACHINE=EM_SE_C33
+# RUN: llvm-readelf --file-headers %t.se_c33.o | FileCheck %s -DMACHINE="S1C33 Family of Seiko Epson processors"
+
+# RUN: yaml2obj %s -o %t.sep.o -D MACHINE=EM_SEP
+# RUN: llvm-readelf --file-headers %t.sep.o | FileCheck %s -DMACHINE="Sharp embedded microprocessor"
+
+# RUN: yaml2obj %s -o %t.arca.o -D MACHINE=EM_ARCA
+# RUN: llvm-readelf --file-headers %t.arca.o | FileCheck %s -DMACHINE="Arca RISC microprocessor"
+
+# RUN: yaml2obj %s -o %t.unicore.o -D MACHINE=EM_UNICORE
+# RUN: llvm-readelf --file-headers %t.unicore.o | FileCheck %s -DMACHINE="Unicore"
+
+# RUN: yaml2obj %s -o %t.excess.o -D MACHINE=EM_EXCESS
+# RUN: llvm-readelf --file-headers %t.excess.o | FileCheck %s -DMACHINE="eXcess 16/32/64-bit configurable embedded CPU"
+
+# RUN: yaml2obj %s -o %t.dxp.o -D MACHINE=EM_DXP
+# RUN: llvm-readelf --file-headers %t.dxp.o | FileCheck %s -DMACHINE="Icera Semiconductor Inc. Deep Execution Processor"
+
+# RUN: yaml2obj %s -o %t.altera_nios2.o -D MACHINE=EM_ALTERA_NIOS2
+# RUN: llvm-readelf --file-headers %t.altera_nios2.o | FileCheck %s -DMACHINE="Altera Nios"
+
+# RUN: yaml2obj %s -o %t.crx.o -D MACHINE=EM_CRX
+# RUN: llvm-readelf --file-headers %t.crx.o | FileCheck %s -DMACHINE="National Semiconductor CRX microprocessor"
+
+# RUN: yaml2obj %s -o %t.xgate.o -D MACHINE=EM_XGATE
+# RUN: llvm-readelf --file-headers %t.xgate.o | FileCheck %s -DMACHINE="Motorola XGATE embedded processor"
+
+# RUN: yaml2obj %s -o %t.c166.o -D MACHINE=EM_C166
+# RUN: llvm-readelf --file-headers %t.c166.o | FileCheck %s -DMACHINE="Infineon Technologies xc16x"
+
+# RUN: yaml2obj %s -o %t.m16c.o -D MACHINE=EM_M16C
+# RUN: llvm-readelf --file-headers %t.m16c.o | FileCheck %s -DMACHINE="Renesas M16C"
+
+# RUN: yaml2obj %s -o %t.dspic30f.o -D MACHINE=EM_DSPIC30F
+# RUN: llvm-readelf --file-headers %t.dspic30f.o | FileCheck %s -DMACHINE="Microchip Technology dsPIC30F Digital Signal Controller"
+
+# RUN: yaml2obj %s -o %t.ce.o -D MACHINE=EM_CE
+# RUN: llvm-readelf --file-headers %t.ce.o | FileCheck %s -DMACHINE="Freescale Communication Engine RISC core"
+
+# RUN: yaml2obj %s -o %t.m32c.o -D MACHINE=EM_M32C
+# RUN: llvm-readelf --file-headers %t.m32c.o | FileCheck %s -DMACHINE="Renesas M32C"
+
+# RUN: yaml2obj %s -o %t.tsk3000.o -D MACHINE=EM_TSK3000
+# RUN: llvm-readelf --file-headers %t.tsk3000.o | FileCheck %s -DMACHINE="Altium TSK3000 core"
+
+# RUN: yaml2obj %s -o %t.rs08.o -D MACHINE=EM_RS08
+# RUN: llvm-readelf --file-headers %t.rs08.o | FileCheck %s -DMACHINE="Freescale RS08 embedded processor"
+
+# RUN: yaml2obj %s -o %t.sharc.o -D MACHINE=EM_SHARC
+# RUN: llvm-readelf --file-headers %t.sharc.o | FileCheck %s -DMACHINE="EM_SHARC"
+
+# RUN: yaml2obj %s -o %t.ecog2.o -D MACHINE=EM_ECOG2
+# RUN: llvm-readelf --file-headers %t.ecog2.o | FileCheck %s -DMACHINE="Cyan Technology eCOG2 microprocessor"
+
+# RUN: yaml2obj %s -o %t.score7.o -D MACHINE=EM_SCORE7
+# RUN: llvm-readelf --file-headers %t.score7.o | FileCheck %s -DMACHINE="SUNPLUS S+Core"
+
+# RUN: yaml2obj %s -o %t.dsp24.o -D MACHINE=EM_DSP24
+# RUN: llvm-readelf --file-headers %t.dsp24.o | FileCheck %s -DMACHINE="New Japan Radio (NJR) 24-bit DSP Processor"
+
+# RUN: yaml2obj %s -o %t.videocore3.o -D MACHINE=EM_VIDEOCORE3
+# RUN: llvm-readelf --file-headers %t.videocore3.o | FileCheck %s -DMACHINE="Broadcom VideoCore III processor"
+
+# RUN: yaml2obj %s -o %t.latticemico32.o -D MACHINE=EM_LATTICEMICO32
+# RUN: llvm-readelf --file-headers %t.latticemico32.o | FileCheck %s -DMACHINE="Lattice Mico32"
+
+# RUN: yaml2obj %s -o %t.se_c17.o -D MACHINE=EM_SE_C17
+# RUN: llvm-readelf --file-headers %t.se_c17.o | FileCheck %s -DMACHINE="Seiko Epson C17 family"
+
+# RUN: yaml2obj %s -o %t.ti_c6000.o -D MACHINE=EM_TI_C6000
+# RUN: llvm-readelf --file-headers %t.ti_c6000.o | FileCheck %s -DMACHINE="Texas Instruments TMS320C6000 DSP family"
+
+# RUN: yaml2obj %s -o %t.ti_c2000.o -D MACHINE=EM_TI_C2000
+# RUN: llvm-readelf --file-headers %t.ti_c2000.o | FileCheck %s -DMACHINE="Texas Instruments TMS320C2000 DSP family"
+
+# RUN: yaml2obj %s -o %t.ti_c5500.o -D MACHINE=EM_TI_C5500
+# RUN: llvm-readelf --file-headers %t.ti_c5500.o | FileCheck %s -DMACHINE="Texas Instruments TMS320C55x DSP family"
+
+# RUN: yaml2obj %s -o %t.mmdsp_plus.o -D MACHINE=EM_MMDSP_PLUS
+# RUN: llvm-readelf --file-headers %t.mmdsp_plus.o | FileCheck %s -DMACHINE="STMicroelectronics 64bit VLIW Data Signal Processor"
+
+# RUN: yaml2obj %s -o %t.cypress_m8c.o -D MACHINE=EM_CYPRESS_M8C
+# RUN: llvm-readelf --file-headers %t.cypress_m8c.o | FileCheck %s -DMACHINE="Cypress M8C microprocessor"
+
+# RUN: yaml2obj %s -o %t.r32c.o -D MACHINE=EM_R32C
+# RUN: llvm-readelf --file-headers %t.r32c.o | FileCheck %s -DMACHINE="Renesas R32C series microprocessors"
+
+# RUN: yaml2obj %s -o %t.trimedia.o -D MACHINE=EM_TRIMEDIA
+# RUN: llvm-readelf --file-headers %t.trimedia.o | FileCheck %s -DMACHINE="NXP Semiconductors TriMedia architecture family"
+
+# RUN: yaml2obj %s -o %t.hexagon.o -D MACHINE=EM_HEXAGON
+# RUN: llvm-readelf --file-headers %t.hexagon.o | FileCheck %s -DMACHINE="Qualcomm Hexagon"
+
+# RUN: yaml2obj %s -o %t.8051.o -D MACHINE=EM_8051
+# RUN: llvm-readelf --file-headers %t.8051.o | FileCheck %s -DMACHINE="Intel 8051 and variants"
+
+# RUN: yaml2obj %s -o %t.stxp7x.o -D MACHINE=EM_STXP7X
+# RUN: llvm-readelf --file-headers %t.stxp7x.o | FileCheck %s -DMACHINE="STMicroelectronics STxP7x family"
+
+# RUN: yaml2obj %s -o %t.nds32.o -D MACHINE=EM_NDS32
+# RUN: llvm-readelf --file-headers %t.nds32.o | FileCheck %s -DMACHINE="Andes Technology compact code size embedded RISC processor family"
+
+# RUN: yaml2obj %s -o %t.ecog1.o -D MACHINE=EM_ECOG1
+# RUN: llvm-readelf --file-headers %t.ecog1.o | FileCheck %s -DMACHINE="Cyan Technology eCOG1 microprocessor"
+
+# RUN: yaml2obj %s -o %t.maxq30.o -D MACHINE=EM_MAXQ30
+# RUN: llvm-readelf --file-headers %t.maxq30.o | FileCheck %s -DMACHINE="Dallas Semiconductor MAXQ30 Core microcontrollers"
+
+# RUN: yaml2obj %s -o %t.ximo16.o -D MACHINE=EM_XIMO16
+# RUN: llvm-readelf --file-headers %t.ximo16.o | FileCheck %s -DMACHINE="New Japan Radio (NJR) 16-bit DSP Processor"
+
+# RUN: yaml2obj %s -o %t.manik.o -D MACHINE=EM_MANIK
+# RUN: llvm-readelf --file-headers %t.manik.o | FileCheck %s -DMACHINE="M2000 Reconfigurable RISC Microprocessor"
+
+# RUN: yaml2obj %s -o %t.craynv2.o -D MACHINE=EM_CRAYNV2
+# RUN: llvm-readelf --file-headers %t.craynv2.o | FileCheck %s -DMACHINE="Cray Inc. NV2 vector architecture"
+
+# RUN: yaml2obj %s -o %t.rx.o -D MACHINE=EM_RX
+# RUN: llvm-readelf --file-headers %t.rx.o | FileCheck %s -DMACHINE="Renesas RX"
+
+# RUN: yaml2obj %s -o %t.metag.o -D MACHINE=EM_METAG
+# RUN: llvm-readelf --file-headers %t.metag.o | FileCheck %s -DMACHINE="Imagination Technologies Meta processor architecture"
+
+# RUN: yaml2obj %s -o %t.mcst_elbrus.o -D MACHINE=EM_MCST_ELBRUS
+# RUN: llvm-readelf --file-headers %t.mcst_elbrus.o | FileCheck %s -DMACHINE="MCST Elbrus general purpose hardware architecture"
+
+# RUN: yaml2obj %s -o %t.ecog16.o -D MACHINE=EM_ECOG16
+# RUN: llvm-readelf --file-headers %t.ecog16.o | FileCheck %s -DMACHINE="Cyan Technology eCOG16 family"
+
+# RUN: yaml2obj %s -o %t.cr16.o -D MACHINE=EM_CR16
+# RUN: llvm-readelf --file-headers %t.cr16.o | FileCheck %s -DMACHINE="Xilinx MicroBlaze"
+
+# RUN: yaml2obj %s -o %t.etpu.o -D MACHINE=EM_ETPU
+# RUN: llvm-readelf --file-headers %t.etpu.o | FileCheck %s -DMACHINE="Freescale Extended Time Processing Unit"
+
+# RUN: yaml2obj %s -o %t.sle9x.o -D MACHINE=EM_SLE9X
+# RUN: llvm-readelf --file-headers %t.sle9x.o | FileCheck %s -DMACHINE="Infineon Technologies SLE9X core"
+
+# RUN: yaml2obj %s -o %t.l10m.o -D MACHINE=EM_L10M
+# RUN: llvm-readelf --file-headers %t.l10m.o | FileCheck %s -DMACHINE="EM_L10M"
+
+# RUN: yaml2obj %s -o %t.k10m.o -D MACHINE=EM_K10M
+# RUN: llvm-readelf --file-headers %t.k10m.o | FileCheck %s -DMACHINE="EM_K10M"
+
+# RUN: yaml2obj %s -o %t.aarch64.o -D MACHINE=EM_AARCH64
+# RUN: llvm-readelf --file-headers %t.aarch64.o | FileCheck %s -DMACHINE="AArch64"
+
+# RUN: yaml2obj %s -o %t.avr32.o -D MACHINE=EM_AVR32
+# RUN: llvm-readelf --file-headers %t.avr32.o | FileCheck %s -DMACHINE="Atmel Corporation 32-bit microprocessor family"
+
+# RUN: yaml2obj %s -o %t.stm8.o -D MACHINE=EM_STM8
+# RUN: llvm-readelf --file-headers %t.stm8.o | FileCheck %s -DMACHINE="STMicroeletronics STM8 8-bit microcontroller"
+
+# RUN: yaml2obj %s -o %t.tile64.o -D MACHINE=EM_TILE64
+# RUN: llvm-readelf --file-headers %t.tile64.o | FileCheck %s -DMACHINE="Tilera TILE64 multicore architecture family"
+
+# RUN: yaml2obj %s -o %t.tilepro.o -D MACHINE=EM_TILEPRO
+# RUN: llvm-readelf --file-headers %t.tilepro.o | FileCheck %s -DMACHINE="Tilera TILEPro multicore architecture family"
+
+# RUN: yaml2obj %s -o %t.cuda.o -D MACHINE=EM_CUDA
+# RUN: llvm-readelf --file-headers %t.cuda.o | FileCheck %s -DMACHINE="NVIDIA CUDA architecture"
+
+# RUN: yaml2obj %s -o %t.tilegx.o -D MACHINE=EM_TILEGX
+# RUN: llvm-readelf --file-headers %t.tilegx.o | FileCheck %s -DMACHINE="Tilera TILE-Gx multicore architecture family"
+
+# RUN: yaml2obj %s -o %t.cloudshield.o -D MACHINE=EM_CLOUDSHIELD
+# RUN: llvm-readelf --file-headers %t.cloudshield.o | FileCheck %s -DMACHINE="EM_CLOUDSHIELD"
+
+# RUN: yaml2obj %s -o %t.corea_1st.o -D MACHINE=EM_COREA_1ST
+# RUN: llvm-readelf --file-headers %t.corea_1st.o | FileCheck %s -DMACHINE="EM_COREA_1ST"
+
+# RUN: yaml2obj %s -o %t.corea_2nd.o -D MACHINE=EM_COREA_2ND
+# RUN: llvm-readelf --file-headers %t.corea_2nd.o | FileCheck %s -DMACHINE="EM_COREA_2ND"
+
+# RUN: yaml2obj %s -o %t.arc_compact2.o -D MACHINE=EM_ARC_COMPACT2
+# RUN: llvm-readelf --file-headers %t.arc_compact2.o | FileCheck %s -DMACHINE="EM_ARC_COMPACT2"
+
+# RUN: yaml2obj %s -o %t.open8.o -D MACHINE=EM_OPEN8
+# RUN: llvm-readelf --file-headers %t.open8.o | FileCheck %s -DMACHINE="EM_OPEN8"
+
+# RUN: yaml2obj %s -o %t.rl78.o -D MACHINE=EM_RL78
+# RUN: llvm-readelf --file-headers %t.rl78.o | FileCheck %s -DMACHINE="Renesas RL78"
+
+# RUN: yaml2obj %s -o %t.videocore5.o -D MACHINE=EM_VIDEOCORE5
+# RUN: llvm-readelf --file-headers %t.videocore5.o | FileCheck %s -DMACHINE="Broadcom VideoCore V processor"
+
+# RUN: yaml2obj %s -o %t.78kor.o -D MACHINE=EM_78KOR
+# RUN: llvm-readelf --file-headers %t.78kor.o | FileCheck %s -DMACHINE="EM_78KOR"
+
+# RUN: yaml2obj %s -o %t.56800ex.o -D MACHINE=EM_56800EX
+# RUN: llvm-readelf --file-headers %t.56800ex.o | FileCheck %s -DMACHINE="EM_56800EX"
+
+# RUN: yaml2obj %s -o %t.amdgpu.o -D MACHINE=EM_AMDGPU
+# RUN: llvm-readelf --file-headers %t.amdgpu.o | FileCheck %s -DMACHINE="EM_AMDGPU"
+
+# RUN: yaml2obj %s -o %t.riscv.o -D MACHINE=EM_RISCV
+# RUN: llvm-readelf --file-headers %t.riscv.o | FileCheck %s -DMACHINE="RISC-V"
+
+# RUN: yaml2obj %s -o %t.lanai.o -D MACHINE=EM_LANAI
+# RUN: llvm-readelf --file-headers %t.lanai.o | FileCheck %s -DMACHINE="EM_LANAI"
+
+# RUN: yaml2obj %s -o %t.bpf.o -D MACHINE=EM_BPF
+# RUN: llvm-readelf --file-headers %t.bpf.o | FileCheck %s -DMACHINE="EM_BPF"
+
+# RUN: yaml2obj %s -o %t.ve.o -D MACHINE=EM_VE
+# RUN: llvm-readelf --file-headers %t.ve.o | FileCheck %s -DMACHINE="NEC SX-Aurora Vector Engine"
+
+# CHECK: Machine: [[MACHINE]]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: [[MACHINE]]

llvm/tools/llvm-readobj/ELFDumper.cpp

static const EnumEntry<unsigned> ElfMachineType[] = {
   ENUM_ENT(EM_CYPRESS_M8C,   "Cypress M8C microprocessor"),
   ENUM_ENT(EM_R32C,          "Renesas R32C series microprocessors"),
   ENUM_ENT(EM_TRIMEDIA,      "NXP Semiconductors TriMedia architecture family"),
   ENUM_ENT(EM_HEXAGON,       "Qualcomm Hexagon"),
   ENUM_ENT(EM_8051,          "Intel 8051 and variants"),
   ENUM_ENT(EM_STXP7X,        "STMicroelectronics STxP7x family"),
   ENUM_ENT(EM_NDS32,         "Andes Technology compact code size embedded RISC processor family"),
   ENUM_ENT(EM_ECOG1,         "Cyan Technology eCOG1 microprocessor"),
+  // FIXME: Following EM_ECOG1X definitions is dead code since EM_ECOG1X has
+  //        an identical number to EM_ECOG1.
   ENUM_ENT(EM_ECOG1X,        "Cyan Technology eCOG1X family"),
   ENUM_ENT(EM_MAXQ30,        "Dallas Semiconductor MAXQ30 Core microcontrollers"),
   ENUM_ENT(EM_XIMO16,        "New Japan Radio (NJR) 16-bit DSP Processor"),
   ENUM_ENT(EM_MANIK,         "M2000 Reconfigurable RISC Microprocessor"),
   ENUM_ENT(EM_CRAYNV2,       "Cray Inc. NV2 vector architecture"),
   ENUM_ENT(EM_RX,            "Renesas RX"),
   ENUM_ENT(EM_METAG,         "Imagination Technologies Meta processor architecture"),
   ENUM_ENT(EM_MCST_ELBRUS,   "MCST Elbrus general purpose hardware architecture"),
static const EnumEntry<unsigned> ElfMachineType[] = {
   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_RISCV,         "RISC-V"),
   ENUM_ENT(EM_LANAI,         "EM_LANAI"),
   ENUM_ENT(EM_BPF,           "EM_BPF"),
+  ENUM_ENT(EM_VE,            "NEC SX-Aurora Vector Engine"),
 };
 
 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}};
 

llvm/unittests/Object/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   BinaryFormat
   Object
   )
 
 add_llvm_unittest(ObjectTests
   ArchiveTest.cpp
+  ELFObjectFileTest.cpp
+  ELFTest.cpp
   MinidumpTest.cpp
   ObjectFileTest.cpp
   SymbolSizeTest.cpp
   SymbolicFileTest.cpp
   )
 
 target_link_libraries(ObjectTests PRIVATE LLVMTestingSupport)

llvm/unittests/Object/ELFObjectFileTest.cpp

+//===- ELFObjectFileTest.cpp - Tests for ELFObjectFile --------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Testing/Support/Error.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::object;
+
+template <class ELFT>
+static Expected<ELFObjectFile<ELFT>> create(ArrayRef<uint8_t> Data) {
+  return ELFObjectFile<ELFT>::create(
+      MemoryBufferRef(toStringRef(Data), "Test buffer"));
+}
+
+// A class to initialize a buffer to represent an ELF object file.
+struct DataForTest {
+  std::vector<uint8_t> Data;
+
+  template <typename T>
+  std::vector<uint8_t> makeElfData(uint8_t Class, uint8_t Encoding,
+                                   uint16_t Machine) {
+    T Ehdr{}; // Zero-initialise the header.
+    Ehdr.e_ident[ELF::EI_MAG0] = 0x7f;
+    Ehdr.e_ident[ELF::EI_MAG1] = 'E';
+    Ehdr.e_ident[ELF::EI_MAG2] = 'L';
+    Ehdr.e_ident[ELF::EI_MAG3] = 'F';
+    Ehdr.e_ident[ELF::EI_CLASS] = Class;
+    Ehdr.e_ident[ELF::EI_DATA] = Encoding;
+    Ehdr.e_ident[ELF::EI_VERSION] = 1;
+    Ehdr.e_type = ELF::ET_REL;
+    Ehdr.e_machine = Machine;
+    Ehdr.e_version = 1;
+    Ehdr.e_ehsize = sizeof(T);
+
+    bool IsLittleEndian = Encoding == ELF::ELFDATA2LSB;
+    if (sys::IsLittleEndianHost != IsLittleEndian) {
+      sys::swapByteOrder(Ehdr.e_type);
+      sys::swapByteOrder(Ehdr.e_machine);
+      sys::swapByteOrder(Ehdr.e_version);
+      sys::swapByteOrder(Ehdr.e_ehsize);
+    }
+
+    uint8_t *EhdrBytes = reinterpret_cast<uint8_t *>(&Ehdr);
+    std::vector<uint8_t> Bytes;
+    std::copy(EhdrBytes, EhdrBytes + sizeof(Ehdr), std::back_inserter(Bytes));
+    return Bytes;
+  }
+
+  DataForTest(uint8_t Class, uint8_t Encoding, uint16_t Machine) {
+    if (Class == ELF::ELFCLASS64)
+      Data = makeElfData<ELF::Elf64_Ehdr>(Class, Encoding, Machine);
+    else {
+      assert(Class == ELF::ELFCLASS32);
+      Data = makeElfData<ELF::Elf64_Ehdr>(Class, Encoding, Machine);
+    }
+  }
+};
+
+TEST(ELFObjectFileTest, MachineTestForVE) {
+  DataForTest Data(ELF::ELFCLASS64, ELF::ELFDATA2LSB, ELF::EM_VE);
+  auto ExpectedFile = create<ELF64LE>(Data.Data);
+  ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+  const ELFObjectFile<ELF64LE> &File = *ExpectedFile;
+  EXPECT_EQ("elf64-ve", File.getFileFormatName());
+  EXPECT_EQ(Triple::ve, File.getArch());
+}
+
+TEST(ELFObjectFileTest, MachineTestForX86_64) {
+  DataForTest Data(ELF::ELFCLASS64, ELF::ELFDATA2LSB, ELF::EM_X86_64);
+  auto ExpectedFile = create<ELF64LE>(Data.Data);
+  ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+  const ELFObjectFile<ELF64LE> &File = *ExpectedFile;
+  EXPECT_EQ("elf64-x86-64", File.getFileFormatName());
+  EXPECT_EQ(Triple::x86_64, File.getArch());
+}
+
+TEST(ELFObjectFileTest, MachineTestFor386) {
+  DataForTest Data(ELF::ELFCLASS32, ELF::ELFDATA2LSB, ELF::EM_386);
+  auto ExpectedFile = create<ELF32LE>(Data.Data);
+  ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+  const ELFObjectFile<ELF32LE> &File = *ExpectedFile;
+  EXPECT_EQ("elf32-i386", File.getFileFormatName());
+  EXPECT_EQ(Triple::x86, File.getArch());
+}
+
+TEST(ELFObjectFileTest, MachineTestForMIPS) {
+  {
+    DataForTest Data(ELF::ELFCLASS64, ELF::ELFDATA2LSB, ELF::EM_MIPS);
+    auto ExpectedFile = create<ELF64LE>(Data.Data);
+    ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+    const ELFObjectFile<ELF64LE> &File = *ExpectedFile;
+    EXPECT_EQ("elf64-mips", File.getFileFormatName());
+    EXPECT_EQ(Triple::mips64el, File.getArch());
+  }
+  {
+    DataForTest Data(ELF::ELFCLASS64, ELF::ELFDATA2MSB, ELF::EM_MIPS);
+    auto ExpectedFile = create<ELF64BE>(Data.Data);
+    ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+    const ELFObjectFile<ELF64BE> &File = *ExpectedFile;
+    EXPECT_EQ("elf64-mips", File.getFileFormatName());
+    EXPECT_EQ(Triple::mips64, File.getArch());
+  }
+  {
+    DataForTest Data(ELF::ELFCLASS32, ELF::ELFDATA2LSB, ELF::EM_MIPS);
+    auto ExpectedFile = create<ELF32LE>(Data.Data);
+    ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+    const ELFObjectFile<ELF32LE> &File = *ExpectedFile;
+    EXPECT_EQ("elf32-mips", File.getFileFormatName());
+    EXPECT_EQ(Triple::mipsel, File.getArch());
+  }
+  {
+    DataForTest Data(ELF::ELFCLASS32, ELF::ELFDATA2MSB, ELF::EM_MIPS);
+    auto ExpectedFile = create<ELF32BE>(Data.Data);
+    ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+    const ELFObjectFile<ELF32BE> &File = *ExpectedFile;
+    EXPECT_EQ("elf32-mips", File.getFileFormatName());
+    EXPECT_EQ(Triple::mips, File.getArch());
+  }
+}

llvm/unittests/Object/ELFTest.cpp

+//===- ELFTest.cpp - Tests for ELF.cpp ------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Object/ELF.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::object;
+using namespace llvm::ELF;
+
+TEST(ELFTest, getELFRelocationTypeNameForVE) {
+  EXPECT_EQ("R_VE_NONE", getELFRelocationTypeName(EM_VE, R_VE_NONE));
+  EXPECT_EQ("R_VE_REFLONG", getELFRelocationTypeName(EM_VE, R_VE_REFLONG));
+  EXPECT_EQ("R_VE_REFQUAD", getELFRelocationTypeName(EM_VE, R_VE_REFQUAD));
+  EXPECT_EQ("R_VE_SREL32", getELFRelocationTypeName(EM_VE, R_VE_SREL32));
+  EXPECT_EQ("R_VE_HI32", getELFRelocationTypeName(EM_VE, R_VE_HI32));
+  EXPECT_EQ("R_VE_LO32", getELFRelocationTypeName(EM_VE, R_VE_LO32));
+  EXPECT_EQ("R_VE_PC_HI32", getELFRelocationTypeName(EM_VE, R_VE_PC_HI32));
+  EXPECT_EQ("R_VE_PC_LO32", getELFRelocationTypeName(EM_VE, R_VE_PC_LO32));
+  EXPECT_EQ("R_VE_GOT32", getELFRelocationTypeName(EM_VE, R_VE_GOT32));
+  EXPECT_EQ("R_VE_GOT_HI32", getELFRelocationTypeName(EM_VE, R_VE_GOT_HI32));
+  EXPECT_EQ("R_VE_GOT_LO32", getELFRelocationTypeName(EM_VE, R_VE_GOT_LO32));
+  EXPECT_EQ("R_VE_GOTOFF32", getELFRelocationTypeName(EM_VE, R_VE_GOTOFF32));
+  EXPECT_EQ("R_VE_GOTOFF_HI32",
+            getELFRelocationTypeName(EM_VE, R_VE_GOTOFF_HI32));
+  EXPECT_EQ("R_VE_GOTOFF_LO32",
+            getELFRelocationTypeName(EM_VE, R_VE_GOTOFF_LO32));
+  EXPECT_EQ("R_VE_PLT32", getELFRelocationTypeName(EM_VE, R_VE_PLT32));
+  EXPECT_EQ("R_VE_PLT_HI32", getELFRelocationTypeName(EM_VE, R_VE_PLT_HI32));
+  EXPECT_EQ("R_VE_PLT_LO32", getELFRelocationTypeName(EM_VE, R_VE_PLT_LO32));
+  EXPECT_EQ("R_VE_RELATIVE", getELFRelocationTypeName(EM_VE, R_VE_RELATIVE));
+  EXPECT_EQ("R_VE_GLOB_DAT", getELFRelocationTypeName(EM_VE, R_VE_GLOB_DAT));
+  EXPECT_EQ("R_VE_JUMP_SLOT", getELFRelocationTypeName(EM_VE, R_VE_JUMP_SLOT));
+  EXPECT_EQ("R_VE_COPY", getELFRelocationTypeName(EM_VE, R_VE_COPY));
+  EXPECT_EQ("R_VE_DTPMOD64", getELFRelocationTypeName(EM_VE, R_VE_DTPMOD64));
+  EXPECT_EQ("R_VE_DTPOFF64", getELFRelocationTypeName(EM_VE, R_VE_DTPOFF64));
+  EXPECT_EQ("R_VE_TLS_GD_HI32",
+            getELFRelocationTypeName(EM_VE, R_VE_TLS_GD_HI32));
+  EXPECT_EQ("R_VE_TLS_GD_LO32",
+            getELFRelocationTypeName(EM_VE, R_VE_TLS_GD_LO32));
+  EXPECT_EQ("R_VE_TPOFF_HI32",
+            getELFRelocationTypeName(EM_VE, R_VE_TPOFF_HI32));
+  EXPECT_EQ("R_VE_TPOFF_LO32",
+            getELFRelocationTypeName(EM_VE, R_VE_TPOFF_LO32));
+  EXPECT_EQ("R_VE_CALL_HI32", getELFRelocationTypeName(EM_VE, R_VE_CALL_HI32));
+  EXPECT_EQ("R_VE_CALL_LO32", getELFRelocationTypeName(EM_VE, R_VE_CALL_LO32));
+}
+
+TEST(ELFTest, getELFRelativeRelocationType) {
+  EXPECT_EQ(0U, getELFRelativeRelocationType(EM_VE));
+}

llvm/unittests/ObjectYAML/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Object
   ObjectYAML
   )
 
 add_llvm_unittest(ObjectYAMLTests
+  ELFYAMLTest.cpp
   MinidumpYAMLTest.cpp
   YAML2ObjTest.cpp
   YAMLTest.cpp
   )
 
 target_link_libraries(ObjectYAMLTests PRIVATE LLVMTestingSupport)

llvm/unittests/ObjectYAML/ELFYAMLTest.cpp

+//===- ELFYAMLTest.cpp - Tests for ELFYAML.cpp ----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Object/ELF.h"
+#include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/ELFTypes.h"
+#include "llvm/ObjectYAML/yaml2obj.h"
+#include "llvm/Support/YAMLTraits.h"
+#include "llvm/Testing/Support/Error.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::object;
+
+template <class ELFT>
+static Expected<ELFObjectFile<ELFT>> toBinary(SmallVectorImpl<char> &Storage,
+                                              StringRef Yaml) {
+  Storage.clear();
+  raw_svector_ostream OS(Storage);
+  yaml::Input YIn(Yaml);
+  if (!yaml::convertYAML(YIn, OS, [](const Twine &Msg) {}))
+    return createStringError(std::errc::invalid_argument,
+                             "unable to convert YAML");
+
+  return ELFObjectFile<ELFT>::create(MemoryBufferRef(OS.str(), "Binary"));
+}
+
+TEST(ELFRelocationTypeTest, RelocationTestForVE) {
+  SmallString<0> Storage;
+  Expected<ELFObjectFile<ELF64LE>> ExpectedFile = toBinary<ELF64LE>(Storage, R"(
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_VE
+Sections:
+  - Name: .rela.text
+    Type: SHT_RELA
+    Relocations:
+      - Type: R_VE_NONE
+      - Type: R_VE_REFLONG
+      - Type: R_VE_REFQUAD
+      - Type: R_VE_SREL32
+      - Type: R_VE_HI32
+      - Type: R_VE_LO32
+      - Type: R_VE_PC_HI32
+      - Type: R_VE_PC_LO32
+      - Type: R_VE_GOT32
+      - Type: R_VE_GOT_HI32
+      - Type: R_VE_GOT_LO32
+      - Type: R_VE_GOTOFF32
+      - Type: R_VE_GOTOFF_HI32
+      - Type: R_VE_GOTOFF_LO32
+      - Type: R_VE_PLT32
+      - Type: R_VE_PLT_HI32
+      - Type: R_VE_PLT_LO32
+      - Type: R_VE_RELATIVE
+      - Type: R_VE_GLOB_DAT
+      - Type: R_VE_JUMP_SLOT
+      - Type: R_VE_COPY
+      - Type: R_VE_DTPMOD64
+      - Type: R_VE_DTPOFF64
+      - Type: R_VE_TLS_GD_HI32
+      - Type: R_VE_TLS_GD_LO32
+      - Type: R_VE_TPOFF_HI32
+      - Type: R_VE_TPOFF_LO32
+      - Type: R_VE_CALL_HI32
+      - Type: R_VE_CALL_LO32)");
+  ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+  const ELFObjectFile<ELF64LE> &File = *ExpectedFile;
+  EXPECT_EQ("elf64-ve", File.getFileFormatName());
+  EXPECT_EQ(Triple::ve, File.getArch());
+
+  // Test relocation types.
+  for (SectionRef Sec : File.sections()) {
+    Expected<StringRef> NameOrErr = Sec.getName();
+    ASSERT_THAT_EXPECTED(NameOrErr, Succeeded());
+    StringRef SectionName = *NameOrErr;
+    if (SectionName != ".rela.text")
+      continue;
+
+    for (RelocationRef R : Sec.relocations()) {
+      SmallString<32> RelTypeName;
+      using namespace llvm::ELF;
+
+#define NAME_CHECK(ID)                                                         \
+  case ID:                                                                     \
+    R.getTypeName(RelTypeName);                                                \
+    EXPECT_EQ(#ID, RelTypeName);                                               \
+    break
+
+      switch (R.getType()) {
+        NAME_CHECK(R_VE_NONE);
+        NAME_CHECK(R_VE_REFLONG);
+        NAME_CHECK(R_VE_REFQUAD);
+        NAME_CHECK(R_VE_SREL32);
+        NAME_CHECK(R_VE_HI32);
+        NAME_CHECK(R_VE_LO32);
+        NAME_CHECK(R_VE_PC_HI32);
+        NAME_CHECK(R_VE_PC_LO32);
+        NAME_CHECK(R_VE_GOT32);
+        NAME_CHECK(R_VE_GOT_HI32);
+        NAME_CHECK(R_VE_GOT_LO32);
+        NAME_CHECK(R_VE_GOTOFF32);
+        NAME_CHECK(R_VE_GOTOFF_HI32);
+        NAME_CHECK(R_VE_GOTOFF_LO32);
+        NAME_CHECK(R_VE_PLT32);
+        NAME_CHECK(R_VE_PLT_HI32);
+        NAME_CHECK(R_VE_PLT_LO32);
+        NAME_CHECK(R_VE_RELATIVE);
+        NAME_CHECK(R_VE_GLOB_DAT);
+        NAME_CHECK(R_VE_JUMP_SLOT);
+        NAME_CHECK(R_VE_COPY);
+        NAME_CHECK(R_VE_DTPMOD64);
+        NAME_CHECK(R_VE_DTPOFF64);
+        NAME_CHECK(R_VE_TLS_GD_HI32);
+        NAME_CHECK(R_VE_TLS_GD_LO32);
+        NAME_CHECK(R_VE_TPOFF_HI32);
+        NAME_CHECK(R_VE_TPOFF_LO32);
+        NAME_CHECK(R_VE_CALL_HI32);
+        NAME_CHECK(R_VE_CALL_LO32);
+      default:
+        FAIL() << "Found unexpected relocation type: " + Twine(R.getType());
+        break;
+      }
+    }
+  }
+}