Merge commit 'b19b6d9fab0b' from llvm.org/main into next

Author: git apple-llvm automerger

llvm/include/llvm/MC/MCExpr.h

@@ -197,20 +197,14 @@ class MCSymbolRefExpr : public MCExpr {
     VK_None,
 
     VK_GOT,
-    VK_GOTENT,
     VK_GOTOFF,
     VK_GOTPCREL,
     VK_GOTTPOFF,
-    VK_INDNTPOFF,
-    VK_NTPOFF,
     VK_PLT,
     VK_TLSGD,
     VK_TLSLD,
     VK_TLSLDM,
     VK_TPOFF,
-    VK_DTPOFF,
-    VK_TLSCALL, // symbol(tlscall)
-    VK_TLSDESC, // symbol(tlsdesc)
     VK_TLVP,    // Mach-O thread local variable relocations
     VK_TLVPPAGE,
     VK_TLVPPAGEOFF,

llvm/lib/MC/ELFObjectWriter.cpp

@@ -1523,15 +1523,10 @@ void ELFObjectWriter::fixSymbolsInTLSFixups(MCAssembler &Asm,
     default:
       return;
     case MCSymbolRefExpr::VK_GOTTPOFF:
-    case MCSymbolRefExpr::VK_INDNTPOFF:
-    case MCSymbolRefExpr::VK_NTPOFF:
-    case MCSymbolRefExpr::VK_TLSCALL:
-    case MCSymbolRefExpr::VK_TLSDESC:
     case MCSymbolRefExpr::VK_TLSGD:
     case MCSymbolRefExpr::VK_TLSLD:
     case MCSymbolRefExpr::VK_TLSLDM:
     case MCSymbolRefExpr::VK_TPOFF:
-    case MCSymbolRefExpr::VK_DTPOFF:
       break;
     }
     Asm.registerSymbol(symRef.getSymbol());

llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp

@@ -8,6 +8,7 @@
 
 #include "MCTargetDesc/SystemZGNUInstPrinter.h"
 #include "MCTargetDesc/SystemZMCAsmInfo.h"
+#include "MCTargetDesc/SystemZMCExpr.h"
 #include "MCTargetDesc/SystemZMCTargetDesc.h"
 #include "MCTargetDesc/SystemZTargetStreamer.h"
 #include "TargetInfo/SystemZTargetInfo.h"
@@ -1668,12 +1669,12 @@ ParseStatus SystemZAsmParser::parsePCRel(OperandVector &Operands,
     if (Parser.getTok().isNot(AsmToken::Identifier))
       return Error(Parser.getTok().getLoc(), "unexpected token");
 
-    MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;
+    SystemZMCExpr::Specifier Kind = SystemZMCExpr::VK_None;
     StringRef Name = Parser.getTok().getString();
     if (Name == "tls_gdcall")
-      Kind = MCSymbolRefExpr::VK_TLSGD;
+      Kind = SystemZMCExpr::VK_TLSGD;
     else if (Name == "tls_ldcall")
-      Kind = MCSymbolRefExpr::VK_TLSLDM;
+      Kind = SystemZMCExpr::VK_TLSLDM;
     else
       return Error(Parser.getTok().getLoc(), "unknown TLS tag");
     Parser.Lex();

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZELFObjectWriter.cpp

@@ -6,6 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "MCTargetDesc/SystemZMCExpr.h"
 #include "MCTargetDesc/SystemZMCFixups.h"
 #include "MCTargetDesc/SystemZMCTargetDesc.h"
 #include "llvm/BinaryFormat/ELF.h"
@@ -33,6 +34,8 @@ class SystemZELFObjectWriter : public MCELFObjectTargetWriter {
   // Override MCELFObjectTargetWriter.
   unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                         const MCFixup &Fixup, bool IsPCRel) const override;
+  bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym,
+                               unsigned Type) const override;
 };
 
 } // end anonymous namespace
@@ -155,43 +158,57 @@ unsigned SystemZELFObjectWriter::getRelocType(MCContext &Ctx,
   unsigned Kind = Fixup.getKind();
   if (Kind >= FirstLiteralRelocationKind)
     return Kind - FirstLiteralRelocationKind;
-  MCSymbolRefExpr::VariantKind Modifier = Target.getAccessVariant();
-  switch (Modifier) {
-  case MCSymbolRefExpr::VK_None:
+  auto Specifier = SystemZMCExpr::Specifier(Target.getAccessVariant());
+  switch (Specifier) {
+  case SystemZMCExpr::VK_INDNTPOFF:
+  case SystemZMCExpr::VK_NTPOFF:
+  case SystemZMCExpr::VK_TLSGD:
+  case SystemZMCExpr::VK_TLSLD:
+  case SystemZMCExpr::VK_TLSLDM:
+  case SystemZMCExpr::VK_DTPOFF:
+    if (auto *S = Target.getSymA())
+      cast<MCSymbolELF>(S->getSymbol()).setType(ELF::STT_TLS);
+    break;
+  default:
+    break;
+  }
+
+  switch (Specifier) {
+  case SystemZMCExpr::VK_None:
     if (IsPCRel)
       return getPCRelReloc(Ctx, Loc, Kind);
     return getAbsoluteReloc(Ctx, Loc, Kind);
 
-  case MCSymbolRefExpr::VK_NTPOFF:
+  case SystemZMCExpr::VK_NTPOFF:
     assert(!IsPCRel && "NTPOFF shouldn't be PC-relative");
     return getTLSLEReloc(Ctx, Loc, Kind);
 
-  case MCSymbolRefExpr::VK_INDNTPOFF:
+  case SystemZMCExpr::VK_INDNTPOFF:
     if (IsPCRel && Kind == SystemZ::FK_390_PC32DBL)
       return ELF::R_390_TLS_IEENT;
     Ctx.reportError(Loc, "Only PC-relative INDNTPOFF accesses are supported for now");
     return 0;
 
-  case MCSymbolRefExpr::VK_DTPOFF:
+  case SystemZMCExpr::VK_DTPOFF:
     assert(!IsPCRel && "DTPOFF shouldn't be PC-relative");
     return getTLSLDOReloc(Ctx, Loc, Kind);
 
-  case MCSymbolRefExpr::VK_TLSLDM:
+  case SystemZMCExpr::VK_TLSLDM:
     assert(!IsPCRel && "TLSLDM shouldn't be PC-relative");
     return getTLSLDMReloc(Ctx, Loc, Kind);
 
-  case MCSymbolRefExpr::VK_TLSGD:
+  case SystemZMCExpr::VK_TLSGD:
     assert(!IsPCRel && "TLSGD shouldn't be PC-relative");
     return getTLSGDReloc(Ctx, Loc, Kind);
 
-  case MCSymbolRefExpr::VK_GOT:
-  case MCSymbolRefExpr::VK_GOTENT:
+  case SystemZMCExpr::VK_GOT:
+  case SystemZMCExpr::VK_GOTENT:
     if (IsPCRel && Kind == SystemZ::FK_390_PC32DBL)
       return ELF::R_390_GOTENT;
     Ctx.reportError(Loc, "Only PC-relative GOT accesses are supported for now");
     return 0;
 
-  case MCSymbolRefExpr::VK_PLT:
+  case SystemZMCExpr::VK_PLT:
     assert(IsPCRel && "@PLT shouldn't be PC-relative");
     return getPLTReloc(Ctx, Loc, Kind);
 
@@ -200,6 +217,18 @@ unsigned SystemZELFObjectWriter::getRelocType(MCContext &Ctx,
   }
 }
 
+bool SystemZELFObjectWriter::needsRelocateWithSymbol(const MCValue &V,
+                                                     const MCSymbol &Sym,
+                                                     unsigned Type) const {
+  switch (getSpecifier(V.getSymA())) {
+  case SystemZMCExpr::VK_GOT:
+  case SystemZMCExpr::VK_PLT:
+    return true;
+  default:
+    return false;
+  }
+}
+
 std::unique_ptr<MCObjectTargetWriter>
 llvm::createSystemZELFObjectWriter(uint8_t OSABI) {
   return std::make_unique<SystemZELFObjectWriter>(OSABI);

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZInstPrinterCommon.cpp

@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "SystemZInstPrinterCommon.h"
+#include "MCTargetDesc/SystemZMCExpr.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCRegister.h"
@@ -168,11 +169,11 @@ void SystemZInstPrinterCommon::printPCRelTLSOperand(const MCInst *MI,
   if ((unsigned)OpNum + 1 < MI->getNumOperands()) {
     const MCOperand &MO = MI->getOperand(OpNum + 1);
     const MCSymbolRefExpr &refExp = cast<MCSymbolRefExpr>(*MO.getExpr());
-    switch (refExp.getKind()) {
-    case MCSymbolRefExpr::VK_TLSGD:
+    switch (getSpecifier(&refExp)) {
+    case SystemZMCExpr::VK_TLSGD:
       O << ":tls_gdcall:";
       break;
-    case MCSymbolRefExpr::VK_TLSLDM:
+    case SystemZMCExpr::VK_TLSLDM:
       O << ":tls_ldcall:";
       break;
     default:

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCAsmInfo.cpp

@@ -7,21 +7,22 @@
 //===----------------------------------------------------------------------===//
 
 #include "SystemZMCAsmInfo.h"
+#include "MCTargetDesc/SystemZMCExpr.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 
 using namespace llvm;
 
 const MCAsmInfo::VariantKindDesc variantKindDescs[] = {
-    {MCSymbolRefExpr::VK_DTPOFF, "DTPOFF"},
-    {MCSymbolRefExpr::VK_GOT, "GOT"},
-    {MCSymbolRefExpr::VK_GOTENT, "GOTENT"},
-    {MCSymbolRefExpr::VK_INDNTPOFF, "INDNTPOFF"},
-    {MCSymbolRefExpr::VK_NTPOFF, "NTPOFF"},
-    {MCSymbolRefExpr::VK_PLT, "PLT"},
-    {MCSymbolRefExpr::VK_TLSGD, "TLSGD"},
-    {MCSymbolRefExpr::VK_TLSLD, "TLSLD"},
-    {MCSymbolRefExpr::VK_TLSLDM, "TLSLDM"},
+    {SystemZMCExpr::VK_DTPOFF, "DTPOFF"},
+    {SystemZMCExpr::VK_GOT, "GOT"},
+    {SystemZMCExpr::VK_GOTENT, "GOTENT"},
+    {SystemZMCExpr::VK_INDNTPOFF, "INDNTPOFF"},
+    {SystemZMCExpr::VK_NTPOFF, "NTPOFF"},
+    {SystemZMCExpr::VK_PLT, "PLT"},
+    {SystemZMCExpr::VK_TLSGD, "TLSGD"},
+    {SystemZMCExpr::VK_TLSLD, "TLSLD"},
+    {SystemZMCExpr::VK_TLSLDM, "TLSLDM"},
 };
 
 SystemZMCAsmInfoELF::SystemZMCAsmInfoELF(const Triple &TT) {

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCExpr.cpp

@@ -12,14 +12,14 @@ using namespace llvm;
 
 #define DEBUG_TYPE "systemzmcexpr"
 
-const SystemZMCExpr *SystemZMCExpr::create(VariantKind Kind, const MCExpr *Expr,
-                                           MCContext &Ctx) {
+const SystemZMCExpr *SystemZMCExpr::create(SystemZMCExpr::Specifier Kind,
+                                           const MCExpr *Expr, MCContext &Ctx) {
   return new (Ctx) SystemZMCExpr(Kind, Expr);
 }
 
 StringRef SystemZMCExpr::getVariantKindName() const {
-  switch (static_cast<uint32_t>(getKind())) {
-  case VK_SystemZ_None:
+  switch (getSpecifier()) {
+  case VK_None:
     return "A";
   case VK_SystemZ_RCon:
     return "R";
@@ -41,8 +41,8 @@ bool SystemZMCExpr::evaluateAsRelocatableImpl(MCValue &Res,
   if (!getSubExpr()->evaluateAsRelocatable(Res, Asm))
     return false;
 
-  Res =
-      MCValue::get(Res.getSymA(), Res.getSymB(), Res.getConstant(), getKind());
+  Res = MCValue::get(Res.getSymA(), Res.getSymB(), Res.getConstant(),
+                     getSpecifier());
 
   return true;
 }

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCExpr.h

@@ -17,29 +17,37 @@ namespace llvm {
 
 class SystemZMCExpr : public MCTargetExpr {
 public:
-// HLASM docs for address constants:
-// https://www.ibm.com/docs/en/hla-and-tf/1.6?topic=value-address-constants
-  enum VariantKind {
-    VK_SystemZ_None,
-    VK_SystemZ_RCon,            // Address of ADA of symbol.
-    VK_SystemZ_VCon,            // Address of external function symbol.
+  enum Specifier : uint8_t {
+    VK_None,
+
+    VK_DTPOFF = MCSymbolRefExpr::FirstTargetSpecifier,
+    VK_GOT,
+    VK_GOTENT,
+    VK_INDNTPOFF,
+    VK_NTPOFF,
+    VK_PLT,
+    VK_TLSGD,
+    VK_TLSLD,
+    VK_TLSLDM,
+
+    // HLASM docs for address constants:
+    // https://www.ibm.com/docs/en/hla-and-tf/1.6?topic=value-address-constants
+    VK_SystemZ_RCon, // Address of ADA of symbol.
+    VK_SystemZ_VCon, // Address of external function symbol.
   };
 
 private:
-  const VariantKind Kind;
+  const Specifier specifier;
   const MCExpr *Expr;
 
-  explicit SystemZMCExpr(VariantKind Kind, const MCExpr *Expr)
-      : Kind(Kind), Expr(Expr) {}
+  explicit SystemZMCExpr(Specifier S, const MCExpr *Expr)
+      : specifier(S), Expr(Expr) {}
 
 public:
-  static const SystemZMCExpr *create(VariantKind Kind, const MCExpr *Expr,
+  static const SystemZMCExpr *create(Specifier Kind, const MCExpr *Expr,
                                      MCContext &Ctx);
 
-  /// getOpcode - Get the kind of this expression.
-  VariantKind getKind() const { return Kind; }
-
-  /// getSubExpr - Get the child of this expression.
+  Specifier getSpecifier() const { return specifier; }
   const MCExpr *getSubExpr() const { return Expr; }
 
   StringRef getVariantKindName() const;
@@ -58,6 +66,11 @@ class SystemZMCExpr : public MCTargetExpr {
     return E->getKind() == MCExpr::Target;
   }
 };
+
+static inline SystemZMCExpr::Specifier
+getSpecifier(const MCSymbolRefExpr *SRE) {
+  return SystemZMCExpr::Specifier(SRE->getKind());
+}
 } // end namespace llvm
 
 #endif