[RISCV] Support for mapping symbol in RISCV.

[LiDongjin]

Summary

Support for mapping symbol in RISCV.

There are three types in mapping symbols: $d $x $x<isa>.
For $d and $x is same as ARM, So i just copy related codes and testcases
For $x<isa>, the content of isa must same as Tag_RISCV_arch.
When emit Tag_RISCV_arch attribute, The following codes must have $x<isa> mapping symbol.
Adjacent same Tag_RISCV_arch attribute do not need two$x<isa>.

Here we have two testcases: mapping-symbols.s and mapping-isa.s.
mapping-symbols.s about the $d and $x in different segment.
mapping-isa.s about $x<isa> in different attribute Tag_RISCV_arch.

The mapping symbol in riscv references:
https://github.com/riscv-non-isa/riscv-elf-psabi-doc/pull/196

[StephenFan]

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

344

The comment line should be deleted.

382

These comments should be deleted.

llvm/test/MC/RISCV/mapping-isa.s

2

Copy-paste from ARM?

[StephenFan]

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

27

Do we need this header file?

[StephenFan]

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

118

It seems like 5 is a magic number.

[LiDongjin]

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

118

It will change to RISCVAttrs::ARCH.

[asb]

@kito-cheng, @jrtc27: I was wondering on if you could comment from a psABI workgroup perspective on the status of the mapping symbol proposal and the path to it becoming part of the standard?

[LiDongjin]

Ping.

[jrtc27]

The short summary is that there was a bunch of discussion about a year ago, things went quiet and nobody pushed it forward to get consensus and land it in the spec. I don't think there are outstanding technical reasons for that though, just that it wasn't prioritised and followed up on. Even if we did want to change it we're probably stuck with the current draft, anyway, since an implementation of it was merged in binutils a while ago despite that being bad practice for ABI things...

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

189–190

Can the moving of this please be split out into a separate patch? That makes it obvious what's changing and what's just moving.

[kito-cheng]

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

220

"$x" + LastEMSInfo->ISAInfo + "", we didn't use < and > around arch string

[LiDongjin]

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

118

Done

220

Done

[kito-cheng]

LGTM, this match what we have in psABI PR and binutils implemention, but I would like to make sure @asb is happy with this too :)

[asb]

In D137417#4076835, @kito-cheng wrote:

LGTM, this match what we have in psABI PR and binutils implemention, but I would like to make sure @asb is happy with this too :)

I've not done a super in-depth review, but from a high-level look it seems good to me. Despite the fact binutils already supports this, I'd probably rather see the psABI change approved before landing this patch. Is it possible that might happen soon?

[kito-cheng]

In D137417#4077226, @asb wrote:

In D137417#4076835, @kito-cheng wrote:

LGTM, this match what we have in psABI PR and binutils implemention, but I would like to make sure @asb is happy with this too :)

I've not done a super in-depth review, but from a high-level look it seems good to me. Despite the fact binutils already supports this, I'd probably rather see the psABI change approved before landing this patch. Is it possible that might happen soon?

Going to push this forward, hope this will happen soon, will notify here once it getting merged :)

[kito-cheng]

@asb let you know psABI has merged the mapping symbol :)

[kito-cheng]

@LiDongjin could you rebase this patch? it seems will result some conflict with current main branch, thanks :)

[LiDongjin]

@kito-cheng rebase done .

[LiDongjin]

This comment was removed by LiDongjin.

[Joe]

The mapping symbol seems to be getting stripped out at the linker stage (either ld or lld), but I'm not sure why. Will continue to look into it.

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

316

Do we not need to set the State to something here? Otherwise the state never changes and an ISA mapping symbol will be generated for every instruction.

For example:

.attribute arch, "rv32i"
nop
nop
nop
nop

>

SYMBOL TABLE:
0000000000000000         *UND*  0000000000000000 $xrv32i2p1.0
0000000000000000         *UND*  0000000000000000 $xrv32i2p1.1
0000000000000000         *UND*  0000000000000000 $xrv32i2p1.2
0000000000000000         *UND*  0000000000000000 $xrv32i2p1.3
0000000000000000         *UND*  0000000000000000 $d.4

[LiDongjin]

fix duplicate $x symbol for same isa attribute instructions.

[Joe]

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

316

I think we need to assign the mapping symbol a location. This was the only way I was able to get the linker not to discard the symbol.

Example:

EmitMappingSymbol("$x" + LastEMSInfo->ISAInfo, SMLoc(),
    &getCurrentSectionOnly()->getDummyFragment(), 0);
LastEMSInfo->State = EMS_ISA;

327

By having the label suffixed by .n, gnu objdump interprets the last extension with the dot, leading to many warnings/errors. E.G cannot find default versions of the ISA extension zvl64b1p0.'`

It works if you remove the ., but equally you will get an error if you try and generate the same symbol twice.

Sorry I haven't got a solution for you, but I think it's definitely something that needs to be addressed.

[Joe]

llvm/test/MC/RISCV/mapping-isa.s

54

Probably should add a MAPPINGSYMBOLS-NOT check here and other palces, as this was not happening before your latest change, but the testing wasn't picking it up.

[LiDongjin]

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

316

I try to fix the EmitMappingSymbol to use emitLabel. it works for assigning the mapping symbol a location.

327

Arm and aarch64 use the .n to distinguish the same symbol. I copy this solution to the riscv.
So how this case for arm and aarch64 to fix in the gnu objdum? thanks for any advice.

[LiDongjin]

Fix some text cases in lld about the section labels.
if there are no symbols follow the section label, it will output the <section name>.
if we inserted the mapping symbols after the section label, it will output the <$x> or <$d>.

[MaskRay]

Thanks for the patch. This needs rebase as mapping symbols have been implemented...

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

 
 public:
   RISCVELFStreamer(MCContext &C, std::unique_ptr<MCAsmBackend> MAB,
                    std::unique_ptr<MCObjectWriter> MOW,
                    std::unique_ptr<MCCodeEmitter> MCE)
       : MCELFStreamer(C, std::move(MAB), std::move(MOW), std::move(MCE)) {}
 
   void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override;
+  void emitFill(const MCExpr &NumBytes, uint64_t FillValue, SMLoc Loc) override;
+  void changeSection(MCSection *Section, const MCExpr *Subsection) override;
+  void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override;
+  void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
+  void emitBytes(StringRef Data) override;
+  void setAttributeItem(unsigned Attribute, StringRef Value,
+                        bool OverwriteExisting);
+
+private:
+  enum ElfMappingSymbol { EMS_None, EMS_ISA, EMS_Change, EMS_Data };
+
+  struct ElfMappingSymbolInfo {
+    explicit ElfMappingSymbolInfo(SMLoc Loc, MCFragment *F, uint64_t O)
+        : Loc(Loc), F(F), Offset(O), State(EMS_None) {}
+    void resetInfo() {
+      F = nullptr;
+      Offset = 0;
+    }
+    bool hasInfo() { return F != nullptr; }
+    SMLoc Loc;
+    MCFragment *F;
+    uint64_t Offset;
+    ElfMappingSymbol State;
+    std::string ISAInfo;
+  };
+
+  void emitDataMappingSymbol();
+  void FlushPendingMappingSymbol();
+  void ChangeISAMappingSymbol(StringRef arch);
+  void EmitISAMappingSymbol();
+  void EmitMappingSymbol(StringRef Name, SMLoc Loc, MCFragment *F,
+                         uint64_t Offset);
+  void EmitMappingSymbol(StringRef Name);
+
+  int64_t MappingSymbolCounter = 0;
+
+  DenseMap<const MCSection *, std::unique_ptr<ElfMappingSymbolInfo>>
+      LastMappingSymbols;
+
+  std::unique_ptr<ElfMappingSymbolInfo> LastEMSInfo;
 };
 
 namespace llvm {
 
 class RISCVTargetELFStreamer : public RISCVTargetStreamer {
 private:
   enum class AttributeType { Hidden, Numeric, Text, NumericAndText };
 

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

 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCValue.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), CurrentVendor("riscv"), STI(STI) {
   MCAssembler &MCA = getStreamer().getAssembler();

 
 void RISCVTargetELFStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
   setAttributeItem(Attribute, Value, /*OverwriteExisting=*/true);
 }
 
 void RISCVTargetELFStreamer::emitTextAttribute(unsigned Attribute,
                                                StringRef String) {
   setAttributeItem(Attribute, String, /*OverwriteExisting=*/true);
+  static_cast<RISCVELFStreamer &>(getStreamer())
+      .setAttributeItem(Attribute, String, true);
 }
 
 void RISCVTargetELFStreamer::emitIntTextAttribute(unsigned Attribute,
                                                   unsigned IntValue,
                                                   StringRef StringValue) {
   setAttributeItems(Attribute, IntValue, StringValue,
                     /*OverwriteExisting=*/true);
 }
for (AttributeItem item : Contents) {
     case AttributeType::Numeric:
       Streamer.emitULEB128IntValue(item.IntValue);
       break;
     case AttributeType::Text:
       Streamer.emitBytes(item.StringValue);
       Streamer.emitInt8(0); // '\0'
       break;
     case AttributeType::NumericAndText:
       Streamer.emitULEB128IntValue(item.IntValue);
       Streamer.emitBytes(item.StringValue);
       Streamer.emitInt8(0); // '\0'
       break;
     }
   }
 
   Contents.clear();
 }
void RISCVTargetELFStreamer::finish() {
 
   MCA.setELFHeaderEFlags(EFlags);
 }
 
 void RISCVTargetELFStreamer::reset() {
   AttributeSection = nullptr;
   Contents.clear();
 }
 
 void RISCVTargetELFStreamer::emitDirectiveVariantCC(MCSymbol &Symbol) {
   getStreamer().getAssembler().registerSymbol(Symbol);
   cast<MCSymbolELF>(Symbol).setOther(ELF::STO_RISCV_VARIANT_CC);
 }
 
 std::pair<unsigned, unsigned>
 RISCVELFStreamer::getRelocPairForSize(unsigned Size) {
   switch (Size) {
   default:

 
 bool RISCVELFStreamer::requiresFixups(MCContext &C, const MCExpr *Value,
                                       const MCExpr *&LHS, const MCExpr *&RHS) {
   const auto *MBE = dyn_cast<MCBinaryExpr>(Value);
   if (MBE == nullptr)
     return false;
 
   MCValue E;
   if (!Value->evaluateAsRelocatable(E, nullptr, nullptr))
     return false;
   if (E.getSymA() == nullptr || E.getSymB() == nullptr)
     return false;
 
   const auto &A = E.getSymA()->getSymbol();
   const auto &B = E.getSymB()->getSymbol();
 
   LHS = MCBinaryExpr::create(MCBinaryExpr::Add, MCSymbolRefExpr::create(&A, C),
void RISCVELFStreamer::emitValueImpl(const MCExpr *Value, unsigned Size,
   DF->getFixups().push_back(MCFixup::create(
       DF->getContents().size(), A, static_cast<MCFixupKind>(Add), Loc));
   DF->getFixups().push_back(MCFixup::create(
       DF->getContents().size(), B, static_cast<MCFixupKind>(Sub), Loc));
 
   DF->getContents().resize(DF->getContents().size() + Size, 0);
 }
 
+// This part is for mapping symbol.
+
+void RISCVELFStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue,
+                                SMLoc Loc) override {
+  emitDataMappingSymbol();
+  MCObjectStreamer::emitFill(NumBytes, FillValue, Loc);
+}
+
+void RISCVELFStreamer::changeSection(MCSection *Section,
+                                     const MCExpr *Subsection) override {
+  LastMappingSymbols[getCurrentSection().first] = std::move(LastEMSInfo);
+  MCELFStreamer::changeSection(Section, Subsection);
+  auto LastMappingSymbol = LastMappingSymbols.find(Section);
+  if (LastMappingSymbol != LastMappingSymbols.end()) {
+    LastEMSInfo = std::move(LastMappingSymbol->second);
+    return;
+  }
+  LastEMSInfo.reset(new ElfMappingSymbolInfo(SMLoc(), nullptr, EMS_None));
+}
+
+void RISCVELFStreamer::setAttributeItem(unsigned Attribute, StringRef Value,
+                                        bool OverwriteExisting) {
+  if (Attribute == RISCVAttrs::ARCH)
+    ChangeISAMappingSymbol(Value);
+}
+
+void RISCVELFStreamer::emitValueImpl(const MCExpr *Value, unsigned Size,
+                                     SMLoc Loc) override {
+  emitDataMappingSymbol();
+  const MCExpr *A, *B;
+  if (!requiresFixups(getContext(), Value, A, B))
+    return MCELFStreamer::emitValueImpl(Value, Size, Loc);
+
+  MCStreamer::emitValueImpl(Value, Size, Loc);
+
+  MCDataFragment *DF = getOrCreateDataFragment();
+  flushPendingLabels(DF, DF->getContents().size());
+  MCDwarfLineEntry::make(this, getCurrentSectionOnly());
+
+  unsigned Add, Sub;
+  std::tie(Add, Sub) = getRelocPairForSize(Size);
+
+  DF->getFixups().push_back(MCFixup::create(
+      DF->getContents().size(), A, static_cast<MCFixupKind>(Add), Loc));
+  DF->getFixups().push_back(MCFixup::create(
+      DF->getContents().size(), B, static_cast<MCFixupKind>(Sub), Loc));
+
+  DF->getContents().resize(DF->getContents().size() + Size, 0);
+}
+
+/// This function is the one used to emit instruction data into the ELF
+/// streamer. We override it to add the appropriate mapping symbol if
+/// necessary.
+void RISCVELFStreamer::emitInstruction(const MCInst &Inst,
+                                       const MCSubtargetInfo &STI) override {
+  EmitISAMappingSymbol();
+  MCELFStreamer::emitInstruction(Inst, STI);
+}
+
+/// This is one of the functions used to emit data into an ELF section, so the
+/// RISCV streamer overrides it to add the appropriate mapping symbol ($d) if
+/// necessary.
+void RISCVELFStreamer::emitBytes(StringRef Data) override {
+  emitDataMappingSymbol();
+  MCELFStreamer::emitBytes(Data);
+}
+
+void RISCVELFStreamer::emitDataMappingSymbol() {
+  if (LastEMSInfo->State == EMS_Data)
+    return;
+  else if (LastEMSInfo->State == EMS_None) {
+    ElfMappingSymbolInfo *EMS = LastEMSInfo.get();
+    auto *DF = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
+    if (!DF)
+      return;
+    EMS->Loc = SMLoc();
+    EMS->F = getCurrentFragment();
+    EMS->Offset = DF->getContents().size();
+    LastEMSInfo->State = EMS_Data;
+    return;
+  }
+  EmitMappingSymbol("$d");
+  LastEMSInfo->State = EMS_Data;
+}
+
+void RISCVELFStreamer::FlushPendingMappingSymbol() {
+  if (!LastEMSInfo->hasInfo())
+    return;
+  ElfMappingSymbolInfo *EMS = LastEMSInfo.get();
+  EmitMappingSymbol("$d", EMS->Loc, EMS->F, EMS->Offset);
+  EMS->resetInfo();
+}
+
+void RISCVELFStreamer::ChangeISAMappingSymbol(StringRef arch) {
+  if (arch != LastEMSInfo->ISAInfo) {
+    LastEMSInfo->State = EMS_Change;
+    LastEMSInfo->ISAInfo = std::string(arch);
+  }
+}
+
+void RISCVELFStreamer::EmitISAMappingSymbol() {
+  if (LastEMSInfo->State == EMS_ISA)
+    return;
+  FlushPendingMappingSymbol();
+  if (LastEMSInfo->ISAInfo.empty())
+    EmitMappingSymbol("$x");
+  else
+    EmitMappingSymbol("$x" + LastEMSInfo->ISAInfo);
+  LastEMSInfo->State = EMS_ISA;
+}
+
+void RISCVELFStreamer::EmitMappingSymbol(StringRef Name, SMLoc Loc,
+                                         MCFragment *F, uint64_t Offset) {
+  auto *Symbol = cast<MCSymbolELF>(getContext().getOrCreateSymbol(
+      Name + "." + Twine(MappingSymbolCounter++)));
+  emitLabelAtPos(Symbol, Loc, F, Offset);
+  Symbol->setType(ELF::STT_NOTYPE);
+  Symbol->setBinding(ELF::STB_LOCAL);
+}
+
+void RISCVELFStreamer::EmitMappingSymbol(StringRef Name) {
+  auto *Symbol = cast<MCSymbolELF>(getContext().getOrCreateSymbol(
+      Name + "." + Twine(MappingSymbolCounter++)));
+  getAssembler().registerSymbol(*Symbol);
+  Symbol->setType(ELF::STT_NOTYPE);
+  Symbol->setBinding(ELF::STB_LOCAL);
+}
+
 namespace llvm {
 MCELFStreamer *createRISCVELFStreamer(MCContext &C,
                                       std::unique_ptr<MCAsmBackend> MAB,
                                       std::unique_ptr<MCObjectWriter> MOW,
                                       std::unique_ptr<MCCodeEmitter> MCE,
                                       bool RelaxAll) {
   RISCVELFStreamer *S =
       new RISCVELFStreamer(C, std::move(MAB), std::move(MOW), std::move(MCE));
   S->getAssembler().setRelaxAll(RelaxAll);
   return S;
 }
 } // namespace llvm

llvm/test/MC/RISCV/Inputs/1.s

+        .section        .foobar,"ax",%progbits
+        nop
+        .word 32

llvm/test/MC/RISCV/Inputs/2.s

+        .section        .foobar,"",%progbits
+        nop
+        .word 32

llvm/test/MC/RISCV/Inputs/3.s

+        .section        .foobar,"aw",%progbits
+        nop
+        .word 32

llvm/test/MC/RISCV/Inputs/4.s

+        .section        .foobar,"",%progbits
+        .word 32

llvm/test/MC/RISCV/Inputs/5.s

+        .section        .foobar,"aw",%progbits
+        .word 32

llvm/test/MC/RISCV/Inputs/6.s

+        .section        .foo
+        .word 30
+        .word 31
+        .word 32
+        .word 33
+        nop
+        .word 34
+        .word 35
+        .word 36
+        .word 37
+        .word 38
+        nop

llvm/test/MC/RISCV/Inputs/7.s

+        .section        .foobar,"aw",%progbits
+        .word 32
+        nop

llvm/test/MC/RISCV/Inputs/ident.s

+  .ident  "LLVM RISCV Compiler"

llvm/test/MC/RISCV/mapping-isa.s

+## Arch string with mapping symbols.
+
+# RUN: llvm-mc -triple=riscv32 -filetype=obj -o %t.o %s
+# RUN: llvm-objdump -t %t.o | FileCheck %s -check-prefix=MAPPINGSYMBOLS
+# RUN: llvm-mc -triple=riscv64 -filetype=obj -o %t.o %s
+# RUN: llvm-objdump -t %t.o | FileCheck %s -check-prefix=MAPPINGSYMBOLS
+
+nop
+.word 32
+# MAPPINGSYMBOLS: $x
+
+.attribute arch, "rv32i"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0
+
+.attribute arch, "rv32i2"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0
+
+.attribute arch, "rv32i2p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0
+
+.attribute arch, "rv32i2_m2"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_m2p0
+
+.attribute arch, "rv32i2_ma"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_m2p0_a2p0
+
+.attribute arch, "rv32g"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_m2p0_a2p0_f2p0_d2p0
+
+.attribute arch, "rv32imafdc"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_m2p0_a2p0_f2p0_d2p0_c2p0
+
+.attribute arch, "rv32i2p0_mafdc"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_m2p0_a2p0_f2p0_d2p0_c2p0
+
+.attribute arch, "rv32ima2p0_fdc"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_m2p0_a2p0_f2p0_d2p0_c2p0
+
+.attribute arch, "rv32ima2p0_fdc"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_m2p0_a2p0_f2p0_d2p0_c2p0
+
+.attribute arch, "rv32iv"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl128b1p0_zvl32b1p0_zvl64b1p0
+
+.attribute arch, "rv32ivzvl32b"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl128b1p0_zvl32b1p0_zvl64b1p0
+
+.attribute arch, "rv32ivzvl64b"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl128b1p0_zvl32b1p0_zvl64b1p0
+
+.attribute arch, "rv32ivzvl128b"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl128b1p0_zvl32b1p0_zvl64b1p0
+
+.attribute arch, "rv32ivzvl256b"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl128b1p0_zvl256b1p0_zvl32b1p0_zvl64b1p0
+
+.attribute arch, "rv32ivzvl512b"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl128b1p0_zvl256b1p0_zvl32b1p0_zvl512b1p0_zvl64b1p0
+
+.attribute arch, "rv32ivzvl1024b"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl1024b1p0_zvl128b1p0_zvl256b1p0_zvl32b1p0_zvl512b1p0_zvl64b1p0
+
+.attribute arch, "rv32ivzvl2048b"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl1024b1p0_zvl128b1p0_zvl2048b1p0_zvl256b1p0_zvl32b1p0_zvl512b1p0_zvl64b1p0
+
+.attribute arch, "rv32ivzvl4096b"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl1024b1p0_zvl128b1p0_zvl2048b1p0_zvl256b1p0_zvl32b1p0_zvl4096b1p0_zvl512b1p0_zvl64b1p0
+
+.attribute arch, "rv32ivzvl8192b"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl1024b1p0_zvl128b1p0_zvl2048b1p0_zvl256b1p0_zvl32b1p0_zvl4096b1p0_zvl512b1p0_zvl64b1p0_zvl8192b1p0
+
+.attribute arch, "rv32ivzvl16384b"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl1024b1p0_zvl128b1p0_zvl16384b1p0_zvl2048b1p0_zvl256b1p0_zvl32b1p0_zvl4096b1p0_zvl512b1p0_zvl64b1p0_zvl8192b1p0
+
+.attribute arch, "rv32ivzvl32768b"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl1024b1p0_zvl128b1p0_zvl16384b1p0_zvl2048b1p0_zvl256b1p0_zvl32768b1p0_zvl32b1p0_zvl4096b1p0_zvl512b1p0_zvl64b1p0_zvl8192b1p0
+
+.attribute arch, "rv32ivzvl65536b"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_v1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl1024b1p0_zvl128b1p0_zvl16384b1p0_zvl2048b1p0_zvl256b1p0_zvl32768b1p0_zvl32b1p0_zvl4096b1p0_zvl512b1p0_zvl64b1p0_zvl65536b1p0_zvl8192b1p0
+
+.attribute arch, "rv32izve32x"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zve32x1p0_zvl32b1p0
+
+.attribute arch, "rv32ifzve32f"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_zve32f1p0_zve32x1p0_zvl32b1p0
+
+.attribute arch, "rv32izve64x"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zve32x1p0_zve64x1p0_zvl32b1p0_zvl64b1p0
+
+.attribute arch, "rv32ifzve64f"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_zve32f1p0_zve32x1p0_zve64f1p0_zve64x1p0_zvl32b1p0_zvl64b1p0
+
+.attribute arch, "rv32ifdzve64d"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_d2p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvl32b1p0_zvl64b1p0
+
+.attribute arch, "rv32izicbom"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zicbom1p0
+
+.attribute arch, "rv32izicboz"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zicboz1p0
+
+.attribute arch, "rv32izicbop"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zicbop1p0
+
+## Experimental extensions require version string to be explicitly specified
+
+.attribute arch, "rv32izba1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zba1p0
+
+.attribute arch, "rv32izbb1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zbb1p0
+
+.attribute arch, "rv32izbc1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zbc1p0
+
+.attribute arch, "rv32izbs1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zbs1p0
+
+.attribute arch, "rv32ifzfhmin1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_zfhmin1p0
+
+.attribute arch, "rv32ifzfh1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_zfh1p0
+
+.attribute arch, "rv32izfinx"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zfinx1p0
+
+.attribute arch, "rv32izfinx_zdinx"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zfinx1p0_zdinx1p0
+
+.attribute arch, "rv32izfinx_zhinxmin"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zfinx1p0_zhinxmin1p0
+
+.attribute arch, "rv32izfinx_zhinx1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zfinx1p0_zhinx1p0
+
+.attribute arch, "rv32i_zbkb1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zbkb1p0
+
+.attribute arch, "rv32i_zbkc1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zbkc1p0
+
+.attribute arch, "rv32i_zbkx1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zbkx1p0
+
+.attribute arch, "rv32i_zknd1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zknd1p0
+
+.attribute arch, "rv32i_zkne1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zkne1p0
+
+.attribute arch, "rv32i_zknh1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zknh1p0
+
+.attribute arch, "rv32i_zksed1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zksed1p0
+
+.attribute arch, "rv32i_zksh1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zksh1p0
+
+.attribute arch, "rv32i_zkr1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zkr1p0
+
+.attribute arch, "rv32i_zkn1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zbkb1p0_zbkc1p0_zbkx1p0_zkn1p0_zknd1p0_zkne1p0_zknh1p0
+
+.attribute arch, "rv32i_zks1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zbkb1p0_zbkc1p0_zbkx1p0_zks1p0_zksed1p0_zksh1p0
+
+.attribute arch, "rv32i_zkt1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zkt1p0
+
+.attribute arch, "rv32i_zk1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zbkb1p0_zbkc1p0_zbkx1p0_zk1p0_zkn1p0_zknd1p0_zkne1p0_zknh1p0_zkr1p0_zkt1p0
+
+.attribute arch, "rv32izihintntl0p2"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zihintntl0p2
+
+.attribute arch, "rv32iczihintntl0p2"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_c2p0_zihintntl0p2
+
+.attribute arch, "rv32if_zkt1p0_zve32f1p0_zve32x1p0_zvl32b1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_f2p0_zkt1p0_zve32f1p0_zve32x1p0_zvl32b1p0
+
+.attribute arch, "rv32izca0p70"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zca0p70
+
+.attribute arch, "rv32izawrs1p0"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_zawrs1p0
+
+.attribute arch, "rv32iztso0p1"
+nop
+.word 32
+# MAPPINGSYMBOLS: $xrv32i2p0_ztso0p1

llvm/test/MC/RISCV/mapping-symbols.s

+# Check section containing code and data with permission executable for the section.
+# RUN: llvm-mc -triple=riscv64 -filetype=obj -o %t.o %p/Inputs/1.s
+# RUN: llvm-readelf -s %t.o | FileCheck %s
+
+# Check section containing code and data with no permissions for the section.
+# RUN: llvm-mc -triple=riscv64 -filetype=obj -o %t.o %p/Inputs/2.s
+# RUN: llvm-readelf -s %t.o | FileCheck %s
+
+# Check section containing code and data with read/write permissions for the section.
+# RUN: llvm-mc -triple=riscv64 -filetype=obj -o %t.o %p/Inputs/3.s
+# RUN: llvm-readelf -s %t.o | FileCheck %s
+
+# Check section containing data with no permissions for the section.
+# RUN: llvm-mc -triple=riscv64 -filetype=obj -o %t.o %p/Inputs/4.s
+# RUN: llvm-readelf -s %t.o | FileCheck %s -check-prefix=MAPPINGSYMBOLS
+
+# Check section containing only data with read/write permissions for the section.
+# RUN: llvm-mc -triple=riscv64 -filetype=obj -o %t.o %p/Inputs/5.s
+# RUN: llvm-readelf -s %t.o | FileCheck %s -check-prefix=MAPPINGSYMBOLS
+
+# Check section containing the ident string with no permissions for the section.
+# RUN: llvm-mc -triple=riscv64 -filetype=obj -o %t.o %p/Inputs/ident.s
+# RUN: llvm-readelf -s %t.o | FileCheck %s -check-prefix=MAPPINGSYMBOLS
+
+# Check section containing code and data with no permissions for the section.
+# data comes before code.
+# RUN: llvm-mc -triple=riscv64 -filetype=obj -o %t.o %p/Inputs/6.s
+# RUN: llvm-readelf -s %t.o | FileCheck %s -check-prefix=MIX
+
+# Check section containing code and data with no permissions for the section.
+# data comes before code.
+# RUN: llvm-mc -triple=riscv64 -filetype=obj -o %t.o %p/Inputs/7.s
+# RUN: llvm-readelf -s %t.o | FileCheck %s
+
+#CHECK-DAG: $x
+#CHECK-DAG: $d
+
+#MIX: $d
+#MIX: $x
+#MIX: $d
+#MIX: $x
+
+#MAPPINGSYMBOLS-NOT: $x
+#MAPPINGSYMBOLS-NOT: $d

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

static bool isArmElf(const ObjectFile &Obj) {
   return Elf && Elf->getEMachine() == ELF::EM_ARM;
 }
 
 static bool isCSKYElf(const ObjectFile &Obj) {
   const auto *Elf = dyn_cast<ELFObjectFileBase>(&Obj);
   return Elf && Elf->getEMachine() == ELF::EM_CSKY;
 }
 
+static bool isRISCVElf(const ObjectFile &Obj) {
+  const auto *Elf = dyn_cast<ELFObjectFileBase>(&Obj);
+  return Elf && Elf->getEMachine() == ELF::EM_RISCV;
+}
+
 static bool hasMappingSymbols(const ObjectFile &Obj) {
-  return isArmElf(Obj) || isAArch64Elf(Obj) || isCSKYElf(Obj) ;
+  return isArmElf(Obj) || isAArch64Elf(Obj) || isCSKYElf(Obj) ||
+         isRISCVElf(Obj);
 }
 
 static bool isMappingSymbol(const SymbolInfoTy &Sym) {
   return Sym.Name.startswith("$d") || Sym.Name.startswith("$x") ||
          Sym.Name.startswith("$a") || Sym.Name.startswith("$t");
 }
 
 static void printRelocation(formatted_raw_ostream &OS, StringRef FileName,