MachineVerifier.cpp revision f935e945c0fc0444324347882ac41104b12204c2
15567bb0c5fed4f769d51970b73465c82fe903162Bill Wendling//===-- MachineVerifier.cpp - Machine Code Verifier -----------------------===// 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 26d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling#include "llvm/Instructions.h" 2748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/Function.h" 281fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen#include "llvm/CodeGen/LiveIntervalAnalysis.h" 2948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/CodeGen/LiveVariables.h" 30e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen#include "llvm/CodeGen/LiveStackAnalysis.h" 3130e98a03a3c524026e2da2607e04bb655b0b6350Jakob Stoklund Olesen#include "llvm/CodeGen/MachineInstrBundle.h" 3248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/CodeGen/MachineFunctionPass.h" 33a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen#include "llvm/CodeGen/MachineFrameInfo.h" 342dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman#include "llvm/CodeGen/MachineMemOperand.h" 3548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/CodeGen/MachineRegisterInfo.h" 3648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/CodeGen/Passes.h" 37d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling#include "llvm/MC/MCAsmInfo.h" 3848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/Target/TargetMachine.h" 3948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/Target/TargetRegisterInfo.h" 4048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/Target/TargetInstrInfo.h" 41cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner#include "llvm/ADT/DenseSet.h" 42cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner#include "llvm/ADT/SetOperations.h" 43cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner#include "llvm/ADT/SmallVector.h" 4448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/Support/Debug.h" 457d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/ErrorHandling.h" 467d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/raw_ostream.h" 4748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenusing namespace llvm; 4848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 4948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesennamespace { 508f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen struct MachineVerifier { 5148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 5289cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen MachineVerifier(Pass *pass, const char *b) : 538f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen PASS(pass), 5489cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen Banner(b), 5548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen OutFileName(getenv("LLVM_VERIFY_MACHINEINSTRS")) 568f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen {} 5748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 5848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool runOnMachineFunction(MachineFunction &MF); 5948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 608f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen Pass *const PASS; 6189cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen const char *Banner; 6248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const char *const OutFileName; 6317e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner raw_ostream *OS; 6448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineFunction *MF; 6548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const TargetMachine *TM; 6615993f83a419950f06d2879d6701530ae6449317Evan Cheng const TargetInstrInfo *TII; 6748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const TargetRegisterInfo *TRI; 6848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineRegisterInfo *MRI; 6948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 7048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned foundErrors; 7148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 7248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen typedef SmallVector<unsigned, 16> RegVector; 739ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen typedef SmallVector<const uint32_t*, 4> RegMaskVector; 7448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen typedef DenseSet<unsigned> RegSet; 7548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen typedef DenseMap<unsigned, const MachineInstr*> RegMap; 7648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 775adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen const MachineInstr *FirstTerminator; 785adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen 7948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BitVector regsReserved; 8003698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames BitVector regsAllocatable; 8148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet regsLive; 82710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen RegVector regsDefined, regsDead, regsKilled; 839ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen RegMaskVector regMasks; 84710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen RegSet regsLiveInButUnused; 8548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 86fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen SlotIndex lastIndex; 87fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen 8848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Add Reg and any sub-registers to RV 8948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void addRegWithSubRegs(RegVector &RV, unsigned Reg) { 9048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RV.push_back(Reg); 9148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Reg)) 92396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen for (MCSubRegIterator SubRegs(Reg, TRI); SubRegs.isValid(); ++SubRegs) 93396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen RV.push_back(*SubRegs); 9448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 9548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 9648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen struct BBInfo { 9748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Is this MBB reachable from the MF entry point? 9848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool reachable; 9948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 10048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Vregs that must be live in because they are used without being 10148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // defined. Map value is the user. 10248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegMap vregsLiveIn; 10348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 10448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Regs killed in MBB. They may be defined again, and will then be in both 10548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // regsKilled and regsLiveOut. 10648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet regsKilled; 10748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 10848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Regs defined in MBB and live out. Note that vregs passing through may 10948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // be live out without being mentioned here. 11048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet regsLiveOut; 11148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 11248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Vregs that pass through MBB untouched. This set is disjoint from 11348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // regsKilled and regsLiveOut. 11448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet vregsPassed; 11548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 1168f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Vregs that must pass through MBB because they are needed by a successor 1178f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // block. This set is disjoint from regsLiveOut. 1188f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen RegSet vregsRequired; 1198f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 12048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo() : reachable(false) {} 12148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 12248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Add register to vregsPassed if it belongs there. Return true if 12348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // anything changed. 12448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool addPassed(unsigned Reg) { 12548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!TargetRegisterInfo::isVirtualRegister(Reg)) 12648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return false; 12748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (regsKilled.count(Reg) || regsLiveOut.count(Reg)) 12848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return false; 12948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return vregsPassed.insert(Reg).second; 13048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 13148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 13248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Same for a full set. 13348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool addPassed(const RegSet &RS) { 13448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool changed = false; 13548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (RegSet::const_iterator I = RS.begin(), E = RS.end(); I != E; ++I) 13648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (addPassed(*I)) 13748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen changed = true; 13848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return changed; 13948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 14048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 1418f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Add register to vregsRequired if it belongs there. Return true if 1428f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // anything changed. 1438f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool addRequired(unsigned Reg) { 1448f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (!TargetRegisterInfo::isVirtualRegister(Reg)) 1458f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return false; 1468f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (regsLiveOut.count(Reg)) 1478f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return false; 1488f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return vregsRequired.insert(Reg).second; 1498f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 1508f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 1518f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Same for a full set. 1528f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool addRequired(const RegSet &RS) { 1538f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool changed = false; 1548f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (RegSet::const_iterator I = RS.begin(), E = RS.end(); I != E; ++I) 1558f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (addRequired(*I)) 1568f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen changed = true; 1578f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return changed; 1588f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 1598f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 1608f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Same for a full map. 1618f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool addRequired(const RegMap &RM) { 1628f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool changed = false; 1638f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (RegMap::const_iterator I = RM.begin(), E = RM.end(); I != E; ++I) 1648f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (addRequired(I->first)) 1658f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen changed = true; 1668f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return changed; 1678f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 1688f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 16948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Live-out registers are either in regsLiveOut or vregsPassed. 17048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool isLiveOut(unsigned Reg) const { 17148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return regsLiveOut.count(Reg) || vregsPassed.count(Reg); 17248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 17348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen }; 17448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 17548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Extra register info per MBB. 17648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen DenseMap<const MachineBasicBlock*, BBInfo> MBBInfoMap; 17748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 17848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool isReserved(unsigned Reg) { 179d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen return Reg < regsReserved.size() && regsReserved.test(Reg); 18048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 18148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 18203698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames bool isAllocatable(unsigned Reg) { 18303698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames return Reg < regsAllocatable.size() && regsAllocatable.test(Reg); 18403698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames } 18503698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames 1868f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Analysis information if available 1878f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen LiveVariables *LiveVars; 188501dc4224586d3cee61101ed6cd0ccc8ba74c43cJakob Stoklund Olesen LiveIntervals *LiveInts; 189e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveStacks *LiveStks; 190f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen SlotIndexes *Indexes; 1918f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 19248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineFunctionBefore(); 19348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineBasicBlockBefore(const MachineBasicBlock *MBB); 1941f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen void visitMachineBundleBefore(const MachineInstr *MI); 19548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineInstrBefore(const MachineInstr *MI); 19648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineOperand(const MachineOperand *MO, unsigned MONum); 19748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineInstrAfter(const MachineInstr *MI); 1981f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen void visitMachineBundleAfter(const MachineInstr *MI); 19948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineBasicBlockAfter(const MachineBasicBlock *MBB); 20048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineFunctionAfter(); 20148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 20248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineFunction *MF); 20348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineBasicBlock *MBB); 20448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineInstr *MI); 20548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineOperand *MO, unsigned MONum); 20648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 207948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen void checkLiveness(const MachineOperand *MO, unsigned MONum); 20848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void markReachable(const MachineBasicBlock *MBB); 209b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen void calcRegsPassed(); 21048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void checkPHIOps(const MachineBasicBlock *MBB); 2118f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 2128f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen void calcRegsRequired(); 2138f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen void verifyLiveVariables(); 21458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen void verifyLiveIntervals(); 2158f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen }; 2168f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 2178f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen struct MachineVerifierPass : public MachineFunctionPass { 2188f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen static char ID; // Pass ID, replacement for typeid 21989cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen const char *const Banner; 2208f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 22189cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen MachineVerifierPass(const char *b = 0) 22289cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen : MachineFunctionPass(ID), Banner(b) { 223081c34b725980f995be9080eaec24cd3dfaaf065Owen Anderson initializeMachineVerifierPassPass(*PassRegistry::getPassRegistry()); 224081c34b725980f995be9080eaec24cd3dfaaf065Owen Anderson } 2258f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 2268f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen void getAnalysisUsage(AnalysisUsage &AU) const { 2278f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen AU.setPreservesAll(); 2288f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen MachineFunctionPass::getAnalysisUsage(AU); 2298f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 2308f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 2318f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool runOnMachineFunction(MachineFunction &MF) { 23289cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen MF.verify(this, Banner); 2338f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return false; 2348f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 23548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen }; 2368f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 23748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 23848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 2398f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesenchar MachineVerifierPass::ID = 0; 24002dd53e1c5b941ca5f60fca1b95ebcaf9ccd1dfcOwen AndersonINITIALIZE_PASS(MachineVerifierPass, "machineverifier", 241ce665bd2e2b581ab0858d1afe359192bac96b868Owen Anderson "Verify generated machine code", false, false) 24248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 24389cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund OlesenFunctionPass *llvm::createMachineVerifierPass(const char *Banner) { 24489cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen return new MachineVerifierPass(Banner); 24548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 24648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 24789cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesenvoid MachineFunction::verify(Pass *p, const char *Banner) const { 24889cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen MachineVerifier(p, Banner) 24989cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen .runOnMachineFunction(const_cast<MachineFunction&>(*this)); 250ce727d0da006ca59bbd8c9ddc86e2fa71217d293Jakob Stoklund Olesen} 251ce727d0da006ca59bbd8c9ddc86e2fa71217d293Jakob Stoklund Olesen 25217e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattnerbool MachineVerifier::runOnMachineFunction(MachineFunction &MF) { 25317e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner raw_ostream *OutFile = 0; 25448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (OutFileName) { 25517e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner std::string ErrorInfo; 25617e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner OutFile = new raw_fd_ostream(OutFileName, ErrorInfo, 25717e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner raw_fd_ostream::F_Append); 25817e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner if (!ErrorInfo.empty()) { 25917e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner errs() << "Error opening '" << OutFileName << "': " << ErrorInfo << '\n'; 26017e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner exit(1); 26117e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner } 262b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesen 26317e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner OS = OutFile; 26448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 26517e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner OS = &errs(); 26648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 26748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 26848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen foundErrors = 0; 26948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 27048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen this->MF = &MF; 27148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen TM = &MF.getTarget(); 27215993f83a419950f06d2879d6701530ae6449317Evan Cheng TII = TM->getInstrInfo(); 27348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen TRI = TM->getRegisterInfo(); 27448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MRI = &MF.getRegInfo(); 27548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 276c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen LiveVars = NULL; 277c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen LiveInts = NULL; 278e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveStks = NULL; 279f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen Indexes = NULL; 2808f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (PASS) { 2811fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen LiveInts = PASS->getAnalysisIfAvailable<LiveIntervals>(); 282c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen // We don't want to verify LiveVariables if LiveIntervals is available. 283c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen if (!LiveInts) 284c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen LiveVars = PASS->getAnalysisIfAvailable<LiveVariables>(); 285e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveStks = PASS->getAnalysisIfAvailable<LiveStacks>(); 286f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen Indexes = PASS->getAnalysisIfAvailable<SlotIndexes>(); 2878f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 2888f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 28948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineFunctionBefore(); 29048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF.begin(), MFE = MF.end(); 29148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI!=MFE; ++MFI) { 29248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineBasicBlockBefore(MFI); 2931f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen // Keep track of the current bundle header. 2941f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen const MachineInstr *CurBundle = 0; 295ddfd1377d2e4154d44dc3ad217735adc15af2e3fEvan Cheng for (MachineBasicBlock::const_instr_iterator MBBI = MFI->instr_begin(), 296ddfd1377d2e4154d44dc3ad217735adc15af2e3fEvan Cheng MBBE = MFI->instr_end(); MBBI != MBBE; ++MBBI) { 2977bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen if (MBBI->getParent() != MFI) { 2987bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen report("Bad instruction parent pointer", MFI); 2997bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen *OS << "Instruction: " << *MBBI; 3007bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen continue; 3017bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen } 3021f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen // Is this a bundle header? 3031f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen if (!MBBI->isInsideBundle()) { 3041f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen if (CurBundle) 3051f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen visitMachineBundleAfter(CurBundle); 3061f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen CurBundle = MBBI; 3071f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen visitMachineBundleBefore(CurBundle); 3081f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen } else if (!CurBundle) 3091f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen report("No bundle header", MBBI); 31048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineInstrBefore(MBBI); 31148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (unsigned I = 0, E = MBBI->getNumOperands(); I != E; ++I) 31248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineOperand(&MBBI->getOperand(I), I); 31348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineInstrAfter(MBBI); 31448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 3151f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen if (CurBundle) 3161f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen visitMachineBundleAfter(CurBundle); 31748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineBasicBlockAfter(MFI); 31848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 31948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineFunctionAfter(); 32048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 32117e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner if (OutFile) 32217e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner delete OutFile; 32317e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner else if (foundErrors) 32475361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("Found "+Twine(foundErrors)+" machine code errors."); 32548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 3266349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen // Clean up. 3276349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsLive.clear(); 3286349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsDefined.clear(); 3296349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsDead.clear(); 3306349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsKilled.clear(); 3319ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen regMasks.clear(); 3326349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsLiveInButUnused.clear(); 3336349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen MBBInfoMap.clear(); 3346349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen 33548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return false; // no changes 33648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 33748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 338372fefe8d24e40df2390fffeea0dc2dec611f88bChris Lattnervoid MachineVerifier::report(const char *msg, const MachineFunction *MF) { 33948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MF); 34017e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner *OS << '\n'; 34189cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen if (!foundErrors++) { 34289cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen if (Banner) 34389cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen *OS << "# " << Banner << '\n'; 344f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen MF->print(*OS, Indexes); 34589cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen } 34648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "*** Bad machine code: " << msg << " ***\n" 347a7b0cb759433c715065440ee2a963a04db7f2b0bBenjamin Kramer << "- function: " << MF->getFunction()->getName() << "\n"; 34848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 34948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 350b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, const MachineBasicBlock *MBB) { 35148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MBB); 35248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report(msg, MBB->getParent()); 353324da7647cfc3025e0c987176f0a300f9f780e6fJakob Stoklund Olesen *OS << "- basic block: " << MBB->getName() 35448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " " << (void*)MBB 355f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen << " (BB#" << MBB->getNumber() << ")"; 356f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen if (Indexes) 357f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen *OS << " [" << Indexes->getMBBStartIdx(MBB) 358f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen << ';' << Indexes->getMBBEndIdx(MBB) << ')'; 359f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen *OS << '\n'; 36048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 36148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 362b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, const MachineInstr *MI) { 36348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MI); 36448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report(msg, MI->getParent()); 36548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "- instruction: "; 366f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen if (Indexes && Indexes->hasIndex(MI)) 367f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen *OS << Indexes->getInstructionIndex(MI) << '\t'; 368705e07f578e2b3af47ddab610feb4e7f2d3063a5Chris Lattner MI->print(*OS, TM); 36948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 37048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 371b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, 372b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesen const MachineOperand *MO, unsigned MONum) { 37348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MO); 37448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report(msg, MO->getParent()); 37548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "- operand " << MONum << ": "; 37648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MO->print(*OS, TM); 37748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "\n"; 37848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 37948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 380b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::markReachable(const MachineBasicBlock *MBB) { 38148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MBB]; 38248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) { 38348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MInfo.reachable = true; 38448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator SuI = MBB->succ_begin(), 38548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen SuE = MBB->succ_end(); SuI != SuE; ++SuI) 38648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen markReachable(*SuI); 38748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 38848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 38948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 390b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineFunctionBefore() { 391fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen lastIndex = SlotIndex(); 39248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsReserved = TRI->getReservedRegs(*MF); 393d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen 394d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen // A sub-register of a reserved register is also reserved 395d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen for (int Reg = regsReserved.find_first(); Reg>=0; 396d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen Reg = regsReserved.find_next(Reg)) { 397396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen for (MCSubRegIterator SubRegs(Reg, TRI); SubRegs.isValid(); ++SubRegs) { 398d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen // FIXME: This should probably be: 399396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen // assert(regsReserved.test(*SubRegs) && "Non-reserved sub-register"); 400396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen regsReserved.set(*SubRegs); 401d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen } 402d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen } 40303698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames 40403698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames regsAllocatable = TRI->getAllocatableSet(*MF); 40503698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames 40648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen markReachable(&MF->front()); 40748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 40848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 4091dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen// Does iterator point to a and b as the first two elements? 410b35798347ea87b8b6d36155b211016a7769f01abDan Gohmanstatic bool matchPair(MachineBasicBlock::const_succ_iterator i, 411b35798347ea87b8b6d36155b211016a7769f01abDan Gohman const MachineBasicBlock *a, const MachineBasicBlock *b) { 4121dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen if (*i == a) 4131dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen return *++i == b; 4141dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen if (*i == b) 4151dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen return *++i == a; 4161dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen return false; 4171dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen} 4181dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen 4191dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesenvoid 4201dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund OlesenMachineVerifier::visitMachineBasicBlockBefore(const MachineBasicBlock *MBB) { 4215adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen FirstTerminator = 0; 4225adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen 42303698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames if (MRI->isSSA()) { 42403698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames // If this block has allocatable physical registers live-in, check that 42503698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames // it is an entry block or landing pad. 42603698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames for (MachineBasicBlock::livein_iterator LI = MBB->livein_begin(), 42703698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames LE = MBB->livein_end(); 42803698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames LI != LE; ++LI) { 42903698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames unsigned reg = *LI; 43003698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames if (isAllocatable(reg) && !MBB->isLandingPad() && 43103698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames MBB != MBB->getParent()->begin()) { 43203698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames report("MBB has allocable live-in, but isn't entry or landing-pad.", MBB); 43303698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames } 43403698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames } 43503698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames } 43603698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames 4370a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen // Count the number of landing pad successors. 4382100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich SmallPtrSet<MachineBasicBlock*, 4> LandingPadSuccs; 4390a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator I = MBB->succ_begin(), 4402100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich E = MBB->succ_end(); I != E; ++I) { 4412100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich if ((*I)->isLandingPad()) 4422100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich LandingPadSuccs.insert(*I); 4432100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich } 444d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling 445d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling const MCAsmInfo *AsmInfo = TM->getMCAsmInfo(); 446d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling const BasicBlock *BB = MBB->getBasicBlock(); 447d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling if (LandingPadSuccs.size() > 1 && 448d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling !(AsmInfo && 449d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling AsmInfo->getExceptionHandlingType() == ExceptionHandling::SjLj && 450d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling BB && isa<SwitchInst>(BB->getTerminator()))) 4510a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen report("MBB has more than one landing pad successor", MBB); 4520a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen 45327920594b940d824038d16b13846aa76cac493cfDan Gohman // Call AnalyzeBranch. If it succeeds, there several more conditions to check. 45427920594b940d824038d16b13846aa76cac493cfDan Gohman MachineBasicBlock *TBB = 0, *FBB = 0; 45527920594b940d824038d16b13846aa76cac493cfDan Gohman SmallVector<MachineOperand, 4> Cond; 45627920594b940d824038d16b13846aa76cac493cfDan Gohman if (!TII->AnalyzeBranch(*const_cast<MachineBasicBlock *>(MBB), 45727920594b940d824038d16b13846aa76cac493cfDan Gohman TBB, FBB, Cond)) { 45827920594b940d824038d16b13846aa76cac493cfDan Gohman // Ok, AnalyzeBranch thinks it knows what's going on with this block. Let's 45927920594b940d824038d16b13846aa76cac493cfDan Gohman // check whether its answers match up with reality. 46027920594b940d824038d16b13846aa76cac493cfDan Gohman if (!TBB && !FBB) { 46127920594b940d824038d16b13846aa76cac493cfDan Gohman // Block falls through to its successor. 46227920594b940d824038d16b13846aa76cac493cfDan Gohman MachineFunction::const_iterator MBBI = MBB; 46327920594b940d824038d16b13846aa76cac493cfDan Gohman ++MBBI; 46427920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBBI == MF->end()) { 465a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // It's possible that the block legitimately ends with a noreturn 466a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // call or an unreachable, in which case it won't actually fall 467a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // out the bottom of the function. 4682100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich } else if (MBB->succ_size() == LandingPadSuccs.size()) { 469a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // It's possible that the block legitimately ends with a noreturn 470a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // call or an unreachable, in which case it won't actuall fall 471a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // out of the block. 4722100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich } else if (MBB->succ_size() != 1+LandingPadSuccs.size()) { 47327920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but doesn't have " 47427920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly one CFG successor!", MBB); 4750a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen } else if (!MBB->isSuccessor(MBBI)) { 47627920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but its successor " 47727920594b940d824038d16b13846aa76cac493cfDan Gohman "differs from its CFG successor!", MBB); 47827920594b940d824038d16b13846aa76cac493cfDan Gohman } 4796b0cd9b9c65dc8c91827ddd926e050738ea590fdAkira Hatanaka if (!MBB->empty() && getBundleStart(&MBB->back())->isBarrier() && 4806b0cd9b9c65dc8c91827ddd926e050738ea590fdAkira Hatanaka !TII->isPredicated(getBundleStart(&MBB->back()))) { 48127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but ends with a " 48227920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 48327920594b940d824038d16b13846aa76cac493cfDan Gohman } 48427920594b940d824038d16b13846aa76cac493cfDan Gohman if (!Cond.empty()) { 48527920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but has a condition!", 48627920594b940d824038d16b13846aa76cac493cfDan Gohman MBB); 48727920594b940d824038d16b13846aa76cac493cfDan Gohman } 48827920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (TBB && !FBB && Cond.empty()) { 48927920594b940d824038d16b13846aa76cac493cfDan Gohman // Block unconditionally branches somewhere. 4902100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich if (MBB->succ_size() != 1+LandingPadSuccs.size()) { 49127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but doesn't have " 49227920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly one CFG successor!", MBB); 4930a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen } else if (!MBB->isSuccessor(TBB)) { 49427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but the CFG " 49527920594b940d824038d16b13846aa76cac493cfDan Gohman "successor doesn't match the actual successor!", MBB); 49627920594b940d824038d16b13846aa76cac493cfDan Gohman } 49727920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 49827920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but doesn't contain " 49927920594b940d824038d16b13846aa76cac493cfDan Gohman "any instructions!", MBB); 5006b0cd9b9c65dc8c91827ddd926e050738ea590fdAkira Hatanaka } else if (!getBundleStart(&MBB->back())->isBarrier()) { 50127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but doesn't end with a " 50227920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 5036b0cd9b9c65dc8c91827ddd926e050738ea590fdAkira Hatanaka } else if (!getBundleStart(&MBB->back())->isTerminator()) { 50427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but the branch isn't a " 50527920594b940d824038d16b13846aa76cac493cfDan Gohman "terminator instruction!", MBB); 50627920594b940d824038d16b13846aa76cac493cfDan Gohman } 50727920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (TBB && !FBB && !Cond.empty()) { 50827920594b940d824038d16b13846aa76cac493cfDan Gohman // Block conditionally branches somewhere, otherwise falls through. 50927920594b940d824038d16b13846aa76cac493cfDan Gohman MachineFunction::const_iterator MBBI = MBB; 51027920594b940d824038d16b13846aa76cac493cfDan Gohman ++MBBI; 51127920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBBI == MF->end()) { 51227920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB conditionally falls through out of function!", MBB); 51327920594b940d824038d16b13846aa76cac493cfDan Gohman } if (MBB->succ_size() != 2) { 51427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but doesn't have " 51527920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly two CFG successors!", MBB); 5161dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen } else if (!matchPair(MBB->succ_begin(), TBB, MBBI)) { 51727920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but the CFG " 51827920594b940d824038d16b13846aa76cac493cfDan Gohman "successors don't match the actual successors!", MBB); 51927920594b940d824038d16b13846aa76cac493cfDan Gohman } 52027920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 52127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but doesn't " 52227920594b940d824038d16b13846aa76cac493cfDan Gohman "contain any instructions!", MBB); 5236b0cd9b9c65dc8c91827ddd926e050738ea590fdAkira Hatanaka } else if (getBundleStart(&MBB->back())->isBarrier()) { 52427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but ends with a " 52527920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 5266b0cd9b9c65dc8c91827ddd926e050738ea590fdAkira Hatanaka } else if (!getBundleStart(&MBB->back())->isTerminator()) { 52727920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but the branch " 52827920594b940d824038d16b13846aa76cac493cfDan Gohman "isn't a terminator instruction!", MBB); 52927920594b940d824038d16b13846aa76cac493cfDan Gohman } 53027920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (TBB && FBB) { 53127920594b940d824038d16b13846aa76cac493cfDan Gohman // Block conditionally branches somewhere, otherwise branches 53227920594b940d824038d16b13846aa76cac493cfDan Gohman // somewhere else. 53327920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->succ_size() != 2) { 53427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but doesn't have " 53527920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly two CFG successors!", MBB); 5361dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen } else if (!matchPair(MBB->succ_begin(), TBB, FBB)) { 53727920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but the CFG " 53827920594b940d824038d16b13846aa76cac493cfDan Gohman "successors don't match the actual successors!", MBB); 53927920594b940d824038d16b13846aa76cac493cfDan Gohman } 54027920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 54127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but doesn't " 54227920594b940d824038d16b13846aa76cac493cfDan Gohman "contain any instructions!", MBB); 5436b0cd9b9c65dc8c91827ddd926e050738ea590fdAkira Hatanaka } else if (!getBundleStart(&MBB->back())->isBarrier()) { 54427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but doesn't end with a " 54527920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 5466b0cd9b9c65dc8c91827ddd926e050738ea590fdAkira Hatanaka } else if (!getBundleStart(&MBB->back())->isTerminator()) { 54727920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but the branch " 54827920594b940d824038d16b13846aa76cac493cfDan Gohman "isn't a terminator instruction!", MBB); 54927920594b940d824038d16b13846aa76cac493cfDan Gohman } 55027920594b940d824038d16b13846aa76cac493cfDan Gohman if (Cond.empty()) { 55127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditinal branch/branch but there's no " 55227920594b940d824038d16b13846aa76cac493cfDan Gohman "condition!", MBB); 55327920594b940d824038d16b13846aa76cac493cfDan Gohman } 55427920594b940d824038d16b13846aa76cac493cfDan Gohman } else { 55527920594b940d824038d16b13846aa76cac493cfDan Gohman report("AnalyzeBranch returned invalid data!", MBB); 55627920594b940d824038d16b13846aa76cac493cfDan Gohman } 55727920594b940d824038d16b13846aa76cac493cfDan Gohman } 55827920594b940d824038d16b13846aa76cac493cfDan Gohman 55948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.clear(); 56081bf03eb5cd68243eabb52505105aa5f4a831bf3Dan Gohman for (MachineBasicBlock::livein_iterator I = MBB->livein_begin(), 56148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen E = MBB->livein_end(); I != E; ++I) { 56248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!TargetRegisterInfo::isPhysicalRegister(*I)) { 56348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("MBB live-in list contains non-physical register", MBB); 56448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 56548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 56648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.insert(*I); 567396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen for (MCSubRegIterator SubRegs(*I, TRI); SubRegs.isValid(); ++SubRegs) 568396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen regsLive.insert(*SubRegs); 56948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 570710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen regsLiveInButUnused = regsLive; 571a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen 572a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen const MachineFrameInfo *MFI = MF->getFrameInfo(); 573a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen assert(MFI && "Function has no frame info"); 574a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen BitVector PR = MFI->getPristineRegs(MBB); 575a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen for (int I = PR.find_first(); I>0; I = PR.find_next(I)) { 576a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen regsLive.insert(I); 577396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen for (MCSubRegIterator SubRegs(I, TRI); SubRegs.isValid(); ++SubRegs) 578396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen regsLive.insert(*SubRegs); 579a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen } 580a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen 58148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsKilled.clear(); 58248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsDefined.clear(); 583fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen 584fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen if (Indexes) 585fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen lastIndex = Indexes->getMBBStartIdx(MBB); 58648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 58748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 5881f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen// This function gets called for all bundle headers, including normal 5891f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen// stand-alone unbundled instructions. 5901f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesenvoid MachineVerifier::visitMachineBundleBefore(const MachineInstr *MI) { 5911f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen if (Indexes && Indexes->hasIndex(MI)) { 5921f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen SlotIndex idx = Indexes->getInstructionIndex(MI); 5931f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen if (!(idx > lastIndex)) { 5941f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen report("Instruction index out of order", MI); 5951f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen *OS << "Last instruction was at " << lastIndex << '\n'; 5961f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen } 5971f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen lastIndex = idx; 5981f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen } 59983569cb062930a62e96ba87a47b002366e00124dPete Cooper 60083569cb062930a62e96ba87a47b002366e00124dPete Cooper // Ensure non-terminators don't follow terminators. 60183569cb062930a62e96ba87a47b002366e00124dPete Cooper // Ignore predicated terminators formed by if conversion. 60283569cb062930a62e96ba87a47b002366e00124dPete Cooper // FIXME: If conversion shouldn't need to violate this rule. 60383569cb062930a62e96ba87a47b002366e00124dPete Cooper if (MI->isTerminator() && !TII->isPredicated(MI)) { 60483569cb062930a62e96ba87a47b002366e00124dPete Cooper if (!FirstTerminator) 60583569cb062930a62e96ba87a47b002366e00124dPete Cooper FirstTerminator = MI; 60683569cb062930a62e96ba87a47b002366e00124dPete Cooper } else if (FirstTerminator) { 60783569cb062930a62e96ba87a47b002366e00124dPete Cooper report("Non-terminator instruction after the first terminator", MI); 60883569cb062930a62e96ba87a47b002366e00124dPete Cooper *OS << "First terminator was:\t" << *FirstTerminator; 60983569cb062930a62e96ba87a47b002366e00124dPete Cooper } 6101f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen} 6111f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen 612b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineInstrBefore(const MachineInstr *MI) { 613e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &MCID = MI->getDesc(); 614e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MI->getNumOperands() < MCID.getNumOperands()) { 61548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Too few operands", MI); 616e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng *OS << MCID.getNumOperands() << " operands expected, but " 61748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << MI->getNumExplicitOperands() << " given.\n"; 61848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 6192dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman 6202dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman // Check the MachineMemOperands for basic consistency. 6212dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman for (MachineInstr::mmo_iterator I = MI->memoperands_begin(), 6222dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman E = MI->memoperands_end(); I != E; ++I) { 6235a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if ((*I)->isLoad() && !MI->mayLoad()) 6242dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman report("Missing mayLoad flag", MI); 6255a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if ((*I)->isStore() && !MI->mayStore()) 6262dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman report("Missing mayStore flag", MI); 6272dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman } 6281fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen 6291fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen // Debug values must not have a slot index. 630121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // Other instructions must have one, unless they are inside a bundle. 6311fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (LiveInts) { 6321fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen bool mapped = !LiveInts->isNotInMIMap(MI); 6331fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (MI->isDebugValue()) { 6341fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (mapped) 6351fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen report("Debug instruction has a slot index", MI); 636121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } else if (MI->isInsideBundle()) { 637121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (mapped) 638121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Instruction inside bundle has a slot index", MI); 6391fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } else { 6401fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (!mapped) 6411fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen report("Missing slot index", MI); 6421fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 6431fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 6441fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen 6453be654f8082dcbdff011a6716a7c90486e28fc9eAndrew Trick StringRef ErrorInfo; 6463be654f8082dcbdff011a6716a7c90486e28fc9eAndrew Trick if (!TII->verifyInstruction(MI, ErrorInfo)) 6473be654f8082dcbdff011a6716a7c90486e28fc9eAndrew Trick report(ErrorInfo.data(), MI); 64848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 64948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 65048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenvoid 651b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund OlesenMachineVerifier::visitMachineOperand(const MachineOperand *MO, unsigned MONum) { 65248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineInstr *MI = MO->getParent(); 653e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &MCID = MI->getDesc(); 654e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCOperandInfo &MCOI = MCID.OpInfo[MONum]; 65544b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen 656e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng // The first MCID.NumDefs operands must be explicit register defines 657e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MONum < MCID.getNumDefs()) { 65844b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen if (!MO->isReg()) 65944b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen report("Explicit definition must be a register", MO, MONum); 660cac58aa80ea9450d5e5b0499ac598b646f419b51Evan Cheng else if (!MO->isDef() && !MCOI.isOptionalDef()) 66144b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen report("Explicit definition marked as use", MO, MONum); 66244b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen else if (MO->isImplicit()) 66344b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen report("Explicit definition marked as implicit", MO, MONum); 664e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng } else if (MONum < MCID.getNumOperands()) { 665113a06cff443f5d73c4f1f89bd31b0efb4222227Eric Christopher // Don't check if it's the last operand in a variadic instruction. See, 666113a06cff443f5d73c4f1f89bd31b0efb4222227Eric Christopher // e.g., LDM_RET in the arm back end. 667e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MO->isReg() && 6685a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng !(MI->isVariadic() && MONum == MCID.getNumOperands()-1)) { 669e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MO->isDef() && !MCOI.isOptionalDef()) 67022d67cf6ac84c06867681a2fe72f78d5d2b9444dCameron Zwarich report("Explicit operand marked as def", MO, MONum); 67139523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen if (MO->isImplicit()) 67239523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen report("Explicit operand marked as implicit", MO, MONum); 67339523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen } 67439523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen } else { 6755711564b091c39188775aee2768ad36a9b9a99b2Jakob Stoklund Olesen // ARM adds %reg0 operands to indicate predicates. We'll allow that. 6765a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (MO->isReg() && !MO->isImplicit() && !MI->isVariadic() && MO->getReg()) 67739523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen report("Extra explicit operand on non-variadic instruction", MO, MONum); 67844b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen } 67944b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen 68048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen switch (MO->getType()) { 68148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen case MachineOperand::MO_Register: { 68248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const unsigned Reg = MO->getReg(); 68348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!Reg) 68448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return; 685948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MRI->tracksLiveness() && !MI->isDebugValue()) 686948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen checkLiveness(MO, MONum); 68748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 68848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 68948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Check register classes. 690e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MONum < MCID.getNumOperands() && !MO->isImplicit()) { 69148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned SubIdx = MO->getSubReg(); 69248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 69348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Reg)) { 69448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SubIdx) { 695b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen report("Illegal subregister index for physical register", MO, MONum); 696b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen return; 69748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 698397fc4874efe9c17e737d4c5c50bd19dc3bf27f5Jakob Stoklund Olesen if (const TargetRegisterClass *DRC = 699397fc4874efe9c17e737d4c5c50bd19dc3bf27f5Jakob Stoklund Olesen TII->getRegClass(MCID, MONum, TRI, *MF)) { 700b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (!DRC->contains(Reg)) { 70148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Illegal physical register for instruction", MO, MONum); 702b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen *OS << TRI->getName(Reg) << " is not a " 70348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << DRC->getName() << " register.\n"; 70448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 70548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 70648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 70748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Virtual register. 70848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const TargetRegisterClass *RC = MRI->getRegClass(Reg); 70948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SubIdx) { 710b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen const TargetRegisterClass *SRC = 711b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen TRI->getSubClassWithSubReg(RC, SubIdx); 7126a8d2c6119aeb32ac914c3dd9b1263ebd0baa51fJakob Stoklund Olesen if (!SRC) { 71348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Invalid subregister index for virtual register", MO, MONum); 7146a8d2c6119aeb32ac914c3dd9b1263ebd0baa51fJakob Stoklund Olesen *OS << "Register class " << RC->getName() 7156a8d2c6119aeb32ac914c3dd9b1263ebd0baa51fJakob Stoklund Olesen << " does not support subreg index " << SubIdx << "\n"; 71648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return; 71748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 718b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (RC != SRC) { 719b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen report("Invalid register class for subregister index", MO, MONum); 720b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen *OS << "Register class " << RC->getName() 721b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen << " does not fully support subreg index " << SubIdx << "\n"; 722b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen return; 723b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen } 72448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 725397fc4874efe9c17e737d4c5c50bd19dc3bf27f5Jakob Stoklund Olesen if (const TargetRegisterClass *DRC = 726397fc4874efe9c17e737d4c5c50bd19dc3bf27f5Jakob Stoklund Olesen TII->getRegClass(MCID, MONum, TRI, *MF)) { 727b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (SubIdx) { 728b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen const TargetRegisterClass *SuperRC = 729b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen TRI->getLargestLegalSuperClass(RC); 730b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (!SuperRC) { 731b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen report("No largest legal super class exists.", MO, MONum); 732b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen return; 733b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen } 734b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen DRC = TRI->getMatchingSuperRegClass(SuperRC, DRC, SubIdx); 735b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (!DRC) { 736b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen report("No matching super-reg register class.", MO, MONum); 737b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen return; 738b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen } 739b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen } 740fa226bccaa90c520cac154df74069bbabb976eabJakob Stoklund Olesen if (!RC->hasSuperClassEq(DRC)) { 74148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Illegal virtual register for instruction", MO, MONum); 74248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "Expected a " << DRC->getName() << " register, but got a " 74348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << RC->getName() << " register\n"; 74448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 74548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 74648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 74748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 74848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen break; 74948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 750a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen 7519ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen case MachineOperand::MO_RegisterMask: 7529ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen regMasks.push_back(MO->getRegMask()); 7539ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen break; 7549ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen 755a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen case MachineOperand::MO_MachineBasicBlock: 756518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner if (MI->isPHI() && !MO->getMBB()->isSuccessor(MI->getParent())) 757518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner report("PHI operand is not in the CFG", MO, MONum); 758a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen break; 759a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen 760e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen case MachineOperand::MO_FrameIndex: 761e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen if (LiveStks && LiveStks->hasInterval(MO->getIndex()) && 762e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveInts && !LiveInts->isNotInMIMap(MI)) { 763e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveInterval &LI = LiveStks->getInterval(MO->getIndex()); 764e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen SlotIndex Idx = LiveInts->getInstructionIndex(MI); 7655a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (MI->mayLoad() && !LI.liveAt(Idx.getRegSlot(true))) { 766e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen report("Instruction loads from dead spill slot", MO, MONum); 767e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen *OS << "Live stack: " << LI << '\n'; 768e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen } 7695a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (MI->mayStore() && !LI.liveAt(Idx.getRegSlot())) { 770e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen report("Instruction stores to dead spill slot", MO, MONum); 771e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen *OS << "Live stack: " << LI << '\n'; 772e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen } 773e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen } 774e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen break; 775e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen 77648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen default: 77748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen break; 77848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 77948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 78048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 781948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesenvoid MachineVerifier::checkLiveness(const MachineOperand *MO, unsigned MONum) { 782948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen const MachineInstr *MI = MO->getParent(); 783948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen const unsigned Reg = MO->getReg(); 784948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 785948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Both use and def operands can read a register. 786948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MO->readsReg()) { 787948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen regsLiveInButUnused.erase(Reg); 788948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 789948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen bool isKill = false; 790948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen unsigned defIdx; 791948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MI->isRegTiedToDefOperand(MONum, &defIdx)) { 792948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // A two-addr use counts as a kill if use and def are the same. 793948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen unsigned DefReg = MI->getOperand(defIdx).getReg(); 794948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (Reg == DefReg) 795948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen isKill = true; 796948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen else if (TargetRegisterInfo::isPhysicalRegister(Reg)) { 797948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Two-address instruction operands must be identical", MO, MONum); 798948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 799948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } else 800948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen isKill = MO->isKill(); 801948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 802948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (isKill) 803948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen addRegWithSubRegs(regsKilled, Reg); 804948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 805948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Check that LiveVars knows this kill. 806948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (LiveVars && TargetRegisterInfo::isVirtualRegister(Reg) && 807948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen MO->isKill()) { 808948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen LiveVariables::VarInfo &VI = LiveVars->getVarInfo(Reg); 809948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (std::find(VI.Kills.begin(), VI.Kills.end(), MI) == VI.Kills.end()) 810948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Kill missing from LiveVariables", MO, MONum); 811948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 812948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 813948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Check LiveInts liveness and kill. 814948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(Reg) && 815948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen LiveInts && !LiveInts->isNotInMIMap(MI)) { 816948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen SlotIndex UseIdx = LiveInts->getInstructionIndex(MI).getRegSlot(true); 817948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (LiveInts->hasInterval(Reg)) { 818948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen const LiveInterval &LI = LiveInts->getInterval(Reg); 819948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (!LI.liveAt(UseIdx)) { 820948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("No live range at use", MO, MONum); 821948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen *OS << UseIdx << " is not live in " << LI << '\n'; 822948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 823948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Check for extra kill flags. 824948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Note that we allow missing kill flags for now. 825948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MO->isKill() && !LI.killedAt(UseIdx.getRegSlot())) { 826948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Live range continues after kill flag", MO, MONum); 827948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen *OS << "Live range: " << LI << '\n'; 828948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 829948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } else { 830948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Virtual register has no Live interval", MO, MONum); 831948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 832948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 833948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 834948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Use of a dead register. 835948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (!regsLive.count(Reg)) { 836948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Reg)) { 837948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Reserved registers may be used even when 'dead'. 838948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (!isReserved(Reg)) 839948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Using an undefined physical register", MO, MONum); 840948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } else { 841948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MI->getParent()]; 842948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // We don't know which virtual registers are live in, so only complain 843948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // if vreg was killed in this MBB. Otherwise keep track of vregs that 844948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // must be live in. PHI instructions are handled separately. 845948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MInfo.regsKilled.count(Reg)) 846948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Using a killed virtual register", MO, MONum); 847948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen else if (!MI->isPHI()) 848948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen MInfo.vregsLiveIn.insert(std::make_pair(Reg, MI)); 849948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 850948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 851948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 852948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 853948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MO->isDef()) { 854948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Register defined. 855948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // TODO: verify that earlyclobber ops are not used. 856948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MO->isDead()) 857948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen addRegWithSubRegs(regsDead, Reg); 858948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen else 859948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen addRegWithSubRegs(regsDefined, Reg); 860948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 861948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Verify SSA form. 862948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MRI->isSSA() && TargetRegisterInfo::isVirtualRegister(Reg) && 863948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen llvm::next(MRI->def_begin(Reg)) != MRI->def_end()) 864948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Multiple virtual register defs in SSA form", MO, MONum); 865948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 866948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Check LiveInts for a live range, but only for virtual registers. 867948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (LiveInts && TargetRegisterInfo::isVirtualRegister(Reg) && 868948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen !LiveInts->isNotInMIMap(MI)) { 869f935e945c0fc0444324347882ac41104b12204c2Jakob Stoklund Olesen SlotIndex DefIdx = LiveInts->getInstructionIndex(MI); 870f935e945c0fc0444324347882ac41104b12204c2Jakob Stoklund Olesen DefIdx = DefIdx.getRegSlot(MO->isEarlyClobber()); 871948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (LiveInts->hasInterval(Reg)) { 872948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen const LiveInterval &LI = LiveInts->getInterval(Reg); 873948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (const VNInfo *VNI = LI.getVNInfoAt(DefIdx)) { 874948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen assert(VNI && "NULL valno is not allowed"); 875f935e945c0fc0444324347882ac41104b12204c2Jakob Stoklund Olesen if (VNI->def != DefIdx) { 876948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Inconsistent valno->def", MO, MONum); 877948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen *OS << "Valno " << VNI->id << " is not defined at " 878948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen << DefIdx << " in " << LI << '\n'; 879948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 880948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } else { 881948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("No live range at def", MO, MONum); 882948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen *OS << DefIdx << " is not live in " << LI << '\n'; 883948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 884948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } else { 885948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Virtual register has no Live interval", MO, MONum); 886948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 887948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 888948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 889948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen} 890948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 891b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineInstrAfter(const MachineInstr *MI) { 8921f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen} 8931f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen 8941f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen// This function gets called after visiting all instructions in a bundle. The 8951f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen// argument points to the bundle header. 8961f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen// Normal stand-alone instructions are also considered 'bundles', and this 8971f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen// function is called for all of them. 8981f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesenvoid MachineVerifier::visitMachineBundleAfter(const MachineInstr *MI) { 89948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MI->getParent()]; 90048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen set_union(MInfo.regsKilled, regsKilled); 90173cf709a08d480c4315dc4aa9f644cf86494c4cfJakob Stoklund Olesen set_subtract(regsLive, regsKilled); regsKilled.clear(); 9029ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen // Kill any masked registers. 9039ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen while (!regMasks.empty()) { 9049ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen const uint32_t *Mask = regMasks.pop_back_val(); 9059ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen for (RegSet::iterator I = regsLive.begin(), E = regsLive.end(); I != E; ++I) 9069ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(*I) && 9079ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen MachineOperand::clobbersPhysReg(Mask, *I)) 9089ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen regsDead.push_back(*I); 9099ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen } 91073cf709a08d480c4315dc4aa9f644cf86494c4cfJakob Stoklund Olesen set_subtract(regsLive, regsDead); regsDead.clear(); 91173cf709a08d480c4315dc4aa9f644cf86494c4cfJakob Stoklund Olesen set_union(regsLive, regsDefined); regsDefined.clear(); 91248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 91348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 91448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenvoid 915b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund OlesenMachineVerifier::visitMachineBasicBlockAfter(const MachineBasicBlock *MBB) { 91648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MBBInfoMap[MBB].regsLiveOut = regsLive; 91748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.clear(); 918fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen 919fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen if (Indexes) { 920fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen SlotIndex stop = Indexes->getMBBEndIdx(MBB); 921fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen if (!(stop > lastIndex)) { 922fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen report("Block ends before last instruction index", MBB); 923fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen *OS << "Block ends at " << stop 924fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen << " last instruction was at " << lastIndex << '\n'; 925fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen } 926fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen lastIndex = stop; 927fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen } 92848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 92948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 93048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Calculate the largest possible vregsPassed sets. These are the registers that 93148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// can pass through an MBB live, but may not be live every time. It is assumed 93248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// that all vregsPassed sets are empty before the call. 933b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesenvoid MachineVerifier::calcRegsPassed() { 93448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // First push live-out regs to successors' vregsPassed. Remember the MBBs that 93548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // have any vregsPassed. 9361efd6b94a917449da5007fd332cd895692aa0319Jakob Stoklund Olesen SmallPtrSet<const MachineBasicBlock*, 8> todo; 93748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF->begin(), MFE = MF->end(); 93848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI != MFE; ++MFI) { 93948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineBasicBlock &MBB(*MFI); 94048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[&MBB]; 94148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) 94248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 94348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator SuI = MBB.succ_begin(), 94448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen SuE = MBB.succ_end(); SuI != SuE; ++SuI) { 94548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &SInfo = MBBInfoMap[*SuI]; 94648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SInfo.addPassed(MInfo.regsLiveOut)) 94748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.insert(*SuI); 94848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 94948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 95048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 95148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Iteratively push vregsPassed to successors. This will converge to the same 95248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // final state regardless of DenseSet iteration order. 95348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen while (!todo.empty()) { 95448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineBasicBlock *MBB = *todo.begin(); 95548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.erase(MBB); 95648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MBB]; 95748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator SuI = MBB->succ_begin(), 95848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen SuE = MBB->succ_end(); SuI != SuE; ++SuI) { 95948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (*SuI == MBB) 96048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 96148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &SInfo = MBBInfoMap[*SuI]; 96248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SInfo.addPassed(MInfo.vregsPassed)) 96348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.insert(*SuI); 96448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 96548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 96648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 96748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 9688f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen// Calculate the set of virtual registers that must be passed through each basic 9698f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen// block in order to satisfy the requirements of successor blocks. This is very 970b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen// similar to calcRegsPassed, only backwards. 9718f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesenvoid MachineVerifier::calcRegsRequired() { 9728f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // First push live-in regs to predecessors' vregsRequired. 9731efd6b94a917449da5007fd332cd895692aa0319Jakob Stoklund Olesen SmallPtrSet<const MachineBasicBlock*, 8> todo; 9748f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF->begin(), MFE = MF->end(); 9758f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen MFI != MFE; ++MFI) { 9768f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen const MachineBasicBlock &MBB(*MFI); 9778f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[&MBB]; 9788f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MBB.pred_begin(), 9798f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen PrE = MBB.pred_end(); PrI != PrE; ++PrI) { 9808f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &PInfo = MBBInfoMap[*PrI]; 9818f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (PInfo.addRequired(MInfo.vregsLiveIn)) 9828f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen todo.insert(*PrI); 9838f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 9848f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 9858f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 9868f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Iteratively push vregsRequired to predecessors. This will converge to the 9878f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // same final state regardless of DenseSet iteration order. 9888f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen while (!todo.empty()) { 9898f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen const MachineBasicBlock *MBB = *todo.begin(); 9908f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen todo.erase(MBB); 9918f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MBB]; 9928f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MBB->pred_begin(), 9938f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen PrE = MBB->pred_end(); PrI != PrE; ++PrI) { 9948f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (*PrI == MBB) 9958f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen continue; 9968f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &SInfo = MBBInfoMap[*PrI]; 9978f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (SInfo.addRequired(MInfo.vregsRequired)) 9988f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen todo.insert(*PrI); 9998f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 10008f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 10018f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen} 10028f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 100348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Check PHI instructions at the beginning of MBB. It is assumed that 1004b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen// calcRegsPassed has been run so BBInfo::isLiveOut is valid. 1005b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::checkPHIOps(const MachineBasicBlock *MBB) { 10061efd6b94a917449da5007fd332cd895692aa0319Jakob Stoklund Olesen SmallPtrSet<const MachineBasicBlock*, 8> seen; 100748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_iterator BBI = MBB->begin(), BBE = MBB->end(); 1008518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner BBI != BBE && BBI->isPHI(); ++BBI) { 10091efd6b94a917449da5007fd332cd895692aa0319Jakob Stoklund Olesen seen.clear(); 101048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 101148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (unsigned i = 1, e = BBI->getNumOperands(); i != e; i += 2) { 101248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned Reg = BBI->getOperand(i).getReg(); 101348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineBasicBlock *Pre = BBI->getOperand(i + 1).getMBB(); 101448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!Pre->isSuccessor(MBB)) 101548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 101648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen seen.insert(Pre); 101748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &PrInfo = MBBInfoMap[Pre]; 101848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (PrInfo.reachable && !PrInfo.isLiveOut(Reg)) 101948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("PHI operand is not live-out from predecessor", 102048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen &BBI->getOperand(i), i); 102148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 102248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 102348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Did we see all predecessors? 102448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MBB->pred_begin(), 102548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen PrE = MBB->pred_end(); PrI != PrE; ++PrI) { 102648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!seen.count(*PrI)) { 102748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Missing PHI operand", BBI); 10280ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman *OS << "BB#" << (*PrI)->getNumber() 102948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " is a predecessor according to the CFG.\n"; 103048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 103148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 103248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 103348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 103448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 1035b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineFunctionAfter() { 1036b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen calcRegsPassed(); 103748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 103848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF->begin(), MFE = MF->end(); 103948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI != MFE; ++MFI) { 104048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MFI]; 104148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 104248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Skip unreachable MBBs. 104348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) 104448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 104548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 1046b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen checkPHIOps(MFI); 104748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 104848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 104958e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen // Now check liveness info if available 105064ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen calcRegsRequired(); 105164ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen 105264ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen if (MRI->isSSA() && !MF->empty()) { 105364ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[&MF->front()]; 105464ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen for (RegSet::iterator 105564ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen I = MInfo.vregsRequired.begin(), E = MInfo.vregsRequired.end(); I != E; 1056ff0275ea53842101645000d1d7fefe85e007fb03Jakob Stoklund Olesen ++I) 1057ff0275ea53842101645000d1d7fefe85e007fb03Jakob Stoklund Olesen report("Virtual register def doesn't dominate all uses.", 1058ff0275ea53842101645000d1d7fefe85e007fb03Jakob Stoklund Olesen MRI->getVRegDef(*I)); 105964ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen } 106064ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen 106158e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen if (LiveVars) 10628f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen verifyLiveVariables(); 106358e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen if (LiveInts) 106458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen verifyLiveIntervals(); 106548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 10668f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 10678f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesenvoid MachineVerifier::verifyLiveVariables() { 10688f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen assert(LiveVars && "Don't call verifyLiveVariables without LiveVars"); 106998c54760704878cf5290a9a3b23876b7550c5560Jakob Stoklund Olesen for (unsigned i = 0, e = MRI->getNumVirtRegs(); i != e; ++i) { 107098c54760704878cf5290a9a3b23876b7550c5560Jakob Stoklund Olesen unsigned Reg = TargetRegisterInfo::index2VirtReg(i); 10718f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen LiveVariables::VarInfo &VI = LiveVars->getVarInfo(Reg); 10728f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF->begin(), MFE = MF->end(); 10738f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen MFI != MFE; ++MFI) { 10748f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MFI]; 10758f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 10768f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Our vregsRequired should be identical to LiveVariables' AliveBlocks 10778f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (MInfo.vregsRequired.count(Reg)) { 10788f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (!VI.AliveBlocks.test(MFI->getNumber())) { 10798f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen report("LiveVariables: Block missing from AliveBlocks", MFI); 10804314268128be6d54c9a7f0709680e5a5b40f3ab3Jakob Stoklund Olesen *OS << "Virtual register " << PrintReg(Reg) 10818f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen << " must be live through the block.\n"; 10828f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 10838f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } else { 10848f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (VI.AliveBlocks.test(MFI->getNumber())) { 10858f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen report("LiveVariables: Block should not be in AliveBlocks", MFI); 10864314268128be6d54c9a7f0709680e5a5b40f3ab3Jakob Stoklund Olesen *OS << "Virtual register " << PrintReg(Reg) 10878f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen << " is not needed live through the block.\n"; 10888f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 10898f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 10908f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 10918f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 10928f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen} 10938f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 109458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesenvoid MachineVerifier::verifyLiveIntervals() { 109558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen assert(LiveInts && "Don't call verifyLiveIntervals without LiveInts"); 109612a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen for (unsigned i = 0, e = MRI->getNumVirtRegs(); i != e; ++i) { 109712a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen unsigned Reg = TargetRegisterInfo::index2VirtReg(i); 1098893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen 1099893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen // Spilling and splitting may leave unused registers around. Skip them. 110012a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen if (MRI->reg_nodbg_empty(Reg)) 1101893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen continue; 1102893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen 110312a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen if (!LiveInts->hasInterval(Reg)) { 110412a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen report("Missing live interval for virtual register", MF); 110512a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen *OS << PrintReg(Reg, TRI) << " still has defs or uses\n"; 11068c4564287d5231421d5358d71d23f46cd0be18c7Jakob Stoklund Olesen continue; 110712a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen } 11088c4564287d5231421d5358d71d23f46cd0be18c7Jakob Stoklund Olesen 110912a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen const LiveInterval &LI = LiveInts->getInterval(Reg); 111012a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen assert(Reg == LI.reg && "Invalid reg to interval mapping"); 111158e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 111258e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen for (LiveInterval::const_vni_iterator I = LI.vni_begin(), E = LI.vni_end(); 111358e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen I!=E; ++I) { 111458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen VNInfo *VNI = *I; 1115ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen const VNInfo *DefVNI = LI.getVNInfoAt(VNI->def); 111658e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1117ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen if (!DefVNI) { 111858e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen if (!VNI->isUnused()) { 111958e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen report("Valno not live at def and not marked unused", MF); 112058e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " in " << LI << '\n'; 112158e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 112258e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen continue; 112358e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 112458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 112558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen if (VNI->isUnused()) 112658e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen continue; 112758e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1128ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen if (DefVNI != VNI) { 112958e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen report("Live range at def has different valno", MF); 1130ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 1131dbcc2e119d57dba1e2f013d304ebfbe894c98106Jakob Stoklund Olesen << " where valno #" << DefVNI->id << " is live in " << LI << '\n'; 11323bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen continue; 113358e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 113458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 11353bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen const MachineBasicBlock *MBB = LiveInts->getMBBFromIndex(VNI->def); 11363bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen if (!MBB) { 11373bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen report("Invalid definition index", MF); 1138dbcc2e119d57dba1e2f013d304ebfbe894c98106Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 1139dbcc2e119d57dba1e2f013d304ebfbe894c98106Jakob Stoklund Olesen << " in " << LI << '\n'; 11403bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen continue; 11413bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen } 11423bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen 11433bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen if (VNI->isPHIDef()) { 11443bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen if (VNI->def != LiveInts->getMBBStartIdx(MBB)) { 11453bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen report("PHIDef value is not defined at MBB start", MF); 11463bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 1147dbcc2e119d57dba1e2f013d304ebfbe894c98106Jakob Stoklund Olesen << ", not at the beginning of BB#" << MBB->getNumber() 1148dbcc2e119d57dba1e2f013d304ebfbe894c98106Jakob Stoklund Olesen << " in " << LI << '\n'; 11493bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen } 11503bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen } else { 11513bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen // Non-PHI def. 115230e98a03a3c524026e2da2607e04bb655b0b6350Jakob Stoklund Olesen const MachineInstr *MI = LiveInts->getInstructionFromIndex(VNI->def); 11533bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen if (!MI) { 11543bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen report("No instruction at def index", MF); 11557871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 11567871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen << " in " << LI << '\n'; 1157121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 11583bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen } 11590b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich 1160121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen bool hasDef = false; 11610b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich bool isEarlyClobber = false; 116230e98a03a3c524026e2da2607e04bb655b0b6350Jakob Stoklund Olesen for (ConstMIBundleOperands MOI(MI); MOI.isValid(); ++MOI) { 1163121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!MOI->isReg() || !MOI->isDef()) 1164121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 1165121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(LI.reg)) { 1166121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (MOI->getReg() != LI.reg) 1167121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 1168121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } else { 1169121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!TargetRegisterInfo::isPhysicalRegister(MOI->getReg()) || 1170121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen !TRI->regsOverlap(LI.reg, MOI->getReg())) 1171121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 11720b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich } 1173121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen hasDef = true; 1174121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (MOI->isEarlyClobber()) 1175121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen isEarlyClobber = true; 1176121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1177121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1178121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!hasDef) { 1179121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Defining instruction does not modify register", MI); 1180121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " in " << LI << '\n'; 11810b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich } 11820b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich 11830b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich // Early clobber defs begin at USE slots, but other defs must begin at 11840b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich // DEF slots. 11850b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich if (isEarlyClobber) { 11862debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen if (!VNI->def.isEarlyClobber()) { 11872debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen report("Early clobber def must be at an early-clobber slot", MF); 11880b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 11890b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich << " in " << LI << '\n'; 11900b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich } 11912debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen } else if (!VNI->def.isRegister()) { 11922debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen report("Non-PHI, non-early clobber def must be at a register slot", 11932debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen MF); 11940b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 11950b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich << " in " << LI << '\n'; 11960b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich } 11973bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen } 119858e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 119958e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 120058e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen for (LiveInterval::const_iterator I = LI.begin(), E = LI.end(); I!=E; ++I) { 1201ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen const VNInfo *VNI = I->valno; 1202ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen assert(VNI && "Live range has no valno"); 120358e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1204ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen if (VNI->id >= LI.getNumValNums() || VNI != LI.getValNumInfo(VNI->id)) { 120558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen report("Foreign valno in live range", MF); 1206ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen I->print(*OS); 120758e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen *OS << " has a valno not in " << LI << '\n'; 120858e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 120958e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1210ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen if (VNI->isUnused()) { 121158e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen report("Live range valno is marked unused", MF); 1212ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen I->print(*OS); 121358e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen *OS << " in " << LI << '\n'; 121458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 121558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 12167871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen const MachineBasicBlock *MBB = LiveInts->getMBBFromIndex(I->start); 12177871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen if (!MBB) { 12187871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen report("Bad start of live segment, no basic block", MF); 12197871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen I->print(*OS); 12207871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen *OS << " in " << LI << '\n'; 12217871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen continue; 12227871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 12237871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen SlotIndex MBBStartIdx = LiveInts->getMBBStartIdx(MBB); 12247871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen if (I->start != MBBStartIdx && I->start != VNI->def) { 12257871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen report("Live segment must begin at MBB entry or valno def", MBB); 12267871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen I->print(*OS); 12277871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen *OS << " in " << LI << '\n' << "Basic block starts at " 12287871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen << MBBStartIdx << '\n'; 12297871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 12307871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen 12317871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen const MachineBasicBlock *EndMBB = 12327871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen LiveInts->getMBBFromIndex(I->end.getPrevSlot()); 12337871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen if (!EndMBB) { 12347871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen report("Bad end of live segment, no basic block", MF); 12357871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen I->print(*OS); 12367871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen *OS << " in " << LI << '\n'; 12377871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen continue; 12387871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 1239121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1240121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // No more checks for live-out segments. 1241121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (I->end == LiveInts->getMBBEndIdx(EndMBB)) 1242121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 1243121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1244121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // The live segment is ending inside EndMBB 124530e98a03a3c524026e2da2607e04bb655b0b6350Jakob Stoklund Olesen const MachineInstr *MI = 1246121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen LiveInts->getInstructionFromIndex(I->end.getPrevSlot()); 1247121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!MI) { 1248121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Live segment doesn't end at a valid instruction", EndMBB); 12497871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen I->print(*OS); 12507871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen *OS << " in " << LI << '\n' << "Basic block starts at " 1251121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen << MBBStartIdx << '\n'; 1252121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 1253121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1254121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1255121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // The block slot must refer to a basic block boundary. 1256121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (I->end.isBlock()) { 1257121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Live segment ends at B slot of an instruction", MI); 1258121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen I->print(*OS); 1259121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen *OS << " in " << LI << '\n'; 1260121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1261636f15ff04c9188ea3bf91477fda1cc29f2c4a61Cameron Zwarich 1262121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (I->end.isDead()) { 1263121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // Segment ends on the dead slot. 1264121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // That means there must be a dead def. 1265121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!SlotIndex::isSameInstr(I->start, I->end)) { 1266121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Live segment ending at dead slot spans instructions", MI); 1267121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen I->print(*OS); 1268121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen *OS << " in " << LI << '\n'; 1269121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1270121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1271121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1272121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // A live segment can only end at an early-clobber slot if it is being 1273121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // redefined by an early-clobber def. 1274121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (I->end.isEarlyClobber()) { 1275121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (I+1 == E || (I+1)->start != I->end) { 1276121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Live segment ending at early clobber slot must be " 1277121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen "redefined by an EC def in the same instruction", MI); 1278121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen I->print(*OS); 1279121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen *OS << " in " << LI << '\n'; 1280121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1281121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1282121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1283121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // The following checks only apply to virtual registers. Physreg liveness 1284121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // is too weird to check. 1285121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(LI.reg)) { 1286121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // A live range can end with either a redefinition, a kill flag on a 1287121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // use, or a dead flag on a def. 1288121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen bool hasRead = false; 1289121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen bool hasDeadDef = false; 129030e98a03a3c524026e2da2607e04bb655b0b6350Jakob Stoklund Olesen for (ConstMIBundleOperands MOI(MI); MOI.isValid(); ++MOI) { 1291121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!MOI->isReg() || MOI->getReg() != LI.reg) 1292121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 1293121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (MOI->readsReg()) 1294121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen hasRead = true; 1295121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (MOI->isDef() && MOI->isDead()) 1296121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen hasDeadDef = true; 1297121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1298121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1299121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (I->end.isDead()) { 1300636f15ff04c9188ea3bf91477fda1cc29f2c4a61Cameron Zwarich if (!hasDeadDef) { 1301121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Instruction doesn't have a dead def operand", MI); 1302121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen I->print(*OS); 1303121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen *OS << " in " << LI << '\n'; 1304121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1305121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } else { 1306121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!hasRead) { 1307121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Instruction ending live range doesn't read the register", 1308121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen MI); 1309636f15ff04c9188ea3bf91477fda1cc29f2c4a61Cameron Zwarich I->print(*OS); 1310636f15ff04c9188ea3bf91477fda1cc29f2c4a61Cameron Zwarich *OS << " in " << LI << '\n'; 1311636f15ff04c9188ea3bf91477fda1cc29f2c4a61Cameron Zwarich } 13127871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 13137871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 13147871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen 13157871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen // Now check all the basic blocks in this live segment. 13167871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen MachineFunction::const_iterator MFI = MBB; 1317cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich // Is this live range the beginning of a non-PHIDef VN? 1318cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich if (I->start == VNI->def && !VNI->isPHIDef()) { 13197871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen // Not live-in to any blocks. 13207871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen if (MBB == EndMBB) 13217871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen continue; 13227871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen // Skip this block. 13237871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen ++MFI; 13247871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 13257871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen for (;;) { 13267871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen assert(LiveInts->isLiveInToMBB(LI, MFI)); 1327e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen // We don't know how to track physregs into a landing pad. 1328e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(LI.reg) && 1329e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen MFI->isLandingPad()) { 1330e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen if (&*MFI == EndMBB) 1331e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen break; 1332e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen ++MFI; 1333e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen continue; 1334e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen } 13357871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen // Check that VNI is live-out of all predecessors. 13367871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PI = MFI->pred_begin(), 13377871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen PE = MFI->pred_end(); PI != PE; ++PI) { 1338194eb71a11a77c7fb576780783a77e64924dfb10Jakob Stoklund Olesen SlotIndex PEnd = LiveInts->getMBBEndIdx(*PI); 1339194eb71a11a77c7fb576780783a77e64924dfb10Jakob Stoklund Olesen const VNInfo *PVNI = LI.getVNInfoBefore(PEnd); 13404eee42cb282753ad43e929b0955d7d44c1580905Cameron Zwarich 1341df8412c4c1a3a798c5a849ebc3f56904568d40c4Jakob Stoklund Olesen if (VNI->isPHIDef() && VNI->def == LiveInts->getMBBStartIdx(MFI)) 13424eee42cb282753ad43e929b0955d7d44c1580905Cameron Zwarich continue; 13434eee42cb282753ad43e929b0955d7d44c1580905Cameron Zwarich 1344cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich if (!PVNI) { 1345cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich report("Register not marked live out of predecessor", *PI); 1346cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich *OS << "Valno #" << VNI->id << " live into BB#" << MFI->getNumber() 1347194eb71a11a77c7fb576780783a77e64924dfb10Jakob Stoklund Olesen << '@' << LiveInts->getMBBStartIdx(MFI) << ", not live before " 1348cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich << PEnd << " in " << LI << '\n'; 1349cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich continue; 1350cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich } 1351cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich 13524eee42cb282753ad43e929b0955d7d44c1580905Cameron Zwarich if (PVNI != VNI) { 13537871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen report("Different value live out of predecessor", *PI); 13547871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen *OS << "Valno #" << PVNI->id << " live out of BB#" 13557871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen << (*PI)->getNumber() << '@' << PEnd 13567871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen << "\nValno #" << VNI->id << " live into BB#" << MFI->getNumber() 13577871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen << '@' << LiveInts->getMBBStartIdx(MFI) << " in " << LI << '\n'; 13587871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 13597871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 13607871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen if (&*MFI == EndMBB) 13617871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen break; 13627871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen ++MFI; 13637871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 136458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 1365501dc4224586d3cee61101ed6cd0ccc8ba74c43cJakob Stoklund Olesen 1366501dc4224586d3cee61101ed6cd0ccc8ba74c43cJakob Stoklund Olesen // Check the LI only has one connected component. 13678c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(LI.reg)) { 13688c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen ConnectedVNInfoEqClasses ConEQ(*LiveInts); 13698c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen unsigned NumComp = ConEQ.Classify(&LI); 13708c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen if (NumComp > 1) { 13718c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen report("Multiple connected components in live interval", MF); 13728c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen *OS << NumComp << " components in " << LI << '\n'; 1373cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen for (unsigned comp = 0; comp != NumComp; ++comp) { 1374cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen *OS << comp << ": valnos"; 1375cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen for (LiveInterval::const_vni_iterator I = LI.vni_begin(), 1376cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen E = LI.vni_end(); I!=E; ++I) 1377cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen if (comp == ConEQ.getEqClass(*I)) 1378cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen *OS << ' ' << (*I)->id; 1379cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen *OS << '\n'; 1380cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen } 13818c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen } 1382501dc4224586d3cee61101ed6cd0ccc8ba74c43cJakob Stoklund Olesen } 138358e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 138458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen} 1385