[llvm] [NewPM] Port x86-cleanup-local-dynamic-tls (PR #179864)
Aiden Grossman via llvm-commits
llvm-commits at lists.llvm.org
Thu Feb 5 06:09:40 PST 2026
================
@@ -0,0 +1,170 @@
+//===- X86CleanupLocalDynamicTLS.cpp - Cleanup local dynamic TLS access ---===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass combines multiple accesses to local-dynamic TLS variables so that
+// the TLS base address for the module is only fetched once per execution path
+// through the function.
+//
+//===----------------------------------------------------------------------===//
+
+#include "X86.h"
+#include "X86InstrInfo.h"
+#include "X86MachineFunctionInfo.h"
+#include "X86Subtarget.h"
+#include "llvm/CodeGen/MachineDominators.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/InitializePasses.h"
+
+using namespace llvm;
+
+#define DEBUG_TYPE "x86-cleanup-local-dynamic-tls"
+
+namespace {
+class X86CleanupLocalDynamicTLSLegacy : public MachineFunctionPass {
+public:
+ static char ID;
+
+ X86CleanupLocalDynamicTLSLegacy() : MachineFunctionPass(ID) {}
+
+ StringRef getPassName() const override {
+ return "Local Dynamic TLS Access Clean-up";
+ }
+
+ bool runOnMachineFunction(MachineFunction &MF) override;
+
+ void getAnalysisUsage(AnalysisUsage &AU) const override {
+ AU.setPreservesCFG();
+ AU.addRequired<MachineDominatorTreeWrapperPass>();
+ MachineFunctionPass::getAnalysisUsage(AU);
+ }
+};
+} // end anonymous namespace
+
+char X86CleanupLocalDynamicTLSLegacy::ID = 0;
+
+INITIALIZE_PASS_BEGIN(X86CleanupLocalDynamicTLSLegacy, DEBUG_TYPE,
+ "Local Dynamic TLS Access Clean-up", false, false)
+INITIALIZE_PASS_DEPENDENCY(MachineDominatorTreeWrapperPass)
+INITIALIZE_PASS_END(X86CleanupLocalDynamicTLSLegacy, DEBUG_TYPE,
+ "Local Dynamic TLS Access Clean-up", false, false)
+
+FunctionPass *llvm::createCleanupLocalDynamicTLSLegacyPass() {
+ return new X86CleanupLocalDynamicTLSLegacy();
+}
+
+// Replace the TLS_base_addr instruction I with a copy from
+// TLSBaseAddrReg, returning the new instruction.
+static MachineInstr *ReplaceTLSBaseAddrCall(MachineInstr &I,
+ Register TLSBaseAddrReg) {
+ MachineFunction *MF = I.getParent()->getParent();
+ const X86Subtarget &STI = MF->getSubtarget<X86Subtarget>();
+ const bool is64Bit = STI.is64Bit();
+ const X86InstrInfo *TII = STI.getInstrInfo();
+
+ // Insert a Copy from TLSBaseAddrReg to RAX/EAX.
+ MachineInstr *Copy =
+ BuildMI(*I.getParent(), I, I.getDebugLoc(), TII->get(TargetOpcode::COPY),
+ is64Bit ? X86::RAX : X86::EAX)
+ .addReg(TLSBaseAddrReg);
+
+ // Erase the TLS_base_addr instruction.
+ I.eraseFromParent();
+
+ return Copy;
+}
+
+// Create a virtual register in *TLSBaseAddrReg, and populate it by
+// inserting a copy instruction after I. Returns the new instruction.
+static MachineInstr *SetRegister(MachineInstr &I, Register *TLSBaseAddrReg) {
+ MachineFunction *MF = I.getParent()->getParent();
+ const X86Subtarget &STI = MF->getSubtarget<X86Subtarget>();
+ const bool is64Bit = STI.is64Bit();
+ const X86InstrInfo *TII = STI.getInstrInfo();
+
+ // Create a virtual register for the TLS base address.
+ MachineRegisterInfo &RegInfo = MF->getRegInfo();
+ *TLSBaseAddrReg = RegInfo.createVirtualRegister(is64Bit ? &X86::GR64RegClass
+ : &X86::GR32RegClass);
+
+ // Insert a copy from RAX/EAX to TLSBaseAddrReg.
+ MachineInstr *Next = I.getNextNode();
+ MachineInstr *Copy = BuildMI(*I.getParent(), Next, I.getDebugLoc(),
+ TII->get(TargetOpcode::COPY), *TLSBaseAddrReg)
+ .addReg(is64Bit ? X86::RAX : X86::EAX);
+
+ return Copy;
+}
+
+// Visit the dominator subtree rooted at Node in pre-order.
+// If TLSBaseAddrReg is non-null, then use that to replace any
+// TLS_base_addr instructions. Otherwise, create the register
+// when the first such instruction is seen, and then use it
+// as we encounter more instructions.
+static bool VisitNode(MachineDomTreeNode *Node, Register TLSBaseAddrReg) {
+ MachineBasicBlock *BB = Node->getBlock();
+ bool Changed = false;
+
+ // Traverse the current block.
+ for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;
+ ++I) {
+ switch (I->getOpcode()) {
+ case X86::TLS_base_addr32:
+ case X86::TLS_base_addr64:
+ if (TLSBaseAddrReg)
+ I = ReplaceTLSBaseAddrCall(*I, TLSBaseAddrReg);
+ else
+ I = SetRegister(*I, &TLSBaseAddrReg);
+ Changed = true;
+ break;
+ default:
+ break;
+ }
+ }
+
+ // Visit the children of this block in the dominator tree.
+ for (MachineDomTreeNode *I : Node->children())
+ Changed |= VisitNode(I, TLSBaseAddrReg);
+
+ return Changed;
+}
+
+static bool cleanupLocalDynamicTLS(MachineFunction &MF,
+ MachineDominatorTree &DT) {
+ X86MachineFunctionInfo *MFI = MF.getInfo<X86MachineFunctionInfo>();
+ if (MFI->getNumLocalDynamicTLSAccesses() < 2) {
+ // No point folding accesses if there isn't at least two.
+ return false;
+ }
+
+ return VisitNode(DT.getRootNode(), Register());
+}
+
+bool X86CleanupLocalDynamicTLSLegacy::runOnMachineFunction(
+ MachineFunction &MF) {
+ if (skipFunction(MF.getFunction()))
+ return false;
+
+ MachineDominatorTree &DT =
+ getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
+ return cleanupLocalDynamicTLS(MF, DT);
+}
+
+PreservedAnalyses
+X86CleanupLocalDynamicTLSPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ MachineDominatorTree &DT = MFAM.getResult<MachineDominatorTreeAnalysis>(MF);
+ bool Changed = cleanupLocalDynamicTLS(MF, DT);
+ if (!Changed)
+ return PreservedAnalyses::all();
+ PreservedAnalyses PA = getMachineFunctionPassPreservedAnalyses();
+ PA.preserve<MachineDominatorTreeAnalysis>();
----------------
boomanaiden154 wrote:
I would imagine `MachineDominatorTree` is included in `CFGAnalyses`.
https://github.com/llvm/llvm-project/pull/179864
More information about the llvm-commits
mailing list