LLVM API Documentation
00001 //===-- AlphaLLRP.cpp - Alpha Load Load Replay Trap elimination pass. -- --===// 00002 // 00003 // The LLVM Compiler Infrastructure 00004 // 00005 // This file is distributed under the University of Illinois Open Source 00006 // License. See LICENSE.TXT for details. 00007 // 00008 //===----------------------------------------------------------------------===// 00009 // 00010 // Here we check for potential replay traps introduced by the spiller 00011 // We also align some branch targets if we can do so for free. 00012 // 00013 //===----------------------------------------------------------------------===// 00014 00015 #define DEBUG_TYPE "alpha-nops" 00016 #include "Alpha.h" 00017 #include "llvm/CodeGen/MachineFunctionPass.h" 00018 #include "llvm/CodeGen/MachineInstrBuilder.h" 00019 #include "llvm/Target/TargetMachine.h" 00020 #include "llvm/Target/TargetInstrInfo.h" 00021 #include "llvm/ADT/SetOperations.h" 00022 #include "llvm/ADT/Statistic.h" 00023 #include "llvm/Support/CommandLine.h" 00024 using namespace llvm; 00025 00026 STATISTIC(nopintro, "Number of nops inserted"); 00027 STATISTIC(nopalign, "Number of nops inserted for alignment"); 00028 00029 namespace { 00030 cl::opt<bool> 00031 AlignAll("alpha-align-all", cl::Hidden, 00032 cl::desc("Align all blocks")); 00033 00034 struct AlphaLLRPPass : public MachineFunctionPass { 00035 /// Target machine description which we query for reg. names, data 00036 /// layout, etc. 00037 /// 00038 AlphaTargetMachine &TM; 00039 00040 static char ID; 00041 AlphaLLRPPass(AlphaTargetMachine &tm) 00042 : MachineFunctionPass(&ID), TM(tm) { } 00043 00044 virtual const char *getPassName() const { 00045 return "Alpha NOP inserter"; 00046 } 00047 00048 bool runOnMachineFunction(MachineFunction &F) { 00049 const TargetInstrInfo *TII = F.getTarget().getInstrInfo(); 00050 bool Changed = false; 00051 MachineInstr* prev[3] = {0,0,0}; 00052 DebugLoc dl = DebugLoc::getUnknownLoc(); 00053 unsigned count = 0; 00054 for (MachineFunction::iterator FI = F.begin(), FE = F.end(); 00055 FI != FE; ++FI) { 00056 MachineBasicBlock& MBB = *FI; 00057 bool ub = false; 00058 for (MachineBasicBlock::iterator I = MBB.begin(); I != MBB.end(); ) { 00059 if (count%4 == 0) 00060 prev[0] = prev[1] = prev[2] = 0; //Slots cleared at fetch boundary 00061 ++count; 00062 MachineInstr *MI = I++; 00063 switch (MI->getOpcode()) { 00064 case Alpha::LDQ: case Alpha::LDL: 00065 case Alpha::LDWU: case Alpha::LDBU: 00066 case Alpha::LDT: case Alpha::LDS: 00067 case Alpha::STQ: case Alpha::STL: 00068 case Alpha::STW: case Alpha::STB: 00069 case Alpha::STT: case Alpha::STS: 00070 if (MI->getOperand(2).getReg() == Alpha::R30) { 00071 if (prev[0] && 00072 prev[0]->getOperand(2).getReg() == MI->getOperand(2).getReg()&& 00073 prev[0]->getOperand(1).getImm() == MI->getOperand(1).getImm()){ 00074 prev[0] = prev[1]; 00075 prev[1] = prev[2]; 00076 prev[2] = 0; 00077 BuildMI(MBB, MI, dl, TII->get(Alpha::BISr), Alpha::R31) 00078 .addReg(Alpha::R31) 00079 .addReg(Alpha::R31); 00080 Changed = true; nopintro += 1; 00081 count += 1; 00082 } else if (prev[1] 00083 && prev[1]->getOperand(2).getReg() == 00084 MI->getOperand(2).getReg() 00085 && prev[1]->getOperand(1).getImm() == 00086 MI->getOperand(1).getImm()) { 00087 prev[0] = prev[2]; 00088 prev[1] = prev[2] = 0; 00089 BuildMI(MBB, MI, dl, TII->get(Alpha::BISr), Alpha::R31) 00090 .addReg(Alpha::R31) 00091 .addReg(Alpha::R31); 00092 BuildMI(MBB, MI, dl, TII->get(Alpha::BISr), Alpha::R31) 00093 .addReg(Alpha::R31) 00094 .addReg(Alpha::R31); 00095 Changed = true; nopintro += 2; 00096 count += 2; 00097 } else if (prev[2] 00098 && prev[2]->getOperand(2).getReg() == 00099 MI->getOperand(2).getReg() 00100 && prev[2]->getOperand(1).getImm() == 00101 MI->getOperand(1).getImm()) { 00102 prev[0] = prev[1] = prev[2] = 0; 00103 BuildMI(MBB, MI, dl, TII->get(Alpha::BISr), Alpha::R31) 00104 .addReg(Alpha::R31).addReg(Alpha::R31); 00105 BuildMI(MBB, MI, dl, TII->get(Alpha::BISr), Alpha::R31) 00106 .addReg(Alpha::R31).addReg(Alpha::R31); 00107 BuildMI(MBB, MI, dl, TII->get(Alpha::BISr), Alpha::R31) 00108 .addReg(Alpha::R31).addReg(Alpha::R31); 00109 Changed = true; nopintro += 3; 00110 count += 3; 00111 } 00112 prev[0] = prev[1]; 00113 prev[1] = prev[2]; 00114 prev[2] = MI; 00115 break; 00116 } 00117 prev[0] = prev[1]; 00118 prev[1] = prev[2]; 00119 prev[2] = 0; 00120 break; 00121 case Alpha::ALTENT: 00122 case Alpha::MEMLABEL: 00123 case Alpha::PCLABEL: 00124 --count; 00125 break; 00126 case Alpha::BR: 00127 case Alpha::JMP: 00128 ub = true; 00129 //fall through 00130 default: 00131 prev[0] = prev[1]; 00132 prev[1] = prev[2]; 00133 prev[2] = 0; 00134 break; 00135 } 00136 } 00137 if (ub || AlignAll) { 00138 //we can align stuff for free at this point 00139 while (count % 4) { 00140 BuildMI(MBB, MBB.end(), dl, TII->get(Alpha::BISr), Alpha::R31) 00141 .addReg(Alpha::R31).addReg(Alpha::R31); 00142 ++count; 00143 ++nopalign; 00144 prev[0] = prev[1]; 00145 prev[1] = prev[2]; 00146 prev[2] = 0; 00147 } 00148 } 00149 } 00150 return Changed; 00151 } 00152 }; 00153 char AlphaLLRPPass::ID = 0; 00154 } // end of anonymous namespace 00155 00156 FunctionPass *llvm::createAlphaLLRPPass(AlphaTargetMachine &tm) { 00157 return new AlphaLLRPPass(tm); 00158 }