MachineVerifier.cpp revision b44fad7f95b9c0c65d5c772f6ed5084cf46283e9
148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen//===-- MachineVerifier.cpp - Machine Code Verifier -------------*- C++ -*-===// 248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// 348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// The LLVM Compiler Infrastructure 448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// 548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// This file is distributed under the University of Illinois Open Source 648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// License. See LICENSE.TXT for details. 748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// 848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen//===----------------------------------------------------------------------===// 948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// 1048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Pass to verify generated machine code. The following is checked: 1148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// 1248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Operand counts: All explicit operands must be present. 1348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// 1448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Register classes: All physical and virtual register operands must be 1548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// compatible with the register class required by the instruction descriptor. 1648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// 1748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Register live intervals: Registers must be defined only once, and must be 1848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// defined before use. 1948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// 2048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// The machine code verifier is enabled from LLVMTargetMachine.cpp with the 2148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// command-line option -verify-machineinstrs, or by defining the environment 2248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// variable LLVM_VERIFY_MACHINEINSTRS to the name of a file that will receive 2348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// the verifier errors. 2448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen//===----------------------------------------------------------------------===// 2548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 2648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/Function.h" 2748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/CodeGen/LiveVariables.h" 2848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/CodeGen/MachineFunctionPass.h" 29a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen#include "llvm/CodeGen/MachineFrameInfo.h" 3048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/CodeGen/MachineRegisterInfo.h" 3148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/CodeGen/Passes.h" 3248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/Target/TargetMachine.h" 3348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/Target/TargetRegisterInfo.h" 3448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/Target/TargetInstrInfo.h" 35cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner#include "llvm/ADT/DenseSet.h" 36cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner#include "llvm/ADT/SetOperations.h" 37cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner#include "llvm/ADT/SmallVector.h" 3848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/Support/Compiler.h" 3948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/Support/Debug.h" 407d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/ErrorHandling.h" 417d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/raw_ostream.h" 4248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenusing namespace llvm; 4348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 4448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesennamespace { 4548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen struct VISIBILITY_HIDDEN MachineVerifier : public MachineFunctionPass { 4648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen static char ID; // Pass ID, replacement for typeid 4748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 4848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MachineVerifier(bool allowDoubleDefs = false) : 4948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MachineFunctionPass(&ID), 5048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen allowVirtDoubleDefs(allowDoubleDefs), 5148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen allowPhysDoubleDefs(allowDoubleDefs), 5248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen OutFileName(getenv("LLVM_VERIFY_MACHINEINSTRS")) 5348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen {} 5448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 5548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void getAnalysisUsage(AnalysisUsage &AU) const { 5648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen AU.setPreservesAll(); 57ad2afc2a421a0e41603d5eee412d4d8c77e9bc1cDan Gohman MachineFunctionPass::getAnalysisUsage(AU); 5848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 5948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 6048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool runOnMachineFunction(MachineFunction &MF); 6148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 6248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const bool allowVirtDoubleDefs; 6348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const bool allowPhysDoubleDefs; 6448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 6548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const char *const OutFileName; 6617e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner raw_ostream *OS; 6748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineFunction *MF; 6848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const TargetMachine *TM; 6948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const TargetRegisterInfo *TRI; 7048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineRegisterInfo *MRI; 7148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 7248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned foundErrors; 7348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 7448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen typedef SmallVector<unsigned, 16> RegVector; 7548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen typedef DenseSet<unsigned> RegSet; 7648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen typedef DenseMap<unsigned, const MachineInstr*> RegMap; 7748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 7848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BitVector regsReserved; 7948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet regsLive; 80710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen RegVector regsDefined, regsDead, regsKilled; 81710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen RegSet regsLiveInButUnused; 8248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 8348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Add Reg and any sub-registers to RV 8448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void addRegWithSubRegs(RegVector &RV, unsigned Reg) { 8548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RV.push_back(Reg); 8648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Reg)) 8748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (const unsigned *R = TRI->getSubRegisters(Reg); *R; R++) 8848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RV.push_back(*R); 8948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 9048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 9148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen struct BBInfo { 9248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Is this MBB reachable from the MF entry point? 9348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool reachable; 9448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 9548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Vregs that must be live in because they are used without being 9648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // defined. Map value is the user. 9748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegMap vregsLiveIn; 9848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 9948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Vregs that must be dead in because they are defined without being 10048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // killed first. Map value is the defining instruction. 10148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegMap vregsDeadIn; 10248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 10348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Regs killed in MBB. They may be defined again, and will then be in both 10448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // regsKilled and regsLiveOut. 10548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet regsKilled; 10648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 10748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Regs defined in MBB and live out. Note that vregs passing through may 10848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // be live out without being mentioned here. 10948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet regsLiveOut; 11048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 11148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Vregs that pass through MBB untouched. This set is disjoint from 11248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // regsKilled and regsLiveOut. 11348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet vregsPassed; 11448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 11548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo() : reachable(false) {} 11648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 11748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Add register to vregsPassed if it belongs there. Return true if 11848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // anything changed. 11948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool addPassed(unsigned Reg) { 12048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!TargetRegisterInfo::isVirtualRegister(Reg)) 12148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return false; 12248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (regsKilled.count(Reg) || regsLiveOut.count(Reg)) 12348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return false; 12448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return vregsPassed.insert(Reg).second; 12548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 12648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 12748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Same for a full set. 12848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool addPassed(const RegSet &RS) { 12948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool changed = false; 13048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (RegSet::const_iterator I = RS.begin(), E = RS.end(); I != E; ++I) 13148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (addPassed(*I)) 13248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen changed = true; 13348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return changed; 13448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 13548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 13648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Live-out registers are either in regsLiveOut or vregsPassed. 13748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool isLiveOut(unsigned Reg) const { 13848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return regsLiveOut.count(Reg) || vregsPassed.count(Reg); 13948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 14048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen }; 14148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 14248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Extra register info per MBB. 14348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen DenseMap<const MachineBasicBlock*, BBInfo> MBBInfoMap; 14448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 14548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool isReserved(unsigned Reg) { 146d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen return Reg < regsReserved.size() && regsReserved.test(Reg); 14748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 14848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 14948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineFunctionBefore(); 15048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineBasicBlockBefore(const MachineBasicBlock *MBB); 15148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineInstrBefore(const MachineInstr *MI); 15248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineOperand(const MachineOperand *MO, unsigned MONum); 15348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineInstrAfter(const MachineInstr *MI); 15448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineBasicBlockAfter(const MachineBasicBlock *MBB); 15548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineFunctionAfter(); 15648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 15748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineFunction *MF); 15848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineBasicBlock *MBB); 15948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineInstr *MI); 16048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineOperand *MO, unsigned MONum); 16148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 16248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void markReachable(const MachineBasicBlock *MBB); 16348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void calcMaxRegsPassed(); 16448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void calcMinRegsPassed(); 16548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void checkPHIOps(const MachineBasicBlock *MBB); 16648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen }; 16748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 16848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 16948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenchar MachineVerifier::ID = 0; 17048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenstatic RegisterPass<MachineVerifier> 171de67a51b66964e95df05cd2192c05c77dccfa4c9Jakob Stoklund OlesenMachineVer("machineverifier", "Verify generated machine code"); 17248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenstatic const PassInfo *const MachineVerifyID = &MachineVer; 17348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 17417e9edc4a7bbeadf756494cf39fcacc9eff72202Chris LattnerFunctionPass *llvm::createMachineVerifierPass(bool allowPhysDoubleDefs) { 17548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return new MachineVerifier(allowPhysDoubleDefs); 17648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 17748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 17817e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattnerbool MachineVerifier::runOnMachineFunction(MachineFunction &MF) { 17917e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner raw_ostream *OutFile = 0; 18048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (OutFileName) { 18117e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner std::string ErrorInfo; 18217e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner OutFile = new raw_fd_ostream(OutFileName, ErrorInfo, 18317e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner raw_fd_ostream::F_Append); 18417e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner if (!ErrorInfo.empty()) { 18517e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner errs() << "Error opening '" << OutFileName << "': " << ErrorInfo << '\n'; 18617e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner exit(1); 18717e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner } 188b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesen 18917e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner OS = OutFile; 19048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 19117e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner OS = &errs(); 19248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 19348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 19448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen foundErrors = 0; 19548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 19648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen this->MF = &MF; 19748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen TM = &MF.getTarget(); 19848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen TRI = TM->getRegisterInfo(); 19948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MRI = &MF.getRegInfo(); 20048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 20148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineFunctionBefore(); 20248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF.begin(), MFE = MF.end(); 20348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI!=MFE; ++MFI) { 20448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineBasicBlockBefore(MFI); 20548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_iterator MBBI = MFI->begin(), 20648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MBBE = MFI->end(); MBBI != MBBE; ++MBBI) { 20748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineInstrBefore(MBBI); 20848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (unsigned I = 0, E = MBBI->getNumOperands(); I != E; ++I) 20948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineOperand(&MBBI->getOperand(I), I); 21048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineInstrAfter(MBBI); 21148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 21248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineBasicBlockAfter(MFI); 21348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 21448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineFunctionAfter(); 21548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 21617e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner if (OutFile) 21717e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner delete OutFile; 21817e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner else if (foundErrors) 21917e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner llvm_report_error("Found "+Twine(foundErrors)+" machine code errors."); 22048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 2216349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen // Clean up. 2226349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsLive.clear(); 2236349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsDefined.clear(); 2246349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsDead.clear(); 2256349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsKilled.clear(); 2266349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsLiveInButUnused.clear(); 2276349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen MBBInfoMap.clear(); 2286349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen 22948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return false; // no changes 23048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 23148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 232372fefe8d24e40df2390fffeea0dc2dec611f88bChris Lattnervoid MachineVerifier::report(const char *msg, const MachineFunction *MF) { 23348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MF); 23417e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner *OS << '\n'; 23548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!foundErrors++) 236372fefe8d24e40df2390fffeea0dc2dec611f88bChris Lattner MF->print(*OS); 23748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "*** Bad machine code: " << msg << " ***\n" 238ce63ffb52f249b62cdf2d250c128007b13f27e71Daniel Dunbar << "- function: " << MF->getFunction()->getNameStr() << "\n"; 23948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 24048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 241b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, const MachineBasicBlock *MBB) { 24248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MBB); 24348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report(msg, MBB->getParent()); 244ce63ffb52f249b62cdf2d250c128007b13f27e71Daniel Dunbar *OS << "- basic block: " << MBB->getBasicBlock()->getNameStr() 24548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " " << (void*)MBB 24648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " (#" << MBB->getNumber() << ")\n"; 24748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 24848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 249b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, const MachineInstr *MI) { 25048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MI); 25148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report(msg, MI->getParent()); 25248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "- instruction: "; 253705e07f578e2b3af47ddab610feb4e7f2d3063a5Chris Lattner MI->print(*OS, TM); 25448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 25548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 256b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, 257b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesen const MachineOperand *MO, unsigned MONum) { 25848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MO); 25948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report(msg, MO->getParent()); 26048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "- operand " << MONum << ": "; 26148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MO->print(*OS, TM); 26248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "\n"; 26348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 26448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 265b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::markReachable(const MachineBasicBlock *MBB) { 26648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MBB]; 26748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) { 26848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MInfo.reachable = true; 26948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator SuI = MBB->succ_begin(), 27048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen SuE = MBB->succ_end(); SuI != SuE; ++SuI) 27148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen markReachable(*SuI); 27248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 27348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 27448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 275b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineFunctionBefore() { 27648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsReserved = TRI->getReservedRegs(*MF); 277d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen 278d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen // A sub-register of a reserved register is also reserved 279d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen for (int Reg = regsReserved.find_first(); Reg>=0; 280d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen Reg = regsReserved.find_next(Reg)) { 281d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen for (const unsigned *Sub = TRI->getSubRegisters(Reg); *Sub; ++Sub) { 282d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen // FIXME: This should probably be: 283d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen // assert(regsReserved.test(*Sub) && "Non-reserved sub-register"); 284d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen regsReserved.set(*Sub); 285d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen } 286d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen } 28748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen markReachable(&MF->front()); 28848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 28948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 290b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineBasicBlockBefore(const MachineBasicBlock *MBB) { 29127920594b940d824038d16b13846aa76cac493cfDan Gohman const TargetInstrInfo *TII = MF->getTarget().getInstrInfo(); 29227920594b940d824038d16b13846aa76cac493cfDan Gohman 29327920594b940d824038d16b13846aa76cac493cfDan Gohman // Start with minimal CFG sanity checks. 29427920594b940d824038d16b13846aa76cac493cfDan Gohman MachineFunction::const_iterator MBBI = MBB; 29527920594b940d824038d16b13846aa76cac493cfDan Gohman ++MBBI; 29627920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBBI != MF->end()) { 29727920594b940d824038d16b13846aa76cac493cfDan Gohman // Block is not last in function. 29827920594b940d824038d16b13846aa76cac493cfDan Gohman if (!MBB->isSuccessor(MBBI)) { 29927920594b940d824038d16b13846aa76cac493cfDan Gohman // Block does not fall through. 30027920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 30127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB doesn't fall through but is empty!", MBB); 30227920594b940d824038d16b13846aa76cac493cfDan Gohman } 303a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman } 304a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman if (TII->BlockHasNoFallThrough(*MBB)) { 305a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman if (MBB->empty()) { 306a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman report("TargetInstrInfo says the block has no fall through, but the " 307a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman "block is empty!", MBB); 308a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman } else if (!MBB->back().getDesc().isBarrier()) { 30927920594b940d824038d16b13846aa76cac493cfDan Gohman report("TargetInstrInfo says the block has no fall through, but the " 310a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman "block does not end in a barrier!", MBB); 31127920594b940d824038d16b13846aa76cac493cfDan Gohman } 31227920594b940d824038d16b13846aa76cac493cfDan Gohman } 31327920594b940d824038d16b13846aa76cac493cfDan Gohman } else { 31427920594b940d824038d16b13846aa76cac493cfDan Gohman // Block is last in function. 31527920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 31627920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB is last in function but is empty!", MBB); 31727920594b940d824038d16b13846aa76cac493cfDan Gohman } 31827920594b940d824038d16b13846aa76cac493cfDan Gohman } 31927920594b940d824038d16b13846aa76cac493cfDan Gohman 32027920594b940d824038d16b13846aa76cac493cfDan Gohman // Call AnalyzeBranch. If it succeeds, there several more conditions to check. 32127920594b940d824038d16b13846aa76cac493cfDan Gohman MachineBasicBlock *TBB = 0, *FBB = 0; 32227920594b940d824038d16b13846aa76cac493cfDan Gohman SmallVector<MachineOperand, 4> Cond; 32327920594b940d824038d16b13846aa76cac493cfDan Gohman if (!TII->AnalyzeBranch(*const_cast<MachineBasicBlock *>(MBB), 32427920594b940d824038d16b13846aa76cac493cfDan Gohman TBB, FBB, Cond)) { 32527920594b940d824038d16b13846aa76cac493cfDan Gohman // Ok, AnalyzeBranch thinks it knows what's going on with this block. Let's 32627920594b940d824038d16b13846aa76cac493cfDan Gohman // check whether its answers match up with reality. 32727920594b940d824038d16b13846aa76cac493cfDan Gohman if (!TBB && !FBB) { 32827920594b940d824038d16b13846aa76cac493cfDan Gohman // Block falls through to its successor. 32927920594b940d824038d16b13846aa76cac493cfDan Gohman MachineFunction::const_iterator MBBI = MBB; 33027920594b940d824038d16b13846aa76cac493cfDan Gohman ++MBBI; 33127920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBBI == MF->end()) { 332a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // It's possible that the block legitimately ends with a noreturn 333a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // call or an unreachable, in which case it won't actually fall 334a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // out the bottom of the function. 335a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman } else if (MBB->succ_empty()) { 336a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // It's possible that the block legitimately ends with a noreturn 337a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // call or an unreachable, in which case it won't actuall fall 338a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // out of the block. 33927920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (MBB->succ_size() != 1) { 34027920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but doesn't have " 34127920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly one CFG successor!", MBB); 34227920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (MBB->succ_begin()[0] != MBBI) { 34327920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but its successor " 34427920594b940d824038d16b13846aa76cac493cfDan Gohman "differs from its CFG successor!", MBB); 34527920594b940d824038d16b13846aa76cac493cfDan Gohman } 34627920594b940d824038d16b13846aa76cac493cfDan Gohman if (!MBB->empty() && MBB->back().getDesc().isBarrier()) { 34727920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but ends with a " 34827920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 34927920594b940d824038d16b13846aa76cac493cfDan Gohman } 35027920594b940d824038d16b13846aa76cac493cfDan Gohman if (!Cond.empty()) { 35127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but has a condition!", 35227920594b940d824038d16b13846aa76cac493cfDan Gohman MBB); 35327920594b940d824038d16b13846aa76cac493cfDan Gohman } 35427920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (TBB && !FBB && Cond.empty()) { 35527920594b940d824038d16b13846aa76cac493cfDan Gohman // Block unconditionally branches somewhere. 35627920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->succ_size() != 1) { 35727920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but doesn't have " 35827920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly one CFG successor!", MBB); 35927920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (MBB->succ_begin()[0] != TBB) { 36027920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but the CFG " 36127920594b940d824038d16b13846aa76cac493cfDan Gohman "successor doesn't match the actual successor!", MBB); 36227920594b940d824038d16b13846aa76cac493cfDan Gohman } 36327920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 36427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but doesn't contain " 36527920594b940d824038d16b13846aa76cac493cfDan Gohman "any instructions!", MBB); 36627920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (!MBB->back().getDesc().isBarrier()) { 36727920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but doesn't end with a " 36827920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 36927920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (!MBB->back().getDesc().isTerminator()) { 37027920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but the branch isn't a " 37127920594b940d824038d16b13846aa76cac493cfDan Gohman "terminator instruction!", MBB); 37227920594b940d824038d16b13846aa76cac493cfDan Gohman } 37327920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (TBB && !FBB && !Cond.empty()) { 37427920594b940d824038d16b13846aa76cac493cfDan Gohman // Block conditionally branches somewhere, otherwise falls through. 37527920594b940d824038d16b13846aa76cac493cfDan Gohman MachineFunction::const_iterator MBBI = MBB; 37627920594b940d824038d16b13846aa76cac493cfDan Gohman ++MBBI; 37727920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBBI == MF->end()) { 37827920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB conditionally falls through out of function!", MBB); 37927920594b940d824038d16b13846aa76cac493cfDan Gohman } if (MBB->succ_size() != 2) { 38027920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but doesn't have " 38127920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly two CFG successors!", MBB); 38227920594b940d824038d16b13846aa76cac493cfDan Gohman } else if ((MBB->succ_begin()[0] == TBB && MBB->succ_end()[1] == MBBI) || 38327920594b940d824038d16b13846aa76cac493cfDan Gohman (MBB->succ_begin()[1] == TBB && MBB->succ_end()[0] == MBBI)) { 38427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but the CFG " 38527920594b940d824038d16b13846aa76cac493cfDan Gohman "successors don't match the actual successors!", MBB); 38627920594b940d824038d16b13846aa76cac493cfDan Gohman } 38727920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 38827920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but doesn't " 38927920594b940d824038d16b13846aa76cac493cfDan Gohman "contain any instructions!", MBB); 39027920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (MBB->back().getDesc().isBarrier()) { 39127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but ends with a " 39227920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 39327920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (!MBB->back().getDesc().isTerminator()) { 39427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but the branch " 39527920594b940d824038d16b13846aa76cac493cfDan Gohman "isn't a terminator instruction!", MBB); 39627920594b940d824038d16b13846aa76cac493cfDan Gohman } 39727920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (TBB && FBB) { 39827920594b940d824038d16b13846aa76cac493cfDan Gohman // Block conditionally branches somewhere, otherwise branches 39927920594b940d824038d16b13846aa76cac493cfDan Gohman // somewhere else. 40027920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->succ_size() != 2) { 40127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but doesn't have " 40227920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly two CFG successors!", MBB); 40327920594b940d824038d16b13846aa76cac493cfDan Gohman } else if ((MBB->succ_begin()[0] == TBB && MBB->succ_end()[1] == FBB) || 40427920594b940d824038d16b13846aa76cac493cfDan Gohman (MBB->succ_begin()[1] == TBB && MBB->succ_end()[0] == FBB)) { 40527920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but the CFG " 40627920594b940d824038d16b13846aa76cac493cfDan Gohman "successors don't match the actual successors!", MBB); 40727920594b940d824038d16b13846aa76cac493cfDan Gohman } 40827920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 40927920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but doesn't " 41027920594b940d824038d16b13846aa76cac493cfDan Gohman "contain any instructions!", MBB); 41127920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (!MBB->back().getDesc().isBarrier()) { 41227920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but doesn't end with a " 41327920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 41427920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (!MBB->back().getDesc().isTerminator()) { 41527920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but the branch " 41627920594b940d824038d16b13846aa76cac493cfDan Gohman "isn't a terminator instruction!", MBB); 41727920594b940d824038d16b13846aa76cac493cfDan Gohman } 41827920594b940d824038d16b13846aa76cac493cfDan Gohman if (Cond.empty()) { 41927920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditinal branch/branch but there's no " 42027920594b940d824038d16b13846aa76cac493cfDan Gohman "condition!", MBB); 42127920594b940d824038d16b13846aa76cac493cfDan Gohman } 42227920594b940d824038d16b13846aa76cac493cfDan Gohman } else { 42327920594b940d824038d16b13846aa76cac493cfDan Gohman report("AnalyzeBranch returned invalid data!", MBB); 42427920594b940d824038d16b13846aa76cac493cfDan Gohman } 42527920594b940d824038d16b13846aa76cac493cfDan Gohman } 42627920594b940d824038d16b13846aa76cac493cfDan Gohman 42748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.clear(); 42848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_livein_iterator I = MBB->livein_begin(), 42948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen E = MBB->livein_end(); I != E; ++I) { 43048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!TargetRegisterInfo::isPhysicalRegister(*I)) { 43148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("MBB live-in list contains non-physical register", MBB); 43248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 43348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 43448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.insert(*I); 43548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (const unsigned *R = TRI->getSubRegisters(*I); *R; R++) 43648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.insert(*R); 43748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 438710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen regsLiveInButUnused = regsLive; 439a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen 440a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen const MachineFrameInfo *MFI = MF->getFrameInfo(); 441a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen assert(MFI && "Function has no frame info"); 442a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen BitVector PR = MFI->getPristineRegs(MBB); 443a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen for (int I = PR.find_first(); I>0; I = PR.find_next(I)) { 444a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen regsLive.insert(I); 445a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen for (const unsigned *R = TRI->getSubRegisters(I); *R; R++) 446a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen regsLive.insert(*R); 447a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen } 448a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen 44948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsKilled.clear(); 45048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsDefined.clear(); 45148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 45248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 453b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineInstrBefore(const MachineInstr *MI) { 45448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const TargetInstrDesc &TI = MI->getDesc(); 45539523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen if (MI->getNumOperands() < TI.getNumOperands()) { 45648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Too few operands", MI); 45748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << TI.getNumOperands() << " operands expected, but " 45848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << MI->getNumExplicitOperands() << " given.\n"; 45948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 46048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 46148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 46248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenvoid 463b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund OlesenMachineVerifier::visitMachineOperand(const MachineOperand *MO, unsigned MONum) { 46448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineInstr *MI = MO->getParent(); 46544b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen const TargetInstrDesc &TI = MI->getDesc(); 46644b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen 46744b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen // The first TI.NumDefs operands must be explicit register defines 46844b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen if (MONum < TI.getNumDefs()) { 46944b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen if (!MO->isReg()) 47044b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen report("Explicit definition must be a register", MO, MONum); 47144b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen else if (!MO->isDef()) 47244b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen report("Explicit definition marked as use", MO, MONum); 47344b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen else if (MO->isImplicit()) 47444b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen report("Explicit definition marked as implicit", MO, MONum); 47539523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen } else if (MONum < TI.getNumOperands()) { 47639523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen if (MO->isReg()) { 47739523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen if (MO->isDef()) 47839523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen report("Explicit operand marked as def", MO, MONum); 47939523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen if (MO->isImplicit()) 48039523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen report("Explicit operand marked as implicit", MO, MONum); 48139523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen } 48239523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen } else { 48339523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen if (MO->isReg() && !MO->isImplicit() && !TI.isVariadic()) 48439523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen report("Extra explicit operand on non-variadic instruction", MO, MONum); 48544b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen } 48644b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen 48748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen switch (MO->getType()) { 48848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen case MachineOperand::MO_Register: { 48948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const unsigned Reg = MO->getReg(); 49048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!Reg) 49148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return; 49248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 49348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Check Live Variables. 494710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen if (MO->isUndef()) { 495710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen // An <undef> doesn't refer to any register, so just skip it. 496710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen } else if (MO->isUse()) { 497710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen regsLiveInButUnused.erase(Reg); 498710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen 49948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (MO->isKill()) { 50048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen addRegWithSubRegs(regsKilled, Reg); 501f7d3e696a5f6e1f467ff107b6db75175887f4916Jakob Stoklund Olesen // Tied operands on two-address instuctions MUST NOT have a <kill> flag. 502f7d3e696a5f6e1f467ff107b6db75175887f4916Jakob Stoklund Olesen if (MI->isRegTiedToDefOperand(MONum)) 503f7d3e696a5f6e1f467ff107b6db75175887f4916Jakob Stoklund Olesen report("Illegal kill flag on two-address instruction operand", 504f7d3e696a5f6e1f467ff107b6db75175887f4916Jakob Stoklund Olesen MO, MONum); 50548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 506f7d3e696a5f6e1f467ff107b6db75175887f4916Jakob Stoklund Olesen // TwoAddress instr modifying a reg is treated as kill+def. 50748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned defIdx; 50848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (MI->isRegTiedToDefOperand(MONum, &defIdx) && 50948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MI->getOperand(defIdx).getReg() == Reg) 51048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen addRegWithSubRegs(regsKilled, Reg); 51148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 512710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen // Use of a dead register. 513710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen if (!regsLive.count(Reg)) { 51448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Reg)) { 51548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Reserved registers may be used even when 'dead'. 51648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!isReserved(Reg)) 51748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Using an undefined physical register", MO, MONum); 51848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 51948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MI->getParent()]; 52048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // We don't know which virtual registers are live in, so only complain 52148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // if vreg was killed in this MBB. Otherwise keep track of vregs that 52248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // must be live in. PHI instructions are handled separately. 52348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (MInfo.regsKilled.count(Reg)) 52448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Using a killed virtual register", MO, MONum); 52548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen else if (MI->getOpcode() != TargetInstrInfo::PHI) 52648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MInfo.vregsLiveIn.insert(std::make_pair(Reg, MI)); 52748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 528e556720ea8d60581c95d3ca3f9175a3688150d95Duncan Sands } 52948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 530710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen assert(MO->isDef()); 53148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Register defined. 53248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // TODO: verify that earlyclobber ops are not used. 53348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (MO->isDead()) 53448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen addRegWithSubRegs(regsDead, Reg); 535710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen else 536710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen addRegWithSubRegs(regsDefined, Reg); 53748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 53848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 53948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Check register classes. 54048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (MONum < TI.getNumOperands() && !MO->isImplicit()) { 54148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const TargetOperandInfo &TOI = TI.OpInfo[MONum]; 54248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned SubIdx = MO->getSubReg(); 54348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 54448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Reg)) { 54548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned sr = Reg; 54648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SubIdx) { 54748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned s = TRI->getSubReg(Reg, SubIdx); 54848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!s) { 54948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Invalid subregister index for physical register", 55048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MO, MONum); 55148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return; 55248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 55348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen sr = s; 55448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 555cb778a8634454c70d88955b3732f330a6cbe5b07Chris Lattner if (const TargetRegisterClass *DRC = TOI.getRegClass(TRI)) { 55648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!DRC->contains(sr)) { 55748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Illegal physical register for instruction", MO, MONum); 55848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << TRI->getName(sr) << " is not a " 55948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << DRC->getName() << " register.\n"; 56048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 56148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 56248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 56348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Virtual register. 56448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const TargetRegisterClass *RC = MRI->getRegClass(Reg); 56548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SubIdx) { 56648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (RC->subregclasses_begin()+SubIdx >= RC->subregclasses_end()) { 56748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Invalid subregister index for virtual register", MO, MONum); 56848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return; 56948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 57048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RC = *(RC->subregclasses_begin()+SubIdx); 57148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 572cb778a8634454c70d88955b3732f330a6cbe5b07Chris Lattner if (const TargetRegisterClass *DRC = TOI.getRegClass(TRI)) { 57348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (RC != DRC && !RC->hasSuperClass(DRC)) { 57448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Illegal virtual register for instruction", MO, MONum); 57548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "Expected a " << DRC->getName() << " register, but got a " 57648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << RC->getName() << " register\n"; 57748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 57848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 57948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 58048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 58148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen break; 58248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 583a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen 584a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen case MachineOperand::MO_MachineBasicBlock: 585a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen if (MI->getOpcode() == TargetInstrInfo::PHI) { 586a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen if (!MO->getMBB()->isSuccessor(MI->getParent())) 587a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen report("PHI operand is not in the CFG", MO, MONum); 588a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen } 589a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen break; 590a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen 59148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen default: 59248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen break; 59348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 59448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 59548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 596b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineInstrAfter(const MachineInstr *MI) { 59748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MI->getParent()]; 59848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen set_union(MInfo.regsKilled, regsKilled); 59948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen set_subtract(regsLive, regsKilled); 60048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsKilled.clear(); 60148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 602710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen // Verify that both <def> and <def,dead> operands refer to dead registers. 603710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen RegVector defs(regsDefined); 604710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen defs.append(regsDead.begin(), regsDead.end()); 605710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen 606710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen for (RegVector::const_iterator I = defs.begin(), E = defs.end(); 607710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen I != E; ++I) { 60848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (regsLive.count(*I)) { 60948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(*I)) { 610710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen if (!allowPhysDoubleDefs && !isReserved(*I) && 611710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen !regsLiveInButUnused.count(*I)) { 61248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Redefining a live physical register", MI); 61348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "Register " << TRI->getName(*I) 61448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " was defined but already live.\n"; 61548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 61648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 61748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!allowVirtDoubleDefs) { 61848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Redefining a live virtual register", MI); 61948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "Virtual register %reg" << *I 62048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " was defined but already live.\n"; 62148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 62248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 62348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else if (TargetRegisterInfo::isVirtualRegister(*I) && 62448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen !MInfo.regsKilled.count(*I)) { 62548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Virtual register defined without being killed first must be dead on 62648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // entry. 62748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MInfo.vregsDeadIn.insert(std::make_pair(*I, MI)); 62848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 62948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 63048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 63148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen set_subtract(regsLive, regsDead); regsDead.clear(); 632710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen set_union(regsLive, regsDefined); regsDefined.clear(); 63348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 63448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 63548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenvoid 636b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund OlesenMachineVerifier::visitMachineBasicBlockAfter(const MachineBasicBlock *MBB) { 63748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MBBInfoMap[MBB].regsLiveOut = regsLive; 63848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.clear(); 63948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 64048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 64148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Calculate the largest possible vregsPassed sets. These are the registers that 64248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// can pass through an MBB live, but may not be live every time. It is assumed 64348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// that all vregsPassed sets are empty before the call. 644b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::calcMaxRegsPassed() { 64548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // First push live-out regs to successors' vregsPassed. Remember the MBBs that 64648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // have any vregsPassed. 64748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen DenseSet<const MachineBasicBlock*> todo; 64848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF->begin(), MFE = MF->end(); 64948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI != MFE; ++MFI) { 65048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineBasicBlock &MBB(*MFI); 65148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[&MBB]; 65248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) 65348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 65448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator SuI = MBB.succ_begin(), 65548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen SuE = MBB.succ_end(); SuI != SuE; ++SuI) { 65648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &SInfo = MBBInfoMap[*SuI]; 65748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SInfo.addPassed(MInfo.regsLiveOut)) 65848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.insert(*SuI); 65948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 66048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 66148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 66248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Iteratively push vregsPassed to successors. This will converge to the same 66348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // final state regardless of DenseSet iteration order. 66448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen while (!todo.empty()) { 66548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineBasicBlock *MBB = *todo.begin(); 66648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.erase(MBB); 66748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MBB]; 66848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator SuI = MBB->succ_begin(), 66948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen SuE = MBB->succ_end(); SuI != SuE; ++SuI) { 67048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (*SuI == MBB) 67148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 67248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &SInfo = MBBInfoMap[*SuI]; 67348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SInfo.addPassed(MInfo.vregsPassed)) 67448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.insert(*SuI); 67548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 67648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 67748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 67848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 67948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Calculate the minimum vregsPassed set. These are the registers that always 68048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// pass live through an MBB. The calculation assumes that calcMaxRegsPassed has 68148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// been called earlier. 682b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::calcMinRegsPassed() { 68348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen DenseSet<const MachineBasicBlock*> todo; 68448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF->begin(), MFE = MF->end(); 68548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI != MFE; ++MFI) 68648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.insert(MFI); 68748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 68848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen while (!todo.empty()) { 68948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineBasicBlock *MBB = *todo.begin(); 69048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.erase(MBB); 69148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MBB]; 69248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 69348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Remove entries from vRegsPassed that are not live out from all 69448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // reachable predecessors. 69548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet dead; 69648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (RegSet::iterator I = MInfo.vregsPassed.begin(), 69748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen E = MInfo.vregsPassed.end(); I != E; ++I) { 69848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MBB->pred_begin(), 69948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen PrE = MBB->pred_end(); PrI != PrE; ++PrI) { 70048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &PrInfo = MBBInfoMap[*PrI]; 70148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (PrInfo.reachable && !PrInfo.isLiveOut(*I)) { 70248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen dead.insert(*I); 70348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen break; 70448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 70548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 70648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 70748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // If any regs removed, we need to recheck successors. 70848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!dead.empty()) { 70948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen set_subtract(MInfo.vregsPassed, dead); 71048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.insert(MBB->succ_begin(), MBB->succ_end()); 71148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 71248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 71348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 71448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 71548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Check PHI instructions at the beginning of MBB. It is assumed that 71648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// calcMinRegsPassed has been run so BBInfo::isLiveOut is valid. 717b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::checkPHIOps(const MachineBasicBlock *MBB) { 71848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_iterator BBI = MBB->begin(), BBE = MBB->end(); 71948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBI != BBE && BBI->getOpcode() == TargetInstrInfo::PHI; ++BBI) { 72048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen DenseSet<const MachineBasicBlock*> seen; 72148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 72248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (unsigned i = 1, e = BBI->getNumOperands(); i != e; i += 2) { 72348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned Reg = BBI->getOperand(i).getReg(); 72448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineBasicBlock *Pre = BBI->getOperand(i + 1).getMBB(); 72548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!Pre->isSuccessor(MBB)) 72648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 72748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen seen.insert(Pre); 72848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &PrInfo = MBBInfoMap[Pre]; 72948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (PrInfo.reachable && !PrInfo.isLiveOut(Reg)) 73048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("PHI operand is not live-out from predecessor", 73148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen &BBI->getOperand(i), i); 73248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 73348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 73448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Did we see all predecessors? 73548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MBB->pred_begin(), 73648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen PrE = MBB->pred_end(); PrI != PrE; ++PrI) { 73748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!seen.count(*PrI)) { 73848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Missing PHI operand", BBI); 73948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "MBB #" << (*PrI)->getNumber() 74048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " is a predecessor according to the CFG.\n"; 74148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 74248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 74348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 74448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 74548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 746b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineFunctionAfter() { 74748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen calcMaxRegsPassed(); 74848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 74948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // With the maximal set of vregsPassed we can verify dead-in registers. 75048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF->begin(), MFE = MF->end(); 75148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI != MFE; ++MFI) { 75248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MFI]; 75348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 75448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Skip unreachable MBBs. 75548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) 75648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 75748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 75848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MFI->pred_begin(), 75948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen PrE = MFI->pred_end(); PrI != PrE; ++PrI) { 76048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &PrInfo = MBBInfoMap[*PrI]; 76148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!PrInfo.reachable) 76248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 76348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 76448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Verify physical live-ins. EH landing pads have magic live-ins so we 76548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // ignore them. 76648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MFI->isLandingPad()) { 76748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_livein_iterator I = MFI->livein_begin(), 76848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen E = MFI->livein_end(); I != E; ++I) { 76948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(*I) && 770d6fb97761e65fd0db19cd48e22dd05d211822d47Jakob Stoklund Olesen !isReserved (*I) && !PrInfo.isLiveOut(*I)) { 77148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Live-in physical register is not live-out from predecessor", 77248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI); 77348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "Register " << TRI->getName(*I) 77448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " is not live-out from MBB #" << (*PrI)->getNumber() 77548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << ".\n"; 77648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 77748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 77848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 77948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 78048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 78148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Verify dead-in virtual registers. 78248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!allowVirtDoubleDefs) { 78348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (RegMap::iterator I = MInfo.vregsDeadIn.begin(), 78448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen E = MInfo.vregsDeadIn.end(); I != E; ++I) { 78548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // DeadIn register must be in neither regsLiveOut or vregsPassed of 78648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // any predecessor. 78748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (PrInfo.isLiveOut(I->first)) { 78848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Live-in virtual register redefined", I->second); 78948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "Register %reg" << I->first 79048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " was live-out from predecessor MBB #" 79148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << (*PrI)->getNumber() << ".\n"; 79248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 79348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 79448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 79548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 79648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 79748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 79848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen calcMinRegsPassed(); 79948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 80048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // With the minimal set of vregsPassed we can verify live-in virtual 80148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // registers, including PHI instructions. 80248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF->begin(), MFE = MF->end(); 80348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI != MFE; ++MFI) { 80448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MFI]; 80548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 80648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Skip unreachable MBBs. 80748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) 80848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 80948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 81048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen checkPHIOps(MFI); 81148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 81248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MFI->pred_begin(), 81348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen PrE = MFI->pred_end(); PrI != PrE; ++PrI) { 81448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &PrInfo = MBBInfoMap[*PrI]; 81548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!PrInfo.reachable) 81648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 81748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 81848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (RegMap::iterator I = MInfo.vregsLiveIn.begin(), 81948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen E = MInfo.vregsLiveIn.end(); I != E; ++I) { 82048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!PrInfo.isLiveOut(I->first)) { 82148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Used virtual register is not live-in", I->second); 82248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "Register %reg" << I->first 82348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " is not live-out from predecessor MBB #" 82448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << (*PrI)->getNumber() 82548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << ".\n"; 82648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 82748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 82848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 82948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 83048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 831