Commit ea9e182a authored by Finkel, Hal's avatar Finkel, Hal
Browse files

Merging r213960: 

------------------------------------------------------------------------
r213960 | hfinkel | 2014-07-25 17:47:22 +0000 (Fri, 25 Jul 2014) | 3 lines

[PowerPC] Support TLS on PPC32/ELF

Patch by Justin Hibbits!
------------------------------------------------------------------------

llvm-svn: 223734
parent dffdec69

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

+8 −1
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include "llvm/MC/MCExpr.h"

#include "llvm/MC/MCInst.h"

#include "llvm/MC/MCInstrInfo.h"

#include "llvm/MC/MCSymbol.h"

#include "llvm/Support/CommandLine.h"

#include "llvm/Support/raw_ostream.h"

#include "llvm/Target/TargetOpcodes.h"
@@ -308,10 +309,16 @@ void PPCInstPrinter::printMemRegReg(const MCInst *MI, unsigned OpNo, 


void PPCInstPrinter::printTLSCall(const MCInst *MI, unsigned OpNo,

                                  raw_ostream &O) {

  printBranchOperand(MI, OpNo, 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 = cast<MCSymbolRefExpr>(*Op.getExpr());

  O << refExp.getSymbol().getName();

  O << '(';

  printOperand(MI, OpNo+1, O);

  O << ')';

  if (refExp.getKind() != MCSymbolRefExpr::VK_None)

    O << '@' << MCSymbolRefExpr::getVariantKindName(refExp.getKind());

}

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

+20 −5
Original line number Diff line number Diff line
@@ -236,7 +236,10 @@ unsigned PPCELFObjectWriter::getRelocTypeInner(const MCValue &Target, 
        Type = ELF::R_PPC64_DTPREL16_HIGHESTA;

        break;

      case MCSymbolRefExpr::VK_PPC_GOT_TLSGD:

        if (is64Bit())

          Type = ELF::R_PPC64_GOT_TLSGD16;

        else

          Type = ELF::R_PPC_GOT_TLSGD16;

        break;

      case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO:

        Type = ELF::R_PPC64_GOT_TLSGD16_LO;
@@ -248,7 +251,10 @@ unsigned PPCELFObjectWriter::getRelocTypeInner(const MCValue &Target, 
        Type = ELF::R_PPC64_GOT_TLSGD16_HA;

        break;

      case MCSymbolRefExpr::VK_PPC_GOT_TLSLD:

        if (is64Bit())

          Type = ELF::R_PPC64_GOT_TLSLD16;

        else

          Type = ELF::R_PPC_GOT_TLSLD16;

        break;

      case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO:

        Type = ELF::R_PPC64_GOT_TLSLD16_LO;
@@ -344,13 +350,22 @@ unsigned PPCELFObjectWriter::getRelocTypeInner(const MCValue &Target, 
      switch (Modifier) {

      default: llvm_unreachable("Unsupported Modifier");

      case MCSymbolRefExpr::VK_PPC_TLSGD:

        if (is64Bit())

          Type = ELF::R_PPC64_TLSGD;

        else

          Type = ELF::R_PPC_TLSGD;

        break;

      case MCSymbolRefExpr::VK_PPC_TLSLD:

        if (is64Bit())

          Type = ELF::R_PPC64_TLSLD;

        else

          Type = ELF::R_PPC_TLSLD;

        break;

      case MCSymbolRefExpr::VK_PPC_TLS:

        if (is64Bit())

          Type = ELF::R_PPC64_TLS;

        else

          Type = ELF::R_PPC_TLS;

        break;

      }

      break;

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

+101 −38
Original line number Diff line number Diff line
@@ -573,6 +573,34 @@ void PPCAsmPrinter::EmitInstruction(const MachineInstr *MI) { 
    return;

  }



  case PPC::PPC32PICGOT: {

    MCSymbol *GOTSymbol = OutContext.GetOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));

    MCSymbol *GOTRef = OutContext.CreateTempSymbol();

    MCSymbol *NextInstr = OutContext.CreateTempSymbol();



    EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BL)

      // FIXME: We would like an efficient form for this, so we don't have to do

      // a lot of extra uniquing.

      .addExpr(MCSymbolRefExpr::Create(NextInstr, OutContext)));

    const MCExpr *OffsExpr =

      MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(GOTSymbol, OutContext),

                                MCSymbolRefExpr::Create(GOTRef, OutContext),

        OutContext);

    OutStreamer.EmitLabel(GOTRef);

    OutStreamer.EmitValue(OffsExpr, 4);

    OutStreamer.EmitLabel(NextInstr);

    EmitToStreamer(OutStreamer, MCInstBuilder(PPC::MFLR)

                                .addReg(MI->getOperand(0).getReg()));

    EmitToStreamer(OutStreamer, MCInstBuilder(PPC::LWZ)

                                .addReg(MI->getOperand(1).getReg())

                                .addImm(0)

                                .addReg(MI->getOperand(0).getReg()));

    EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADD4)

                                .addReg(MI->getOperand(0).getReg())

                                .addReg(MI->getOperand(1).getReg())

                                .addReg(MI->getOperand(0).getReg()));

    return;

  }

  case PPC::PPC32GOT: {

    MCSymbol *GOTSymbol = OutContext.GetOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));

    const MCExpr *SymGotTlsL =
@@ -606,38 +634,52 @@ void PPCAsmPrinter::EmitInstruction(const MachineInstr *MI) { 
                                .addExpr(SymGotTlsGD));

    return;

  }

  case PPC::ADDItlsgdL: {

  case PPC::ADDItlsgdL:

    // Transform: %Xd = ADDItlsgdL %Xs, <ga:@sym>

    // Into:      %Xd = ADDI8 %Xs, sym@got@tlsgd@l

    assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");

  case PPC::ADDItlsgdL32: {

    // Transform: %Rd = ADDItlsgdL32 %Rs, <ga:@sym>

    // Into:      %Rd = ADDI %Rs, sym@got@tlsgd

    const MachineOperand &MO = MI->getOperand(2);

    const GlobalValue *GValue = MO.getGlobal();

    MCSymbol *MOSymbol = getSymbol(GValue);

    const MCExpr *SymGotTlsGD =

      MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO,

      MCSymbolRefExpr::Create(MOSymbol, Subtarget.isPPC64() ?

                                         MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO :

                                         MCSymbolRefExpr::VK_PPC_GOT_TLSGD,

                              OutContext);

    EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDI8)

    EmitToStreamer(OutStreamer,

                   MCInstBuilder(Subtarget.isPPC64() ? PPC::ADDI8 : PPC::ADDI)

                   .addReg(MI->getOperand(0).getReg())

                   .addReg(MI->getOperand(1).getReg())

                   .addExpr(SymGotTlsGD));

    return;

  }

  case PPC::GETtlsADDR: {

  case PPC::GETtlsADDR:

    // Transform: %X3 = GETtlsADDR %X3, <ga:@sym>

    // Into:      BL8_NOP_TLS __tls_get_addr(sym@tlsgd)

    assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");

  case PPC::GETtlsADDR32: {

    // Transform: %R3 = GETtlsADDR32 %R3, <ga:@sym>

    // Into:      BL_TLS __tls_get_addr(sym@tlsgd)@PLT



    StringRef Name = "__tls_get_addr";

    MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);

    MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;



    if (!Subtarget.isPPC64() && !Subtarget.isDarwin() &&

        TM.getRelocationModel() == Reloc::PIC_)

      Kind = MCSymbolRefExpr::VK_PLT;

    const MCSymbolRefExpr *TlsRef = 

      MCSymbolRefExpr::Create(TlsGetAddr, MCSymbolRefExpr::VK_None, OutContext);

      MCSymbolRefExpr::Create(TlsGetAddr, Kind, OutContext);

    const MachineOperand &MO = MI->getOperand(2);

    const GlobalValue *GValue = MO.getGlobal();

    MCSymbol *MOSymbol = getSymbol(GValue);

    const MCExpr *SymVar =

      MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSGD,

                              OutContext);

    EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BL8_NOP_TLS)

    EmitToStreamer(OutStreamer,

                   MCInstBuilder(Subtarget.isPPC64() ?

                                  PPC::BL8_NOP_TLS : PPC::BL_TLS)

                   .addExpr(TlsRef)

                   .addExpr(SymVar));

    return;
@@ -658,69 +700,90 @@ void PPCAsmPrinter::EmitInstruction(const MachineInstr *MI) { 
                                .addExpr(SymGotTlsLD));

    return;

  }

  case PPC::ADDItlsldL: {

  case PPC::ADDItlsldL:

    // Transform: %Xd = ADDItlsldL %Xs, <ga:@sym>

    // Into:      %Xd = ADDI8 %Xs, sym@got@tlsld@l

    assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");

  case PPC::ADDItlsldL32: {

    // Transform: %Rd = ADDItlsldL32 %Rs, <ga:@sym>

    // Into:      %Rd = ADDI %Rs, sym@got@tlsld

    const MachineOperand &MO = MI->getOperand(2);

    const GlobalValue *GValue = MO.getGlobal();

    MCSymbol *MOSymbol = getSymbol(GValue);

    const MCExpr *SymGotTlsLD =

      MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO,

      MCSymbolRefExpr::Create(MOSymbol, Subtarget.isPPC64() ?

                                         MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO :

                                         MCSymbolRefExpr::VK_PPC_GOT_TLSLD,

                              OutContext);

    EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDI8)

    EmitToStreamer(OutStreamer,

                   MCInstBuilder(Subtarget.isPPC64() ? PPC::ADDI8 : PPC::ADDI)

                   .addReg(MI->getOperand(0).getReg())

                   .addReg(MI->getOperand(1).getReg())

                   .addExpr(SymGotTlsLD));

    return;

  }

  case PPC::GETtlsldADDR: {

  case PPC::GETtlsldADDR:

    // Transform: %X3 = GETtlsldADDR %X3, <ga:@sym>

    // Into:      BL8_NOP_TLS __tls_get_addr(sym@tlsld)

    assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");

  case PPC::GETtlsldADDR32: {

    // Transform: %R3 = GETtlsldADDR32 %R3, <ga:@sym>

    // Into:      BL_TLS __tls_get_addr(sym@tlsld)@PLT



    StringRef Name = "__tls_get_addr";

    MCSymbol *TlsGetAddr = OutContext.GetOrCreateSymbol(Name);

    MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;



    if (!Subtarget.isPPC64() && !Subtarget.isDarwin() &&

        TM.getRelocationModel() == Reloc::PIC_)

      Kind = MCSymbolRefExpr::VK_PLT;



    const MCSymbolRefExpr *TlsRef = 

      MCSymbolRefExpr::Create(TlsGetAddr, MCSymbolRefExpr::VK_None, OutContext);

      MCSymbolRefExpr::Create(TlsGetAddr, Kind, OutContext);

    const MachineOperand &MO = MI->getOperand(2);

    const GlobalValue *GValue = MO.getGlobal();

    MCSymbol *MOSymbol = getSymbol(GValue);

    const MCExpr *SymVar =

      MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_TLSLD,

                              OutContext);

    EmitToStreamer(OutStreamer, MCInstBuilder(PPC::BL8_NOP_TLS)

    EmitToStreamer(OutStreamer,

                   MCInstBuilder(Subtarget.isPPC64() ?

                                  PPC::BL8_NOP_TLS : PPC::BL_TLS)

                   .addExpr(TlsRef)

                   .addExpr(SymVar));

    return;

  }

  case PPC::ADDISdtprelHA: {

  case PPC::ADDISdtprelHA:

    // Transform: %Xd = ADDISdtprelHA %X3, <ga:@sym>

    // Into:      %Xd = ADDIS8 %X3, sym@dtprel@ha

    assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");

  case PPC::ADDISdtprelHA32: {

    // Transform: %Rd = ADDISdtprelHA32 %R3, <ga:@sym>

    // Into:      %Rd = ADDIS %R3, sym@dtprel@ha

    const MachineOperand &MO = MI->getOperand(2);

    const GlobalValue *GValue = MO.getGlobal();

    MCSymbol *MOSymbol = getSymbol(GValue);

    const MCExpr *SymDtprel =

      MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_HA,

                              OutContext);

    EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDIS8)

    EmitToStreamer(OutStreamer,

                   MCInstBuilder(Subtarget.isPPC64() ? PPC::ADDIS8 : PPC::ADDIS)

                   .addReg(MI->getOperand(0).getReg())

                                .addReg(PPC::X3)

                   .addReg(Subtarget.isPPC64() ? PPC::X3 : PPC::R3)

                   .addExpr(SymDtprel));

    return;

  }

  case PPC::ADDIdtprelL: {

  case PPC::ADDIdtprelL:

    // Transform: %Xd = ADDIdtprelL %Xs, <ga:@sym>

    // Into:      %Xd = ADDI8 %Xs, sym@dtprel@l

    assert(Subtarget.isPPC64() && "Not supported for 32-bit PowerPC");

  case PPC::ADDIdtprelL32: {

    // Transform: %Rd = ADDIdtprelL32 %Rs, <ga:@sym>

    // Into:      %Rd = ADDI %Rs, sym@dtprel@l

    const MachineOperand &MO = MI->getOperand(2);

    const GlobalValue *GValue = MO.getGlobal();

    MCSymbol *MOSymbol = getSymbol(GValue);

    const MCExpr *SymDtprel =

      MCSymbolRefExpr::Create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_LO,

                              OutContext);

    EmitToStreamer(OutStreamer, MCInstBuilder(PPC::ADDI8)

    EmitToStreamer(OutStreamer,

                   MCInstBuilder(Subtarget.isPPC64() ? PPC::ADDI8 : PPC::ADDI)

                   .addReg(MI->getOperand(0).getReg())

                   .addReg(MI->getOperand(1).getReg())

                   .addExpr(SymDtprel));

llvm/lib/Target/PowerPC/PPCISelDAGToDAG.cpp

+6 −0
Original line number Diff line number Diff line
@@ -1473,6 +1473,12 @@ SDNode *PPCDAGToDAGISel::Select(SDNode *N) { 
    return CurDAG->getMachineNode(PPC::ADDItocL, dl, MVT::i64,

                                  SDValue(Tmp, 0), GA);

  }

  case PPCISD::PPC32_PICGOT: {

    // Generate a PIC-safe GOT reference.

    assert(!PPCSubTarget->isPPC64() && PPCSubTarget->isSVR4ABI() &&

      "PPCISD::PPC32_PICGOT is only supported for 32-bit SVR4");

    return CurDAG->SelectNodeTo(N, PPC::PPC32PICGOT, PPCLowering->getPointerTy(),  MVT::i32);

  }

  case PPCISD::VADD_SPLAT: {

    // This expands into one of three sequences, depending on whether

    // the first operand is odd or even, positive or negative.

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

+29 −15
Original line number Diff line number Diff line
@@ -1685,47 +1685,61 @@ SDValue PPCTargetLowering::LowerGlobalTLSAddress(SDValue Op, 


  if (Model == TLSModel::GeneralDynamic) {

    SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, 0);

    SDValue GOTPtr;

    if (is64bit) {

      SDValue GOTReg = DAG.getRegister(PPC::X2, MVT::i64);

    SDValue GOTEntryHi = DAG.getNode(PPCISD::ADDIS_TLSGD_HA, dl, PtrVT,

      GOTPtr = DAG.getNode(PPCISD::ADDIS_TLSGD_HA, dl, PtrVT,

                                   GOTReg, TGA);

    } else {

      GOTPtr = DAG.getNode(PPCISD::PPC32_PICGOT, dl, PtrVT);

    }

    SDValue GOTEntry = DAG.getNode(PPCISD::ADDI_TLSGD_L, dl, PtrVT,

                                   GOTEntryHi, TGA);

                                   GOTPtr, TGA);



    // We need a chain node, and don't have one handy.  The underlying

    // call has no side effects, so using the function entry node

    // suffices.

    SDValue Chain = DAG.getEntryNode();

    Chain = DAG.getCopyToReg(Chain, dl, PPC::X3, GOTEntry);

    SDValue ParmReg = DAG.getRegister(PPC::X3, MVT::i64);

    Chain = DAG.getCopyToReg(Chain, dl,

                             is64bit ? PPC::X3 : PPC::R3, GOTEntry);

    SDValue ParmReg = DAG.getRegister(is64bit ? PPC::X3 : PPC::R3,

                                      is64bit ? MVT::i64 : MVT::i32);

    SDValue TLSAddr = DAG.getNode(PPCISD::GET_TLS_ADDR, dl,

                                  PtrVT, ParmReg, TGA);

    // The return value from GET_TLS_ADDR really is in X3 already, but

    // some hacks are needed here to tie everything together.  The extra

    // copies dissolve during subsequent transforms.

    Chain = DAG.getCopyToReg(Chain, dl, PPC::X3, TLSAddr);

    return DAG.getCopyFromReg(Chain, dl, PPC::X3, PtrVT);

    Chain = DAG.getCopyToReg(Chain, dl, is64bit ? PPC::X3 : PPC::R3, TLSAddr);

    return DAG.getCopyFromReg(Chain, dl, is64bit ? PPC::X3 : PPC::R3, PtrVT);

  }



  if (Model == TLSModel::LocalDynamic) {

    SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, 0);

    SDValue GOTPtr;

    if (is64bit) {

      SDValue GOTReg = DAG.getRegister(PPC::X2, MVT::i64);

    SDValue GOTEntryHi = DAG.getNode(PPCISD::ADDIS_TLSLD_HA, dl, PtrVT,

      GOTPtr = DAG.getNode(PPCISD::ADDIS_TLSLD_HA, dl, PtrVT,

                           GOTReg, TGA);

    } else {

      GOTPtr = DAG.getNode(PPCISD::PPC32_PICGOT, dl, PtrVT);

    }

    SDValue GOTEntry = DAG.getNode(PPCISD::ADDI_TLSLD_L, dl, PtrVT,

                                   GOTEntryHi, TGA);

                                   GOTPtr, TGA);



    // We need a chain node, and don't have one handy.  The underlying

    // call has no side effects, so using the function entry node

    // suffices.

    SDValue Chain = DAG.getEntryNode();

    Chain = DAG.getCopyToReg(Chain, dl, PPC::X3, GOTEntry);

    SDValue ParmReg = DAG.getRegister(PPC::X3, MVT::i64);

    Chain = DAG.getCopyToReg(Chain, dl,

                             is64bit ? PPC::X3 : PPC::R3, GOTEntry);

    SDValue ParmReg = DAG.getRegister(is64bit ? PPC::X3 : PPC::R3,

                                      is64bit ? MVT::i64 : MVT::i32);

    SDValue TLSAddr = DAG.getNode(PPCISD::GET_TLSLD_ADDR, dl,

                                  PtrVT, ParmReg, TGA);

    // The return value from GET_TLSLD_ADDR really is in X3 already, but

    // some hacks are needed here to tie everything together.  The extra

    // copies dissolve during subsequent transforms.

    Chain = DAG.getCopyToReg(Chain, dl, PPC::X3, TLSAddr);

    Chain = DAG.getCopyToReg(Chain, dl, is64bit ? PPC::X3 : PPC::R3, TLSAddr);

    SDValue DtvOffsetHi = DAG.getNode(PPCISD::ADDIS_DTPREL_HA, dl, PtrVT,

                                      Chain, ParmReg, TGA);

    return DAG.getNode(PPCISD::ADDI_DTPREL_L, dl, PtrVT, DtvOffsetHi, TGA);