[PPC32] Parse bl __tls_get_addr(x@tlsgd)@plt+32768

[MaskRay]

Summary

PPC32 -fpic/-fPIC generates bl __tls_get_addr(x@tlsgd)@PLT or
bl __tls_get_addr(x@tlsgd)@PLT+32768.
powerpc-linux-gnu-gcc -fPIC generates bl __tls_get_addr+32668(x@tlsgd)@plt.

These expressions can be parsed by GNU assembler but not by the integrated
assembler. Add the support.

[MaskRay]

Move E = Parser.getTok().getLoc(); early, though I believe there is no real behavior difference.

[MaskRay]

Ping:)

[MaskRay]

Ping:)

[MaskRay]

Ping:)

[brad]

Not my area, but this looks good for IAS.

[MaskRay]

In D153206#4545364, @brad wrote:

Not my area, but this looks good for IAS.

Yes, and clang --target=powerpc -save-temps ... uses the integrated assembler to read Clang emitted assembly, which will work with this patch.

[MaskRay]

Ping

[nemanjai]

I think the code could be clarified a bit with some additional comments, but otherwise LGTM.

llvm/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp

1568–1592

Perhaps this should be bl __tls_get_addr[+a](x@tlsgd)@plt[+b] to make it clear that we may be parsing an addend after __tls_get_addr as well as one after @plt.

1587

And here, perhaps a comment that this adds __tls_get_addr with a|b|a+b.

[MaskRay]

thanks for the review!

add more comments

llvm/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp

bool PPCAsmParser::ParseOperand(OperandVector &Operands) {
   default:
     return Error(S, "unknown operand");
   }
 
   // Push the parsed operand into the list of operands
   Operands.push_back(PPCOperand::CreateFromMCExpr(EVal, S, E, isPPC64()));
 
   // Check whether this is a TLS call expression
-  bool TLSCall = false;
-  if (const MCSymbolRefExpr *Ref = dyn_cast<MCSymbolRefExpr>(EVal))
-    TLSCall = Ref->getSymbol().getName() == "__tls_get_addr";
+  const char TlsGetAddr[] = "__tls_get_addr";
+  bool TlsCall = false;
+  const MCExpr *TlsCallAddend = nullptr;
+  if (auto *Ref = dyn_cast<MCSymbolRefExpr>(EVal)) {
+    TlsCall = Ref->getSymbol().getName() == TlsGetAddr;
+  } else if (auto *Bin = dyn_cast<MCBinaryExpr>(EVal);
+             Bin && Bin->getOpcode() == MCBinaryExpr::Add) {
+    if (auto *Ref = dyn_cast<MCSymbolRefExpr>(Bin->getLHS())) {
+      TlsCall = Ref->getSymbol().getName() == TlsGetAddr;
+      TlsCallAddend = Bin->getRHS();
+    }
+  }
 
-  if (TLSCall && parseOptionalToken(AsmToken::LParen)) {
+  if (TlsCall && parseOptionalToken(AsmToken::LParen)) {
     const MCExpr *TLSSym;
-    S = Parser.getTok().getLoc();
+    const SMLoc S2 = Parser.getTok().getLoc();
     if (ParseExpression(TLSSym))
-      return Error(S, "invalid TLS call expression");
+      return Error(S2, "invalid TLS call expression");
+    E = Parser.getTok().getLoc();
     if (parseToken(AsmToken::RParen, "expected ')'"))
       return true;
-    E = Parser.getTok().getLoc();
+    // PPC32 allows bl __tls_get_addr[+a](x@tlsgd)@plt+b. Parse "@plt[+b]".
+    if (!isPPC64() && parseOptionalToken(AsmToken::At)) {
+      AsmToken Tok = getTok();
+      if (!(parseOptionalToken(AsmToken::Identifier) &&
+            Tok.getString().compare_insensitive("plt") == 0))
+        return Error(Tok.getLoc(), "expected 'plt'");
+      EVal = MCSymbolRefExpr::create(TlsGetAddr, MCSymbolRefExpr::VK_PLT,
+                                     getContext());
+      if (parseOptionalToken(AsmToken::Plus)) {
+        const MCExpr *Addend = nullptr;
+        SMLoc EndLoc;
+        if (parsePrimaryExpr(Addend, EndLoc))
+          return true;
+        if (TlsCallAddend) // __tls_get_addr+a(x@tlsgd)@plt+b
+          TlsCallAddend =
+              MCBinaryExpr::createAdd(TlsCallAddend, Addend, getContext());
+        else // __tls_get_addr(x@tlsgd)@plt+b
+          TlsCallAddend = Addend;
+      }
+      if (TlsCallAddend)
+        EVal = MCBinaryExpr::createAdd(EVal, TlsCallAddend, getContext());
+      // Add a __tls_get_addr operand with addend a, b, or a+b.
+      Operands.back() = PPCOperand::CreateFromMCExpr(
+          EVal, S, Parser.getTok().getLoc(), false);
+    }
 
     Operands.push_back(PPCOperand::CreateFromMCExpr(TLSSym, S, E, isPPC64()));
   }
 
   // Otherwise, check for D-form memory operands
-  if (!TLSCall && parseOptionalToken(AsmToken::LParen)) {
+  if (!TlsCall && parseOptionalToken(AsmToken::LParen)) {
     S = Parser.getTok().getLoc();
 
     int64_t IntVal;
     switch (getLexer().getKind()) {
     case AsmToken::Percent: {
       MCRegister RegNo;
       if (MatchRegisterName(RegNo, IntVal))
         return Error(S, "invalid register name");

llvm/lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp

 }
 
 void PPCInstPrinter::printTLSCall(const MCInst *MI, unsigned OpNo,
                                   const MCSubtargetInfo &STI, raw_ostream &O) {
   // On PPC64, VariantKind is VK_None, but on PPC32, it's VK_PLT, and it must
   // come at the _end_ of the expression.
   const MCOperand &Op = MI->getOperand(OpNo);
   const MCSymbolRefExpr *RefExp = nullptr;
-  const MCConstantExpr *ConstExp = nullptr;
+  const MCExpr *Rhs = nullptr;
   if (const MCBinaryExpr *BinExpr = dyn_cast<MCBinaryExpr>(Op.getExpr())) {
     RefExp = cast<MCSymbolRefExpr>(BinExpr->getLHS());
-    ConstExp = cast<MCConstantExpr>(BinExpr->getRHS());
+    Rhs = BinExpr->getRHS();
   } else
     RefExp = cast<MCSymbolRefExpr>(Op.getExpr());
 
   O << RefExp->getSymbol().getName();
   // The variant kind VK_PPC_NOTOC needs to be handled as a special case
   // because we do not want the assembly to print out the @notoc at the
   // end like __tls_get_addr(x@tlsgd)@notoc. Instead we want it to look
   // like __tls_get_addr@notoc(x@tlsgd).
   if (RefExp->getKind() == MCSymbolRefExpr::VK_PPC_NOTOC)
     O << '@' << MCSymbolRefExpr::getVariantKindName(RefExp->getKind());
   O << '(';
   printOperand(MI, OpNo + 1, STI, O);
   O << ')';
   if (RefExp->getKind() != MCSymbolRefExpr::VK_None &&
       RefExp->getKind() != MCSymbolRefExpr::VK_PPC_NOTOC)
     O << '@' << MCSymbolRefExpr::getVariantKindName(RefExp->getKind());
-  if (ConstExp != nullptr)
-    O << '+' << ConstExp->getValue();
+  if (Rhs) {
+    SmallString<0> Buf;
+    raw_svector_ostream Tmp(Buf);
+    Rhs->print(Tmp, &MAI);
+    if (isdigit(Buf[0]))
+      O << '+';
+    O << Buf;
+  }
 }
 
 /// showRegistersWithPercentPrefix - Check if this register name should be
 /// printed with a percentage symbol as prefix.
 bool PPCInstPrinter::showRegistersWithPercentPrefix(const char *RegName) const {
   if (!FullRegNamesWithPercent || TT.getOS() == Triple::AIX)
     return false;
 

llvm/test/MC/PowerPC/ppc32-tls.s

+# RUN: llvm-mc -triple=powerpc %s | FileCheck %s --check-prefix=ASM
+# RUN: llvm-mc -filetype=obj -triple=powerpc %s -o %t
+# RUN: llvm-readobj -r %t | FileCheck %s
+
+# RUN: not llvm-mc -triple=powerpc --defsym ERR=1 %s 2>&1 | FileCheck %s --check-prefix=ERR --implicit-check-not=error:
+
+# ASM: bl __tls_get_addr(a@tlsgd)
+# ASM: bl __tls_get_addr(b@tlsld)
+# ASM: bl __tls_get_addr(c@tlsgd)@PLT
+# ASM: bl __tls_get_addr(d@tlsld)@PLT+32768
+# ASM: bl __tls_get_addr(e@tlsld)@PLT+32768
+bl __tls_get_addr(a@tlsgd)
+bl __tls_get_addr(b@tlsld)
+bl __tls_get_addr(c@tlsgd)@plt
+bl __tls_get_addr(d@tlsld)@PLT+32768
+bl __tls_get_addr+32768(e@tlsld)@plt  # gcc -fPIC
+
+## These are not present in the wild, but just to test we can parse them.
+# ASM: bl __tls_get_addr(f@tlsld)@PLT+1+(-2)
+bl __tls_get_addr+1(f@tlsld)@PLT+-2
+# ASM: bl __tls_get_addr(g@tlsld)@PLT+1+(y-x)
+x:
+bl __tls_get_addr+1(g@tlsld)@PLT+(y-x)
+y:
+
+# CHECK:      .rela.text {
+# CHECK-NEXT:   0x0 R_PPC_TLSGD a 0x0
+# CHECK-NEXT:   0x0 R_PPC_REL24 __tls_get_addr 0x0
+# CHECK-NEXT:   0x4 R_PPC_TLSLD b 0x0
+# CHECK-NEXT:   0x4 R_PPC_REL24 __tls_get_addr 0x0
+# CHECK-NEXT:   0x8 R_PPC_TLSGD c 0x0
+# CHECK-NEXT:   0x8 R_PPC_PLTREL24 __tls_get_addr 0x0
+# CHECK-NEXT:   0xC R_PPC_TLSLD d 0x0
+# CHECK-NEXT:   0xC R_PPC_PLTREL24 __tls_get_addr 0x8000
+# CHECK-NEXT:   0x10 R_PPC_TLSLD e 0x0
+# CHECK-NEXT:   0x10 R_PPC_PLTREL24 __tls_get_addr 0x8000
+# CHECK-NEXT:   0x14 R_PPC_TLSLD f 0x0
+# CHECK-NEXT:   0x14 R_PPC_PLTREL24 __tls_get_addr 0xFFFFFFFF
+# CHECK-NEXT:   0x18 R_PPC_TLSLD g 0x0
+# CHECK-NEXT:   0x18 R_PPC_PLTREL24 __tls_get_addr 0x5
+# CHECK-NEXT: }
+
+.ifdef ERR
+# ERR: :[[#@LINE+1]]:27: error: unexpected token
+bl __tls_get_addr(d@tlsld)plt
+# ERR: :[[#@LINE+1]]:28: error: expected 'plt'
+bl __tls_get_addr(d@tlsld)@invalid
+# ERR: :[[#@LINE+1]]:31: error: unexpected token
+bl __tls_get_addr(d@tlsld)@plt-32768
+
+# ERR: :[[#@LINE+1]]:21: error: invalid memory operand
+bl __tls_get_addr-1(f@tlsld)@plt
+.endif