1 //===- NVPTXProxyRegErasure.cpp - NVPTX Proxy Register Instruction Erasure -==// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // The pass is needed to remove ProxyReg instructions and restore related 10 // registers. The instructions were needed at instruction selection stage to 11 // make sure that callseq_end nodes won't be removed as "dead nodes". This can 12 // happen when we expand instructions into libcalls and the call site doesn't 13 // care about the libcall chain. Call site cares about data flow only, and the 14 // latest data flow node happens to be before callseq_end. Therefore the node 15 // becomes dangling and "dead". The ProxyReg acts like an additional data flow 16 // node *after* the callseq_end in the chain and ensures that everything will be 17 // preserved. 18 // 19 //===----------------------------------------------------------------------===// 20 21 #include "NVPTX.h" 22 #include "llvm/CodeGen/MachineFunctionPass.h" 23 #include "llvm/CodeGen/MachineInstrBuilder.h" 24 #include "llvm/CodeGen/MachineRegisterInfo.h" 25 #include "llvm/CodeGen/TargetInstrInfo.h" 26 #include "llvm/CodeGen/TargetRegisterInfo.h" 27 28 using namespace llvm; 29 30 namespace llvm { 31 void initializeNVPTXProxyRegErasurePass(PassRegistry &); 32 } 33 34 namespace { 35 36 struct NVPTXProxyRegErasure : public MachineFunctionPass { 37 public: 38 static char ID; 39 NVPTXProxyRegErasure() : MachineFunctionPass(ID) { 40 initializeNVPTXProxyRegErasurePass(*PassRegistry::getPassRegistry()); 41 } 42 43 bool runOnMachineFunction(MachineFunction &MF) override; 44 45 StringRef getPassName() const override { 46 return "NVPTX Proxy Register Instruction Erasure"; 47 } 48 49 void getAnalysisUsage(AnalysisUsage &AU) const override { 50 MachineFunctionPass::getAnalysisUsage(AU); 51 } 52 53 private: 54 void replaceMachineInstructionUsage(MachineFunction &MF, MachineInstr &MI); 55 56 void replaceRegisterUsage(MachineInstr &Instr, MachineOperand &From, 57 MachineOperand &To); 58 }; 59 60 } // namespace 61 62 char NVPTXProxyRegErasure::ID = 0; 63 64 INITIALIZE_PASS(NVPTXProxyRegErasure, "nvptx-proxyreg-erasure", "NVPTX ProxyReg Erasure", false, false) 65 66 bool NVPTXProxyRegErasure::runOnMachineFunction(MachineFunction &MF) { 67 SmallVector<MachineInstr *, 16> RemoveList; 68 69 for (auto &BB : MF) { 70 for (auto &MI : BB) { 71 switch (MI.getOpcode()) { 72 case NVPTX::ProxyRegI1: 73 case NVPTX::ProxyRegI16: 74 case NVPTX::ProxyRegI32: 75 case NVPTX::ProxyRegI64: 76 case NVPTX::ProxyRegF16: 77 case NVPTX::ProxyRegF16x2: 78 case NVPTX::ProxyRegF32: 79 case NVPTX::ProxyRegF64: 80 replaceMachineInstructionUsage(MF, MI); 81 RemoveList.push_back(&MI); 82 break; 83 } 84 } 85 } 86 87 for (auto *MI : RemoveList) { 88 MI->eraseFromParent(); 89 } 90 91 return !RemoveList.empty(); 92 } 93 94 void NVPTXProxyRegErasure::replaceMachineInstructionUsage(MachineFunction &MF, 95 MachineInstr &MI) { 96 auto &InOp = *MI.uses().begin(); 97 auto &OutOp = *MI.defs().begin(); 98 99 assert(InOp.isReg() && "ProxyReg input operand should be a register."); 100 assert(OutOp.isReg() && "ProxyReg output operand should be a register."); 101 102 for (auto &BB : MF) { 103 for (auto &I : BB) { 104 replaceRegisterUsage(I, OutOp, InOp); 105 } 106 } 107 } 108 109 void NVPTXProxyRegErasure::replaceRegisterUsage(MachineInstr &Instr, 110 MachineOperand &From, 111 MachineOperand &To) { 112 for (auto &Op : Instr.uses()) { 113 if (Op.isReg() && Op.getReg() == From.getReg()) { 114 Op.setReg(To.getReg()); 115 } 116 } 117 } 118 119 MachineFunctionPass *llvm::createNVPTXProxyRegErasurePass() { 120 return new NVPTXProxyRegErasure(); 121 } 122