LLVM API Documentation

AlphaLLRP.cpp

Go to the documentation of this file.
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 }