1//===-- SystemZLDCleanup.cpp - Clean up local-dynamic TLS accesses --------===//
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 combines multiple accesses to local-dynamic TLS variables so that
11// the TLS base address for the module is only fetched once per execution path
12// through the function.
13//
14//===----------------------------------------------------------------------===//
15
16#include "SystemZTargetMachine.h"
17#include "SystemZMachineFunctionInfo.h"
18#include "llvm/CodeGen/MachineDominators.h"
19#include "llvm/CodeGen/MachineFunctionPass.h"
20#include "llvm/CodeGen/MachineInstrBuilder.h"
21#include "llvm/CodeGen/MachineRegisterInfo.h"
22#include "llvm/Target/TargetInstrInfo.h"
23#include "llvm/Target/TargetMachine.h"
24#include "llvm/Target/TargetRegisterInfo.h"
25
26using namespace llvm;
27
28namespace {
29
30class SystemZLDCleanup : public MachineFunctionPass {
31public:
32  static char ID;
33  SystemZLDCleanup(const SystemZTargetMachine &tm)
34    : MachineFunctionPass(ID), TII(nullptr), MF(nullptr) {}
35
36  const char *getPassName() const override {
37    return "SystemZ Local Dynamic TLS Access Clean-up";
38  }
39
40  bool runOnMachineFunction(MachineFunction &MF) override;
41  void getAnalysisUsage(AnalysisUsage &AU) const override;
42
43private:
44  bool VisitNode(MachineDomTreeNode *Node, unsigned TLSBaseAddrReg);
45  MachineInstr *ReplaceTLSCall(MachineInstr *I, unsigned TLSBaseAddrReg);
46  MachineInstr *SetRegister(MachineInstr *I, unsigned *TLSBaseAddrReg);
47
48  const SystemZInstrInfo *TII;
49  MachineFunction *MF;
50};
51
52char SystemZLDCleanup::ID = 0;
53
54} // end anonymous namespace
55
56FunctionPass *llvm::createSystemZLDCleanupPass(SystemZTargetMachine &TM) {
57  return new SystemZLDCleanup(TM);
58}
59
60void SystemZLDCleanup::getAnalysisUsage(AnalysisUsage &AU) const {
61  AU.setPreservesCFG();
62  AU.addRequired<MachineDominatorTree>();
63  MachineFunctionPass::getAnalysisUsage(AU);
64}
65
66bool SystemZLDCleanup::runOnMachineFunction(MachineFunction &F) {
67  TII = static_cast<const SystemZInstrInfo *>(F.getSubtarget().getInstrInfo());
68  MF = &F;
69
70  SystemZMachineFunctionInfo* MFI = F.getInfo<SystemZMachineFunctionInfo>();
71  if (MFI->getNumLocalDynamicTLSAccesses() < 2) {
72    // No point folding accesses if there isn't at least two.
73    return false;
74  }
75
76  MachineDominatorTree *DT = &getAnalysis<MachineDominatorTree>();
77  return VisitNode(DT->getRootNode(), 0);
78}
79
80// Visit the dominator subtree rooted at Node in pre-order.
81// If TLSBaseAddrReg is non-null, then use that to replace any
82// TLS_LDCALL instructions. Otherwise, create the register
83// when the first such instruction is seen, and then use it
84// as we encounter more instructions.
85bool SystemZLDCleanup::VisitNode(MachineDomTreeNode *Node,
86                                 unsigned TLSBaseAddrReg) {
87  MachineBasicBlock *BB = Node->getBlock();
88  bool Changed = false;
89
90  // Traverse the current block.
91  for (auto I = BB->begin(), E = BB->end(); I != E; ++I) {
92    switch (I->getOpcode()) {
93      case SystemZ::TLS_LDCALL:
94        if (TLSBaseAddrReg)
95          I = ReplaceTLSCall(I, TLSBaseAddrReg);
96        else
97          I = SetRegister(I, &TLSBaseAddrReg);
98        Changed = true;
99        break;
100      default:
101        break;
102    }
103  }
104
105  // Visit the children of this block in the dominator tree.
106  for (auto I = Node->begin(), E = Node->end(); I != E; ++I)
107    Changed |= VisitNode(*I, TLSBaseAddrReg);
108
109  return Changed;
110}
111
112// Replace the TLS_LDCALL instruction I with a copy from TLSBaseAddrReg,
113// returning the new instruction.
114MachineInstr *SystemZLDCleanup::ReplaceTLSCall(MachineInstr *I,
115                                               unsigned TLSBaseAddrReg) {
116  // Insert a Copy from TLSBaseAddrReg to R2.
117  MachineInstr *Copy = BuildMI(*I->getParent(), I, I->getDebugLoc(),
118                               TII->get(TargetOpcode::COPY), SystemZ::R2D)
119                               .addReg(TLSBaseAddrReg);
120
121  // Erase the TLS_LDCALL instruction.
122  I->eraseFromParent();
123
124  return Copy;
125}
126
127// Create a virtal register in *TLSBaseAddrReg, and populate it by
128// inserting a copy instruction after I. Returns the new instruction.
129MachineInstr *SystemZLDCleanup::SetRegister(MachineInstr *I,
130                                            unsigned *TLSBaseAddrReg) {
131  // Create a virtual register for the TLS base address.
132  MachineRegisterInfo &RegInfo = MF->getRegInfo();
133  *TLSBaseAddrReg = RegInfo.createVirtualRegister(&SystemZ::GR64BitRegClass);
134
135  // Insert a copy from R2 to TLSBaseAddrReg.
136  MachineInstr *Next = I->getNextNode();
137  MachineInstr *Copy = BuildMI(*I->getParent(), Next, I->getDebugLoc(),
138                               TII->get(TargetOpcode::COPY), *TLSBaseAddrReg)
139                               .addReg(SystemZ::R2D);
140
141  return Copy;
142}
143
144