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 28using namespace llvm; 29 30namespace llvm { 31void initializeNVPTXProxyRegErasurePass(PassRegistry &); 32} 33 34namespace { 35 36struct NVPTXProxyRegErasure : public MachineFunctionPass { 37public: 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 53private: 54 void replaceMachineInstructionUsage(MachineFunction &MF, MachineInstr &MI); 55 56 void replaceRegisterUsage(MachineInstr &Instr, MachineOperand &From, 57 MachineOperand &To); 58}; 59 60} // namespace 61 62char NVPTXProxyRegErasure::ID = 0; 63 64INITIALIZE_PASS(NVPTXProxyRegErasure, "nvptx-proxyreg-erasure", "NVPTX ProxyReg Erasure", false, false) 65 66bool 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 94void 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 109void 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 119MachineFunctionPass *llvm::createNVPTXProxyRegErasurePass() { 120 return new NVPTXProxyRegErasure(); 121} 122