[RISCV] Change the return type of getStreamer() to support the use of overloading and other functions in RISCVELFStreamer.

[LiDongjin]

Summary

Change the return type of getStreamer() to support the use of overloading and other functions in RISCVELFStreamer.
In the process of implementing mapping symbols, the non-overloaded method in RISCVELFStreamer cannot be obtained through getStreamer().
Therefore, changing the return value of getStreamer() is beneficial to the subsequent support for mapping symbols.
https://reviews.llvm.org/D137417

[gkistanova]

I don't think I'm a good reviewer for this patch.

[asb]

LGTM. Would have been easier to review if a separate NFC commit did the change putting the RISCVELFStreamer declaration in RISCVELFStreamer.h.

The change is simple enough I don't feel I need to insist on splitting it up prior to committing (other reviewers might feel differently though). If not splitting, please update the commit description to note how the RISCVELFStreamer declaration was moved.

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

 //===-- RISCVELFStreamer.h - RISCV ELF 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_MCTARGETDESC_RISCVELFSTREAMER_H
 #define LLVM_LIB_TARGET_RISCV_MCTARGETDESC_RISCVELFSTREAMER_H
 
 #include "RISCVTargetStreamer.h"
 #include "llvm/MC/MCELFStreamer.h"
 
+using namespace llvm;
+
+class RISCVELFStreamer : public MCELFStreamer {
+  static std::pair<unsigned, unsigned> getRelocPairForSize(unsigned Size);
+  static bool requiresFixups(MCContext &C, const MCExpr *Value,
+                             const MCExpr *&LHS, const MCExpr *&RHS);
+  void reset() override;
+
+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;
+};
+
 namespace llvm {
 
 class RISCVTargetELFStreamer : public RISCVTargetStreamer {
 private:
   enum class AttributeType { Hidden, Numeric, Text, NumericAndText };
 
   struct AttributeItem {
     AttributeType Type;
private:
   void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
                             StringRef StringValue) override;
   void finishAttributeSection() override;
   size_t calculateContentSize() const;
 
   void reset() override;
 
 public:
-  MCELFStreamer &getStreamer();
+  RISCVELFStreamer &getStreamer();
   RISCVTargetELFStreamer(MCStreamer &S, const MCSubtargetInfo &STI);
 
   void emitDirectiveOptionPush() override;
   void emitDirectiveOptionPop() override;
   void emitDirectiveOptionPIC() override;
   void emitDirectiveOptionNoPIC() override;
   void emitDirectiveOptionRVC() override;
   void emitDirectiveOptionNoRVC() override;

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

RISCVTargetELFStreamer::RISCVTargetELFStreamer(MCStreamer &S,
     : RISCVTargetStreamer(S), CurrentVendor("riscv"), STI(STI) {
   MCAssembler &MCA = getStreamer().getAssembler();
   const FeatureBitset &Features = STI.getFeatureBits();
   auto &MAB = static_cast<RISCVAsmBackend &>(MCA.getBackend());
   setTargetABI(RISCVABI::computeTargetABI(STI.getTargetTriple(), Features,
                                           MAB.getTargetOptions().getABIName()));
 }
 
-MCELFStreamer &RISCVTargetELFStreamer::getStreamer() {
-  return static_cast<MCELFStreamer &>(Streamer);
+RISCVELFStreamer &RISCVTargetELFStreamer::getStreamer() {
+  return static_cast<RISCVELFStreamer &>(Streamer);
 }
 
 void RISCVTargetELFStreamer::emitDirectiveOptionPush() {}
 void RISCVTargetELFStreamer::emitDirectiveOptionPop() {}
 void RISCVTargetELFStreamer::emitDirectiveOptionPIC() {}
 void RISCVTargetELFStreamer::emitDirectiveOptionNoPIC() {}
 void RISCVTargetELFStreamer::emitDirectiveOptionRVC() {}
 void RISCVTargetELFStreamer::emitDirectiveOptionNoRVC() {}
void RISCVTargetELFStreamer::reset() {
   Contents.clear();
 }
 
 void RISCVTargetELFStreamer::emitDirectiveVariantCC(MCSymbol &Symbol) {
   getStreamer().getAssembler().registerSymbol(Symbol);
   cast<MCSymbolELF>(Symbol).setOther(ELF::STO_RISCV_VARIANT_CC);
 }
 
-namespace {
-class RISCVELFStreamer : public MCELFStreamer {
-  static std::pair<unsigned, unsigned> getRelocPairForSize(unsigned Size) {
-    switch (Size) {
-    default:
-      llvm_unreachable("unsupported fixup size");
-    case 1:
-      return std::make_pair(RISCV::fixup_riscv_add_8, RISCV::fixup_riscv_sub_8);
-    case 2:
-      return std::make_pair(RISCV::fixup_riscv_add_16,
-                            RISCV::fixup_riscv_sub_16);
-    case 4:
-      return std::make_pair(RISCV::fixup_riscv_add_32,
-                            RISCV::fixup_riscv_sub_32);
-    case 8:
-      return std::make_pair(RISCV::fixup_riscv_add_64,
-                            RISCV::fixup_riscv_sub_64);
-    }
-  }
+std::pair<unsigned, unsigned>
+RISCVELFStreamer::getRelocPairForSize(unsigned Size) {
+    return std::make_pair(RISCV::fixup_riscv_add_16, RISCV::fixup_riscv_sub_16);
+    return std::make_pair(RISCV::fixup_riscv_add_32, RISCV::fixup_riscv_sub_32);
+    return std::make_pair(RISCV::fixup_riscv_add_64, RISCV::fixup_riscv_sub_64);
 
-  static bool requiresFixups(MCContext &C, const MCExpr *Value,
+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),
+  LHS = MCBinaryExpr::create(MCBinaryExpr::Add, MCSymbolRefExpr::create(&A, C),
                              MCConstantExpr::create(E.getConstant(), C), C);
-    RHS = E.getSymB();
 
-    // If either symbol is in a text section, we need to delay the relocation
-    // evaluation as relaxation may alter the size of the symbol.
-    //
-    // Unfortunately, we cannot identify if the symbol was built with relaxation
-    // as we do not track the state per symbol or section.  However, BFD will
-    // always emit the relocation and so we follow suit which avoids the need to
-    // track that information.
-    if (A.isInSection() && A.getSection().getKind().isText())
-      return true;
-    if (B.isInSection() && B.getSection().getKind().isText())
-      return true;
 
-    // Support cross-section symbolic differences ...
-    return A.isInSection() && B.isInSection() &&
-           A.getSection().getName() != B.getSection().getName();
-  }
 
-  void reset() override {
-    static_cast<RISCVTargetStreamer *>(getTargetStreamer())->reset();
-    MCELFStreamer::reset();
-  }
+void RISCVELFStreamer::reset() {
 
-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 {
-    const MCExpr *A, *B;
-    if (!requiresFixups(getContext(), Value, A, B))
-      return MCELFStreamer::emitValueImpl(Value, Size, Loc);
+void RISCVELFStreamer::emitValueImpl(const MCExpr *Value, unsigned Size,
+                                     SMLoc 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);
-  }
-};
-} // namespace
 
 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