LCOV - code coverage report
Current view: top level - lib/Target/AArch64 - AArch64CleanupLocalDynamicTLSPass.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 46 47 97.9 %
Date: 2018-06-17 00:07:59 Functions: 11 12 91.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- AArch64CleanupLocalDynamicTLSPass.cpp ---------------------*- C++ -*-=//
       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             : // Local-dynamic access to thread-local variables proceeds in three stages.
      11             : //
      12             : // 1. The offset of this Module's thread-local area from TPIDR_EL0 is calculated
      13             : //    in much the same way as a general-dynamic TLS-descriptor access against
      14             : //    the special symbol _TLS_MODULE_BASE.
      15             : // 2. The variable's offset from _TLS_MODULE_BASE_ is calculated using
      16             : //    instructions with "dtprel" modifiers.
      17             : // 3. These two are added, together with TPIDR_EL0, to obtain the variable's
      18             : //    true address.
      19             : //
      20             : // This is only better than general-dynamic access to the variable if two or
      21             : // more of the first stage TLS-descriptor calculations can be combined. This
      22             : // pass looks through a function and performs such combinations.
      23             : //
      24             : //===----------------------------------------------------------------------===//
      25             : #include "AArch64.h"
      26             : #include "AArch64InstrInfo.h"
      27             : #include "AArch64MachineFunctionInfo.h"
      28             : #include "llvm/CodeGen/MachineDominators.h"
      29             : #include "llvm/CodeGen/MachineFunction.h"
      30             : #include "llvm/CodeGen/MachineFunctionPass.h"
      31             : #include "llvm/CodeGen/MachineInstrBuilder.h"
      32             : #include "llvm/CodeGen/MachineRegisterInfo.h"
      33             : using namespace llvm;
      34             : 
      35             : #define TLSCLEANUP_PASS_NAME "AArch64 Local Dynamic TLS Access Clean-up"
      36             : 
      37             : namespace {
      38         738 : struct LDTLSCleanup : public MachineFunctionPass {
      39             :   static char ID;
      40         741 :   LDTLSCleanup() : MachineFunctionPass(ID) {
      41         741 :     initializeLDTLSCleanupPass(*PassRegistry::getPassRegistry());
      42         741 :   }
      43             : 
      44       11050 :   bool runOnMachineFunction(MachineFunction &MF) override {
      45       11050 :     if (skipFunction(MF.getFunction()))
      46             :       return false;
      47             : 
      48       11046 :     AArch64FunctionInfo *AFI = MF.getInfo<AArch64FunctionInfo>();
      49       11046 :     if (AFI->getNumLocalDynamicTLSAccesses() < 2) {
      50             :       // No point folding accesses if there isn't at least two.
      51             :       return false;
      52             :     }
      53             : 
      54           2 :     MachineDominatorTree *DT = &getAnalysis<MachineDominatorTree>();
      55           2 :     return VisitNode(DT->getRootNode(), 0);
      56             :   }
      57             : 
      58             :   // Visit the dominator subtree rooted at Node in pre-order.
      59             :   // If TLSBaseAddrReg is non-null, then use that to replace any
      60             :   // TLS_base_addr instructions. Otherwise, create the register
      61             :   // when the first such instruction is seen, and then use it
      62             :   // as we encounter more instructions.
      63           2 :   bool VisitNode(MachineDomTreeNode *Node, unsigned TLSBaseAddrReg) {
      64           2 :     MachineBasicBlock *BB = Node->getBlock();
      65             :     bool Changed = false;
      66             : 
      67             :     // Traverse the current block.
      68          32 :     for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;
      69             :          ++I) {
      70          56 :       switch (I->getOpcode()) {
      71             :       case AArch64::TLSDESC_CALLSEQ:
      72             :         // Make sure it's a local dynamic access.
      73          12 :         if (!I->getOperand(0).isSymbol() ||
      74           4 :             strcmp(I->getOperand(0).getSymbolName(), "_TLS_MODULE_BASE_"))
      75             :           break;
      76             : 
      77           4 :         if (TLSBaseAddrReg)
      78           2 :           I = replaceTLSBaseAddrCall(*I, TLSBaseAddrReg);
      79             :         else
      80           2 :           I = setRegister(*I, &TLSBaseAddrReg);
      81             :         Changed = true;
      82             :         break;
      83             :       default:
      84             :         break;
      85             :       }
      86             :     }
      87             : 
      88             :     // Visit the children of this block in the dominator tree.
      89           2 :     for (MachineDomTreeNode *N : *Node) {
      90           0 :       Changed |= VisitNode(N, TLSBaseAddrReg);
      91             :     }
      92             : 
      93           2 :     return Changed;
      94             :   }
      95             : 
      96             :   // Replace the TLS_base_addr instruction I with a copy from
      97             :   // TLSBaseAddrReg, returning the new instruction.
      98           2 :   MachineInstr *replaceTLSBaseAddrCall(MachineInstr &I,
      99             :                                        unsigned TLSBaseAddrReg) {
     100           2 :     MachineFunction *MF = I.getParent()->getParent();
     101           2 :     const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
     102             : 
     103             :     // Insert a Copy from TLSBaseAddrReg to x0, which is where the rest of the
     104             :     // code sequence assumes the address will be.
     105           4 :     MachineInstr *Copy = BuildMI(*I.getParent(), I, I.getDebugLoc(),
     106           2 :                                  TII->get(TargetOpcode::COPY), AArch64::X0)
     107           2 :                              .addReg(TLSBaseAddrReg);
     108             : 
     109             :     // Erase the TLS_base_addr instruction.
     110           2 :     I.eraseFromParent();
     111             : 
     112           2 :     return Copy;
     113             :   }
     114             : 
     115             :   // Create a virtual register in *TLSBaseAddrReg, and populate it by
     116             :   // inserting a copy instruction after I. Returns the new instruction.
     117           2 :   MachineInstr *setRegister(MachineInstr &I, unsigned *TLSBaseAddrReg) {
     118           2 :     MachineFunction *MF = I.getParent()->getParent();
     119           2 :     const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
     120             : 
     121             :     // Create a virtual register for the TLS base address.
     122           2 :     MachineRegisterInfo &RegInfo = MF->getRegInfo();
     123           2 :     *TLSBaseAddrReg = RegInfo.createVirtualRegister(&AArch64::GPR64RegClass);
     124             : 
     125             :     // Insert a copy from X0 to TLSBaseAddrReg for later.
     126             :     MachineInstr *Copy =
     127           6 :         BuildMI(*I.getParent(), ++I.getIterator(), I.getDebugLoc(),
     128           2 :                 TII->get(TargetOpcode::COPY), *TLSBaseAddrReg)
     129           2 :             .addReg(AArch64::X0);
     130             : 
     131           2 :     return Copy;
     132             :   }
     133             : 
     134           6 :   StringRef getPassName() const override { return TLSCLEANUP_PASS_NAME; }
     135             : 
     136         738 :   void getAnalysisUsage(AnalysisUsage &AU) const override {
     137         738 :     AU.setPreservesCFG();
     138             :     AU.addRequired<MachineDominatorTree>();
     139         738 :     MachineFunctionPass::getAnalysisUsage(AU);
     140         738 :   }
     141             : };
     142             : }
     143             : 
     144      358578 : INITIALIZE_PASS(LDTLSCleanup, "aarch64-local-dynamic-tls-cleanup",
     145             :                 TLSCLEANUP_PASS_NAME, false, false)
     146             : 
     147             : char LDTLSCleanup::ID = 0;
     148         741 : FunctionPass *llvm::createAArch64CleanupLocalDynamicTLSPass() {
     149         741 :   return new LDTLSCleanup();
     150             : }

Generated by: LCOV version 1.13