[RISCV] ELF attribute section for RISC-V

[HsiangKai]

Summary

Prototyping ELF attribute section for RISC-V according https://github.com/riscv/riscv-elf-psabi-doc/pull/71/files

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/RISCV/attribute.s

15 ↗

(On Diff #246382)

Same comments re. spacing.

llvm/test/tools/llvm-readobj/ELF/RISCV/attribute.test

70

Seems like this comment still hasn't been addressed?

[apazos]

lld/test/ELF/Inputs/riscv-attributes1.s

1 ↗

(On Diff #246382)

Comment refers to SHT_ARM_ATTRIBUTES instead of SHT_RISCV_ATTRIBUTES

[HsiangKai]

lld/test/ELF/riscv-attributes.s

43–44 ↗

(On Diff #246382)

Yes, this test case will link with another file located in Inputs directory. I create this test case to ensure this patch will not broken lld. So, I link two object files together and decode the ELF attributes.

llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp

160–162

I will follow current LLVM coding standards before there is a final decision about variable names.

llvm/test/tools/llvm-readobj/ELF/RISCV/attribute.test

70

I create an assembly version in test/tools/llvm-readobj/ELF/RISCV/attribute.s. I just keep the binary format for the same test.

[HsiangKai]

Formatting.

[HsiangKai]

llvm/lib/Object/ELFObjectFile.cpp

308

I will add a test for it later.

[HsiangKai]

Hi @MaskRay, I know you have a patch to refactor ARMAttributeParser in D75015.
If you have no other comments in this patch, do you mind let this patch upstream first and refactor ARMAttributeParser based on it?

[MaskRay]

lld/test/ELF/riscv-attributes.s

1 ↗

(On Diff #246982)

I suggest not making changes to lld/test/ELF for this patch. The changes can be made in a follow-up patch.

3 ↗

(On Diff #246982)

Remove -unknown-elf

43 ↗

(On Diff #246982)

To disable a missing entry warning:

.globl _start
_start:

is sufficient.

[HsiangKai]

More formatting for test cases.

[HsiangKai]

lld/test/ELF/riscv-attributes.s

1 ↗

(On Diff #246982)

Do you mean there is no need to add a test case for lld in this patch? Indeed, I have no modification for lld. I just want to ensure the patch will not broken lld.

[MaskRay]

In D74023#1895884, @HsiangKai wrote:

Hi @MaskRay, I know you have a patch to refactor ARMAttributeParser in D75015.
If you have no other comments in this patch, do you mind let this patch upstream first and refactor ARMAttributeParser based on it?

I created D75015 because I thought

• it would be more likely accepted before D74023. I am of the belief that new code does not have to start using VariableName.
• Doing D75015 before D4023 can minimize the changes on the RISC-V side. (No future void -> Error. Better error reporting.)

llvm/test/MC/RISCV/invalid-attribute.s

10 ↗

(On Diff #246988)

Write the column number explicitly.

[HsiangKai]

lld/test/ELF/riscv-attributes.s

43 ↗

(On Diff #246982)

I want to call another function func located in another file riscv-attributes1.s.

[HsiangKai]

Use ELFObjectFileBase::getARMFeatures() as reference, return empty feature set when encountering errors and ignore unknown features.d

[HsiangKai]

llvm/lib/Object/ELFObjectFile.cpp

308

Add a test case llvm/test/tools/llvm-readobj/ELF/RISCV/unknown-arch-attr.test.

[HsiangKai]

I think I have addressed all the comments.
Is there anything I am not aware or any comments I missed out?

[MaskRay]

In lld, SHT_ARM_ATTRIBUTES sections are deduplicated, thus test/ELF/arm-attributes.s. No code deduplicate SHT_RISCV_ATTRIBUTES, thus I still suggest we delete the lld test change.

Landing D75015 first can reduce changes in this patch....

lld/test/ELF/Inputs/riscv-attributes1.s

2 ↗

(On Diff #247445)

.text can be deleted

lld/test/ELF/riscv-attributes.s

43 ↗

(On Diff #246982)

ld.lld %t1.rv32.o %t2.rv32.o links both object files. It is not necessary to add a call.

[HsiangKai]

Remove lld test cases and rebase on master branch.

[HsiangKai]

Use clang-format to tidy up.

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/RISCV/section-types.test

11 ↗

(On Diff #247475)

You don't need this line.

23 ↗

(On Diff #247475)

You don't need the Content blob, as the contents of the section aren't important for printing the section header.

llvm/test/tools/llvm-readobj/ELF/RISCV/unknown-arch-attr.test

4 ↗

(On Diff #247475)

process the following

6 ↗

(On Diff #247475)

Write this in the third person, describing what is in the object file, i.e. something like "The object file has the "rv32i2p0_x1p0_m2p0_a2p0" arch feature."

22–27 ↗

(On Diff #247475)

Are these bits relevant to the thing under test?

30 ↗

(On Diff #247475)

Maybe change this prefix to just DISASM:

42 ↗

(On Diff #247475)

I'm guessing this test can't be assembly because it needs to use an unsupported feature? If so, please comment this and the other content block below describing what the content represents. E.g. here you might put something like mov %rsp,3 (or whatever this actually is).

[HsiangKai]

Update test cases.

[jhenderson]

There's a lot of this code that I don't have the knowledge to review, so I'm just focusing on the cosmetic aspects primarily.

Also, what do you think about splitting the changes up a bit. In particular, I think the section types testing for llvm-readobj could be done separately, along with the required code changes (e.g. the SHT_RISCV section type). There are probably other parts too.

llvm/include/llvm/Support/ELFAttributeParser.h

23–24

Do these need to be ordered, or can they be unordered_map (or an LLVM equivalent)?

llvm/include/llvm/Support/RISCVAttributeParser.h

28–29

These function names don't follow LLVM style (old or new). They should be unalignedAccess and stackAlign.

llvm/include/llvm/Support/RISCVAttributes.h

29

Rest of what?

30–35

These names are not in LLVM style. Are they matching part of the specification? If not, please change them.

llvm/lib/Object/ELFObjectFile.cpp

289

is -> are
feature -> features
ignore it -> ignore tehm

292

from -> in

323

To take care -> Handle

llvm/lib/Support/ARMBuildAttrs.cpp

11

The formatting changes here seem unrelated so shouldn't be made with this change, right?

llvm/lib/Support/ELFAttributes.cpp

30 ↗

(On Diff #247789)

Perhaps this should return an Optional<T> to avoid the -1 magic number?

32 ↗

(On Diff #247789)

Range-based for loop?

llvm/lib/Target/RISCV/MCTargetDesc/RISCVELFStreamer.cpp

121

Nit: missing trailing full stop.

llvm/test/MC/RISCV/invalid-attribute.s

1 ↗

(On Diff #247789)

Negative tests:

2–4 ↗

(On Diff #247789)

Full stop at end of each line.

[HsiangKai]

llvm/include/llvm/Support/RISCVAttributes.h

29

Originally, there are three common types before architecture-specific attributes, File, Section, Symbol. These three attribute types have been moved to ELFAttributes.h. I think it is indeed confusing here. I will modify this comment.

30–35

These are some definitions in RISC-V ELF specification. I looked up some ELF definitions in llvm/include/llvm/BinaryFormat/ELF.h. I think it should be fine to include underscore in the names. So, I will capitalize all these names and keep underscores.

llvm/lib/Support/ARMBuildAttrs.cpp

11

They are formatted by clang-format. Actually, I am a little bit confused whether to apply clang-format on unrelated code or not. I will restore them.

[HsiangKai]

Rebase on D75015. @MaskRay, could you help me to review this update? Thanks.

[jhenderson]

llvm/include/llvm/Support/ELFAttributeParser.h

60

No need for else after a return:

if (I == Attributes.end())
  return None;
return I->second;

67

No need for else after return.

llvm/include/llvm/Support/ELFAttributes.h

32 ↗

(On Diff #248523)

Can this be Optional<AttrType>?

llvm/include/llvm/Support/RISCVAttributes.h

30–35

Okay, cool. Since these names are part of the standard, they should match exactly what they are in the standard if possible (casing, underscores etc).

llvm/lib/Support/ARMBuildAttrs.cpp

11

In general, you should only format the code you are working on. Unrelated code should not be changed usually.

[HsiangKai]

llvm/include/llvm/Support/ELFAttributes.h

32 ↗

(On Diff #248523)

AttrType is the enum in ELFAttrs. There is also AttrType in ARMBuildAttributes and RISCVAttributes. They all could be implicitly converted to integer. So, I use integer as the common interface between different architecture attributes enum.

[MaskRay]

The change to ARMAttributeParser.cpp (Error (ARMAttributeParser::*routine)(AttrType); -> Error (ARMAttributeParser::*routine)(unsigned);) is not needed.

Some common parsing tests can be moved from unittests/Support/ARMAttributeParser.cpp to unittests/Object/ELFAttributeParser.cpp

I have checked whether it is easy to move Support/ARM{AttributeParser,BuildAttrs,TargetParser}.cpp to Object/. It is not, but I think the end goal is probably to have them under Object/.

The llvm-readobj changes and tests can be moved to a separate patch.

llvm/include/llvm/Support/ARMAttributeParser.h

19–20

It is not necessary to change AttrType to unsigned.

Reverting the change the reduce the diff in this file to a minimum.

llvm/lib/Target/RISCV/RISCVAsmPrinter.cpp

167

The variable can be inlined

176

excess braces

[HsiangKai]

Move llvm-readobj changes and tests to D75833.

[jhenderson]

llvm/include/llvm/Support/ELFAttributes.h

32 ↗

(On Diff #248523)

Okay, seems reasonable. I wonder if AttrType needs to be specified as having unsigned underlying tap (in all cases) to be consistent with the TagNameItem::attr member.

llvm/unittests/Support/ELFAttributeParser.cpp

1 ↗

(On Diff #249024)

Missing licence header.

Test files usually are called *Test.cpp, where * is the base file/class that is being tested. It seems like this file is only testing the ARMAttributeParser. Should it be called "ARMAttributeParserTest.cpp"

5 ↗

(On Diff #249024)

I think it's normal to put a blank line between standard library headers and other includes.

[jhenderson]

llvm/unittests/Support/ELFAttributeParser.cpp

5 ↗

(On Diff #249024)

Ignore this. I was thinking of a different code base.

[HsiangKai]

llvm/include/llvm/Support/ELFAttributes.h

32 ↗

(On Diff #248523)

OK, I will specify the underlying type explicitly.

llvm/unittests/Support/ELFAttributeParser.cpp

1 ↗

(On Diff #249024)

This file tests the common part of the attribute section, i.e., attribute section header. However, since ELFAttributeParser is an abstract class, I need to use ARMAttributeParser or RISCVAttributeParser as the concrete object to run the test. I just pick ARMAttributeParser as the concrete object. This test is not used to test ARMAttributeParser.

You could refer to https://reviews.llvm.org/D74023#1911405. @MaskRay suggests to extract the common part out.

[HsiangKai]

• Specify underlying type for AttrType.
• Update unit tests.

[HsiangKai]

Fix unit test errors.

[jhenderson]

llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp

1723

I don't understand why this line changed, but more importantly, the 2 looks like a magic number and it is unclear why that value is the correct one. Is there another way of writing this that would be more correct (e.g. bitwise & against a known flag value)?

llvm/test/tools/llvm-objdump/RISCV/unknown-arch-attr.test

20 ↗

(On Diff #249854)

No need for the large amount of whitespace between DISASM: and mul. One space is sufficient.

33 ↗

(On Diff #249854)

when the "m" extension

llvm/unittests/Support/ELFAttributeParserTest.cpp

8 ↗

(On Diff #249854)

I think it's normal to have a blank line after the licence header.

17 ↗

(On Diff #249854)

If these tests are for the generic parts of the attribute parser, you should probably define a concrete parser type that is neither ARM nor RISC-V, and use that in the tests, e.g. TestAttributeParser.

If that's not practical for whatever reason, you need to put a comment somewhere in this file indicating that the ARMAttributeParser is used here for generality. Alternatively, consider changing this function to take a template argument for the parser type, and call the test for all instantiated parser types, or simply duplicating the contents of this function, but for the other parser type.

[HsiangKai]

Address @jhenderson's comments.

[HsiangKai]

llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp

1723

I have added a comment for it.

llvm/unittests/Support/ELFAttributeParserTest.cpp

17 ↗

(On Diff #249854)

Thanks for your suggestions. It makes sense. I have added a concrete parser for testing.

[HsiangKai]

Replace std::find_if with llvm::find_if.

[jhenderson]

@HsiangKai, have you noticed that there are some test failures according to the harbourmaster bot? They look like they could be related to this somehow.

llvm/unittests/Support/ELFAttributeParserTest.cpp

21 ↗

(On Diff #251375)

I might suggest changing this comment to "Treat all attributes as handled."

27 ↗

(On Diff #251375)

sw seems a bit of a random name. What does it mean?

[HsiangKai]

In D74023#1933427, @jhenderson wrote:

@HsiangKai, have you noticed that there are some test failures according to the harbourmaster bot? They look like they could be related to this somehow.

@jhenderson, yes, I found test failures in harbormaster. The failures are occurred after I rebased my patch on master branch. After digging into error messages, I found the failures are triggered by find_if(). Maybe I misuse find_if() in this patch? Do you have any idea about this?
By the way, I also found some patch, D75015, landed even harbormaster is failed. I am curious about is it a necessary condition to pass harbormaster before landing?

[jhenderson]

In D74023#1937220, @HsiangKai wrote:

In D74023#1933427, @jhenderson wrote:

@HsiangKai, have you noticed that there are some test failures according to the harbourmaster bot? They look like they could be related to this somehow.

@jhenderson, yes, I found test failures in harbormaster. The failures are occurred after I rebased my patch on master branch. After digging into error messages, I found the failures are triggered by find_if(). Maybe I misuse find_if() in this patch? Do you have any idea about this?
By the way, I also found some patch, D75015, landed even harbormaster is failed. I am curious about is it a necessary condition to pass harbormaster before landing?

I don't have much understanding of how Harbormaster works, and it may be that the failures are unrelated to anything you did, since I believe it just applies your patch on top of the current HEAD of master, which might not work for various reasons. Still, it's worth reviewing and locally checking the same tests to make sure they aren't failing locally. If you review the logs produced, you might spot an issue. If Harbormaster is failing for a reason related to your patch, your patch will almost certainly cause build bot failures, so in that case, it is necessary to fix the issues (but in other cases, if the issues are unrelated, it isn't).

As for why find_if isn't working, I don't know, and I'd suggest you debug it.

llvm/include/llvm/Support/ARMBuildAttributes.h

37

Same comment as elsewhere.

llvm/lib/Support/ARMBuildAttrs.cpp

10–11

By the way: this clang-format failure might be related to your changes, so it's probably worth checking to see if it is incorrect without your changes, and if not, reformat it as part of this patch.

[HsiangKai]

llvm/include/llvm/Support/ARMBuildAttributes.h

37

I prefer to keep the formatting in this file. We could create another NFC patch for it.

llvm/lib/Support/ARMBuildAttrs.cpp

10–11

I didn't change the formatting in this file. I think it is not related to this patch. We could create another NFC patch to correct the formatting in ARMBuildAttrs.cpp.

llvm/unittests/Support/ELFAttributeParserTest.cpp

27 ↗

(On Diff #251375)

I do not know either. I borrowed the name from ARMAttributeParser. I will change the variable name to 'printer'.

[HsiangKai]

In D74023#1938583, @jhenderson wrote:

In D74023#1937220, @HsiangKai wrote:

In D74023#1933427, @jhenderson wrote:

@HsiangKai, have you noticed that there are some test failures according to the harbourmaster bot? They look like they could be related to this somehow.

@jhenderson, yes, I found test failures in harbormaster. The failures are occurred after I rebased my patch on master branch. After digging into error messages, I found the failures are triggered by find_if(). Maybe I misuse find_if() in this patch? Do you have any idea about this?
By the way, I also found some patch, D75015, landed even harbormaster is failed. I am curious about is it a necessary condition to pass harbormaster before landing?

I don't have much understanding of how Harbormaster works, and it may be that the failures are unrelated to anything you did, since I believe it just applies your patch on top of the current HEAD of master, which might not work for various reasons. Still, it's worth reviewing and locally checking the same tests to make sure they aren't failing locally. If you review the logs produced, you might spot an issue. If Harbormaster is failing for a reason related to your patch, your patch will almost certainly cause build bot failures, so in that case, it is necessary to fix the issues (but in other cases, if the issues are unrelated, it isn't).

As for why find_if isn't working, I don't know, and I'd suggest you debug it.

Thanks for your reply. I will try to figure out why Harbormaster is failed.

[HsiangKai]

Rebase on master.

[HsiangKai]

Fix Harbormaster test failures.

[HsiangKai]

Harbormaster result:

Unit tests pass. 64040 tests passed, 0 failed and 650 were skipped.
clang-tidy fail. clang-tidy found 1 errors and 18 warnings. 0 of them are added as review comments why?.
clang-format fail. Please format your changes with clang-format by running `git-clang-format HEAD^` or applying this patch.

These errors are caused by formatting in ELF.h, ARMBuildAttributes.h, and ARMBuildAttrs.cpp. Although they are located in the same files this patch modified, they are not related to this patch. These errors could be ignored.

[MaskRay]

I remember the patch caused many failures yesterday. The new diff is good.

llvm/unittests/Support/ELFAttributeParserTest.cpp

16 ↗

(On Diff #251375)

static const

[HsiangKai]

I create a patch, D76819, to apply clang-format to the ELF header file and ARM build attributes files.

[HsiangKai]

Rebase on D76819.

[jhenderson]

I haven't really reviewed the funcional parts of this change in the attribute parser stuff, but everything else LGTM. Please wait for somebody else to review the attribute parser bits.

llvm/lib/Support/ARMBuildAttrs.cpp

66–67

clang-format appears to be complaining here?

[HsiangKai]

llvm/lib/Support/ARMBuildAttrs.cpp

66–67

I will rerun clang-format for it.

[HsiangKai]

@MaskRay, do you have any other comments about this patch?

[MaskRay]

llvm/lib/Target/RISCV/MCTargetDesc/RISCVELFStreamer.cpp

102

emitInt8

113

emitInt32

115

emitInt8

llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.cpp

42

These empty lines seem unneeded.

44

Just Arch += "_a2p0";

93

Does String need to be escaped?

llvm/lib/Target/RISCV/RISCVAsmPrinter.cpp

170

TS can be inlined.

179

TS can be inlined.

llvm/test/CodeGen/RISCV/attributes.ll

25 ↗

(On Diff #252801)

Delete nounwind (unneeded detail)

29 ↗

(On Diff #252801)

Delete empty line

llvm/test/MC/RISCV/attribute-arch.s

38 ↗

(On Diff #252801)

Delete empty line

[MaskRay]

The code generally looks good. For unittests, I think we can either make llvm-readobj -A canonical or the unittests canonical. If we decide to place tests on one place, we should delete most tests on the other side.

My current preference is that we use more of unittests and leave the minimum to test/llvm-readobj/ELF/{ARM,RISCV}/

llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp

1685

No space before [

1719

Delete = ""

[HsiangKai]

In D74023#1948388, @MaskRay wrote:

The code generally looks good. For unittests, I think we can either make llvm-readobj -A canonical or the unittests canonical. If we decide to place tests on one place, we should delete most tests on the other side.

My current preference is that we use more of unittests and leave the minimum to test/llvm-readobj/ELF/{ARM,RISCV}/

Agree. I will remove redundant tests in test/tools/llvm-readobj/ELF/{ARM,RISCV}/.

[jhenderson]

In D74023#1949261, @HsiangKai wrote:

In D74023#1948388, @MaskRay wrote:

The code generally looks good. For unittests, I think we can either make llvm-readobj -A canonical or the unittests canonical. If we decide to place tests on one place, we should delete most tests on the other side.

My current preference is that we use more of unittests and leave the minimum to test/llvm-readobj/ELF/{ARM,RISCV}/

Agree. I will remove redundant tests in test/tools/llvm-readobj/ELF/{ARM,RISCV}/.

I also agree with testing primarily through the unit-tests where possible. However, there are probably aspects that still need to be tested via lit, namely code behaviour in ELFDumper.cpp, so just be slightly wary. High-level examples that might or might not be relevant for this patch are making sure that the output is printed correctly, and making sure errors/warnings can be threaded up to the final output.

[HsiangKai]

llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.cpp

93

There is no need to escape the string. The string will be generated in RISCVTargetStreamer::emitTargetAttributes().

llvm/include/llvm/BinaryFormat/ELF.h

enum : unsigned {
 
   SHT_MIPS_REGINFO = 0x70000006,        // Register usage information
   SHT_MIPS_OPTIONS = 0x7000000d,        // General options
   SHT_MIPS_DWARF = 0x7000001e,          // DWARF debugging section.
   SHT_MIPS_ABIFLAGS = 0x7000002a,       // ABI information.
 
   SHT_MSP430_ATTRIBUTES = 0x70000003U,
 
+  SHT_RISCV_ATTRIBUTES = 0x70000003U,
+
   SHT_HIPROC = 0x7fffffff,              // Highest processor arch-specific type.
   SHT_LOUSER = 0x80000000,              // Lowest type reserved for applications.
   SHT_HIUSER = 0xffffffff               // Highest type reserved for applications.
 };
 
 // Section flags.
 enum : unsigned {
   // Section data should be writable during execution.

llvm/include/llvm/Object/ELFObjectFile.h

 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/ARMAttributeParser.h"
-#include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/ELFBuildAttributes.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cassert>
 #include <cstdint>
 #include <system_error>
 
protected:
   virtual uint8_t getSymbolOther(DataRefImpl Symb) const = 0;
   virtual uint8_t getSymbolELFType(DataRefImpl Symb) const = 0;
 
   virtual uint32_t getSectionType(DataRefImpl Sec) const = 0;
   virtual uint64_t getSectionFlags(DataRefImpl Sec) const = 0;
   virtual uint64_t getSectionOffset(DataRefImpl Sec) const = 0;
 
   virtual Expected<int64_t> getRelocationAddend(DataRefImpl Rel) const = 0;
-  virtual Error getBuildAttributes(ARMAttributeParser &Attributes) const = 0;
+  virtual Error getBuildAttributes(ELFAttributeParser &Attributes) const = 0;
 
 public:
   using elf_symbol_iterator_range = iterator_range<elf_symbol_iterator>;
 
   virtual elf_symbol_iterator_range getDynamicSymbolIterators() const = 0;
 
   /// Returns platform-specific object flags, if any.
   virtual unsigned getPlatformFlags() const = 0;
bool isExportedToOtherDSO(const Elf_Sym *ESym) const {
     // visibility is either DEFAULT or PROTECTED. All other symbols are not
     // exported.
     return (
         (Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK ||
          Binding == ELF::STB_GNU_UNIQUE) &&
         (Visibility == ELF::STV_DEFAULT || Visibility == ELF::STV_PROTECTED));
   }
 
-  Error getBuildAttributes(ARMAttributeParser &Attributes) const override {
+  Error getBuildAttributes(ELFAttributeParser &Attributes) const override {
     auto SectionsOrErr = EF.sections();
     if (!SectionsOrErr)
       return SectionsOrErr.takeError();
 
     for (const Elf_Shdr &Sec : *SectionsOrErr) {
-      if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES) {
+      if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES ||
+          Sec.sh_type == ELF::SHT_RISCV_ATTRIBUTES) {
         auto ErrorOrContents = EF.getSectionContents(&Sec);
         if (!ErrorOrContents)
           return ErrorOrContents.takeError();
 
         auto Contents = ErrorOrContents.get();
-        if (Contents[0] != ARMBuildAttrs::Format_Version || Contents.size() == 1)
+        if (Contents[0] != ELFBuildAttrs::Format_Version ||
+            Contents.size() == 1)
           return Error::success();
 
         Attributes.Parse(Contents, ELFT::TargetEndianness == support::little);
         break;
       }
     }
     return Error::success();
   }

llvm/include/llvm/Support/ARMAttributeParser.h

 //===--- ARMAttributeParser.h - ARM Attribute Information Printer ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ARMATTRIBUTEPARSER_H
 #define LLVM_SUPPORT_ARMATTRIBUTEPARSER_H
 
 #include "ARMBuildAttributes.h"
+#include "ELFAttributeParser.h"
 #include "ScopedPrinter.h"
 
-#include <map>
-
 namespace llvm {
-class StringRef;
-
-class ARMAttributeParser {
-  ScopedPrinter *SW;
-
-  std::map<unsigned, unsigned> Attributes;
-
+class ARMAttributeParser : public ELFAttributeParser {
   struct DisplayHandler {
     ARMBuildAttrs::AttrType Attribute;
-    void (ARMAttributeParser::*Routine)(ARMBuildAttrs::AttrType,
-                                        const uint8_t *, uint32_t &);
+    void (ARMAttributeParser::*Routine)(unsigned, const uint8_t *, uint32_t &);
   };
   static const DisplayHandler DisplayRoutines[];
 
-  uint64_t ParseInteger(const uint8_t *Data, uint32_t &Offset);
-  StringRef ParseString(const uint8_t *Data, uint32_t &Offset);
-
-  void IntegerAttribute(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                        uint32_t &Offset);
-  void StringAttribute(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
+  bool Handler(unsigned Tag, const uint8_t *Data, uint32_t &Offset) override;
 
-  void PrintAttribute(unsigned Tag, unsigned Value, StringRef ValueDesc);
-
-  void CPU_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                uint32_t &Offset);
-  void CPU_arch_profile(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                        uint32_t &Offset);
-  void ARM_ISA_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                   uint32_t &Offset);
-  void THUMB_ISA_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                     uint32_t &Offset);
-  void FP_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-               uint32_t &Offset);
-  void WMMX_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                 uint32_t &Offset);
-  void Advanced_SIMD_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                          uint32_t &Offset);
-  void MVE_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                uint32_t &Offset);
-  void PCS_config(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                  uint32_t &Offset);
-  void ABI_PCS_R9_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                      uint32_t &Offset);
-  void ABI_PCS_RW_data(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void ABI_PCS_RO_data(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void ABI_PCS_GOT_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
+  void CPU_arch(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void CPU_arch_profile(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ARM_ISA_use(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void THUMB_ISA_use(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void FP_arch(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void WMMX_arch(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void Advanced_SIMD_arch(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void MVE_arch(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void PCS_config(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_PCS_R9_use(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_PCS_RW_data(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_PCS_RO_data(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_PCS_GOT_use(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_PCS_wchar_t(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_FP_rounding(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_FP_denormal(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_FP_exceptions(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_FP_user_exceptions(unsigned Tag, const uint8_t *Data,
+                              uint32_t &Offset);
+  void ABI_FP_number_model(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_align_needed(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_align_preserved(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_enum_size(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_HardFP_use(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_VFP_args(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_WMMX_args(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_optimization_goals(unsigned Tag, const uint8_t *Data,
                               uint32_t &Offset);
-  void ABI_PCS_wchar_t(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
+  void ABI_FP_optimization_goals(unsigned Tag, const uint8_t *Data,
                                  uint32_t &Offset);
-  void ABI_FP_rounding(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void ABI_FP_denormal(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void ABI_FP_exceptions(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                         uint32_t &Offset);
-  void ABI_FP_user_exceptions(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                              uint32_t &Offset);
-  void ABI_FP_number_model(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                           uint32_t &Offset);
-  void ABI_align_needed(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                        uint32_t &Offset);
-  void ABI_align_preserved(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                           uint32_t &Offset);
-  void ABI_enum_size(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                     uint32_t &Offset);
-  void ABI_HardFP_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                      uint32_t &Offset);
-  void ABI_VFP_args(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                    uint32_t &Offset);
-  void ABI_WMMX_args(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                     uint32_t &Offset);
-  void ABI_optimization_goals(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                              uint32_t &Offset);
-  void ABI_FP_optimization_goals(ARMBuildAttrs::AttrType Tag,
-                                 const uint8_t *Data, uint32_t &Offset);
-  void compatibility(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                     uint32_t &Offset);
-  void CPU_unaligned_access(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                            uint32_t &Offset);
-  void FP_HP_extension(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void ABI_FP_16bit_format(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                           uint32_t &Offset);
-  void MPextension_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void DIV_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-               uint32_t &Offset);
-  void DSP_extension(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                     uint32_t &Offset);
-  void T2EE_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                uint32_t &Offset);
-  void Virtualization_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                          uint32_t &Offset);
-  void nodefaults(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                  uint32_t &Offset);
+  void compatibility(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void CPU_unaligned_access(unsigned Tag, const uint8_t *Data,
+                            uint32_t &Offset);
+  void FP_HP_extension(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void ABI_FP_16bit_format(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void MPextension_use(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void DIV_use(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void DSP_extension(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void T2EE_use(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void Virtualization_use(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void nodefaults(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
 
-  void ParseAttributeList(const uint8_t *Data, uint32_t &Offset,
-                          uint32_t Length);
-  void ParseIndexList(const uint8_t *Data, uint32_t &Offset,
-                      SmallVectorImpl<uint8_t> &IndexList);
-  void ParseSubsection(const uint8_t *Data, uint32_t Length);
 public:
-  ARMAttributeParser(ScopedPrinter *SW) : SW(SW) {}
+  ARMAttributeParser(ScopedPrinter *SW)
+      : ELFAttributeParser(SW, ARMBuildAttrs::ARMAttributeTags, "aeabi") {}
 
-  ARMAttributeParser() : SW(nullptr) { }
-
-  void Parse(ArrayRef<uint8_t> Section, bool isLittle);
-
-  bool hasAttribute(unsigned Tag) const {
-    return Attributes.count(Tag);
-  }
-
-  unsigned getAttributeValue(unsigned Tag) const {
-    return Attributes.find(Tag)->second;
-  }
+  ARMAttributeParser()
+      : ELFAttributeParser(ARMBuildAttrs::ARMAttributeTags, "aeabi") {}
 };
-
 }
 
 #endif
 

llvm/include/llvm/Support/ARMBuildAttributes.h

 //
 // http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044e/IHI0044E_aaelf.pdf
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ARMBUILDATTRIBUTES_H
 #define LLVM_SUPPORT_ARMBUILDATTRIBUTES_H
 
-namespace llvm {
-class StringRef;
+#include "llvm/Support/ELFBuildAttributes.h"
 
+namespace llvm {
 namespace ARMBuildAttrs {
 
+extern TagNameMap ARMAttributeTags;
+
 enum SpecialAttr {
   // This is for the .cpu asm attr. It translates into one or more
   // AttrType (below) entries in the .ARM.attributes section in the ELF.
   SEL_CPU
 };
 
 enum AttrType {
   // Rest correspond to ELF/.ARM.attributes
   File                      = 1,
   CPU_raw_name              = 4,
   CPU_name                  = 5,
   CPU_arch                  = 6,
   CPU_arch_profile          = 7,
   ARM_ISA_use               = 8,
   THUMB_ISA_use             = 9,
   FP_arch                   = 10,
   WMMX_arch                 = 11,
   Advanced_SIMD_arch        = 12,
enum AttrType {
   Symbol                    = 3,  // deprecated (ABI r2.09)
   ABI_align8_needed         = 24, // renamed to ABI_align_needed (ABI r2.09)
   ABI_align8_preserved      = 25, // renamed to ABI_align_preserved (ABI r2.09)
   nodefaults                = 64, // deprecated (ABI r2.09)
   T2EE_use                  = 66, // deprecated (ABI r2.09)
   MPextension_use_old       = 70  // recoded to MPextension_use (ABI r2.08)
 };
 
-StringRef AttrTypeAsString(unsigned Attr, bool HasTagPrefix = true);
-StringRef AttrTypeAsString(AttrType Attr, bool HasTagPrefix = true);
-int AttrTypeFromString(StringRef Tag);
-
-// Magic numbers for .ARM.attributes
-enum AttrMagic {
-  Format_Version  = 0x41
-};
-
 // Legal Values for CPU_arch, (=6), uleb128
 enum CPUArch {
   Pre_v4   = 0,
   v4       = 1,   // e.g. SA110
   v4T      = 2,   // e.g. ARM7TDMI
   v5T      = 3,   // e.g. ARM9TDMI
   v5TE     = 4,   // e.g. ARM946E_S
   v5TEJ    = 5,   // e.g. ARM926EJ_S

llvm/include/llvm/Support/ELFAttributeParser.h

+//===--- ELF AttributeParser.h - ELF Attribute Information Printer --------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_ELFATTRIBUTEPARSER_H
+#define LLVM_SUPPORT_ELFATTRIBUTEPARSER_H
+
+#include "ELFBuildAttributes.h"
+#include "ScopedPrinter.h"
+
+#include <map>
+
+namespace llvm {
+class StringRef;
+
+class ELFAttributeParser {
+  StringRef Vendor;
+  std::map<unsigned, unsigned> Attributes;
+  std::map<unsigned, StringRef> AttributesStr;
+
+  virtual bool Handler(unsigned Tag, const uint8_t *Data, uint32_t &Offset) = 0;
+
+protected:
+  ScopedPrinter *SW;
+  TagNameMap TagToStringMap;
+
+  uint64_t ParseInteger(const uint8_t *Data, uint32_t &Offset);
+  StringRef ParseString(const uint8_t *Data, uint32_t &Offset);
+
+  void PrintAttribute(unsigned Tag, unsigned Value, StringRef ValueDesc);
+
+  void ParseAttributeList(const uint8_t *Data, uint32_t &Offset,
+                          uint32_t Length);
+  void ParseIndexList(const uint8_t *Data, uint32_t &Offset,
+                      SmallVectorImpl<uint8_t> &IndexList);
+  void ParseSubsection(const uint8_t *Data, uint32_t Length);
+
+public:
+  void IntegerAttribute(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void StringAttribute(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+
+  ELFAttributeParser(ScopedPrinter *SW, TagNameMap Map, StringRef Vendor)
+      : Vendor(Vendor), SW(SW), TagToStringMap(Map) {}
+
+  ELFAttributeParser(TagNameMap Map, StringRef Vendor)
+      : Vendor(Vendor), SW(nullptr), TagToStringMap(Map) {}
+
+  void Parse(ArrayRef<uint8_t> Section, bool isLittle);
+
+  bool hasAttribute(unsigned Tag) const { return Attributes.count(Tag); }
+  bool hasAttributeStr(unsigned Tag) const { return AttributesStr.count(Tag); }
+
+  unsigned getAttributeValue(unsigned Tag) const {
+    return Attributes.find(Tag)->second;
+  }
+  StringRef getAttributeString(unsigned Tag) const {
+    return AttributesStr.find(Tag)->second;
+  }
+};
+
+} // namespace llvm
+#endif

llvm/include/llvm/Support/ELFBuildAttributes.h

+//===-- ELFBuildAttributes.h - ELF Build Attributes -------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_ELFBUILDATTRIBUTES_H
+#define LLVM_SUPPORT_ELFBUILDATTRIBUTES_H
+
+#include "llvm/ADT/DenseMap.h"
+
+namespace llvm {
+class StringRef;
+
+struct TagNameItem {
+  unsigned Attr;
+  StringRef TagName;
+};
+
+using TagNameMap = ArrayRef<struct TagNameItem>;
+
+namespace ELFBuildAttrs {
+
+enum AttrType { File = 1, Section = 2, Symbol = 3 };
+
+StringRef AttrTypeAsString(unsigned Attr, TagNameMap Map,
+                           bool HasTagPrefix = true);
+StringRef AttrTypeAsString(AttrType Attr, TagNameMap Map,
+                           bool HasTagPrefix = true);
+int AttrTypeFromString(StringRef Tag, TagNameMap Map);
+
+// Magic numbers for ELF attributes
+enum AttrMagic { Format_Version = 0x41 };
+
+} // namespace ELFBuildAttrs
+} // namespace llvm
+
+#endif

llvm/include/llvm/Support/RISCVAttributeParser.h

+//===--- RISCVAttributeParser.h - RISCV Attribute Information Printer -----===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_RISCVATTRIBUTEPARSER_H
+#define LLVM_SUPPORT_RISCVATTRIBUTEPARSER_H
+
+#include "ScopedPrinter.h"
+#include "llvm/Support/ELFAttributeParser.h"
+#include "llvm/Support/RISCVAttributes.h"
+
+namespace llvm {
+class RISCVAttributeParser : public ELFAttributeParser {
+  struct DisplayHandler {
+    RISCVAttrs::AttrType Attribute;
+    void (RISCVAttributeParser::*Routine)(unsigned, const uint8_t *,
+                                          uint32_t &);
+  };
+  static const DisplayHandler DisplayRoutines[];
+
+  bool Handler(unsigned Tag, const uint8_t *Data, uint32_t &Offset) override;
+
+  void Unaligned_access(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+  void Stack_align(unsigned Tag, const uint8_t *Data, uint32_t &Offset);
+
+public:
+  RISCVAttributeParser(ScopedPrinter *SW)
+      : ELFAttributeParser(SW, RISCVAttrs::RISCVAttributeTags, "riscv") {}
+  RISCVAttributeParser()
+      : ELFAttributeParser(RISCVAttrs::RISCVAttributeTags, "riscv") {}
+};
+
+} // namespace llvm
+
+#endif

llvm/include/llvm/Support/RISCVAttributes.h

+//===-- RISCVAttributes.h - RISCV Attributes --------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains enumerations for RISCV attributes as defined in RISC-V
+// ELF psABI specification.
+//
+// RISC-V ELF psABI specification
+//
+// https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_SUPPORT_RISCVATTRIBUTES_H
+#define LLVM_SUPPORT_RISCVATTRIBUTES_H
+
+#include "llvm/Support/ELFBuildAttributes.h"
+
+namespace llvm {
+namespace RISCVAttrs {
+
+extern TagNameMap RISCVAttributeTags;
+
+enum AttrType {
+  // Rest correspond to ELF/.riscv.attributes
+  Stack_align = 4,
+  Arch = 5,
+  Unaligned_access = 6,
+  Priv_spec = 8,
+  Priv_spec_minor = 10,
+  Priv_spec_revision = 12,
+};
+
+} // namespace RISCVAttrs
+} // namespace llvm
+
+#endif

llvm/lib/Object/ELF.cpp

StringRef llvm::object::getELFSectionTypeName(uint32_t Machine, unsigned Type) {
   case ELF::EM_MIPS_RS3_LE:
     switch (Type) {
       STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
       STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
       STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_DWARF);
       STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
     }
     break;
+  case ELF::EM_RISCV:
+    switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_RISCV_ATTRIBUTES); }
+    break;
   default:
     break;
   }
 
   switch (Type) {
     STRINGIFY_ENUM_CASE(ELF, SHT_NULL);
     STRINGIFY_ENUM_CASE(ELF, SHT_PROGBITS);
     STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB);

llvm/lib/Object/ELFObjectFile.cpp

 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Support/ARMAttributeParser.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/RISCVAttributeParser.h"
+#include "llvm/Support/RISCVAttributes.h"
 #include "llvm/Support/TargetRegistry.h"
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <system_error>
 #include <utility>

 SubtargetFeatures ELFObjectFileBase::getRISCVFeatures() const {
   SubtargetFeatures Features;
   unsigned PlatformFlags = getPlatformFlags();
 
   if (PlatformFlags & ELF::EF_RISCV_RVC) {
     Features.AddFeature("c");
   }
 
+  RISCVAttributeParser Attributes;
+  if (Error E = getBuildAttributes(Attributes))
+    return Features;
+
+  if (Attributes.hasAttributeStr(RISCVAttrs::Arch)) {
+    // The Arch pattern is [rv32|rv64][i|e]version(_[m|a|f|d|c]version)*
+    // Version string pattern is (major)p(minor). Major and minor are optional.
+    // For example, a version number could be 2p0, 2, or p92.
+    StringRef Arch = Attributes.getAttributeString(RISCVAttrs::Arch);
+    if (Arch.startswith("rv32"))
+      Features.AddFeature("64bit", false);
+    else if (Arch.startswith("rv64"))
+      Features.AddFeature("64bit");
+    else
+      return Features;
+    Arch = Arch.drop_front(4); // Discard "rv[32|64]"
+
+    while (!Arch.empty()) {
+      switch (Arch[0]) {
+      default:
+        llvm_unreachable("Unknown extension in Arch attribute.");
+      case 'i':
+        Features.AddFeature("e", false);
+        break;
+      case 'd':
+        Features.AddFeature("f"); // D-ext will imply F-ext.
+        LLVM_FALLTHROUGH;
+      case 'e':
+      case 'm':
+      case 'a':
+      case 'f':
+      case 'c':
+        Features.AddFeature(Arch.take_front());
+        break;
+      }
+
+      // FIXME: To take care version numbers.
+      Arch = Arch.drop_until([](char c) { return c == '_' || c == '\0'; });
+      Arch = Arch.drop_while([](char c) { return c == '_'; });
+    }
+  }
+
   return Features;
 }
 
 SubtargetFeatures ELFObjectFileBase::getFeatures() const {
   switch (getEMachine()) {
   case ELF::EM_MIPS:
     return getMIPSFeatures();
   case ELF::EM_ARM:

llvm/lib/ObjectYAML/ELFYAML.cpp

case ELF::EM_X86_64:
     ECase(SHT_X86_64_UNWIND);
     break;
   case ELF::EM_MIPS:
     ECase(SHT_MIPS_REGINFO);
     ECase(SHT_MIPS_OPTIONS);
     ECase(SHT_MIPS_DWARF);
     ECase(SHT_MIPS_ABIFLAGS);
     break;
+  case ELF::EM_RISCV:
+    ECase(SHT_RISCV_ATTRIBUTES);
   default:
     // Nothing to do.
     break;
   }
 #undef ECase
   IO.enumFallback<Hex32>(Value);
 }
 

llvm/lib/Support/ARMAttributeParser.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 using namespace llvm;
 using namespace llvm::ARMBuildAttrs;
 
-
-static const EnumEntry<unsigned> TagNames[] = {
-  { "Tag_File", ARMBuildAttrs::File },
-  { "Tag_Section", ARMBuildAttrs::Section },
-  { "Tag_Symbol", ARMBuildAttrs::Symbol },
-};
-
 namespace llvm {
 #define ATTRIBUTE_HANDLER(Attr_)                                                \
   { ARMBuildAttrs::Attr_, &ARMAttributeParser::Attr_ }
 
-const ARMAttributeParser::DisplayHandler
-ARMAttributeParser::DisplayRoutines[] = {
-  { ARMBuildAttrs::CPU_raw_name, &ARMAttributeParser::StringAttribute, },
-  { ARMBuildAttrs::CPU_name, &ARMAttributeParser::StringAttribute },
+const ARMAttributeParser::DisplayHandler ARMAttributeParser::DisplayRoutines[] =
+    {{ARMBuildAttrs::CPU_raw_name, &ELFAttributeParser::StringAttribute},
+     {ARMBuildAttrs::CPU_name, &ELFAttributeParser::StringAttribute},
      ATTRIBUTE_HANDLER(CPU_arch),
      ATTRIBUTE_HANDLER(CPU_arch_profile),
      ATTRIBUTE_HANDLER(ARM_ISA_use),
      ATTRIBUTE_HANDLER(THUMB_ISA_use),
      ATTRIBUTE_HANDLER(FP_arch),
      ATTRIBUTE_HANDLER(WMMX_arch),
      ATTRIBUTE_HANDLER(Advanced_SIMD_arch),
      ATTRIBUTE_HANDLER(MVE_arch),
      ATTRIBUTE_HANDLER(PCS_config),
      ATTRIBUTE_HANDLER(ABI_PCS_R9_use),
      ATTRIBUTE_HANDLER(ABI_PCS_RW_data),
      ATTRIBUTE_HANDLER(ABI_PCS_RO_data),
      ATTRIBUTE_HANDLER(ABI_PCS_GOT_use),
      ATTRIBUTE_HANDLER(ABI_PCS_wchar_t),
      ATTRIBUTE_HANDLER(ABI_FP_rounding),
      ATTRIBUTE_HANDLER(ABI_FP_denormal),
      ATTRIBUTE_HANDLER(ABI_FP_exceptions),
      ATTRIBUTE_HANDLER(ABI_FP_user_exceptions),
      ATTRIBUTE_HANDLER(ABI_FP_number_model),
      ATTRIBUTE_HANDLER(ABI_align_needed),
      ATTRIBUTE_HANDLER(ABI_align_preserved),
      ATTRIBUTE_HANDLER(ABI_enum_size),
      ATTRIBUTE_HANDLER(ABI_HardFP_use),
      ATTRIBUTE_HANDLER(ABI_VFP_args),
      ATTRIBUTE_HANDLER(ABI_WMMX_args),
      ATTRIBUTE_HANDLER(ABI_optimization_goals),
      ATTRIBUTE_HANDLER(ABI_FP_optimization_goals),
      ATTRIBUTE_HANDLER(compatibility),
      ATTRIBUTE_HANDLER(CPU_unaligned_access),
      ATTRIBUTE_HANDLER(FP_HP_extension),
      ATTRIBUTE_HANDLER(ABI_FP_16bit_format),
      ATTRIBUTE_HANDLER(MPextension_use),
      ATTRIBUTE_HANDLER(DIV_use),
      ATTRIBUTE_HANDLER(DSP_extension),
      ATTRIBUTE_HANDLER(T2EE_use),
      ATTRIBUTE_HANDLER(Virtualization_use),
-  ATTRIBUTE_HANDLER(nodefaults)
-};
+     ATTRIBUTE_HANDLER(nodefaults)};
 
 #undef ATTRIBUTE_HANDLER
 
-uint64_t ARMAttributeParser::ParseInteger(const uint8_t *Data,
-                                          uint32_t &Offset) {
-  unsigned DecodeLength;
-  uint64_t Value = decodeULEB128(Data + Offset, &DecodeLength);
-  Offset += DecodeLength;
-  return Value;
-}
-
-StringRef ARMAttributeParser::ParseString(const uint8_t *Data,
-                                          uint32_t &Offset) {
-  const char *String = reinterpret_cast<const char*>(Data + Offset);
-  size_t Length = std::strlen(String);
-  Offset = Offset + Length + 1;
-  return StringRef(String, Length);
-}
-
-void ARMAttributeParser::IntegerAttribute(AttrType Tag, const uint8_t *Data,
-                                          uint32_t &Offset) {
-
-  uint64_t Value = ParseInteger(Data, Offset);
-  Attributes.insert(std::make_pair(Tag, Value));
-
-  if (SW)
-    SW->printNumber(ARMBuildAttrs::AttrTypeAsString(Tag), Value);
-}
-
-void ARMAttributeParser::StringAttribute(AttrType Tag, const uint8_t *Data,
-                                         uint32_t &Offset) {
-  StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag, /*TagPrefix*/false);
-  StringRef ValueDesc = ParseString(Data, Offset);
-
-  if (SW) {
-    DictScope AS(*SW, "Attribute");
-    SW->printNumber("Tag", Tag);
-    if (!TagName.empty())
-      SW->printString("TagName", TagName);
-    SW->printString("Value", ValueDesc);
-  }
-}
-
-void ARMAttributeParser::PrintAttribute(unsigned Tag, unsigned Value,
-                                        StringRef ValueDesc) {
-  Attributes.insert(std::make_pair(Tag, Value));
-
-  if (SW) {
-    StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag,
-                                                        /*TagPrefix*/false);
-    DictScope AS(*SW, "Attribute");
-    SW->printNumber("Tag", Tag);
-    SW->printNumber("Value", Value);
-    if (!TagName.empty())
-      SW->printString("TagName", TagName);
-    if (!ValueDesc.empty())
-      SW->printString("Description", ValueDesc);
-  }
-}
-
-void ARMAttributeParser::CPU_arch(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::CPU_arch(unsigned Tag, const uint8_t *Data,
                                   uint32_t &Offset) {
   static const char *const Strings[] = {
     "Pre-v4", "ARM v4", "ARM v4T", "ARM v5T", "ARM v5TE", "ARM v5TEJ", "ARM v6",
     "ARM v6KZ", "ARM v6T2", "ARM v6K", "ARM v7", "ARM v6-M", "ARM v6S-M",
     "ARM v7E-M", "ARM v8", nullptr,
     "ARM v8-M Baseline", "ARM v8-M Mainline", nullptr, nullptr, nullptr,
     "ARM v8.1-M Mainline"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::CPU_arch_profile(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::CPU_arch_profile(unsigned Tag, const uint8_t *Data,
                                           uint32_t &Offset) {
   uint64_t Encoded = ParseInteger(Data, Offset);
 
   StringRef Profile;
   switch (Encoded) {
   default:  Profile = "Unknown"; break;
   case 'A': Profile = "Application"; break;
   case 'R': Profile = "Real-time"; break;
   case 'M': Profile = "Microcontroller"; break;
   case 'S': Profile = "Classic"; break;
   case 0: Profile = "None"; break;
   }
 
   PrintAttribute(Tag, Encoded, Profile);
 }
 
-void ARMAttributeParser::ARM_ISA_use(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ARM_ISA_use(unsigned Tag, const uint8_t *Data,
                                      uint32_t &Offset) {
   static const char *const Strings[] = { "Not Permitted", "Permitted" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::THUMB_ISA_use(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::THUMB_ISA_use(unsigned Tag, const uint8_t *Data,
                                        uint32_t &Offset) {
   static const char *const Strings[] = { "Not Permitted", "Thumb-1", "Thumb-2" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::FP_arch(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::FP_arch(unsigned Tag, const uint8_t *Data,
                                  uint32_t &Offset) {
   static const char *const Strings[] = {
     "Not Permitted", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4",
     "VFPv4-D16", "ARMv8-a FP", "ARMv8-a FP-D16"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::WMMX_arch(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::WMMX_arch(unsigned Tag, const uint8_t *Data,
                                    uint32_t &Offset) {
   static const char *const Strings[] = { "Not Permitted", "WMMXv1", "WMMXv2" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::Advanced_SIMD_arch(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::Advanced_SIMD_arch(unsigned Tag, const uint8_t *Data,
                                             uint32_t &Offset) {
   static const char *const Strings[] = {
     "Not Permitted", "NEONv1", "NEONv2+FMA", "ARMv8-a NEON", "ARMv8.1-a NEON"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::MVE_arch(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::MVE_arch(unsigned Tag, const uint8_t *Data,
                                   uint32_t &Offset) {
   static const char *const Strings[] = {
     "Not Permitted", "MVE integer", "MVE integer and float"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::PCS_config(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::PCS_config(unsigned Tag, const uint8_t *Data,
                                     uint32_t &Offset) {
   static const char *const Strings[] = {
     "None", "Bare Platform", "Linux Application", "Linux DSO", "Palm OS 2004",
     "Reserved (Palm OS)", "Symbian OS 2004", "Reserved (Symbian OS)"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_PCS_R9_use(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_PCS_R9_use(unsigned Tag, const uint8_t *Data,
                                         uint32_t &Offset) {
   static const char *const Strings[] = { "v6", "Static Base", "TLS", "Unused" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_PCS_RW_data(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_PCS_RW_data(unsigned Tag, const uint8_t *Data,
                                          uint32_t &Offset) {
   static const char *const Strings[] = {
     "Absolute", "PC-relative", "SB-relative", "Not Permitted"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_PCS_RO_data(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_PCS_RO_data(unsigned Tag, const uint8_t *Data,
                                          uint32_t &Offset) {
   static const char *const Strings[] = {
     "Absolute", "PC-relative", "Not Permitted"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_PCS_GOT_use(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_PCS_GOT_use(unsigned Tag, const uint8_t *Data,
                                          uint32_t &Offset) {
   static const char *const Strings[] = {
     "Not Permitted", "Direct", "GOT-Indirect"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_PCS_wchar_t(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_PCS_wchar_t(unsigned Tag, const uint8_t *Data,
                                          uint32_t &Offset) {
   static const char *const Strings[] = {
     "Not Permitted", "Unknown", "2-byte", "Unknown", "4-byte"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_FP_rounding(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_FP_rounding(unsigned Tag, const uint8_t *Data,
                                          uint32_t &Offset) {
   static const char *const Strings[] = { "IEEE-754", "Runtime" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_FP_denormal(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_FP_denormal(unsigned Tag, const uint8_t *Data,
                                          uint32_t &Offset) {
   static const char *const Strings[] = {
     "Unsupported", "IEEE-754", "Sign Only"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_FP_exceptions(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_FP_exceptions(unsigned Tag, const uint8_t *Data,
                                            uint32_t &Offset) {
   static const char *const Strings[] = { "Not Permitted", "IEEE-754" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_FP_user_exceptions(AttrType Tag,
+void ARMAttributeParser::ABI_FP_user_exceptions(unsigned Tag,
                                                 const uint8_t *Data,
                                                 uint32_t &Offset) {
   static const char *const Strings[] = { "Not Permitted", "IEEE-754" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_FP_number_model(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_FP_number_model(unsigned Tag, const uint8_t *Data,
                                              uint32_t &Offset) {
   static const char *const Strings[] = {
     "Not Permitted", "Finite Only", "RTABI", "IEEE-754"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_align_needed(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_align_needed(unsigned Tag, const uint8_t *Data,
                                           uint32_t &Offset) {
   static const char *const Strings[] = {
     "Not Permitted", "8-byte alignment", "4-byte alignment", "Reserved"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
 
   std::string Description;
   if (Value < array_lengthof(Strings))
     Description = std::string(Strings[Value]);
   else if (Value <= 12)
     Description = std::string("8-byte alignment, ") + utostr(1ULL << Value)
                 + std::string("-byte extended alignment");
   else
     Description = "Invalid";
 
   PrintAttribute(Tag, Value, Description);
 }
 
-void ARMAttributeParser::ABI_align_preserved(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_align_preserved(unsigned Tag, const uint8_t *Data,
                                              uint32_t &Offset) {
   static const char *const Strings[] = {
     "Not Required", "8-byte data alignment", "8-byte data and code alignment",
     "Reserved"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
 
   std::string Description;
   if (Value < array_lengthof(Strings))
     Description = std::string(Strings[Value]);
   else if (Value <= 12)
     Description = std::string("8-byte stack alignment, ") +
                   utostr(1ULL << Value) + std::string("-byte data alignment");
   else
     Description = "Invalid";
 
   PrintAttribute(Tag, Value, Description);
 }
 
-void ARMAttributeParser::ABI_enum_size(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_enum_size(unsigned Tag, const uint8_t *Data,
                                        uint32_t &Offset) {
   static const char *const Strings[] = {
     "Not Permitted", "Packed", "Int32", "External Int32"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_HardFP_use(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_HardFP_use(unsigned Tag, const uint8_t *Data,
                                         uint32_t &Offset) {
   static const char *const Strings[] = {
     "Tag_FP_arch", "Single-Precision", "Reserved", "Tag_FP_arch (deprecated)"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_VFP_args(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_VFP_args(unsigned Tag, const uint8_t *Data,
                                       uint32_t &Offset) {
   static const char *const Strings[] = {
     "AAPCS", "AAPCS VFP", "Custom", "Not Permitted"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_WMMX_args(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_WMMX_args(unsigned Tag, const uint8_t *Data,
                                        uint32_t &Offset) {
   static const char *const Strings[] = { "AAPCS", "iWMMX", "Custom" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_optimization_goals(AttrType Tag,
+void ARMAttributeParser::ABI_optimization_goals(unsigned Tag,
                                                 const uint8_t *Data,
                                                 uint32_t &Offset) {
   static const char *const Strings[] = {
     "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Debugging",
     "Best Debugging"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_FP_optimization_goals(AttrType Tag,
+void ARMAttributeParser::ABI_FP_optimization_goals(unsigned Tag,
                                                    const uint8_t *Data,
                                                    uint32_t &Offset) {
   static const char *const Strings[] = {
     "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Accuracy",
     "Best Accuracy"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::compatibility(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::compatibility(unsigned Tag, const uint8_t *Data,
                                        uint32_t &Offset) {
   uint64_t Integer = ParseInteger(Data, Offset);
   StringRef String = ParseString(Data, Offset);
 
   if (SW) {
     DictScope AS(*SW, "Attribute");
     SW->printNumber("Tag", Tag);
     SW->startLine() << "Value: " << Integer << ", " << String << '\n';
-    SW->printString("TagName", AttrTypeAsString(Tag, /*TagPrefix*/false));
+    SW->printString("TagName", ELFBuildAttrs::AttrTypeAsString(
+                                   Tag, TagToStringMap, /*TagPrefix*/ false));
     switch (Integer) {
     case 0:
       SW->printString("Description", StringRef("No Specific Requirements"));
       break;
     case 1:
       SW->printString("Description", StringRef("AEABI Conformant"));
       break;
     default:
       SW->printString("Description", StringRef("AEABI Non-Conformant"));
       break;
     }
   }
 }
 
-void ARMAttributeParser::CPU_unaligned_access(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::CPU_unaligned_access(unsigned Tag, const uint8_t *Data,
                                               uint32_t &Offset) {
   static const char *const Strings[] = { "Not Permitted", "v6-style" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::FP_HP_extension(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::FP_HP_extension(unsigned Tag, const uint8_t *Data,
                                          uint32_t &Offset) {
   static const char *const Strings[] = { "If Available", "Permitted" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::ABI_FP_16bit_format(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::ABI_FP_16bit_format(unsigned Tag, const uint8_t *Data,
                                              uint32_t &Offset) {
   static const char *const Strings[] = { "Not Permitted", "IEEE-754", "VFPv3" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::MPextension_use(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::MPextension_use(unsigned Tag, const uint8_t *Data,
                                          uint32_t &Offset) {
   static const char *const Strings[] = { "Not Permitted", "Permitted" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::DIV_use(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::DIV_use(unsigned Tag, const uint8_t *Data,
                                  uint32_t &Offset) {
   static const char *const Strings[] = {
     "If Available", "Not Permitted", "Permitted"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::DSP_extension(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::DSP_extension(unsigned Tag, const uint8_t *Data,
                                        uint32_t &Offset) {
   static const char *const Strings[] = { "Not Permitted", "Permitted" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::T2EE_use(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::T2EE_use(unsigned Tag, const uint8_t *Data,
                                   uint32_t &Offset) {
   static const char *const Strings[] = { "Not Permitted", "Permitted" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::Virtualization_use(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::Virtualization_use(unsigned Tag, const uint8_t *Data,
                                             uint32_t &Offset) {
   static const char *const Strings[] = {
     "Not Permitted", "TrustZone", "Virtualization Extensions",
     "TrustZone + Virtualization Extensions"
   };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
-void ARMAttributeParser::nodefaults(AttrType Tag, const uint8_t *Data,
+void ARMAttributeParser::nodefaults(unsigned Tag, const uint8_t *Data,
                                     uint32_t &Offset) {
   uint64_t Value = ParseInteger(Data, Offset);
   PrintAttribute(Tag, Value, "Unspecified Tags UNDEFINED");
 }
 
-void ARMAttributeParser::ParseIndexList(const uint8_t *Data, uint32_t &Offset,
-                                        SmallVectorImpl<uint8_t> &IndexList) {
-  for (;;) {
-    unsigned DecodeLength;
-    uint64_t Value = decodeULEB128(Data + Offset, &DecodeLength);
-    Offset += DecodeLength;
-    if (Value == 0)
-      break;
-    IndexList.push_back(Value);
-  }
-}
-
-void ARMAttributeParser::ParseAttributeList(const uint8_t *Data,
-                                            uint32_t &Offset, uint32_t Length) {
-  while (Offset < Length) {
-    unsigned DecodeLength;
-    uint64_t Tag = decodeULEB128(Data + Offset, &DecodeLength);
-    Offset += DecodeLength;
-
-    bool Handled = false;
-    for (unsigned AHI = 0, AHE = array_lengthof(DisplayRoutines);
-         AHI != AHE && !Handled; ++AHI) {
-      if (uint64_t(DisplayRoutines[AHI].Attribute) == Tag) {
-        (this->*DisplayRoutines[AHI].Routine)(ARMBuildAttrs::AttrType(Tag),
-                                              Data, Offset);
-        Handled = true;
-        break;
-      }
-    }
-    if (!Handled) {
-      if (Tag < 32) {
-        errs() << "unhandled AEABI Tag " << Tag
-               << " (" << ARMBuildAttrs::AttrTypeAsString(Tag) << ")\n";
-        continue;
-      }
+bool ARMAttributeParser::Handler(unsigned Tag, const uint8_t *Data,
+                                 uint32_t &Offset) {
+      (this->*DisplayRoutines[AHI].Routine)(Tag, Data, Offset);
 
-      if (Tag % 2 == 0)
-        IntegerAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
-      else
-        StringAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
-    }
-  }
-}
-
-void ARMAttributeParser::ParseSubsection(const uint8_t *Data, uint32_t Length) {
-  uint32_t Offset = sizeof(uint32_t); /* SectionLength */
-
-  const char *VendorName = reinterpret_cast<const char*>(Data + Offset);
-  size_t VendorNameLength = std::strlen(VendorName);
-  Offset = Offset + VendorNameLength + 1;
-
-  if (SW) {
-    SW->printNumber("SectionLength", Length);
-    SW->printString("Vendor", StringRef(VendorName, VendorNameLength));
-  }
-
-  if (StringRef(VendorName, VendorNameLength).lower() != "aeabi") {
-    return;
-  }
-
-  while (Offset < Length) {
-    /// Tag_File | Tag_Section | Tag_Symbol   uleb128:byte-size
-    uint8_t Tag = Data[Offset];
-    Offset = Offset + sizeof(Tag);
-
-    uint32_t Size =
-      *reinterpret_cast<const support::ulittle32_t*>(Data + Offset);
-    Offset = Offset + sizeof(Size);
-
-    if (SW) {
-      SW->printEnum("Tag", Tag, makeArrayRef(TagNames));
-      SW->printNumber("Size", Size);
-    }
-
-    if (Size > Length) {
-      errs() << "subsection length greater than section length\n";
-      return;
-    }
-
-    StringRef ScopeName, IndexName;
-    SmallVector<uint8_t, 8> Indicies;
-    switch (Tag) {
-    case ARMBuildAttrs::File:
-      ScopeName = "FileAttributes";
-      break;
-    case ARMBuildAttrs::Section:
-      ScopeName = "SectionAttributes";
-      IndexName = "Sections";
-      ParseIndexList(Data, Offset, Indicies);
-      break;
-    case ARMBuildAttrs::Symbol:
-      ScopeName = "SymbolAttributes";
-      IndexName = "Symbols";
-      ParseIndexList(Data, Offset, Indicies);
-      break;
-    default:
-      errs() << "unrecognised tag: 0x" << Twine::utohexstr(Tag) << '\n';
-      return;
-    }
-
-    if (SW) {
-      DictScope ASS(*SW, ScopeName);
-      if (!Indicies.empty())
-        SW->printList(IndexName, Indicies);
-      ParseAttributeList(Data, Offset, Length);
-    } else {
-      ParseAttributeList(Data, Offset, Length);
-    }
-  }
-}
-
-void ARMAttributeParser::Parse(ArrayRef<uint8_t> Section, bool isLittle) {
-  uint64_t Offset = 1;
-  unsigned SectionNumber = 0;
-
-  while (Offset < Section.size()) {
-    uint32_t SectionLength = isLittle ?
-      support::endian::read32le(Section.data() + Offset) :
-      support::endian::read32be(Section.data() + Offset);
-
-    if (SW) {
-      SW->startLine() << "Section " << ++SectionNumber << " {\n";
-      SW->indent();
-    }
-
-    if (SectionLength == 0 || (SectionLength + Offset) > Section.size()) {
-      errs() << "invalid subsection length " << SectionLength << " at offset "
-             << Offset << "\n";
-      return;
-    }
-
-    ParseSubsection(Section.data() + Offset, SectionLength);
-    Offset = Offset + SectionLength;
-
-    if (SW) {
-      SW->unindent();
-      SW->startLine() << "}\n";
-    }
-  }
+  return Handled;
 }
 }

llvm/lib/Support/ARMBuildAttrs.cpp

 //===-- ARMBuildAttrs.cpp - ARM Build Attributes --------------------------===//
 //
 // 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/ADT/StringRef.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 
-using namespace llvm;
+namespace llvm {
+namespace ARMBuildAttrs {
 
-namespace {
-const struct {
-  ARMBuildAttrs::AttrType Attr;
-  StringRef TagName;
-} ARMAttributeTags[] = {
-  { ARMBuildAttrs::File, "Tag_File" },
-  { ARMBuildAttrs::Section, "Tag_Section" },
-  { ARMBuildAttrs::Symbol, "Tag_Symbol" },
-  { ARMBuildAttrs::CPU_raw_name, "Tag_CPU_raw_name" },
-  { ARMBuildAttrs::CPU_name, "Tag_CPU_name" },
-  { ARMBuildAttrs::CPU_arch, "Tag_CPU_arch" },
-  { ARMBuildAttrs::CPU_arch_profile, "Tag_CPU_arch_profile" },
-  { ARMBuildAttrs::ARM_ISA_use, "Tag_ARM_ISA_use" },
-  { ARMBuildAttrs::THUMB_ISA_use, "Tag_THUMB_ISA_use" },
-  { ARMBuildAttrs::FP_arch, "Tag_FP_arch" },
-  { ARMBuildAttrs::WMMX_arch, "Tag_WMMX_arch" },
-  { ARMBuildAttrs::Advanced_SIMD_arch, "Tag_Advanced_SIMD_arch" },
-  { ARMBuildAttrs::MVE_arch, "Tag_MVE_arch" },
-  { ARMBuildAttrs::PCS_config, "Tag_PCS_config" },
-  { ARMBuildAttrs::ABI_PCS_R9_use, "Tag_ABI_PCS_R9_use" },
-  { ARMBuildAttrs::ABI_PCS_RW_data, "Tag_ABI_PCS_RW_data" },
-  { ARMBuildAttrs::ABI_PCS_RO_data, "Tag_ABI_PCS_RO_data" },
-  { ARMBuildAttrs::ABI_PCS_GOT_use, "Tag_ABI_PCS_GOT_use" },
-  { ARMBuildAttrs::ABI_PCS_wchar_t, "Tag_ABI_PCS_wchar_t" },
-  { ARMBuildAttrs::ABI_FP_rounding, "Tag_ABI_FP_rounding" },
-  { ARMBuildAttrs::ABI_FP_denormal, "Tag_ABI_FP_denormal" },
-  { ARMBuildAttrs::ABI_FP_exceptions, "Tag_ABI_FP_exceptions" },
-  { ARMBuildAttrs::ABI_FP_user_exceptions, "Tag_ABI_FP_user_exceptions" },
-  { ARMBuildAttrs::ABI_FP_number_model, "Tag_ABI_FP_number_model" },
-  { ARMBuildAttrs::ABI_align_needed, "Tag_ABI_align_needed" },
-  { ARMBuildAttrs::ABI_align_preserved, "Tag_ABI_align_preserved" },
-  { ARMBuildAttrs::ABI_enum_size, "Tag_ABI_enum_size" },
-  { ARMBuildAttrs::ABI_HardFP_use, "Tag_ABI_HardFP_use" },
-  { ARMBuildAttrs::ABI_VFP_args, "Tag_ABI_VFP_args" },
-  { ARMBuildAttrs::ABI_WMMX_args, "Tag_ABI_WMMX_args" },
-  { ARMBuildAttrs::ABI_optimization_goals, "Tag_ABI_optimization_goals" },
-  { ARMBuildAttrs::ABI_FP_optimization_goals, "Tag_ABI_FP_optimization_goals" },
-  { ARMBuildAttrs::compatibility, "Tag_compatibility" },
-  { ARMBuildAttrs::CPU_unaligned_access, "Tag_CPU_unaligned_access" },
-  { ARMBuildAttrs::FP_HP_extension, "Tag_FP_HP_extension" },
-  { ARMBuildAttrs::ABI_FP_16bit_format, "Tag_ABI_FP_16bit_format" },
-  { ARMBuildAttrs::MPextension_use, "Tag_MPextension_use" },
-  { ARMBuildAttrs::DIV_use, "Tag_DIV_use" },
-  { ARMBuildAttrs::DSP_extension, "Tag_DSP_extension" },
-  { ARMBuildAttrs::nodefaults, "Tag_nodefaults" },
-  { ARMBuildAttrs::also_compatible_with, "Tag_also_compatible_with" },
-  { ARMBuildAttrs::T2EE_use, "Tag_T2EE_use" },
-  { ARMBuildAttrs::conformance, "Tag_conformance" },
-  { ARMBuildAttrs::Virtualization_use, "Tag_Virtualization_use" },
+TagNameMap ARMAttributeTags = {
+    {ARMBuildAttrs::File, "Tag_File"},
+    {ARMBuildAttrs::Section, "Tag_Section"},
+    {ARMBuildAttrs::Symbol, "Tag_Symbol"},
+    {ARMBuildAttrs::CPU_raw_name, "Tag_CPU_raw_name"},
+    {ARMBuildAttrs::CPU_name, "Tag_CPU_name"},
+    {ARMBuildAttrs::CPU_arch, "Tag_CPU_arch"},
+    {ARMBuildAttrs::CPU_arch_profile, "Tag_CPU_arch_profile"},
+    {ARMBuildAttrs::ARM_ISA_use, "Tag_ARM_ISA_use"},
+    {ARMBuildAttrs::THUMB_ISA_use, "Tag_THUMB_ISA_use"},
+    {ARMBuildAttrs::FP_arch, "Tag_FP_arch"},
+    {ARMBuildAttrs::WMMX_arch, "Tag_WMMX_arch"},
+    {ARMBuildAttrs::Advanced_SIMD_arch, "Tag_Advanced_SIMD_arch"},
+    {ARMBuildAttrs::MVE_arch, "Tag_MVE_arch"},
+    {ARMBuildAttrs::PCS_config, "Tag_PCS_config"},
+    {ARMBuildAttrs::ABI_PCS_R9_use, "Tag_ABI_PCS_R9_use"},
+    {ARMBuildAttrs::ABI_PCS_RW_data, "Tag_ABI_PCS_RW_data"},
+    {ARMBuildAttrs::ABI_PCS_RO_data, "Tag_ABI_PCS_RO_data"},
+    {ARMBuildAttrs::ABI_PCS_GOT_use, "Tag_ABI_PCS_GOT_use"},
+    {ARMBuildAttrs::ABI_PCS_wchar_t, "Tag_ABI_PCS_wchar_t"},
+    {ARMBuildAttrs::ABI_FP_rounding, "Tag_ABI_FP_rounding"},
+    {ARMBuildAttrs::ABI_FP_denormal, "Tag_ABI_FP_denormal"},
+    {ARMBuildAttrs::ABI_FP_exceptions, "Tag_ABI_FP_exceptions"},
+    {ARMBuildAttrs::ABI_FP_user_exceptions, "Tag_ABI_FP_user_exceptions"},
+    {ARMBuildAttrs::ABI_FP_number_model, "Tag_ABI_FP_number_model"},
+    {ARMBuildAttrs::ABI_align_needed, "Tag_ABI_align_needed"},
+    {ARMBuildAttrs::ABI_align_preserved, "Tag_ABI_align_preserved"},
+    {ARMBuildAttrs::ABI_enum_size, "Tag_ABI_enum_size"},
+    {ARMBuildAttrs::ABI_HardFP_use, "Tag_ABI_HardFP_use"},
+    {ARMBuildAttrs::ABI_VFP_args, "Tag_ABI_VFP_args"},
+    {ARMBuildAttrs::ABI_WMMX_args, "Tag_ABI_WMMX_args"},
+    {ARMBuildAttrs::ABI_optimization_goals, "Tag_ABI_optimization_goals"},
+    {ARMBuildAttrs::ABI_FP_optimization_goals, "Tag_ABI_FP_optimization_goals"},
+    {ARMBuildAttrs::compatibility, "Tag_compatibility"},
+    {ARMBuildAttrs::CPU_unaligned_access, "Tag_CPU_unaligned_access"},
+    {ARMBuildAttrs::FP_HP_extension, "Tag_FP_HP_extension"},
+    {ARMBuildAttrs::ABI_FP_16bit_format, "Tag_ABI_FP_16bit_format"},
+    {ARMBuildAttrs::MPextension_use, "Tag_MPextension_use"},
+    {ARMBuildAttrs::DIV_use, "Tag_DIV_use"},
+    {ARMBuildAttrs::DSP_extension, "Tag_DSP_extension"},
+    {ARMBuildAttrs::nodefaults, "Tag_nodefaults"},
+    {ARMBuildAttrs::also_compatible_with, "Tag_also_compatible_with"},
+    {ARMBuildAttrs::T2EE_use, "Tag_T2EE_use"},
+    {ARMBuildAttrs::conformance, "Tag_conformance"},
+    {ARMBuildAttrs::Virtualization_use, "Tag_Virtualization_use"},
 
     // Legacy Names
-  { ARMBuildAttrs::FP_arch, "Tag_VFP_arch" },
-  { ARMBuildAttrs::FP_HP_extension, "Tag_VFP_HP_extension" },
-  { ARMBuildAttrs::ABI_align_needed, "Tag_ABI_align8_needed" },
-  { ARMBuildAttrs::ABI_align_preserved, "Tag_ABI_align8_preserved" },
+    {ARMBuildAttrs::FP_arch, "Tag_VFP_arch"},
+    {ARMBuildAttrs::FP_HP_extension, "Tag_VFP_HP_extension"},
+    {ARMBuildAttrs::ABI_align_needed, "Tag_ABI_align8_needed"},
+    {ARMBuildAttrs::ABI_align_preserved, "Tag_ABI_align8_preserved"},
 };
 }
-
-namespace llvm {
-namespace ARMBuildAttrs {
-StringRef AttrTypeAsString(unsigned Attr, bool HasTagPrefix) {
-  return AttrTypeAsString(static_cast<AttrType>(Attr), HasTagPrefix);
-}
-
-StringRef AttrTypeAsString(AttrType Attr, bool HasTagPrefix) {
-  for (unsigned TI = 0, TE = sizeof(ARMAttributeTags) / sizeof(*ARMAttributeTags);
-       TI != TE; ++TI)
-    if (ARMAttributeTags[TI].Attr == Attr) {
-      auto TagName = ARMAttributeTags[TI].TagName;
-      return HasTagPrefix ? TagName : TagName.drop_front(4);
-    }
-  return "";
-}
-
-int AttrTypeFromString(StringRef Tag) {
-  bool HasTagPrefix = Tag.startswith("Tag_");
-  for (unsigned TI = 0,
-                TE = sizeof(ARMAttributeTags) / sizeof(*ARMAttributeTags);
-       TI != TE; ++TI) {
-    auto TagName = ARMAttributeTags[TI].TagName;
-    if (TagName.drop_front(HasTagPrefix ? 0 : 4) == Tag) {
-      return ARMAttributeTags[TI].Attr;
-    }
-  }
-  return -1;
-}
-}
-}
-
+} // namespace llvm

llvm/lib/Support/CMakeLists.txt

add_llvm_component_library(LLVMSupport
   ConvertUTFWrapper.cpp
   CrashRecoveryContext.cpp
   DataExtractor.cpp
   Debug.cpp
   DebugCounter.cpp
   DeltaAlgorithm.cpp
   DAGDeltaAlgorithm.cpp
   DJB.cpp
+  ELFAttributeParser.cpp
+  ELFBuildAttrs.cpp
   Error.cpp
   ErrorHandling.cpp
   FileCheck.cpp
   FileCollector.cpp
   FileUtilities.cpp
   FileOutputBuffer.cpp
   FoldingSet.cpp
   FormattedStream.cpp
add_llvm_component_library(LLVMSupport
   MD5.cpp
   NativeFormatting.cpp
   Optional.cpp
   Parallel.cpp
   PluginLoader.cpp
   PrettyStackTrace.cpp
   RandomNumberGenerator.cpp
   Regex.cpp
+  RISCVAttributes.cpp
+  RISCVAttributeParser.cpp
   ScaledNumber.cpp
   ScopedPrinter.cpp
   SHA1.cpp
   Signposts.cpp
   SmallPtrSet.cpp
   SmallVector.cpp
   SourceMgr.cpp
   SpecialCaseList.cpp

llvm/lib/Support/ELFAttributeParser.cpp

+//===--- ELFAttributeParser.cpp - ELF Attribute Information Printer -------===//
+//
+// 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/Support/ELFAttributeParser.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/LEB128.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+using namespace llvm;
+using namespace llvm::ELFBuildAttrs;
+
+static const EnumEntry<unsigned> TagNames[] = {
+    {"Tag_File", ELFBuildAttrs::File},
+    {"Tag_Section", ELFBuildAttrs::Section},
+    {"Tag_Symbol", ELFBuildAttrs::Symbol},
+};
+
+namespace llvm {
+uint64_t ELFAttributeParser::ParseInteger(const uint8_t *Data,
+                                          uint32_t &Offset) {
+  unsigned DecodeLength;
+  uint64_t Value = decodeULEB128(Data + Offset, &DecodeLength);
+  Offset += DecodeLength;
+  return Value;
+}
+
+StringRef ELFAttributeParser::ParseString(const uint8_t *Data,
+                                          uint32_t &Offset) {
+  const char *String = reinterpret_cast<const char *>(Data + Offset);
+  size_t Length = std::strlen(String);
+  Offset = Offset + Length + 1;
+  return StringRef(String, Length);
+}
+
+void ELFAttributeParser::IntegerAttribute(unsigned Tag, const uint8_t *Data,
+                                          uint32_t &Offset) {
+  StringRef TagName =
+      ELFBuildAttrs::AttrTypeAsString(Tag, TagToStringMap, /*TagPrefix*/ false);
+  uint64_t Value = ParseInteger(Data, Offset);
+  Attributes.insert(std::make_pair(Tag, Value));
+
+  if (SW) {
+    DictScope AS(*SW, "Attribute");
+    SW->printNumber("Tag", Tag);
+    if (!TagName.empty())
+      SW->printString("TagName", TagName);
+    SW->printNumber("Value", Value);
+  }
+}
+
+void ELFAttributeParser::StringAttribute(unsigned Tag, const uint8_t *Data,
+                                         uint32_t &Offset) {
+  StringRef TagName =
+      ELFBuildAttrs::AttrTypeAsString(Tag, TagToStringMap, /*TagPrefix*/ false);
+  StringRef Value = ParseString(Data, Offset);
+  AttributesStr.insert(std::make_pair(Tag, Value));
+
+  if (SW) {
+    DictScope AS(*SW, "Attribute");
+    SW->printNumber("Tag", Tag);
+    if (!TagName.empty())
+      SW->printString("TagName", TagName);
+    SW->printString("Value", Value);
+  }
+}
+
+void ELFAttributeParser::PrintAttribute(unsigned Tag, unsigned Value,
+                                        StringRef ValueDesc) {
+  Attributes.insert(std::make_pair(Tag, Value));
+
+  if (SW) {
+    StringRef TagName = ELFBuildAttrs::AttrTypeAsString(Tag, TagToStringMap,
+                                                        /*TagPrefix*/ false);
+    DictScope AS(*SW, "Attribute");
+    SW->printNumber("Tag", Tag);
+    SW->printNumber("Value", Value);
+    if (!TagName.empty())
+      SW->printString("TagName", TagName);
+    if (!ValueDesc.empty())
+      SW->printString("Description", ValueDesc);
+  }
+}
+
+void ELFAttributeParser::ParseIndexList(const uint8_t *Data, uint32_t &Offset,
+                                        SmallVectorImpl<uint8_t> &IndexList) {
+  for (;;) {
+    unsigned DecodeLength;
+    uint64_t Value = decodeULEB128(Data + Offset, &DecodeLength);
+    Offset += DecodeLength;
+    if (Value == 0)
+      break;
+    IndexList.push_back(Value);
+  }
+}
+
+void ELFAttributeParser::ParseAttributeList(const uint8_t *Data,
+                                            uint32_t &Offset, uint32_t Length) {
+  while (Offset < Length) {
+    unsigned DecodeLength;
+    uint64_t Tag = decodeULEB128(Data + Offset, &DecodeLength);
+    Offset += DecodeLength;
+
+    bool Handled = Handler(Tag, Data, Offset);
+    if (!Handled) {
+      if (Tag < 32) {
+        errs() << "unhandled Tag " << Tag << " ("
+               << ELFBuildAttrs::AttrTypeAsString(Tag, TagToStringMap) << ")\n";
+        continue;
+      }
+
+      if (Tag % 2 == 0)
+        IntegerAttribute(Tag, Data, Offset);
+      else
+        StringAttribute(Tag, Data, Offset);
+    }
+  }
+}
+
+void ELFAttributeParser::ParseSubsection(const uint8_t *Data, uint32_t Length) {
+  uint32_t Offset = sizeof(uint32_t); /* SectionLength */
+
+  const char *VendorName = reinterpret_cast<const char *>(Data + Offset);
+  size_t VendorNameLength = std::strlen(VendorName);
+  Offset = Offset + VendorNameLength + 1;
+
+  if (SW) {
+    SW->printNumber("SectionLength", Length);
+    SW->printString("Vendor", StringRef(VendorName, VendorNameLength));
+  }
+
+  if (StringRef(VendorName, VendorNameLength).lower() != Vendor) {
+    return;
+  }
+
+  while (Offset < Length) {
+    /// Tag_File | Tag_Section | Tag_Symbol   uleb128:byte-size
+    uint8_t Tag = Data[Offset];
+    Offset = Offset + sizeof(Tag);
+
+    uint32_t Size =
+        *reinterpret_cast<const support::ulittle32_t *>(Data + Offset);
+    Offset = Offset + sizeof(Size);
+
+    if (SW) {
+      SW->printEnum("Tag", Tag, makeArrayRef(TagNames));
+      SW->printNumber("Size", Size);
+    }
+
+    if (Size > Length) {
+      errs() << "subsection length greater than section length\n";
+      return;
+    }
+
+    StringRef ScopeName, IndexName;
+    SmallVector<uint8_t, 8> Indicies;
+    switch (Tag) {
+    case ELFBuildAttrs::File:
+      ScopeName = "FileAttributes";
+      break;
+    case ELFBuildAttrs::Section:
+      ScopeName = "SectionAttributes";
+      IndexName = "Sections";
+      ParseIndexList(Data, Offset, Indicies);
+      break;
+    case ELFBuildAttrs::Symbol:
+      ScopeName = "SymbolAttributes";
+      IndexName = "Symbols";
+      ParseIndexList(Data, Offset, Indicies);
+      break;
+    default:
+      errs() << "unrecognised tag: 0x" << Twine::utohexstr(Tag) << '\n';
+      return;
+    }
+
+    if (SW) {
+      DictScope ASS(*SW, ScopeName);
+      if (!Indicies.empty())
+        SW->printList(IndexName, Indicies);
+      ParseAttributeList(Data, Offset, Length);
+    } else {
+      ParseAttributeList(Data, Offset, Length);
+    }
+  }
+}
+
+void ELFAttributeParser::Parse(ArrayRef<uint8_t> Section, bool isLittle) {
+  uint64_t Offset = 1;
+  unsigned SectionNumber = 0;
+
+  while (Offset < Section.size()) {
+    uint32_t SectionLength =
+        isLittle ? support::endian::read32le(Section.data() + Offset)
+                 : support::endian::read32be(Section.data() + Offset);
+
+    if (SW) {
+      SW->startLine() << "Section " << ++SectionNumber << " {\n";
+      SW->indent();
+    }
+
+    if (SectionLength == 0 || (SectionLength + Offset) > Section.size()) {
+      errs() << "invalid subsection length " << SectionLength << " at offset "
+             << Offset << "\n";
+      return;
+    }
+
+    ParseSubsection(Section.data() + Offset, SectionLength);
+    Offset = Offset + SectionLength;
+
+    if (SW) {
+      SW->unindent();
+      SW->startLine() << "}\n";
+    }
+  }
+}
+} // namespace llvm

llvm/lib/Support/ELFBuildAttrs.cpp

+//===-- ELFBuildAttrs.cpp - ELF Build Attributes --------------------------===//
+//
+// 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/ADT/StringRef.h"
+#include "llvm/Support/ELFBuildAttributes.h"
+
+using namespace llvm;
+
+namespace llvm {
+namespace ELFBuildAttrs {
+StringRef AttrTypeAsString(unsigned Attr, TagNameMap Map, bool HasTagPrefix) {
+  return AttrTypeAsString(static_cast<AttrType>(Attr), Map, HasTagPrefix);
+}
+
+StringRef AttrTypeAsString(AttrType Attr, TagNameMap Map, bool HasTagPrefix) {
+  for (auto TI = Map.begin(), TE = Map.end(); TI != TE; ++TI) {
+    if (TI->Attr == Attr) {
+      auto TagName = TI->TagName;
+      return HasTagPrefix ? TagName : TagName.drop_front(4);
+    }
+  }
+  return "";
+}
+
+int AttrTypeFromString(StringRef Tag, TagNameMap Map) {
+  bool HasTagPrefix = Tag.startswith("Tag_");
+  for (auto TI = Map.begin(), TE = Map.end(); TI != TE; ++TI) {
+    auto TagName = TI->TagName;
+    if (TagName.drop_front(HasTagPrefix ? 0 : 4) == Tag) {
+      return TI->Attr;
+    }
+  }
+  return -1;
+}
+} // namespace ELFBuildAttrs
+} // namespace llvm

llvm/lib/Support/RISCVAttributeParser.cpp

+//===--- RISCVAttributeParser.cpp - RISCV Attribute Information Printer ---===//
+//
+// 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/Support/RISCVAttributeParser.h"
+#include "llvm/ADT/StringExtras.h"
+
+using namespace llvm;
+using namespace llvm::RISCVAttrs;
+
+namespace llvm {
+#define ATTRIBUTE_HANDLER(Attr_)                                               \
+  { RISCVAttrs::Attr_, &RISCVAttributeParser::Attr_ }
+
+const RISCVAttributeParser::DisplayHandler
+    RISCVAttributeParser::DisplayRoutines[] = {
+        {
+            RISCVAttrs::Arch,
+            &ELFAttributeParser::StringAttribute,
+        },
+        {
+            RISCVAttrs::Priv_spec,
+            &ELFAttributeParser::IntegerAttribute,
+        },
+        {
+            RISCVAttrs::Priv_spec_minor,
+            &ELFAttributeParser::IntegerAttribute,
+        },
+        {
+            RISCVAttrs::Priv_spec_revision,
+            &ELFAttributeParser::IntegerAttribute,
+        },
+        ATTRIBUTE_HANDLER(Stack_align),
+        ATTRIBUTE_HANDLER(Unaligned_access)};
+
+#undef ATTRIBUTE_HANDLER
+
+void RISCVAttributeParser::Unaligned_access(unsigned Tag, const uint8_t *Data,
+                                            uint32_t &Offset) {
+  static const char *const Strings[] = {"No unaligned access",
+                                        "Unaligned access"};
+
+  uint64_t Value = ParseInteger(Data, Offset);
+  StringRef ValueDesc =
+      (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
+  PrintAttribute(Tag, Value, ValueDesc);
+}
+
+void RISCVAttributeParser::Stack_align(unsigned Tag, const uint8_t *Data,
+                                       uint32_t &Offset) {
+  uint64_t Value = ParseInteger(Data, Offset);
+  std::string Description =
+      "Stack alignment is " + utostr(Value) + std::string("-bytes");
+
+  PrintAttribute(Tag, Value, Description);
+}
+
+bool RISCVAttributeParser::Handler(unsigned Tag, const uint8_t *Data,
+                                   uint32_t &Offset) {
+  bool Handled = false;
+  for (unsigned AHI = 0, AHE = array_lengthof(DisplayRoutines);
+       AHI != AHE && !Handled; ++AHI) {
+    if (uint64_t(DisplayRoutines[AHI].Attribute) == Tag) {
+      (this->*DisplayRoutines[AHI].Routine)(Tag, Data, Offset);
+      Handled = true;
+      break;
+    }
+  }
+
+  return Handled;
+}
+
+} // namespace llvm

llvm/lib/Support/RISCVAttributes.cpp

+//===-- RISCVAttributes.cpp - RISCV Attributes ----------------------------===//
+//
+// 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/Support/RISCVAttributes.h"
+
+namespace llvm {
+namespace RISCVAttrs {
+
+TagNameMap RISCVAttributeTags = {
+    {Stack_align, "Tag_stack_align"},
+    {Arch, "Tag_arch"},
+    {Unaligned_access, "Tag_unaligned_access"},
+    {Priv_spec, "Tag_priv_spec"},
+    {Priv_spec_minor, "Tag_priv_spec_minor"},
+    {Priv_spec_revision, "Tag_priv_spec_revision"},
+};
+
+} // namespace RISCVAttrs
+} // namespace llvm

llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp

 ///  ::= .eabi_attribute Tag_name, int [, "str"]
 bool ARMAsmParser::parseDirectiveEabiAttr(SMLoc L) {
   MCAsmParser &Parser = getParser();
   int64_t Tag;
   SMLoc TagLoc;
   TagLoc = Parser.getTok().getLoc();
   if (Parser.getTok().is(AsmToken::Identifier)) {
     StringRef Name = Parser.getTok().getIdentifier();
-    Tag = ARMBuildAttrs::AttrTypeFromString(Name);
+    Tag = ELFBuildAttrs::AttrTypeFromString(Name,
+                                            ARMBuildAttrs::ARMAttributeTags);
     if (Tag == -1) {
       Error(TagLoc, "attribute name not recognised: " + Name);
       return false;
     }
     Parser.Lex();
   } else {
     const MCExpr *AttrExpr;
 

llvm/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

void ARMTargetAsmStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
   OS << "}\n";
 }
 
 void ARMTargetAsmStreamer::switchVendor(StringRef Vendor) {}
 
 void ARMTargetAsmStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
   OS << "\t.eabi_attribute\t" << Attribute << ", " << Twine(Value);
   if (IsVerboseAsm) {
-    StringRef Name = ARMBuildAttrs::AttrTypeAsString(Attribute);
+    StringRef Name = ELFBuildAttrs::AttrTypeAsString(
+        Attribute, ARMBuildAttrs::ARMAttributeTags);
     if (!Name.empty())
       OS << "\t@ " << Name;
   }
   OS << "\n";
 }
 
 void ARMTargetAsmStreamer::emitTextAttribute(unsigned Attribute,
                                              StringRef String) {
   switch (Attribute) {
   case ARMBuildAttrs::CPU_name:
     OS << "\t.cpu\t" << String.lower();
     break;
   default:
     OS << "\t.eabi_attribute\t" << Attribute << ", \"" << String << "\"";
     if (IsVerboseAsm) {
-      StringRef Name = ARMBuildAttrs::AttrTypeAsString(Attribute);
+      StringRef Name = ELFBuildAttrs::AttrTypeAsString(
+          Attribute, ARMBuildAttrs::ARMAttributeTags);
       if (!Name.empty())
         OS << "\t@ " << Name;
     }
     break;
   }
   OS << "\n";
 }
 
 void ARMTargetAsmStreamer::emitIntTextAttribute(unsigned Attribute,
                                                 unsigned IntValue,
                                                 StringRef StringValue) {
   switch (Attribute) {
   default: llvm_unreachable("unsupported multi-value attribute in asm mode");
   case ARMBuildAttrs::compatibility:
     OS << "\t.eabi_attribute\t" << Attribute << ", " << IntValue;
     if (!StringValue.empty())
       OS << ", \"" << StringValue << "\"";
     if (IsVerboseAsm)
-      OS << "\t@ " << ARMBuildAttrs::AttrTypeAsString(Attribute);
+      OS << "\t@ "
+         << ELFBuildAttrs::AttrTypeAsString(Attribute,
+                                            ARMBuildAttrs::ARMAttributeTags);
     break;
   }
   OS << "\n";
 }
 
 void ARMTargetAsmStreamer::emitArch(ARM::ArchKind Arch) {
   OS << "\t.arch\t" << ARM::getArchName(Arch) << "\n";
 }

llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp

 #include "llvm/MC/MCParser/MCAsmLexer.h"
 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/RISCVAttributes.h"
 #include "llvm/Support/TargetRegistry.h"
 
 #include <limits>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "riscv-asm-parser"
 
#include "RISCVGenAsmMatcher.inc"
   OperandMatchResultTy parseBareSymbol(OperandVector &Operands);
   OperandMatchResultTy parseCallSymbol(OperandVector &Operands);
   OperandMatchResultTy parsePseudoJumpSymbol(OperandVector &Operands);
   OperandMatchResultTy parseJALOffset(OperandVector &Operands);
 
   bool parseOperand(OperandVector &Operands, StringRef Mnemonic);
 
   bool parseDirectiveOption();
+  bool parseDirectiveAttribute();
 
   void setFeatureBits(uint64_t Feature, StringRef FeatureString) {
     if (!(getSTI().getFeatureBits()[Feature])) {
       MCSubtargetInfo &STI = copySTI();
       setAvailableFeatures(
           ComputeAvailableFeatures(STI.ToggleFeature(FeatureString)));
     }
   }
 
   void clearFeatureBits(uint64_t Feature, StringRef FeatureString) {
     if (getSTI().getFeatureBits()[Feature]) {
       MCSubtargetInfo &STI = copySTI();
       setAvailableFeatures(
           ComputeAvailableFeatures(STI.ToggleFeature(FeatureString)));
     }
   }
 
   void pushFeatureBits() {
     FeatureBitStack.push_back(getSTI().getFeatureBits());
   }
bool RISCVAsmParser::ParseDirective(AsmToken DirectiveID) {
   // This returns false if this function recognizes the directive
   // regardless of whether it is successfully handles or reports an
   // error. Otherwise it returns true to give the generic parser a
   // chance at recognizing it.
   StringRef IDVal = DirectiveID.getString();
 
   if (IDVal == ".option")
     return parseDirectiveOption();
+  else if (IDVal == ".attribute")
+    return parseDirectiveAttribute();
 
   return true;
 }
 
 bool RISCVAsmParser::parseDirectiveOption() {
   MCAsmParser &Parser = getParser();
   // Get the option token.
   AsmToken Tok = Parser.getTok();
bool RISCVAsmParser::parseDirectiveOption() {
   // Unknown option.
   Warning(Parser.getTok().getLoc(),
           "unknown option, expected 'push', 'pop', 'rvc', 'norvc', 'relax' or "
           "'norelax'");
   Parser.eatToEndOfStatement();
   return false;
 }
 
+/// parseDirectiveAttribute
+///  ::= .attribute int, int [, "str"]
+///  ::= .attribute Tag_name, int [, "str"]
+bool RISCVAsmParser::parseDirectiveAttribute() {
+  MCAsmParser &Parser = getParser();
+  int64_t Tag;
+  SMLoc TagLoc;
+  TagLoc = Parser.getTok().getLoc();
+  if (Parser.getTok().is(AsmToken::Identifier)) {
+    StringRef Name = Parser.getTok().getIdentifier();
+    Tag =
+        ELFBuildAttrs::AttrTypeFromString(Name, RISCVAttrs::RISCVAttributeTags);
+    if (Tag == -1) {
+      Error(TagLoc, "attribute name not recognised: " + Name);
+      return false;
+    }
+    Parser.Lex();
+  } else {
+    const MCExpr *AttrExpr;
+
+    TagLoc = Parser.getTok().getLoc();
+    if (Parser.parseExpression(AttrExpr))
+      return true;
+
+    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(AttrExpr);
+    if (check(!CE, TagLoc, "expected numeric constant"))
+      return true;
+
+    Tag = CE->getValue();
+  }
+
+  if (Parser.parseToken(AsmToken::Comma, "comma expected"))
+    return true;
+
+  StringRef StringValue = "";
+  bool IsStringValue = false;
+
+  int64_t IntegerValue = 0;
+  bool IsIntegerValue = false;
+
+  if (Tag == RISCVAttrs::Arch)
+    IsStringValue = true;
+  else
+    IsIntegerValue = true;
+
+  if (IsIntegerValue) {
+    const MCExpr *ValueExpr;
+    SMLoc ValueExprLoc = Parser.getTok().getLoc();
+    if (Parser.parseExpression(ValueExpr))
+      return true;
+
+    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ValueExpr);
+    if (!CE)
+      return Error(ValueExprLoc, "expected numeric constant");
+    IntegerValue = CE->getValue();
+  }
+
+  if (IsStringValue) {
+    if (Parser.getTok().isNot(AsmToken::String))
+      return Error(Parser.getTok().getLoc(), "bad string constant");
+
+    StringValue = Parser.getTok().getStringContents();
+    Parser.Lex();
+  }
+
+  if (Parser.parseToken(AsmToken::EndOfStatement,
+                        "unexpected token in '.attribute' directive"))
+    return true;
+
+  if (IsIntegerValue)
+    getTargetStreamer().emitAttribute(Tag, IntegerValue);
+  else if (IsStringValue)
+    getTargetStreamer().emitTextAttribute(Tag, StringValue);
+
+  if (Tag == RISCVAttrs::Arch) {
+    StringRef Arch = StringValue;
+    if (Arch.startswith("rv32"))
+      clearFeatureBits(RISCV::Feature64Bit, "64bit");
+    else if (Arch.startswith("rv64"))
+      setFeatureBits(RISCV::Feature64Bit, "64bit");
+    else
+      return Error(Parser.getTok().getLoc(), "bad string constant");
+    Arch = Arch.drop_front(4); // Discard "rv[32|64]"
+
+    while (!Arch.empty()) {
+      if (Arch[0] == 'i')
+        clearFeatureBits(RISCV::FeatureRV32E, "e");
+      else if (Arch[0] == 'e')
+        setFeatureBits(RISCV::FeatureRV32E, "e");
+      else if (Arch[0] == 'm')
+        setFeatureBits(RISCV::FeatureStdExtM, "m");
+      else if (Arch[0] == 'a')
+        setFeatureBits(RISCV::FeatureStdExtA, "a");
+      else if (Arch[0] == 'f')
+        setFeatureBits(RISCV::FeatureStdExtF, "f");
+      else if (Arch[0] == 'd') {
+        setFeatureBits(RISCV::FeatureStdExtF, "f");
+        setFeatureBits(RISCV::FeatureStdExtD, "d");
+      } else if (Arch[0] == 'c') {
+        setFeatureBits(RISCV::FeatureStdExtC, "c");
+      } else
+        return Error(Parser.getTok().getLoc(), "bad string constant");
+
+      Arch = Arch.drop_until([](char c) { return c == '_' || c == '"'; });
+      Arch = Arch.drop_while([](char c) { return c == '_'; });
+    }
+  }
+
+  return false;
+}
+
 void RISCVAsmParser::emitToStreamer(MCStreamer &S, const MCInst &Inst) {
   MCInst CInst;
   bool Res = compressInst(CInst, Inst, getSTI(), S.getContext());
   if (Res)
     ++RISCVNumInstrsCompressed;
   S.EmitInstruction((Res ? CInst : Inst), getSTI());
 }
 

llvm/lib/Target/RISCV/MCTargetDesc/RISCVELFStreamer.h

 #define LLVM_LIB_TARGET_RISCV_RISCVELFSTREAMER_H
 
 #include "RISCVTargetStreamer.h"
 #include "llvm/MC/MCELFStreamer.h"
 
 namespace llvm {
 
 class RISCVTargetELFStreamer : public RISCVTargetStreamer {
+private:
+  struct AttributeItem {
+    enum {
+      HiddenAttribute = 0,
+      NumericAttribute,
+      TextAttribute,
+      NumericAndTextAttributes
+    } Type;
+    unsigned Tag;
+    unsigned IntValue;
+    std::string StringValue;
+  };
+
+  StringRef CurrentVendor;
+  SmallVector<AttributeItem, 64> Contents;
+
+  MCSection *AttributeSection = nullptr;
+
+  AttributeItem *getAttributeItem(unsigned Attribute) {
+    for (size_t i = 0; i < Contents.size(); ++i)
+      if (Contents[i].Tag == Attribute)
+        return &Contents[i];
+    return nullptr;
+  }
+
+  void setAttributeItem(unsigned Attribute, unsigned Value,
+                        bool OverwriteExisting) {
+    // Look for existing attribute item
+    if (AttributeItem *Item = getAttributeItem(Attribute)) {
+      if (!OverwriteExisting)
+        return;
+      Item->Type = AttributeItem::NumericAttribute;
+      Item->IntValue = Value;
+      return;
+    }
+
+    // Create new attribute item
+    AttributeItem Item = {AttributeItem::NumericAttribute, Attribute, Value,
+                          std::string(StringRef(""))};
+    Contents.push_back(Item);
+  }
+
+  void setAttributeItem(unsigned Attribute, StringRef Value,
+                        bool OverwriteExisting) {
+    // Look for existing attribute item
+    if (AttributeItem *Item = getAttributeItem(Attribute)) {
+      if (!OverwriteExisting)
+        return;
+      Item->Type = AttributeItem::TextAttribute;
+      Item->StringValue = std::string(Value);
+      return;
+    }
+
+    // Create new attribute item
+    AttributeItem Item = {AttributeItem::TextAttribute, Attribute, 0,
+                          std::string(Value)};
+    Contents.push_back(Item);
+  }
+
+  void setAttributeItems(unsigned Attribute, unsigned IntValue,
+                         StringRef StringValue, bool OverwriteExisting) {
+    // Look for existing attribute item
+    if (AttributeItem *Item = getAttributeItem(Attribute)) {
+      if (!OverwriteExisting)
+        return;
+      Item->Type = AttributeItem::NumericAndTextAttributes;
+      Item->IntValue = IntValue;
+      Item->StringValue = std::string(StringValue);
+      return;
+    }
+
+    // Create new attribute item
+    AttributeItem Item = {AttributeItem::NumericAndTextAttributes, Attribute,
+                          IntValue, std::string(StringValue)};
+    Contents.push_back(Item);
+  }
+
+  void emitAttribute(unsigned Attribute, unsigned Value) override;
+  void emitTextAttribute(unsigned Attribute, StringRef String) override;
+  void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
+                            StringRef StringValue) override;
+  void finishAttributeSection() override;
+  size_t calculateContentSize() const;
+
 public:
   MCELFStreamer &getStreamer();
   RISCVTargetELFStreamer(MCStreamer &S, const MCSubtargetInfo &STI);
 
   virtual void emitDirectiveOptionPush();
   virtual void emitDirectiveOptionPop();
   virtual void emitDirectiveOptionRVC();
   virtual void emitDirectiveOptionNoRVC();
   virtual void emitDirectiveOptionRelax();
   virtual void emitDirectiveOptionNoRelax();
 };
 }
 #endif

llvm/lib/Target/RISCV/MCTargetDesc/RISCVELFStreamer.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "RISCVELFStreamer.h"
 #include "MCTargetDesc/RISCVAsmBackend.h"
 #include "RISCVMCTargetDesc.h"
 #include "Utils/RISCVBaseInfo.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/Support/LEB128.h"
+#include "llvm/Support/RISCVAttributes.h"
 
 using namespace llvm;
 
 // This part is for ELF object output.
 RISCVTargetELFStreamer::RISCVTargetELFStreamer(MCStreamer &S,
                                                const MCSubtargetInfo &STI)
-    : RISCVTargetStreamer(S) {
+    : RISCVTargetStreamer(S), CurrentVendor("riscv") {
   MCAssembler &MCA = getStreamer().getAssembler();
   const FeatureBitset &Features = STI.getFeatureBits();
   auto &MAB = static_cast<RISCVAsmBackend &>(MCA.getBackend());
   RISCVABI::ABI ABI = MAB.getTargetABI();
   assert(ABI != RISCVABI::ABI_Unknown && "Improperly initialised target ABI");
 
   unsigned EFlags = MCA.getELFHeaderEFlags();
 

 }
 
 void RISCVTargetELFStreamer::emitDirectiveOptionPush() {}
 void RISCVTargetELFStreamer::emitDirectiveOptionPop() {}
 void RISCVTargetELFStreamer::emitDirectiveOptionRVC() {}
 void RISCVTargetELFStreamer::emitDirectiveOptionNoRVC() {}
 void RISCVTargetELFStreamer::emitDirectiveOptionRelax() {}
 void RISCVTargetELFStreamer::emitDirectiveOptionNoRelax() {}
+
+void RISCVTargetELFStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
+  setAttributeItem(Attribute, Value, /*OverwriteExisting=*/true);
+}
+
+void RISCVTargetELFStreamer::emitTextAttribute(unsigned Attribute,
+                                               StringRef String) {
+  setAttributeItem(Attribute, String, /* OverwriteExisting= */ true);
+}
+
+void RISCVTargetELFStreamer::emitIntTextAttribute(unsigned Attribute,
+                                                  unsigned IntValue,
+                                                  StringRef StringValue) {
+  setAttributeItems(Attribute, IntValue, StringValue,
+                    /* OverwriteExisting= */ true);
+}
+
+void RISCVTargetELFStreamer::finishAttributeSection() {
+  if (Contents.empty())
+    return;
+
+  if (AttributeSection) {
+    Streamer.SwitchSection(AttributeSection);
+  } else {
+    MCAssembler &MCA = getStreamer().getAssembler();
+    AttributeSection = MCA.getContext().getELFSection(
+        ".riscv.attributes", ELF::SHT_RISCV_ATTRIBUTES, 0);
+    Streamer.SwitchSection(AttributeSection);
+
+    Streamer.EmitIntValue(ELFBuildAttrs::Format_Version, 1);
+  }
+
+  // Vendor size + Vendor name + '\0'
+  const size_t VendorHeaderSize = 4 + CurrentVendor.size() + 1;
+
+  // Tag + Tag Size
+  const size_t TagHeaderSize = 1 + 4;
+
+  const size_t ContentsSize = calculateContentSize();
+
+  Streamer.EmitIntValue(VendorHeaderSize + TagHeaderSize + ContentsSize, 4);
+  Streamer.EmitBytes(CurrentVendor);
+  Streamer.EmitIntValue(0, 1); // '\0'
+
+  Streamer.EmitIntValue(ELFBuildAttrs::File, 1);
+  Streamer.EmitIntValue(TagHeaderSize + ContentsSize, 4);
+
+  // Size should have been accounted for already, now
+  // emit each field as its type (ULEB or String)
+  for (size_t i = 0; i < Contents.size(); ++i) {
+    AttributeItem item = Contents[i];
+    Streamer.EmitULEB128IntValue(item.Tag);
+    switch (item.Type) {
+    default:
+      llvm_unreachable("Invalid attribute type");
+    case AttributeItem::NumericAttribute:
+      Streamer.EmitULEB128IntValue(item.IntValue);
+      break;
+    case AttributeItem::TextAttribute:
+      Streamer.EmitBytes(item.StringValue);
+      Streamer.EmitIntValue(0, 1); // '\0'
+      break;
+    case AttributeItem::NumericAndTextAttributes:
+      Streamer.EmitULEB128IntValue(item.IntValue);
+      Streamer.EmitBytes(item.StringValue);
+      Streamer.EmitIntValue(0, 1); // '\0'
+      break;
+    }
+  }
+
+  Contents.clear();
+}
+
+size_t RISCVTargetELFStreamer::calculateContentSize() const {
+  size_t Result = 0;
+  for (size_t i = 0; i < Contents.size(); ++i) {
+    AttributeItem item = Contents[i];
+    switch (item.Type) {
+    case AttributeItem::HiddenAttribute:
+      break;
+    case AttributeItem::NumericAttribute:
+      Result += getULEB128Size(item.Tag);
+      Result += getULEB128Size(item.IntValue);
+      break;
+    case AttributeItem::TextAttribute:
+      Result += getULEB128Size(item.Tag);
+      Result += item.StringValue.size() + 1; // string + '\0'
+      break;
+    case AttributeItem::NumericAndTextAttributes:
+      Result += getULEB128Size(item.Tag);
+      Result += getULEB128Size(item.IntValue);
+      Result += item.StringValue.size() + 1; // string + '\0';
+      break;
+    }
+  }
+  return Result;
+}

llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.h

 //===-- RISCVTargetStreamer.h - RISCV Target Streamer ----------*- C++ -*--===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_RISCV_RISCVTARGETSTREAMER_H
 #define LLVM_LIB_TARGET_RISCV_RISCVTARGETSTREAMER_H
 
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 
 namespace llvm {
 
 class RISCVTargetStreamer : public MCTargetStreamer {
 public:
   RISCVTargetStreamer(MCStreamer &S);
+  void finish() override;
 
   virtual void emitDirectiveOptionPush() = 0;
   virtual void emitDirectiveOptionPop() = 0;
   virtual void emitDirectiveOptionRVC() = 0;
   virtual void emitDirectiveOptionNoRVC() = 0;
   virtual void emitDirectiveOptionRelax() = 0;
   virtual void emitDirectiveOptionNoRelax() = 0;
+  virtual void emitAttribute(unsigned Attribute, unsigned Value) = 0;
+  virtual void finishAttributeSection() = 0;
+  virtual void emitTextAttribute(unsigned Attribute, StringRef String) = 0;
+  virtual void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
+                                    StringRef StringValue = "") = 0;
+
+  void emitTargetAttributes(const MCSubtargetInfo &STI);
 };
 
 // This part is for ascii assembly output
 class RISCVTargetAsmStreamer : public RISCVTargetStreamer {
   formatted_raw_ostream &OS;
 
+  void finishAttributeSection() override;
+  void emitAttribute(unsigned Attribute, unsigned Value) override;
+  void emitTextAttribute(unsigned Attribute, StringRef String) override;
+  void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
+                            StringRef StringValue) override;
+
 public:
   RISCVTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS);
 
   void emitDirectiveOptionPush() override;
   void emitDirectiveOptionPop() override;
   void emitDirectiveOptionRVC() override;
   void emitDirectiveOptionNoRVC() override;
   void emitDirectiveOptionRelax() override;
   void emitDirectiveOptionNoRelax() override;
 };
 
 }
 #endif

llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.cpp

 //===-- RISCVTargetStreamer.cpp - RISCV Target Streamer Methods -----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides RISCV specific target streamer methods.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RISCVTargetStreamer.h"
+#include "RISCVSubtarget.h"
 #include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/RISCVAttributes.h"
 
 using namespace llvm;
 
 RISCVTargetStreamer::RISCVTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {}
 
+void RISCVTargetStreamer::finish() { finishAttributeSection(); }
+
+void RISCVTargetStreamer::emitTargetAttributes(const MCSubtargetInfo &STI) {
+  if (STI.hasFeature(RISCV::FeatureRV32E))
+    emitAttribute(RISCVAttrs::Stack_align, 4);
+  else
+    emitAttribute(RISCVAttrs::Stack_align, 16);
+
+  std::string Arch = Twine("rv32").str();
+
+  if (STI.hasFeature(RISCV::Feature64Bit))
+    Arch = Twine("rv64").str();
+
+  if (STI.hasFeature(RISCV::FeatureRV32E))
+    Arch = (Twine(Arch) + "e1p9").str();
+  else
+    Arch = (Twine(Arch) + "i2p0").str();
+
+  if (STI.hasFeature(RISCV::FeatureStdExtM))
+    Arch = (Twine(Arch) + "_m2p0").str();
+
+  if (STI.hasFeature(RISCV::FeatureStdExtA))
+    Arch = (Twine(Arch) + "_a2p0").str();
+
+  if (STI.hasFeature(RISCV::FeatureStdExtF))
+    Arch = (Twine(Arch) + "_f2p0").str();
+
+  if (STI.hasFeature(RISCV::FeatureStdExtD))
+    Arch = (Twine(Arch) + "_d2p0").str();
+
+  if (STI.hasFeature(RISCV::FeatureStdExtC))
+    Arch = (Twine(Arch) + "_c2p0").str();
+
+  emitTextAttribute(RISCVAttrs::Arch, Arch);
+}
+
 // This part is for ascii assembly output
 RISCVTargetAsmStreamer::RISCVTargetAsmStreamer(MCStreamer &S,
                                                formatted_raw_ostream &OS)
     : RISCVTargetStreamer(S), OS(OS) {}
 
 void RISCVTargetAsmStreamer::emitDirectiveOptionPush() {
   OS << "\t.option\tpush\n";
 }

 
 void RISCVTargetAsmStreamer::emitDirectiveOptionRelax() {
   OS << "\t.option\trelax\n";
 }
 
 void RISCVTargetAsmStreamer::emitDirectiveOptionNoRelax() {
   OS << "\t.option\tnorelax\n";
 }
+
+void RISCVTargetAsmStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
+  OS << "\t.attribute\t" << Attribute << ", " << Twine(Value) << "\n";
+}
+
+void RISCVTargetAsmStreamer::emitTextAttribute(unsigned Attribute,
+                                               StringRef String) {
+  OS << "\t.attribute\t" << Attribute << ", \"" << String << "\""
+     << "\n";
+}
+
+void RISCVTargetAsmStreamer::emitIntTextAttribute(unsigned Attribute,
+                                                  unsigned IntValue,
+                                                  StringRef StringValue) {}
+
+void RISCVTargetAsmStreamer::finishAttributeSection() {}

llvm/lib/Target/RISCV/RISCVAsmPrinter.cpp

 //===-- RISCVAsmPrinter.cpp - RISCV LLVM assembly writer ------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a printer that converts from our internal representation
 // of machine-dependent LLVM code to the RISCV assembly language.
 //
 //===----------------------------------------------------------------------===//
 
-#include "RISCV.h"
 #include "MCTargetDesc/RISCVInstPrinter.h"
 #include "MCTargetDesc/RISCVMCExpr.h"
+#include "MCTargetDesc/RISCVTargetStreamer.h"
+#include "RISCV.h"
 #include "RISCVTargetMachine.h"
 #include "TargetInfo/RISCVTargetInfo.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
public:
   void EmitToStreamer(MCStreamer &S, const MCInst &Inst);
   bool emitPseudoExpansionLowering(MCStreamer &OutStreamer,
                                    const MachineInstr *MI);
 
   // Wrapper needed for tblgenned pseudo lowering.
   bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp) const {
     return LowerRISCVMachineOperandToMCOperand(MO, MCOp, *this);
   }
+
+  void EmitStartOfAsmFile(Module &M) override;
+  void EmitEndOfAsmFile(Module &M) override;
+
+private:
+  void emitAttributes();
 };
 }
 
 #define GEN_COMPRESS_INSTR
 #include "RISCVGenCompressInstEmitter.inc"
 void RISCVAsmPrinter::EmitToStreamer(MCStreamer &S, const MCInst &Inst) {
   MCInst CInst;
   bool Res = compressInst(CInst, Inst, *TM.getMCSubtargetInfo(),
if (!ExtraCode) {
 
     OS << "0(" << RISCVInstPrinter::getRegisterName(MO.getReg()) << ")";
     return false;
   }
 
   return AsmPrinter::PrintAsmMemoryOperand(MI, OpNo, ExtraCode, OS);
 }
 
+void RISCVAsmPrinter::EmitStartOfAsmFile(Module &M) {
+  const Triple &TT = TM.getTargetTriple();
+
+  if (TT.isOSBinFormatELF())
+    emitAttributes();
+}
+
+void RISCVAsmPrinter::EmitEndOfAsmFile(Module &M) {
+  const Triple &TT = TM.getTargetTriple();
+  MCTargetStreamer &TS = *OutStreamer->getTargetStreamer();
+  RISCVTargetStreamer &RTS = static_cast<RISCVTargetStreamer &>(TS);
+
+  if (TT.isOSBinFormatELF()) {
+    RTS.finishAttributeSection();
+  }
+}
+
+void RISCVAsmPrinter::emitAttributes() {
+  MCTargetStreamer &TS = *OutStreamer->getTargetStreamer();
+  RISCVTargetStreamer &RTS = static_cast<RISCVTargetStreamer &>(TS);
+
+  const Triple &TT = TM.getTargetTriple();
+  StringRef CPU = TM.getTargetCPU();
+  StringRef FS = TM.getTargetFeatureString();
+  const RISCVTargetMachine &RTM = static_cast<const RISCVTargetMachine &>(TM);
+  const RISCVSubtarget STI(TT, CPU, FS, /*ABIName=*/"", RTM);
+
+  RTS.emitTargetAttributes(STI);
+}
+
 // Force static initialization.
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeRISCVAsmPrinter() {
   RegisterAsmPrinter<RISCVAsmPrinter> X(getTheRISCV32Target());
   RegisterAsmPrinter<RISCVAsmPrinter> Y(getTheRISCV64Target());
 }

llvm/test/MC/RISCV/attribute-with-insts.s

+## Test .attribute effects.
+## We do not provide '-mattr=' and '.option rvc' and enable extensions through
+## '.attribute arch'.
+
+# RUN: llvm-mc -triple riscv32 -filetype=obj %s \
+# RUN: | llvm-objdump -triple riscv32 -d -M no-aliases - \
+# RUN: | FileCheck -check-prefix=CHECK-INST %s
+
+# RUN: llvm-mc -triple riscv64 -filetype=obj %s \
+# RUN: | llvm-objdump -triple riscv64 -d -M no-aliases - \
+# RUN: | FileCheck -check-prefix=CHECK-INST %s
+
+.attribute arch, "rv64i2p0_m2p0_a2p0_d2p0_c2p0"
+
+# CHECK-INST: lr.w t0, (t1)
+lr.w t0, (t1)
+
+# CHECK-INST: c.addi a3, -32
+c.addi a3, -32
+
+# CHECK-INST: fmadd.d fa0, fa1, fa2, fa3, dyn
+fmadd.d f10, f11, f12, f13, dyn
+
+# CHECK-INST: fmadd.s fa0, fa1, fa2, fa3, dyn
+fmadd.s f10, f11, f12, f13, dyn
+
+# CHECK-INST: addi ra, sp, 2
+addi ra, sp, 2
+
+# CHECK-INST: mul a4, ra, s0
+mul a4, ra, s0
+
+# CHECK-INST: addw a2, a3, a4
+addw a2, a3, a4

llvm/test/MC/RISCV/attribute.s

+# Test llvm-mc could handle .attribute correctly.
+
+# RUN: llvm-mc %s -triple=riscv32 -filetype=asm \
+# RUN:     | FileCheck %s
+# RUN: llvm-mc %s -triple=riscv64 -filetype=asm \
+# RUN:     | FileCheck %s
+
+.attribute stack_align, 16
+# CHECK: attribute      4, 16
+
+.attribute arch, "rv32i2p0_m2p0_a2p0_c2p0"
+# CHECK: attribute      5, "rv32i2p0_m2p0_a2p0_c2p0"
+
+.attribute unaligned_access, 0
+# CHECK: attribute      6, 0
+
+.attribute priv_spec, 2
+# CHECK: attribute      8, 2
+
+.attribute priv_spec_minor, 0
+# CHECK: attribute      10, 0
+
+.attribute priv_spec_revision, 0
+# CHECK: attribute      12, 0

llvm/test/tools/llvm-readobj/ELF/RISCV/attribute.test

+## Test llvm-readobj decodes RISCV attributes correctly.
+
+# RUN: yaml2obj %s -D BITS=32 -o %t.32.o
+# RUN: llvm-readobj --arch-specific %t.32.o \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-OBJ32,BOTH
+# RUN: yaml2obj %s -D BITS=64 -o %t.64.o
+# RUN: llvm-readobj --arch-specific %t.64.o \
+# RUN:     | FileCheck %s --check-prefixes=CHECK-OBJ64,BOTH
+
+# CHECK-OBJ32:      Format: ELF32-riscv
+# CHECK-OBJ32-NEXT: Arch: riscv32
+# CHECK-OBJ32-NEXT: AddressSize: 32bit
+# CHECK-OBJ64:      Format: ELF64-riscv
+# CHECK-OBJ64-NEXT: Arch: riscv64
+# CHECK-OBJ64-NEXT: AddressSize: 64bit
+# BOTH:             BuildAttributes {
+# BOTH-NEXT:          FormatVersion: 0x41
+# BOTH-NEXT:          Section 1 {
+# BOTH-NEXT:            SectionLength: 50
+# BOTH-NEXT:            Vendor: riscv
+# BOTH-NEXT:            Tag: Tag_File (0x1)
+# BOTH-NEXT:            Size: 40
+# BOTH-NEXT:            FileAttributes {
+# BOTH-NEXT:              Attribute {
+# BOTH-NEXT:                Tag: 4
+# BOTH-NEXT:                Value: 16
+# BOTH-NEXT:                TagName: stack_align
+# BOTH-NEXT:                Description: Stack alignment is 16-bytes
+# BOTH-NEXT:              }
+# BOTH-NEXT:              Attribute {
+# BOTH-NEXT:                Tag: 5
+# BOTH-NEXT:                TagName: arch
+# BOTH-NEXT:                Value: rv32i2p0_m2p0_a2p0_c2p0
+# BOTH-NEXT:              }
+# BOTH-NEXT:              Attribute {
+# BOTH-NEXT:                Tag: 6
+# BOTH-NEXT:                Value: 0
+# BOTH-NEXT:                TagName: unaligned_access
+# BOTH-NEXT:                Description: No unaligned access
+# BOTH-NEXT:              }
+# BOTH-NEXT:              Attribute {
+# BOTH-NEXT:                Tag: 8
+# BOTH-NEXT:                TagName: priv_spec
+# BOTH-NEXT:                Value: 2
+# BOTH-NEXT:              }
+# BOTH-NEXT:              Attribute {
+# BOTH-NEXT:                Tag: 10
+# BOTH-NEXT:                TagName: priv_spec_minor
+# BOTH-NEXT:                Value: 0
+# BOTH-NEXT:              }
+# BOTH-NEXT:              Attribute {
+# BOTH-NEXT:                Tag: 12
+# BOTH-NEXT:                TagName: priv_spec_revision
+# BOTH-NEXT:                Value: 0
+# BOTH-NEXT:              }
+# BOTH-NEXT:            }
+# BOTH-NEXT:          }
+# BOTH-NEXT:        }
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS[[BITS]]
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_RISCV
+Sections:
+  - Name: .riscv.attributes
+    Type: SHT_RISCV_ATTRIBUTES
+    Content: 4132000000726973637600012800000004100572763332693270305F6D3270305F613270305F6332703000060008020A000C00

llvm/test/tools/llvm-readobj/ELF/RISCV/lit.local.cfg

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

llvm/tools/llvm-readobj/ELFDumper.cpp

 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MipsABIFlags.h"
+#include "llvm/Support/RISCVAttributeParser.h"
+#include "llvm/Support/RISCVAttributes.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <iterator>

 template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
   W.printString("LoadName", SOName);
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printArchSpecificInfo() {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   switch (Obj->getHeader()->e_machine) {
   case EM_ARM:
+  case EM_RISCV:
     printAttributes();
     break;
   case EM_MIPS: {
     ELFDumperStyle->printMipsABIFlags(ObjF);
     printMipsOptions();
     printMipsReginfo();
 
     MipsGOTParser<ELFT> Parser(Obj, ObjF->getFileName(), dynamic_table(),
                                dynamic_symbols());
     if (Parser.hasGot())
       ELFDumperStyle->printMipsGOT(Parser);
     if (Parser.hasPlt())
       ELFDumperStyle->printMipsPLT(Parser);
     break;
   }
   default:
     break;
   }
 }
 
+namespace {
+
 template <class ELFT> void ELFDumper<ELFT>::printAttributes() {
+  const ELFFile<ELFT> *Obj = ObjF->getELFFile();
+  if (!Obj->isLE()) {
     W.startLine() << "Attributes not implemented.\n";
+    return;
   }
 
-namespace {
-
-template <> void ELFDumper<ELF32LE>::printAttributes() {
-  const ELFFile<ELF32LE> *Obj = ObjF->getELFFile();
-  if (Obj->getHeader()->e_machine != EM_ARM) {
+  if (Obj->getHeader()->e_machine != EM_ARM &&
+      Obj->getHeader()->e_machine != EM_RISCV) {
     W.startLine() << "Attributes not implemented.\n";
     return;
   }
 
   DictScope BA(W, "BuildAttributes");
-  for (const ELFO::Elf_Shdr &Sec :
+  for (const auto &Sec :
        unwrapOrError(ObjF->getFileName(), Obj->sections())) {
-    if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES)
+    if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES &&
+        Sec.sh_type != ELF::SHT_RISCV_ATTRIBUTES)
       continue;
 
     ArrayRef<uint8_t> Contents =
         unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(&Sec));
-    if (Contents[0] != ARMBuildAttrs::Format_Version) {
+    if (Contents[0] != ELFBuildAttrs::Format_Version) {
       errs() << "unrecognised FormatVersion: 0x"
              << Twine::utohexstr(Contents[0]) << '\n';
       continue;
     }
-
     W.printHex("FormatVersion", Contents[0]);
     if (Contents.size() == 1)
       continue;
 
-    ARMAttributeParser(&W).Parse(Contents, true);
+    if (Obj->getHeader()->e_machine == EM_ARM) {
+      ARMAttributeParser(&W).Parse(Contents, Obj->isLE());
+    } else if (Obj->getHeader()->e_machine == EM_RISCV) {
+      RISCVAttributeParser(&W).Parse(Contents, Obj->isLE());
+    }
   }
 }
 
 template <class ELFT> class MipsGOTParser {
 public:
   TYPEDEF_ELF_TYPES(ELFT)
   using Entry = typename ELFO::Elf_Addr;
   using Entries = ArrayRef<Entry>;
if (Type >= SHT_LOOS && Type <= SHT_HIOS)
     return "LOOS+0x" + to_hexString(Type - SHT_LOOS);
   else if (Type >= SHT_LOPROC && Type <= SHT_HIPROC)
     return "LOPROC+0x" + to_hexString(Type - SHT_LOPROC);
   else if (Type >= SHT_LOUSER && Type <= SHT_HIUSER)
     return "LOUSER+0x" + to_hexString(Type - SHT_LOUSER);
   return "0x" + to_hexString(Type) + ": <unknown>";
 }
 
 static std::string getSectionTypeString(unsigned Arch, unsigned Type) {
   using namespace ELF;
 
   switch (Arch) {
   case EM_ARM:
     switch (Type) {
     case SHT_ARM_EXIDX:
       return "ARM_EXIDX";
     case SHT_ARM_PREEMPTMAP:
case EM_MIPS_RS3_LE:
     case SHT_MIPS_DWARF:
       return "MIPS_DWARF";
     case SHT_MIPS_ABIFLAGS:
       return "MIPS_ABIFLAGS";
     }
     break;
   }
   switch (Type) {
   case SHT_NULL:
     return "NULL";
   case SHT_PROGBITS:
     return "PROGBITS";
   case SHT_SYMTAB:
     return "SYMTAB";
   case SHT_STRTAB:
     return "STRTAB";
   case SHT_RELA:

llvm/unittests/Support/ARMAttributeParser.cpp

 #include "llvm/Support/ARMAttributeParser.h"
 #include "llvm/Support/ARMBuildAttributes.h"
+#include "llvm/Support/ELFBuildAttributes.h"
 #include "gtest/gtest.h"
 #include <string>
 
 using namespace llvm;
 
 struct AttributeSection {
   unsigned Tag;
   unsigned Value;
bool testBuildAttr(unsigned Tag, unsigned Value,
   ARMAttributeParser Parser;
   Parser.Parse(Bytes, true);
 
   return (Parser.hasAttribute(ExpectedTag) &&
     Parser.getAttributeValue(ExpectedTag) == ExpectedValue);
 }
 
 bool testTagString(unsigned Tag, const char *name) {
-  return ARMBuildAttrs::AttrTypeAsString(Tag).str() == name;
+  return ELFBuildAttrs::AttrTypeAsString(Tag, ARMBuildAttrs::ARMAttributeTags)
+             .str() == name;
 }
 
 TEST(CPUArchBuildAttr, testBuildAttr) {
   EXPECT_TRUE(testTagString(6, "Tag_CPU_arch"));
 
   EXPECT_TRUE(testBuildAttr(6, 0, ARMBuildAttrs::CPU_arch,
                             ARMBuildAttrs::Pre_v4));
   EXPECT_TRUE(testBuildAttr(6, 1, ARMBuildAttrs::CPU_arch,