[LoongArch] Implement MCTargetExpr::fixELFSymbolsInTLSFixups hook

[wangleiat]

Remove irrelevant code.

[SixWeining]

LGTM and wait others.

[MaskRay]

This should use an assembly test at MC layer (llvm/test/MC)

llvm/test/CodeGen/LoongArch/tls-symbols.ll

2

remove <

13

It's better to use

CHECK-DAG to leave flexibility for MC to order symbol tables in another way. The symbol order is not guaranteed.

[wangleiat]

Address @MaskRay's comments and rebase.

[wangleiat]

In D137628#3920159, @MaskRay wrote:

This should use an assembly test at MC layer (llvm/test/MC)

Thanks a lot, it's done.

llvm/test/CodeGen/LoongArch/tls-symbols.ll

2

thanks

13

It's better to use

CHECK-DAG to leave flexibility for MC to order symbol tables in another way. The symbol order is not guaranteed.

thanks!

[MaskRay]

llvm/test/MC/LoongArch/Misc/tls-symbols.s

1 ↗

(On Diff #474636)

remove <

it's conventional to use -o %t and llvm-readobj -s %t

7 ↗

(On Diff #474636)

{{.*}} can be expanded to GLOBAL DEFAULT. Only a few more characters but check some properties which could be useful.

[wangleiat]

Use llvm-readobj for test.
Use CHECK directly, since the location doesn't change in the .s file?

[wangleiat]

llvm/test/MC/LoongArch/Misc/tls-symbols.s

7 ↗

(On Diff #474636)

{{.*}} can be expanded to GLOBAL DEFAULT. Only a few more characters but check some properties which could be useful.

thanks！

llvm/lib/Target/LoongArch/LoongArchInstrInfo.h

public:
   unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
                         MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
                         const DebugLoc &dl,
                         int *BytesAdded = nullptr) const override;
 
   bool
   reverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const override;
 
+  std::pair<unsigned, unsigned>
+  decomposeMachineOperandsTargetFlags(unsigned TF) const override;
+
+  ArrayRef<std::pair<unsigned, const char *>>
+  getSerializableDirectMachineOperandTargetFlags() const override;
+
 protected:
   const LoongArchSubtarget &STI;
 };
 
 } // end namespace llvm
 #endif // LLVM_LIB_TARGET_LOONGARCH_LOONGARCHINSTRINFO_H

llvm/lib/Target/LoongArch/LoongArchInstrInfo.cpp

 }
 
 bool LoongArchInstrInfo::reverseBranchCondition(
     SmallVectorImpl<MachineOperand> &Cond) const {
   assert((Cond.size() && Cond.size() <= 3) && "Invalid branch condition!");
   Cond[0].setImm(getOppositeBranchOpc(Cond[0].getImm()));
   return false;
 }
+
+std::pair<unsigned, unsigned>
+LoongArchInstrInfo::decomposeMachineOperandsTargetFlags(unsigned TF) const {
+  return std::make_pair(TF, 0u);
+}
+
+ArrayRef<std::pair<unsigned, const char *>>
+LoongArchInstrInfo::getSerializableDirectMachineOperandTargetFlags() const {
+  using namespace LoongArchII;
+  // TODO: Add more target flags.
+  static const std::pair<unsigned, const char *> TargetFlags[] = {
+      {MO_CALL, "loongarch-call"},
+      {MO_CALL_PLT, "loongarch-call-plt"},
+      {MO_PCREL_HI, "loongarch-pcrel-hi"},
+      {MO_PCREL_LO, "loongarch-pcrel-lo"},
+      {MO_GOT_PC_HI, "loongarch-got-pc-hi"},
+      {MO_GOT_PC_LO, "loongarch-got-pc-lo"},
+      {MO_LE_HI, "loongarch-le-hi"},
+      {MO_LE_LO, "loongarch-le-lo"},
+      {MO_IE_PC_HI, "loongarch-ie-pc-hi"},
+      {MO_IE_PC_LO, "loongarch-ie-pc-lo"},
+      {MO_LD_PC_HI, "loongarch-ld-pc-hi"},
+      {MO_GD_PC_HI, "loongarch-gd-pc-hi"}};
+  return makeArrayRef(TargetFlags);
+}

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchMCExpr.h

public:
   void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override;
   bool evaluateAsRelocatableImpl(MCValue &Res, const MCAsmLayout *Layout,
                                  const MCFixup *Fixup) const override;
   void visitUsedExpr(MCStreamer &Streamer) const override;
   MCFragment *findAssociatedFragment() const override {
     return getSubExpr()->findAssociatedFragment();
   }
 
-  void fixELFSymbolsInTLSFixups(MCAssembler &Asm) const override {}
+  void fixELFSymbolsInTLSFixups(MCAssembler &Asm) const override;
 
   static bool classof(const MCExpr *E) {
     return E->getKind() == MCExpr::Target;
   }
 
   static StringRef getVariantKindName(VariantKind Kind);
   static VariantKind getVariantKindForName(StringRef name);
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchMCExpr.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "LoongArchMCExpr.h"
 #include "LoongArchAsmBackend.h"
 #include "LoongArchFixupKinds.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCValue.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "loongarch-mcexpr"
 
 const LoongArchMCExpr *
 LoongArchMCExpr::create(const MCExpr *Expr, VariantKind Kind, MCContext &Ctx) {
return StringSwitch<LoongArchMCExpr::VariantKind>(name)
       .Case("ie64_lo20", VK_LoongArch_TLS_IE64_LO20)
       .Case("ie64_hi12", VK_LoongArch_TLS_IE64_HI12)
       .Case("ld_pc_hi20", VK_LoongArch_TLS_LD_PC_HI20)
       .Case("ld_hi20", VK_LoongArch_TLS_LD_HI20)
       .Case("gd_pc_hi20", VK_LoongArch_TLS_GD_PC_HI20)
       .Case("gd_hi20", VK_LoongArch_TLS_GD_HI20)
       .Default(VK_LoongArch_Invalid);
 }
+
+static void fixELFSymbolsInTLSFixupsImpl(const MCExpr *Expr, MCAssembler &Asm) {
+  switch (Expr->getKind()) {
+  case MCExpr::Target:
+    llvm_unreachable("Can't handle nested target expression");
+    break;
+  case MCExpr::Constant:
+    break;
+  case MCExpr::Unary:
+    fixELFSymbolsInTLSFixupsImpl(cast<MCUnaryExpr>(Expr)->getSubExpr(), Asm);
+    break;
+  case MCExpr::Binary: {
+    const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
+    fixELFSymbolsInTLSFixupsImpl(BE->getLHS(), Asm);
+    fixELFSymbolsInTLSFixupsImpl(BE->getRHS(), Asm);
+    break;
+  }
+  case MCExpr::SymbolRef: {
+    // We're known to be under a TLS fixup, so any symbol should be
+    // modified. There should be only one.
+    const MCSymbolRefExpr &SymRef = *cast<MCSymbolRefExpr>(Expr);
+    cast<MCSymbolELF>(SymRef.getSymbol()).setType(ELF::STT_TLS);
+    break;
+  }
+  }
+}
+
+void LoongArchMCExpr::fixELFSymbolsInTLSFixups(MCAssembler &Asm) const {
+  switch (getKind()) {
+  default:
+    return;
+  case VK_LoongArch_TLS_LE_HI20:
+  case VK_LoongArch_TLS_IE_PC_HI20:
+  case VK_LoongArch_TLS_IE_HI20:
+  case VK_LoongArch_TLS_LD_PC_HI20:
+  case VK_LoongArch_TLS_LD_HI20:
+  case VK_LoongArch_TLS_GD_PC_HI20:
+  case VK_LoongArch_TLS_GD_HI20:
+    break;
+  }
+  fixELFSymbolsInTLSFixupsImpl(getSubExpr(), Asm);
+}

llvm/test/CodeGen/LoongArch/tls-symbols.ll

+; RUN: llc --mtriple=loongarch64 --relocation-model=pic --filetype=obj < %s \
+; RUN:     -o - | llvm-readelf -s - | FileCheck %s
+
+@unspecified = external thread_local global i32
+@ld = external thread_local(localdynamic) global i32
+@ie = external thread_local(initialexec) global i32
+@le = external thread_local(localexec) global i32
+
+; CHECK-LABEL: Symbol table
+define ptr @f1() nounwind {
+entry:
+; CHECK: TLS{{.*}}UND unspecified
+  ret ptr @unspecified
+}
+
+define ptr @f2() nounwind {
+entry:
+; CHECK: TLS{{.*}}UND ld
+  ret ptr @ld
+}
+
+define ptr @f3() nounwind {
+entry:
+; CHECK: TLS{{.*}}UND ie
+  ret ptr @ie
+}
+
+define ptr @f4() nounwind {
+entry:
+; CHECK: TLS{{.*}}UND le
+  ret ptr @le
+}