1 //===---------- PPCTLSDynamicCall.cpp - TLS Dynamic Call Fixup ------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This pass fixes up GETtls[ld]ADDR[32] machine instructions so that 11 // they read and write GPR3. These are really call instructions, so 12 // must use the calling convention registers. This is done in a late 13 // pass so that TLS variable accesses can be fully commoned. 14 // 15 //===----------------------------------------------------------------------===// 16 17 #include "PPCInstrInfo.h" 18 #include "PPC.h" 19 #include "PPCInstrBuilder.h" 20 #include "PPCTargetMachine.h" 21 #include "llvm/CodeGen/MachineFunctionPass.h" 22 #include "llvm/CodeGen/MachineInstrBuilder.h" 23 #include "llvm/Support/Debug.h" 24 #include "llvm/Support/raw_ostream.h" 25 26 using namespace llvm; 27 28 #define DEBUG_TYPE "ppc-tls-dynamic-call" 29 30 namespace llvm { 31 void initializePPCTLSDynamicCallPass(PassRegistry&); 32 } 33 34 namespace { 35 // PPCTLSDynamicCall pass - Add copies to and from GPR3 around 36 // GETtls[ld]ADDR[32] machine instructions. These instructions 37 // are actually call instructions, so the register choice is 38 // constrained. We delay introducing these copies as late as 39 // possible so that TLS variable accesses can be fully commoned. 40 struct PPCTLSDynamicCall : public MachineFunctionPass { 41 static char ID; 42 PPCTLSDynamicCall() : MachineFunctionPass(ID) { 43 initializePPCTLSDynamicCallPass(*PassRegistry::getPassRegistry()); 44 } 45 46 const PPCTargetMachine *TM; 47 const PPCInstrInfo *TII; 48 49 protected: 50 bool processBlock(MachineBasicBlock &MBB) { 51 bool Changed = false; 52 bool Is64Bit = TM->getSubtargetImpl()->isPPC64(); 53 54 for (MachineBasicBlock::iterator I = MBB.begin(), IE = MBB.end(); 55 I != IE; ++I) { 56 MachineInstr *MI = I; 57 58 if (MI->getOpcode() != PPC::GETtlsADDR && 59 MI->getOpcode() != PPC::GETtlsldADDR && 60 MI->getOpcode() != PPC::GETtlsADDR32 && 61 MI->getOpcode() != PPC::GETtlsldADDR32) 62 continue; 63 64 DEBUG(dbgs() << "TLS Dynamic Call Fixup:\n " << *MI;); 65 66 unsigned OutReg = MI->getOperand(0).getReg(); 67 unsigned InReg = MI->getOperand(1).getReg(); 68 DebugLoc DL = MI->getDebugLoc(); 69 unsigned GPR3 = Is64Bit ? PPC::X3 : PPC::R3; 70 71 BuildMI(MBB, I, DL, TII->get(TargetOpcode::COPY), GPR3) 72 .addReg(InReg); 73 MI->getOperand(0).setReg(GPR3); 74 MI->getOperand(1).setReg(GPR3); 75 BuildMI(MBB, ++I, DL, TII->get(TargetOpcode::COPY), OutReg) 76 .addReg(GPR3); 77 78 Changed = true; 79 } 80 81 return Changed; 82 } 83 84 public: 85 bool runOnMachineFunction(MachineFunction &MF) override { 86 TM = static_cast<const PPCTargetMachine *>(&MF.getTarget()); 87 TII = TM->getSubtargetImpl()->getInstrInfo(); 88 89 bool Changed = false; 90 91 for (MachineFunction::iterator I = MF.begin(); I != MF.end();) { 92 MachineBasicBlock &B = *I++; 93 if (processBlock(B)) 94 Changed = true; 95 } 96 97 return Changed; 98 } 99 100 void getAnalysisUsage(AnalysisUsage &AU) const override { 101 MachineFunctionPass::getAnalysisUsage(AU); 102 } 103 }; 104 } 105 106 INITIALIZE_PASS_BEGIN(PPCTLSDynamicCall, DEBUG_TYPE, 107 "PowerPC TLS Dynamic Call Fixup", false, false) 108 INITIALIZE_PASS_END(PPCTLSDynamicCall, DEBUG_TYPE, 109 "PowerPC TLS Dynamic Call Fixup", false, false) 110 111 char PPCTLSDynamicCall::ID = 0; 112 FunctionPass* 113 llvm::createPPCTLSDynamicCallPass() { return new PPCTLSDynamicCall(); } 114