MachineVerifier.cpp revision 30e98a03a3c524026e2da2607e04bb655b0b6350
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)) 9248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (const unsigned *R = TRI->getSubRegisters(Reg); *R; R++) 9348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RV.push_back(*R); 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); 19448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineInstrBefore(const MachineInstr *MI); 19548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineOperand(const MachineOperand *MO, unsigned MONum); 19648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineInstrAfter(const MachineInstr *MI); 19748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineBasicBlockAfter(const MachineBasicBlock *MBB); 19848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineFunctionAfter(); 19948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 20048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineFunction *MF); 20148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineBasicBlock *MBB); 20248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineInstr *MI); 20348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineOperand *MO, unsigned MONum); 20448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 20548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void markReachable(const MachineBasicBlock *MBB); 206b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen void calcRegsPassed(); 20748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void checkPHIOps(const MachineBasicBlock *MBB); 2088f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 2098f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen void calcRegsRequired(); 2108f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen void verifyLiveVariables(); 21158e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen void verifyLiveIntervals(); 2128f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen }; 2138f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 2148f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen struct MachineVerifierPass : public MachineFunctionPass { 2158f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen static char ID; // Pass ID, replacement for typeid 21689cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen const char *const Banner; 2178f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 21889cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen MachineVerifierPass(const char *b = 0) 21989cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen : MachineFunctionPass(ID), Banner(b) { 220081c34b725980f995be9080eaec24cd3dfaaf065Owen Anderson initializeMachineVerifierPassPass(*PassRegistry::getPassRegistry()); 221081c34b725980f995be9080eaec24cd3dfaaf065Owen Anderson } 2228f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 2238f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen void getAnalysisUsage(AnalysisUsage &AU) const { 2248f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen AU.setPreservesAll(); 2258f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen MachineFunctionPass::getAnalysisUsage(AU); 2268f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 2278f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 2288f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool runOnMachineFunction(MachineFunction &MF) { 22989cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen MF.verify(this, Banner); 2308f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return false; 2318f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 23248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen }; 2338f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 23448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 23548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 2368f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesenchar MachineVerifierPass::ID = 0; 23702dd53e1c5b941ca5f60fca1b95ebcaf9ccd1dfcOwen AndersonINITIALIZE_PASS(MachineVerifierPass, "machineverifier", 238ce665bd2e2b581ab0858d1afe359192bac96b868Owen Anderson "Verify generated machine code", false, false) 23948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 24089cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund OlesenFunctionPass *llvm::createMachineVerifierPass(const char *Banner) { 24189cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen return new MachineVerifierPass(Banner); 24248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 24348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 24489cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesenvoid MachineFunction::verify(Pass *p, const char *Banner) const { 24589cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen MachineVerifier(p, Banner) 24689cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen .runOnMachineFunction(const_cast<MachineFunction&>(*this)); 247ce727d0da006ca59bbd8c9ddc86e2fa71217d293Jakob Stoklund Olesen} 248ce727d0da006ca59bbd8c9ddc86e2fa71217d293Jakob Stoklund Olesen 24917e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattnerbool MachineVerifier::runOnMachineFunction(MachineFunction &MF) { 25017e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner raw_ostream *OutFile = 0; 25148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (OutFileName) { 25217e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner std::string ErrorInfo; 25317e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner OutFile = new raw_fd_ostream(OutFileName, ErrorInfo, 25417e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner raw_fd_ostream::F_Append); 25517e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner if (!ErrorInfo.empty()) { 25617e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner errs() << "Error opening '" << OutFileName << "': " << ErrorInfo << '\n'; 25717e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner exit(1); 25817e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner } 259b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesen 26017e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner OS = OutFile; 26148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 26217e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner OS = &errs(); 26348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 26448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 26548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen foundErrors = 0; 26648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 26748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen this->MF = &MF; 26848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen TM = &MF.getTarget(); 26915993f83a419950f06d2879d6701530ae6449317Evan Cheng TII = TM->getInstrInfo(); 27048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen TRI = TM->getRegisterInfo(); 27148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MRI = &MF.getRegInfo(); 27248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 273c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen LiveVars = NULL; 274c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen LiveInts = NULL; 275e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveStks = NULL; 276f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen Indexes = NULL; 2778f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (PASS) { 2781fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen LiveInts = PASS->getAnalysisIfAvailable<LiveIntervals>(); 279c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen // We don't want to verify LiveVariables if LiveIntervals is available. 280c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen if (!LiveInts) 281c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen LiveVars = PASS->getAnalysisIfAvailable<LiveVariables>(); 282e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveStks = PASS->getAnalysisIfAvailable<LiveStacks>(); 283f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen Indexes = PASS->getAnalysisIfAvailable<SlotIndexes>(); 2848f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 2858f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 28648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineFunctionBefore(); 28748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF.begin(), MFE = MF.end(); 28848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI!=MFE; ++MFI) { 28948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineBasicBlockBefore(MFI); 290ddfd1377d2e4154d44dc3ad217735adc15af2e3fEvan Cheng for (MachineBasicBlock::const_instr_iterator MBBI = MFI->instr_begin(), 291ddfd1377d2e4154d44dc3ad217735adc15af2e3fEvan Cheng MBBE = MFI->instr_end(); MBBI != MBBE; ++MBBI) { 2927bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen if (MBBI->getParent() != MFI) { 2937bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen report("Bad instruction parent pointer", MFI); 2947bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen *OS << "Instruction: " << *MBBI; 2957bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen continue; 2967bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen } 297ddfd1377d2e4154d44dc3ad217735adc15af2e3fEvan Cheng // Skip BUNDLE instruction for now. FIXME: We should add code to verify 298ddfd1377d2e4154d44dc3ad217735adc15af2e3fEvan Cheng // the BUNDLE's specifically. 299ddfd1377d2e4154d44dc3ad217735adc15af2e3fEvan Cheng if (MBBI->isBundle()) 300ddfd1377d2e4154d44dc3ad217735adc15af2e3fEvan Cheng continue; 30148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineInstrBefore(MBBI); 30248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (unsigned I = 0, E = MBBI->getNumOperands(); I != E; ++I) 30348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineOperand(&MBBI->getOperand(I), I); 30448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineInstrAfter(MBBI); 30548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 30648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineBasicBlockAfter(MFI); 30748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 30848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineFunctionAfter(); 30948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 31017e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner if (OutFile) 31117e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner delete OutFile; 31217e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner else if (foundErrors) 31375361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("Found "+Twine(foundErrors)+" machine code errors."); 31448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 3156349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen // Clean up. 3166349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsLive.clear(); 3176349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsDefined.clear(); 3186349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsDead.clear(); 3196349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsKilled.clear(); 3209ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen regMasks.clear(); 3216349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsLiveInButUnused.clear(); 3226349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen MBBInfoMap.clear(); 3236349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen 32448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return false; // no changes 32548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 32648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 327372fefe8d24e40df2390fffeea0dc2dec611f88bChris Lattnervoid MachineVerifier::report(const char *msg, const MachineFunction *MF) { 32848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MF); 32917e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner *OS << '\n'; 33089cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen if (!foundErrors++) { 33189cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen if (Banner) 33289cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen *OS << "# " << Banner << '\n'; 333f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen MF->print(*OS, Indexes); 33489cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen } 33548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "*** Bad machine code: " << msg << " ***\n" 336a7b0cb759433c715065440ee2a963a04db7f2b0bBenjamin Kramer << "- function: " << MF->getFunction()->getName() << "\n"; 33748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 33848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 339b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, const MachineBasicBlock *MBB) { 34048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MBB); 34148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report(msg, MBB->getParent()); 342324da7647cfc3025e0c987176f0a300f9f780e6fJakob Stoklund Olesen *OS << "- basic block: " << MBB->getName() 34348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " " << (void*)MBB 344f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen << " (BB#" << MBB->getNumber() << ")"; 345f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen if (Indexes) 346f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen *OS << " [" << Indexes->getMBBStartIdx(MBB) 347f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen << ';' << Indexes->getMBBEndIdx(MBB) << ')'; 348f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen *OS << '\n'; 34948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 35048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 351b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, const MachineInstr *MI) { 35248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MI); 35348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report(msg, MI->getParent()); 35448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "- instruction: "; 355f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen if (Indexes && Indexes->hasIndex(MI)) 356f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen *OS << Indexes->getInstructionIndex(MI) << '\t'; 357705e07f578e2b3af47ddab610feb4e7f2d3063a5Chris Lattner MI->print(*OS, TM); 35848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 35948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 360b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, 361b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesen const MachineOperand *MO, unsigned MONum) { 36248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MO); 36348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report(msg, MO->getParent()); 36448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "- operand " << MONum << ": "; 36548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MO->print(*OS, TM); 36648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "\n"; 36748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 36848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 369b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::markReachable(const MachineBasicBlock *MBB) { 37048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MBB]; 37148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) { 37248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MInfo.reachable = true; 37348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator SuI = MBB->succ_begin(), 37448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen SuE = MBB->succ_end(); SuI != SuE; ++SuI) 37548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen markReachable(*SuI); 37648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 37748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 37848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 379b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineFunctionBefore() { 380fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen lastIndex = SlotIndex(); 38148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsReserved = TRI->getReservedRegs(*MF); 382d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen 383d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen // A sub-register of a reserved register is also reserved 384d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen for (int Reg = regsReserved.find_first(); Reg>=0; 385d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen Reg = regsReserved.find_next(Reg)) { 386d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen for (const unsigned *Sub = TRI->getSubRegisters(Reg); *Sub; ++Sub) { 387d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen // FIXME: This should probably be: 388d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen // assert(regsReserved.test(*Sub) && "Non-reserved sub-register"); 389d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen regsReserved.set(*Sub); 390d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen } 391d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen } 39203698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames 39303698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames regsAllocatable = TRI->getAllocatableSet(*MF); 39403698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames 39548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen markReachable(&MF->front()); 39648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 39748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 3981dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen// Does iterator point to a and b as the first two elements? 399b35798347ea87b8b6d36155b211016a7769f01abDan Gohmanstatic bool matchPair(MachineBasicBlock::const_succ_iterator i, 400b35798347ea87b8b6d36155b211016a7769f01abDan Gohman const MachineBasicBlock *a, const MachineBasicBlock *b) { 4011dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen if (*i == a) 4021dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen return *++i == b; 4031dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen if (*i == b) 4041dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen return *++i == a; 4051dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen return false; 4061dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen} 4071dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen 4081dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesenvoid 4091dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund OlesenMachineVerifier::visitMachineBasicBlockBefore(const MachineBasicBlock *MBB) { 4105adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen FirstTerminator = 0; 4115adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen 41203698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames if (MRI->isSSA()) { 41303698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames // If this block has allocatable physical registers live-in, check that 41403698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames // it is an entry block or landing pad. 41503698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames for (MachineBasicBlock::livein_iterator LI = MBB->livein_begin(), 41603698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames LE = MBB->livein_end(); 41703698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames LI != LE; ++LI) { 41803698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames unsigned reg = *LI; 41903698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames if (isAllocatable(reg) && !MBB->isLandingPad() && 42003698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames MBB != MBB->getParent()->begin()) { 42103698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames report("MBB has allocable live-in, but isn't entry or landing-pad.", MBB); 42203698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames } 42303698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames } 42403698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames } 42503698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames 4260a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen // Count the number of landing pad successors. 4272100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich SmallPtrSet<MachineBasicBlock*, 4> LandingPadSuccs; 4280a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator I = MBB->succ_begin(), 4292100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich E = MBB->succ_end(); I != E; ++I) { 4302100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich if ((*I)->isLandingPad()) 4312100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich LandingPadSuccs.insert(*I); 4322100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich } 433d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling 434d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling const MCAsmInfo *AsmInfo = TM->getMCAsmInfo(); 435d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling const BasicBlock *BB = MBB->getBasicBlock(); 436d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling if (LandingPadSuccs.size() > 1 && 437d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling !(AsmInfo && 438d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling AsmInfo->getExceptionHandlingType() == ExceptionHandling::SjLj && 439d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling BB && isa<SwitchInst>(BB->getTerminator()))) 4400a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen report("MBB has more than one landing pad successor", MBB); 4410a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen 44227920594b940d824038d16b13846aa76cac493cfDan Gohman // Call AnalyzeBranch. If it succeeds, there several more conditions to check. 44327920594b940d824038d16b13846aa76cac493cfDan Gohman MachineBasicBlock *TBB = 0, *FBB = 0; 44427920594b940d824038d16b13846aa76cac493cfDan Gohman SmallVector<MachineOperand, 4> Cond; 44527920594b940d824038d16b13846aa76cac493cfDan Gohman if (!TII->AnalyzeBranch(*const_cast<MachineBasicBlock *>(MBB), 44627920594b940d824038d16b13846aa76cac493cfDan Gohman TBB, FBB, Cond)) { 44727920594b940d824038d16b13846aa76cac493cfDan Gohman // Ok, AnalyzeBranch thinks it knows what's going on with this block. Let's 44827920594b940d824038d16b13846aa76cac493cfDan Gohman // check whether its answers match up with reality. 44927920594b940d824038d16b13846aa76cac493cfDan Gohman if (!TBB && !FBB) { 45027920594b940d824038d16b13846aa76cac493cfDan Gohman // Block falls through to its successor. 45127920594b940d824038d16b13846aa76cac493cfDan Gohman MachineFunction::const_iterator MBBI = MBB; 45227920594b940d824038d16b13846aa76cac493cfDan Gohman ++MBBI; 45327920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBBI == MF->end()) { 454a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // It's possible that the block legitimately ends with a noreturn 455a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // call or an unreachable, in which case it won't actually fall 456a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // out the bottom of the function. 4572100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich } else if (MBB->succ_size() == LandingPadSuccs.size()) { 458a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // It's possible that the block legitimately ends with a noreturn 459a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // call or an unreachable, in which case it won't actuall fall 460a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // out of the block. 4612100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich } else if (MBB->succ_size() != 1+LandingPadSuccs.size()) { 46227920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but doesn't have " 46327920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly one CFG successor!", MBB); 4640a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen } else if (!MBB->isSuccessor(MBBI)) { 46527920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but its successor " 46627920594b940d824038d16b13846aa76cac493cfDan Gohman "differs from its CFG successor!", MBB); 46727920594b940d824038d16b13846aa76cac493cfDan Gohman } 4685a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (!MBB->empty() && MBB->back().isBarrier() && 46986050dc8cc0aaea8c9dfeb89de02cafbd7f48d92Evan Cheng !TII->isPredicated(&MBB->back())) { 47027920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but ends with a " 47127920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 47227920594b940d824038d16b13846aa76cac493cfDan Gohman } 47327920594b940d824038d16b13846aa76cac493cfDan Gohman if (!Cond.empty()) { 47427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but has a condition!", 47527920594b940d824038d16b13846aa76cac493cfDan Gohman MBB); 47627920594b940d824038d16b13846aa76cac493cfDan Gohman } 47727920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (TBB && !FBB && Cond.empty()) { 47827920594b940d824038d16b13846aa76cac493cfDan Gohman // Block unconditionally branches somewhere. 4792100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich if (MBB->succ_size() != 1+LandingPadSuccs.size()) { 48027920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but doesn't have " 48127920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly one CFG successor!", MBB); 4820a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen } else if (!MBB->isSuccessor(TBB)) { 48327920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but the CFG " 48427920594b940d824038d16b13846aa76cac493cfDan Gohman "successor doesn't match the actual successor!", MBB); 48527920594b940d824038d16b13846aa76cac493cfDan Gohman } 48627920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 48727920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but doesn't contain " 48827920594b940d824038d16b13846aa76cac493cfDan Gohman "any instructions!", MBB); 4895a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng } else if (!MBB->back().isBarrier()) { 49027920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but doesn't end with a " 49127920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 4925a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng } else if (!MBB->back().isTerminator()) { 49327920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but the branch isn't a " 49427920594b940d824038d16b13846aa76cac493cfDan Gohman "terminator instruction!", MBB); 49527920594b940d824038d16b13846aa76cac493cfDan Gohman } 49627920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (TBB && !FBB && !Cond.empty()) { 49727920594b940d824038d16b13846aa76cac493cfDan Gohman // Block conditionally branches somewhere, otherwise falls through. 49827920594b940d824038d16b13846aa76cac493cfDan Gohman MachineFunction::const_iterator MBBI = MBB; 49927920594b940d824038d16b13846aa76cac493cfDan Gohman ++MBBI; 50027920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBBI == MF->end()) { 50127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB conditionally falls through out of function!", MBB); 50227920594b940d824038d16b13846aa76cac493cfDan Gohman } if (MBB->succ_size() != 2) { 50327920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but doesn't have " 50427920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly two CFG successors!", MBB); 5051dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen } else if (!matchPair(MBB->succ_begin(), TBB, MBBI)) { 50627920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but the CFG " 50727920594b940d824038d16b13846aa76cac493cfDan Gohman "successors don't match the actual successors!", MBB); 50827920594b940d824038d16b13846aa76cac493cfDan Gohman } 50927920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 51027920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but doesn't " 51127920594b940d824038d16b13846aa76cac493cfDan Gohman "contain any instructions!", MBB); 5125a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng } else if (MBB->back().isBarrier()) { 51327920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but ends with a " 51427920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 5155a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng } else if (!MBB->back().isTerminator()) { 51627920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but the branch " 51727920594b940d824038d16b13846aa76cac493cfDan Gohman "isn't a terminator instruction!", MBB); 51827920594b940d824038d16b13846aa76cac493cfDan Gohman } 51927920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (TBB && FBB) { 52027920594b940d824038d16b13846aa76cac493cfDan Gohman // Block conditionally branches somewhere, otherwise branches 52127920594b940d824038d16b13846aa76cac493cfDan Gohman // somewhere else. 52227920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->succ_size() != 2) { 52327920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but doesn't have " 52427920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly two CFG successors!", MBB); 5251dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen } else if (!matchPair(MBB->succ_begin(), TBB, FBB)) { 52627920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but the CFG " 52727920594b940d824038d16b13846aa76cac493cfDan Gohman "successors don't match the actual successors!", MBB); 52827920594b940d824038d16b13846aa76cac493cfDan Gohman } 52927920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 53027920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but doesn't " 53127920594b940d824038d16b13846aa76cac493cfDan Gohman "contain any instructions!", MBB); 5325a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng } else if (!MBB->back().isBarrier()) { 53327920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but doesn't end with a " 53427920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 5355a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng } else if (!MBB->back().isTerminator()) { 53627920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but the branch " 53727920594b940d824038d16b13846aa76cac493cfDan Gohman "isn't a terminator instruction!", MBB); 53827920594b940d824038d16b13846aa76cac493cfDan Gohman } 53927920594b940d824038d16b13846aa76cac493cfDan Gohman if (Cond.empty()) { 54027920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditinal branch/branch but there's no " 54127920594b940d824038d16b13846aa76cac493cfDan Gohman "condition!", MBB); 54227920594b940d824038d16b13846aa76cac493cfDan Gohman } 54327920594b940d824038d16b13846aa76cac493cfDan Gohman } else { 54427920594b940d824038d16b13846aa76cac493cfDan Gohman report("AnalyzeBranch returned invalid data!", MBB); 54527920594b940d824038d16b13846aa76cac493cfDan Gohman } 54627920594b940d824038d16b13846aa76cac493cfDan Gohman } 54727920594b940d824038d16b13846aa76cac493cfDan Gohman 54848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.clear(); 54981bf03eb5cd68243eabb52505105aa5f4a831bf3Dan Gohman for (MachineBasicBlock::livein_iterator I = MBB->livein_begin(), 55048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen E = MBB->livein_end(); I != E; ++I) { 55148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!TargetRegisterInfo::isPhysicalRegister(*I)) { 55248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("MBB live-in list contains non-physical register", MBB); 55348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 55448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 55548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.insert(*I); 55648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (const unsigned *R = TRI->getSubRegisters(*I); *R; R++) 55748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.insert(*R); 55848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 559710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen regsLiveInButUnused = regsLive; 560a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen 561a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen const MachineFrameInfo *MFI = MF->getFrameInfo(); 562a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen assert(MFI && "Function has no frame info"); 563a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen BitVector PR = MFI->getPristineRegs(MBB); 564a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen for (int I = PR.find_first(); I>0; I = PR.find_next(I)) { 565a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen regsLive.insert(I); 566a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen for (const unsigned *R = TRI->getSubRegisters(I); *R; R++) 567a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen regsLive.insert(*R); 568a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen } 569a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen 57048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsKilled.clear(); 57148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsDefined.clear(); 572fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen 573fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen if (Indexes) 574fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen lastIndex = Indexes->getMBBStartIdx(MBB); 57548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 57648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 577b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineInstrBefore(const MachineInstr *MI) { 578e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &MCID = MI->getDesc(); 579e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MI->getNumOperands() < MCID.getNumOperands()) { 58048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Too few operands", MI); 581e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng *OS << MCID.getNumOperands() << " operands expected, but " 58248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << MI->getNumExplicitOperands() << " given.\n"; 58348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 5842dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman 5852dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman // Check the MachineMemOperands for basic consistency. 5862dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman for (MachineInstr::mmo_iterator I = MI->memoperands_begin(), 5872dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman E = MI->memoperands_end(); I != E; ++I) { 5885a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if ((*I)->isLoad() && !MI->mayLoad()) 5892dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman report("Missing mayLoad flag", MI); 5905a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if ((*I)->isStore() && !MI->mayStore()) 5912dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman report("Missing mayStore flag", MI); 5922dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman } 5931fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen 5941fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen // Debug values must not have a slot index. 595121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // Other instructions must have one, unless they are inside a bundle. 5961fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (LiveInts) { 5971fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen bool mapped = !LiveInts->isNotInMIMap(MI); 5981fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (MI->isDebugValue()) { 5991fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (mapped) 6001fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen report("Debug instruction has a slot index", MI); 601121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } else if (MI->isInsideBundle()) { 602121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (mapped) 603121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Instruction inside bundle has a slot index", MI); 6041fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } else { 6051fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (!mapped) 6061fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen report("Missing slot index", MI); 6071fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 6081fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 6091fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen 6105adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen // Ensure non-terminators don't follow terminators. 6115a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (MI->isTerminator()) { 6125adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen if (!FirstTerminator) 6135adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen FirstTerminator = MI; 6145adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen } else if (FirstTerminator) { 6155adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen report("Non-terminator instruction after the first terminator", MI); 6165adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen *OS << "First terminator was:\t" << *FirstTerminator; 6175adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen } 6185adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen 6193be654f8082dcbdff011a6716a7c90486e28fc9eAndrew Trick StringRef ErrorInfo; 6203be654f8082dcbdff011a6716a7c90486e28fc9eAndrew Trick if (!TII->verifyInstruction(MI, ErrorInfo)) 6213be654f8082dcbdff011a6716a7c90486e28fc9eAndrew Trick report(ErrorInfo.data(), MI); 62248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 62348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 62448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenvoid 625b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund OlesenMachineVerifier::visitMachineOperand(const MachineOperand *MO, unsigned MONum) { 62648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineInstr *MI = MO->getParent(); 627e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &MCID = MI->getDesc(); 628e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCOperandInfo &MCOI = MCID.OpInfo[MONum]; 62944b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen 630e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng // The first MCID.NumDefs operands must be explicit register defines 631e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MONum < MCID.getNumDefs()) { 63244b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen if (!MO->isReg()) 63344b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen report("Explicit definition must be a register", MO, MONum); 63444b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen else if (!MO->isDef()) 63544b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen report("Explicit definition marked as use", MO, MONum); 63644b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen else if (MO->isImplicit()) 63744b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen report("Explicit definition marked as implicit", MO, MONum); 638e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng } else if (MONum < MCID.getNumOperands()) { 639113a06cff443f5d73c4f1f89bd31b0efb4222227Eric Christopher // Don't check if it's the last operand in a variadic instruction. See, 640113a06cff443f5d73c4f1f89bd31b0efb4222227Eric Christopher // e.g., LDM_RET in the arm back end. 641e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MO->isReg() && 6425a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng !(MI->isVariadic() && MONum == MCID.getNumOperands()-1)) { 643e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MO->isDef() && !MCOI.isOptionalDef()) 64422d67cf6ac84c06867681a2fe72f78d5d2b9444dCameron Zwarich report("Explicit operand marked as def", MO, MONum); 64539523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen if (MO->isImplicit()) 64639523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen report("Explicit operand marked as implicit", MO, MONum); 64739523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen } 64839523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen } else { 6495711564b091c39188775aee2768ad36a9b9a99b2Jakob Stoklund Olesen // ARM adds %reg0 operands to indicate predicates. We'll allow that. 6505a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (MO->isReg() && !MO->isImplicit() && !MI->isVariadic() && MO->getReg()) 65139523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen report("Extra explicit operand on non-variadic instruction", MO, MONum); 65244b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen } 65344b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen 65448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen switch (MO->getType()) { 65548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen case MachineOperand::MO_Register: { 65648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const unsigned Reg = MO->getReg(); 65748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!Reg) 65848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return; 65948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 66048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Check Live Variables. 6618ec88ba58866a840a27ab5172fd2b954780b52f3Cameron Zwarich if (MI->isDebugValue()) { 6628ec88ba58866a840a27ab5172fd2b954780b52f3Cameron Zwarich // Liveness checks are not valid for debug values. 6638e53aca51a141c99209ced69c9a51f52f6a8370bJakob Stoklund Olesen } else if (MO->isUse() && !MO->isUndef()) { 664710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen regsLiveInButUnused.erase(Reg); 665710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen 6668f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool isKill = false; 6671b2c761a9cc9a57b417c676f4bd97d11b6ba1869Jakob Stoklund Olesen unsigned defIdx; 6681b2c761a9cc9a57b417c676f4bd97d11b6ba1869Jakob Stoklund Olesen if (MI->isRegTiedToDefOperand(MONum, &defIdx)) { 6691b2c761a9cc9a57b417c676f4bd97d11b6ba1869Jakob Stoklund Olesen // A two-addr use counts as a kill if use and def are the same. 6701b2c761a9cc9a57b417c676f4bd97d11b6ba1869Jakob Stoklund Olesen unsigned DefReg = MI->getOperand(defIdx).getReg(); 67102ae9f2f273d53fa5c5de4134ffd22ff2cedb115Jakob Stoklund Olesen if (Reg == DefReg) 6721b2c761a9cc9a57b417c676f4bd97d11b6ba1869Jakob Stoklund Olesen isKill = true; 67302ae9f2f273d53fa5c5de4134ffd22ff2cedb115Jakob Stoklund Olesen else if (TargetRegisterInfo::isPhysicalRegister(Reg)) { 6741b2c761a9cc9a57b417c676f4bd97d11b6ba1869Jakob Stoklund Olesen report("Two-address instruction operands must be identical", 6751b2c761a9cc9a57b417c676f4bd97d11b6ba1869Jakob Stoklund Olesen MO, MONum); 6761b2c761a9cc9a57b417c676f4bd97d11b6ba1869Jakob Stoklund Olesen } 6771b2c761a9cc9a57b417c676f4bd97d11b6ba1869Jakob Stoklund Olesen } else 6781b2c761a9cc9a57b417c676f4bd97d11b6ba1869Jakob Stoklund Olesen isKill = MO->isKill(); 6791b2c761a9cc9a57b417c676f4bd97d11b6ba1869Jakob Stoklund Olesen 680c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen if (isKill) 6818f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen addRegWithSubRegs(regsKilled, Reg); 6828f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 683c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen // Check that LiveVars knows this kill. 684c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen if (LiveVars && TargetRegisterInfo::isVirtualRegister(Reg) && 685c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen MO->isKill()) { 686c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen LiveVariables::VarInfo &VI = LiveVars->getVarInfo(Reg); 687c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen if (std::find(VI.Kills.begin(), 688c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen VI.Kills.end(), MI) == VI.Kills.end()) 689c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen report("Kill missing from LiveVariables", MO, MONum); 69048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 6918f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 6921fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen // Check LiveInts liveness and kill. 693ab56647e6b2a7b376f0c245a0bc92cd632107edbJakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(Reg) && 694ab56647e6b2a7b376f0c245a0bc92cd632107edbJakob Stoklund Olesen LiveInts && !LiveInts->isNotInMIMap(MI)) { 6952debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex UseIdx = LiveInts->getInstructionIndex(MI).getRegSlot(true); 6961fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (LiveInts->hasInterval(Reg)) { 6971fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen const LiveInterval &LI = LiveInts->getInterval(Reg); 6981fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (!LI.liveAt(UseIdx)) { 6991fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen report("No live range at use", MO, MONum); 7001fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen *OS << UseIdx << " is not live in " << LI << '\n'; 7011fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 702a7b586ba7410dd2dddbfa82a6a57485985747f2cJakob Stoklund Olesen // Check for extra kill flags. 703a7b586ba7410dd2dddbfa82a6a57485985747f2cJakob Stoklund Olesen // Note that we allow missing kill flags for now. 7042debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen if (MO->isKill() && !LI.killedAt(UseIdx.getRegSlot())) { 705a7b586ba7410dd2dddbfa82a6a57485985747f2cJakob Stoklund Olesen report("Live range continues after kill flag", MO, MONum); 706a7b586ba7410dd2dddbfa82a6a57485985747f2cJakob Stoklund Olesen *OS << "Live range: " << LI << '\n'; 7071c163d2a06e94375b811f807b1667d419f5cb258Jakob Stoklund Olesen } 708ab56647e6b2a7b376f0c245a0bc92cd632107edbJakob Stoklund Olesen } else { 7091fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen report("Virtual register has no Live interval", MO, MONum); 7101fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 7111fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 7121fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen 713710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen // Use of a dead register. 714710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen if (!regsLive.count(Reg)) { 71548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Reg)) { 7164af0f5fecb42563ff3ca5bd7fddb2f4f111e2fefJakob Stoklund Olesen // Reserved registers may be used even when 'dead'. 7174af0f5fecb42563ff3ca5bd7fddb2f4f111e2fefJakob Stoklund Olesen if (!isReserved(Reg)) 71848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Using an undefined physical register", MO, MONum); 71948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 72048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MI->getParent()]; 72148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // We don't know which virtual registers are live in, so only complain 72248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // if vreg was killed in this MBB. Otherwise keep track of vregs that 72348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // must be live in. PHI instructions are handled separately. 72448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (MInfo.regsKilled.count(Reg)) 72548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Using a killed virtual register", MO, MONum); 726518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner else if (!MI->isPHI()) 72748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MInfo.vregsLiveIn.insert(std::make_pair(Reg, MI)); 72848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 729e556720ea8d60581c95d3ca3f9175a3688150d95Duncan Sands } 7308e53aca51a141c99209ced69c9a51f52f6a8370bJakob Stoklund Olesen } else if (MO->isDef()) { 73148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Register defined. 73248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // TODO: verify that earlyclobber ops are not used. 73348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (MO->isDead()) 73448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen addRegWithSubRegs(regsDead, Reg); 735710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen else 736710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen addRegWithSubRegs(regsDefined, Reg); 7371fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen 73893e6f02759a9d98c0c0621540382074219aa374aJakob Stoklund Olesen // Verify SSA form. 73993e6f02759a9d98c0c0621540382074219aa374aJakob Stoklund Olesen if (MRI->isSSA() && TargetRegisterInfo::isVirtualRegister(Reg) && 74093e6f02759a9d98c0c0621540382074219aa374aJakob Stoklund Olesen llvm::next(MRI->def_begin(Reg)) != MRI->def_end()) 74193e6f02759a9d98c0c0621540382074219aa374aJakob Stoklund Olesen report("Multiple virtual register defs in SSA form", MO, MONum); 74293e6f02759a9d98c0c0621540382074219aa374aJakob Stoklund Olesen 743775aa22da28c0ded619308fa71a9be2b16bcd19bJakob Stoklund Olesen // Check LiveInts for a live range, but only for virtual registers. 744775aa22da28c0ded619308fa71a9be2b16bcd19bJakob Stoklund Olesen if (LiveInts && TargetRegisterInfo::isVirtualRegister(Reg) && 745775aa22da28c0ded619308fa71a9be2b16bcd19bJakob Stoklund Olesen !LiveInts->isNotInMIMap(MI)) { 7462debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex DefIdx = LiveInts->getInstructionIndex(MI).getRegSlot(); 7471fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (LiveInts->hasInterval(Reg)) { 7481fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen const LiveInterval &LI = LiveInts->getInterval(Reg); 749ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen if (const VNInfo *VNI = LI.getVNInfoAt(DefIdx)) { 750ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen assert(VNI && "NULL valno is not allowed"); 7511b031ddedec2901ef01f103512b1d79f63a1bb85Cameron Zwarich if (VNI->def != DefIdx && !MO->isEarlyClobber()) { 7521fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen report("Inconsistent valno->def", MO, MONum); 753ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen *OS << "Valno " << VNI->id << " is not defined at " 7541fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen << DefIdx << " in " << LI << '\n'; 7551fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 7561fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } else { 7571fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen report("No live range at def", MO, MONum); 7581fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen *OS << DefIdx << " is not live in " << LI << '\n'; 7591fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 760775aa22da28c0ded619308fa71a9be2b16bcd19bJakob Stoklund Olesen } else { 7611fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen report("Virtual register has no Live interval", MO, MONum); 7621fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 7631fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 76448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 76548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 76648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Check register classes. 767e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MONum < MCID.getNumOperands() && !MO->isImplicit()) { 76848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned SubIdx = MO->getSubReg(); 76948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 77048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Reg)) { 77148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SubIdx) { 772b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen report("Illegal subregister index for physical register", MO, MONum); 773b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen return; 77448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 775e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (const TargetRegisterClass *DRC = TII->getRegClass(MCID,MONum,TRI)) { 776b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (!DRC->contains(Reg)) { 77748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Illegal physical register for instruction", MO, MONum); 778b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen *OS << TRI->getName(Reg) << " is not a " 77948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << DRC->getName() << " register.\n"; 78048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 78148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 78248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 78348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Virtual register. 78448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const TargetRegisterClass *RC = MRI->getRegClass(Reg); 78548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SubIdx) { 786b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen const TargetRegisterClass *SRC = 787b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen TRI->getSubClassWithSubReg(RC, SubIdx); 7886a8d2c6119aeb32ac914c3dd9b1263ebd0baa51fJakob Stoklund Olesen if (!SRC) { 78948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Invalid subregister index for virtual register", MO, MONum); 7906a8d2c6119aeb32ac914c3dd9b1263ebd0baa51fJakob Stoklund Olesen *OS << "Register class " << RC->getName() 7916a8d2c6119aeb32ac914c3dd9b1263ebd0baa51fJakob Stoklund Olesen << " does not support subreg index " << SubIdx << "\n"; 79248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return; 79348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 794b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (RC != SRC) { 795b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen report("Invalid register class for subregister index", MO, MONum); 796b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen *OS << "Register class " << RC->getName() 797b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen << " does not fully support subreg index " << SubIdx << "\n"; 798b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen return; 799b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen } 80048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 801e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (const TargetRegisterClass *DRC = TII->getRegClass(MCID,MONum,TRI)) { 802b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (SubIdx) { 803b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen const TargetRegisterClass *SuperRC = 804b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen TRI->getLargestLegalSuperClass(RC); 805b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (!SuperRC) { 806b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen report("No largest legal super class exists.", MO, MONum); 807b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen return; 808b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen } 809b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen DRC = TRI->getMatchingSuperRegClass(SuperRC, DRC, SubIdx); 810b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (!DRC) { 811b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen report("No matching super-reg register class.", MO, MONum); 812b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen return; 813b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen } 814b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen } 815fa226bccaa90c520cac154df74069bbabb976eabJakob Stoklund Olesen if (!RC->hasSuperClassEq(DRC)) { 81648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Illegal virtual register for instruction", MO, MONum); 81748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "Expected a " << DRC->getName() << " register, but got a " 81848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << RC->getName() << " register\n"; 81948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 82048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 82148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 82248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 82348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen break; 82448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 825a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen 8269ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen case MachineOperand::MO_RegisterMask: 8279ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen regMasks.push_back(MO->getRegMask()); 8289ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen break; 8299ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen 830a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen case MachineOperand::MO_MachineBasicBlock: 831518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner if (MI->isPHI() && !MO->getMBB()->isSuccessor(MI->getParent())) 832518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner report("PHI operand is not in the CFG", MO, MONum); 833a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen break; 834a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen 835e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen case MachineOperand::MO_FrameIndex: 836e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen if (LiveStks && LiveStks->hasInterval(MO->getIndex()) && 837e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveInts && !LiveInts->isNotInMIMap(MI)) { 838e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveInterval &LI = LiveStks->getInterval(MO->getIndex()); 839e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen SlotIndex Idx = LiveInts->getInstructionIndex(MI); 8405a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (MI->mayLoad() && !LI.liveAt(Idx.getRegSlot(true))) { 841e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen report("Instruction loads from dead spill slot", MO, MONum); 842e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen *OS << "Live stack: " << LI << '\n'; 843e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen } 8445a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (MI->mayStore() && !LI.liveAt(Idx.getRegSlot())) { 845e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen report("Instruction stores to dead spill slot", MO, MONum); 846e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen *OS << "Live stack: " << LI << '\n'; 847e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen } 848e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen } 849e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen break; 850e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen 85148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen default: 85248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen break; 85348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 85448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 85548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 856b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineInstrAfter(const MachineInstr *MI) { 85748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MI->getParent()]; 85848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen set_union(MInfo.regsKilled, regsKilled); 85973cf709a08d480c4315dc4aa9f644cf86494c4cfJakob Stoklund Olesen set_subtract(regsLive, regsKilled); regsKilled.clear(); 8609ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen // Kill any masked registers. 8619ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen while (!regMasks.empty()) { 8629ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen const uint32_t *Mask = regMasks.pop_back_val(); 8639ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen for (RegSet::iterator I = regsLive.begin(), E = regsLive.end(); I != E; ++I) 8649ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(*I) && 8659ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen MachineOperand::clobbersPhysReg(Mask, *I)) 8669ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen regsDead.push_back(*I); 8679ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen } 86873cf709a08d480c4315dc4aa9f644cf86494c4cfJakob Stoklund Olesen set_subtract(regsLive, regsDead); regsDead.clear(); 86973cf709a08d480c4315dc4aa9f644cf86494c4cfJakob Stoklund Olesen set_union(regsLive, regsDefined); regsDefined.clear(); 870fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen 871fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen if (Indexes && Indexes->hasIndex(MI)) { 872fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen SlotIndex idx = Indexes->getInstructionIndex(MI); 873fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen if (!(idx > lastIndex)) { 874fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen report("Instruction index out of order", MI); 875fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen *OS << "Last instruction was at " << lastIndex << '\n'; 876fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen } 877fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen lastIndex = idx; 878fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen } 87948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 88048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 88148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenvoid 882b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund OlesenMachineVerifier::visitMachineBasicBlockAfter(const MachineBasicBlock *MBB) { 88348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MBBInfoMap[MBB].regsLiveOut = regsLive; 88448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.clear(); 885fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen 886fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen if (Indexes) { 887fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen SlotIndex stop = Indexes->getMBBEndIdx(MBB); 888fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen if (!(stop > lastIndex)) { 889fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen report("Block ends before last instruction index", MBB); 890fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen *OS << "Block ends at " << stop 891fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen << " last instruction was at " << lastIndex << '\n'; 892fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen } 893fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen lastIndex = stop; 894fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen } 89548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 89648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 89748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Calculate the largest possible vregsPassed sets. These are the registers that 89848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// can pass through an MBB live, but may not be live every time. It is assumed 89948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// that all vregsPassed sets are empty before the call. 900b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesenvoid MachineVerifier::calcRegsPassed() { 90148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // First push live-out regs to successors' vregsPassed. Remember the MBBs that 90248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // have any vregsPassed. 90348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen DenseSet<const MachineBasicBlock*> todo; 90448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF->begin(), MFE = MF->end(); 90548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI != MFE; ++MFI) { 90648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineBasicBlock &MBB(*MFI); 90748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[&MBB]; 90848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) 90948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 91048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator SuI = MBB.succ_begin(), 91148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen SuE = MBB.succ_end(); SuI != SuE; ++SuI) { 91248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &SInfo = MBBInfoMap[*SuI]; 91348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SInfo.addPassed(MInfo.regsLiveOut)) 91448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.insert(*SuI); 91548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 91648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 91748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 91848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Iteratively push vregsPassed to successors. This will converge to the same 91948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // final state regardless of DenseSet iteration order. 92048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen while (!todo.empty()) { 92148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineBasicBlock *MBB = *todo.begin(); 92248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.erase(MBB); 92348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MBB]; 92448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator SuI = MBB->succ_begin(), 92548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen SuE = MBB->succ_end(); SuI != SuE; ++SuI) { 92648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (*SuI == MBB) 92748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 92848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &SInfo = MBBInfoMap[*SuI]; 92948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SInfo.addPassed(MInfo.vregsPassed)) 93048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.insert(*SuI); 93148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 93248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 93348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 93448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 9358f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen// Calculate the set of virtual registers that must be passed through each basic 9368f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen// block in order to satisfy the requirements of successor blocks. This is very 937b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen// similar to calcRegsPassed, only backwards. 9388f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesenvoid MachineVerifier::calcRegsRequired() { 9398f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // First push live-in regs to predecessors' vregsRequired. 9408f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen DenseSet<const MachineBasicBlock*> todo; 9418f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF->begin(), MFE = MF->end(); 9428f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen MFI != MFE; ++MFI) { 9438f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen const MachineBasicBlock &MBB(*MFI); 9448f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[&MBB]; 9458f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MBB.pred_begin(), 9468f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen PrE = MBB.pred_end(); PrI != PrE; ++PrI) { 9478f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &PInfo = MBBInfoMap[*PrI]; 9488f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (PInfo.addRequired(MInfo.vregsLiveIn)) 9498f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen todo.insert(*PrI); 9508f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 9518f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 9528f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 9538f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Iteratively push vregsRequired to predecessors. This will converge to the 9548f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // same final state regardless of DenseSet iteration order. 9558f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen while (!todo.empty()) { 9568f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen const MachineBasicBlock *MBB = *todo.begin(); 9578f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen todo.erase(MBB); 9588f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MBB]; 9598f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MBB->pred_begin(), 9608f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen PrE = MBB->pred_end(); PrI != PrE; ++PrI) { 9618f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (*PrI == MBB) 9628f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen continue; 9638f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &SInfo = MBBInfoMap[*PrI]; 9648f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (SInfo.addRequired(MInfo.vregsRequired)) 9658f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen todo.insert(*PrI); 9668f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 9678f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 9688f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen} 9698f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 97048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Check PHI instructions at the beginning of MBB. It is assumed that 971b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen// calcRegsPassed has been run so BBInfo::isLiveOut is valid. 972b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::checkPHIOps(const MachineBasicBlock *MBB) { 97348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_iterator BBI = MBB->begin(), BBE = MBB->end(); 974518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner BBI != BBE && BBI->isPHI(); ++BBI) { 97548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen DenseSet<const MachineBasicBlock*> seen; 97648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 97748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (unsigned i = 1, e = BBI->getNumOperands(); i != e; i += 2) { 97848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned Reg = BBI->getOperand(i).getReg(); 97948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineBasicBlock *Pre = BBI->getOperand(i + 1).getMBB(); 98048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!Pre->isSuccessor(MBB)) 98148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 98248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen seen.insert(Pre); 98348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &PrInfo = MBBInfoMap[Pre]; 98448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (PrInfo.reachable && !PrInfo.isLiveOut(Reg)) 98548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("PHI operand is not live-out from predecessor", 98648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen &BBI->getOperand(i), i); 98748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 98848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 98948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Did we see all predecessors? 99048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MBB->pred_begin(), 99148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen PrE = MBB->pred_end(); PrI != PrE; ++PrI) { 99248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!seen.count(*PrI)) { 99348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Missing PHI operand", BBI); 9940ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman *OS << "BB#" << (*PrI)->getNumber() 99548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " is a predecessor according to the CFG.\n"; 99648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 99748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 99848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 99948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 100048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 1001b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineFunctionAfter() { 1002b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen calcRegsPassed(); 100348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 100448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF->begin(), MFE = MF->end(); 100548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI != MFE; ++MFI) { 100648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MFI]; 100748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 100848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Skip unreachable MBBs. 100948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) 101048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 101148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 1012b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen checkPHIOps(MFI); 101348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 101448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 101558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen // Now check liveness info if available 101658e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen if (LiveVars || LiveInts) 10178f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen calcRegsRequired(); 101858e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen if (LiveVars) 10198f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen verifyLiveVariables(); 102058e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen if (LiveInts) 102158e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen verifyLiveIntervals(); 102248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 10238f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 10248f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesenvoid MachineVerifier::verifyLiveVariables() { 10258f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen assert(LiveVars && "Don't call verifyLiveVariables without LiveVars"); 102698c54760704878cf5290a9a3b23876b7550c5560Jakob Stoklund Olesen for (unsigned i = 0, e = MRI->getNumVirtRegs(); i != e; ++i) { 102798c54760704878cf5290a9a3b23876b7550c5560Jakob Stoklund Olesen unsigned Reg = TargetRegisterInfo::index2VirtReg(i); 10288f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen LiveVariables::VarInfo &VI = LiveVars->getVarInfo(Reg); 10298f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF->begin(), MFE = MF->end(); 10308f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen MFI != MFE; ++MFI) { 10318f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MFI]; 10328f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 10338f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Our vregsRequired should be identical to LiveVariables' AliveBlocks 10348f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (MInfo.vregsRequired.count(Reg)) { 10358f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (!VI.AliveBlocks.test(MFI->getNumber())) { 10368f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen report("LiveVariables: Block missing from AliveBlocks", MFI); 10374314268128be6d54c9a7f0709680e5a5b40f3ab3Jakob Stoklund Olesen *OS << "Virtual register " << PrintReg(Reg) 10388f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen << " must be live through the block.\n"; 10398f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 10408f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } else { 10418f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (VI.AliveBlocks.test(MFI->getNumber())) { 10428f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen report("LiveVariables: Block should not be in AliveBlocks", MFI); 10434314268128be6d54c9a7f0709680e5a5b40f3ab3Jakob Stoklund Olesen *OS << "Virtual register " << PrintReg(Reg) 10448f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen << " is not needed live through the block.\n"; 10458f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 10468f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 10478f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 10488f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 10498f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen} 10508f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 105158e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesenvoid MachineVerifier::verifyLiveIntervals() { 105258e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen assert(LiveInts && "Don't call verifyLiveIntervals without LiveInts"); 105358e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen for (LiveIntervals::const_iterator LVI = LiveInts->begin(), 105458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen LVE = LiveInts->end(); LVI != LVE; ++LVI) { 105558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen const LiveInterval &LI = *LVI->second; 1056893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen 1057893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen // Spilling and splitting may leave unused registers around. Skip them. 1058893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen if (MRI->use_empty(LI.reg)) 1059893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen continue; 1060893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen 10618c4564287d5231421d5358d71d23f46cd0be18c7Jakob Stoklund Olesen // Physical registers have much weirdness going on, mostly from coalescing. 10628c4564287d5231421d5358d71d23f46cd0be18c7Jakob Stoklund Olesen // We should probably fix it, but for now just ignore them. 10638c4564287d5231421d5358d71d23f46cd0be18c7Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(LI.reg)) 10648c4564287d5231421d5358d71d23f46cd0be18c7Jakob Stoklund Olesen continue; 10658c4564287d5231421d5358d71d23f46cd0be18c7Jakob Stoklund Olesen 106658e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen assert(LVI->first == LI.reg && "Invalid reg to interval mapping"); 106758e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 106858e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen for (LiveInterval::const_vni_iterator I = LI.vni_begin(), E = LI.vni_end(); 106958e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen I!=E; ++I) { 107058e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen VNInfo *VNI = *I; 1071ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen const VNInfo *DefVNI = LI.getVNInfoAt(VNI->def); 107258e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1073ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen if (!DefVNI) { 107458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen if (!VNI->isUnused()) { 107558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen report("Valno not live at def and not marked unused", MF); 107658e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " in " << LI << '\n'; 107758e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 107858e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen continue; 107958e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 108058e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 108158e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen if (VNI->isUnused()) 108258e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen continue; 108358e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1084ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen if (DefVNI != VNI) { 108558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen report("Live range at def has different valno", MF); 1086ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 1087dbcc2e119d57dba1e2f013d304ebfbe894c98106Jakob Stoklund Olesen << " where valno #" << DefVNI->id << " is live in " << LI << '\n'; 10883bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen continue; 108958e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 109058e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 10913bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen const MachineBasicBlock *MBB = LiveInts->getMBBFromIndex(VNI->def); 10923bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen if (!MBB) { 10933bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen report("Invalid definition index", MF); 1094dbcc2e119d57dba1e2f013d304ebfbe894c98106Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 1095dbcc2e119d57dba1e2f013d304ebfbe894c98106Jakob Stoklund Olesen << " in " << LI << '\n'; 10963bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen continue; 10973bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen } 10983bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen 10993bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen if (VNI->isPHIDef()) { 11003bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen if (VNI->def != LiveInts->getMBBStartIdx(MBB)) { 11013bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen report("PHIDef value is not defined at MBB start", MF); 11023bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 1103dbcc2e119d57dba1e2f013d304ebfbe894c98106Jakob Stoklund Olesen << ", not at the beginning of BB#" << MBB->getNumber() 1104dbcc2e119d57dba1e2f013d304ebfbe894c98106Jakob Stoklund Olesen << " in " << LI << '\n'; 11053bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen } 11063bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen } else { 11073bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen // Non-PHI def. 110830e98a03a3c524026e2da2607e04bb655b0b6350Jakob Stoklund Olesen const MachineInstr *MI = LiveInts->getInstructionFromIndex(VNI->def); 11093bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen if (!MI) { 11103bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen report("No instruction at def index", MF); 11117871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 11127871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen << " in " << LI << '\n'; 1113121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 11143bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen } 11150b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich 1116121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen bool hasDef = false; 11170b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich bool isEarlyClobber = false; 111830e98a03a3c524026e2da2607e04bb655b0b6350Jakob Stoklund Olesen for (ConstMIBundleOperands MOI(MI); MOI.isValid(); ++MOI) { 1119121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!MOI->isReg() || !MOI->isDef()) 1120121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 1121121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(LI.reg)) { 1122121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (MOI->getReg() != LI.reg) 1123121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 1124121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } else { 1125121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!TargetRegisterInfo::isPhysicalRegister(MOI->getReg()) || 1126121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen !TRI->regsOverlap(LI.reg, MOI->getReg())) 1127121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 11280b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich } 1129121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen hasDef = true; 1130121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (MOI->isEarlyClobber()) 1131121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen isEarlyClobber = true; 1132121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1133121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1134121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!hasDef) { 1135121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Defining instruction does not modify register", MI); 1136121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " in " << LI << '\n'; 11370b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich } 11380b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich 11390b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich // Early clobber defs begin at USE slots, but other defs must begin at 11400b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich // DEF slots. 11410b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich if (isEarlyClobber) { 11422debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen if (!VNI->def.isEarlyClobber()) { 11432debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen report("Early clobber def must be at an early-clobber slot", MF); 11440b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 11450b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich << " in " << LI << '\n'; 11460b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich } 11472debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen } else if (!VNI->def.isRegister()) { 11482debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen report("Non-PHI, non-early clobber def must be at a register slot", 11492debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen MF); 11500b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 11510b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich << " in " << LI << '\n'; 11520b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich } 11533bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen } 115458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 115558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 115658e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen for (LiveInterval::const_iterator I = LI.begin(), E = LI.end(); I!=E; ++I) { 1157ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen const VNInfo *VNI = I->valno; 1158ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen assert(VNI && "Live range has no valno"); 115958e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1160ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen if (VNI->id >= LI.getNumValNums() || VNI != LI.getValNumInfo(VNI->id)) { 116158e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen report("Foreign valno in live range", MF); 1162ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen I->print(*OS); 116358e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen *OS << " has a valno not in " << LI << '\n'; 116458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 116558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1166ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen if (VNI->isUnused()) { 116758e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen report("Live range valno is marked unused", MF); 1168ed8263553ab80e99704554c6f34d7d5a27bf45f0Jakob Stoklund Olesen I->print(*OS); 116958e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen *OS << " in " << LI << '\n'; 117058e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 117158e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 11727871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen const MachineBasicBlock *MBB = LiveInts->getMBBFromIndex(I->start); 11737871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen if (!MBB) { 11747871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen report("Bad start of live segment, no basic block", MF); 11757871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen I->print(*OS); 11767871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen *OS << " in " << LI << '\n'; 11777871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen continue; 11787871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 11797871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen SlotIndex MBBStartIdx = LiveInts->getMBBStartIdx(MBB); 11807871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen if (I->start != MBBStartIdx && I->start != VNI->def) { 11817871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen report("Live segment must begin at MBB entry or valno def", MBB); 11827871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen I->print(*OS); 11837871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen *OS << " in " << LI << '\n' << "Basic block starts at " 11847871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen << MBBStartIdx << '\n'; 11857871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 11867871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen 11877871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen const MachineBasicBlock *EndMBB = 11887871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen LiveInts->getMBBFromIndex(I->end.getPrevSlot()); 11897871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen if (!EndMBB) { 11907871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen report("Bad end of live segment, no basic block", MF); 11917871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen I->print(*OS); 11927871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen *OS << " in " << LI << '\n'; 11937871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen continue; 11947871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 1195121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1196121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // No more checks for live-out segments. 1197121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (I->end == LiveInts->getMBBEndIdx(EndMBB)) 1198121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 1199121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1200121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // The live segment is ending inside EndMBB 120130e98a03a3c524026e2da2607e04bb655b0b6350Jakob Stoklund Olesen const MachineInstr *MI = 1202121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen LiveInts->getInstructionFromIndex(I->end.getPrevSlot()); 1203121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!MI) { 1204121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Live segment doesn't end at a valid instruction", EndMBB); 12057871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen I->print(*OS); 12067871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen *OS << " in " << LI << '\n' << "Basic block starts at " 1207121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen << MBBStartIdx << '\n'; 1208121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 1209121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1210121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1211121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // The block slot must refer to a basic block boundary. 1212121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (I->end.isBlock()) { 1213121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Live segment ends at B slot of an instruction", MI); 1214121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen I->print(*OS); 1215121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen *OS << " in " << LI << '\n'; 1216121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1217636f15ff04c9188ea3bf91477fda1cc29f2c4a61Cameron Zwarich 1218121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (I->end.isDead()) { 1219121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // Segment ends on the dead slot. 1220121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // That means there must be a dead def. 1221121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!SlotIndex::isSameInstr(I->start, I->end)) { 1222121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Live segment ending at dead slot spans instructions", MI); 1223121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen I->print(*OS); 1224121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen *OS << " in " << LI << '\n'; 1225121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1226121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1227121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1228121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // A live segment can only end at an early-clobber slot if it is being 1229121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // redefined by an early-clobber def. 1230121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (I->end.isEarlyClobber()) { 1231121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (I+1 == E || (I+1)->start != I->end) { 1232121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Live segment ending at early clobber slot must be " 1233121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen "redefined by an EC def in the same instruction", MI); 1234121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen I->print(*OS); 1235121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen *OS << " in " << LI << '\n'; 1236121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1237121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1238121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1239121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // The following checks only apply to virtual registers. Physreg liveness 1240121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // is too weird to check. 1241121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(LI.reg)) { 1242121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // A live range can end with either a redefinition, a kill flag on a 1243121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // use, or a dead flag on a def. 1244121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen bool hasRead = false; 1245121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen bool hasDeadDef = false; 124630e98a03a3c524026e2da2607e04bb655b0b6350Jakob Stoklund Olesen for (ConstMIBundleOperands MOI(MI); MOI.isValid(); ++MOI) { 1247121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!MOI->isReg() || MOI->getReg() != LI.reg) 1248121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 1249121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (MOI->readsReg()) 1250121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen hasRead = true; 1251121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (MOI->isDef() && MOI->isDead()) 1252121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen hasDeadDef = true; 1253121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1254121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1255121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (I->end.isDead()) { 1256636f15ff04c9188ea3bf91477fda1cc29f2c4a61Cameron Zwarich if (!hasDeadDef) { 1257121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Instruction doesn't have a dead def operand", MI); 1258121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen I->print(*OS); 1259121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen *OS << " in " << LI << '\n'; 1260121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1261121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } else { 1262121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (!hasRead) { 1263121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Instruction ending live range doesn't read the register", 1264121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen MI); 1265636f15ff04c9188ea3bf91477fda1cc29f2c4a61Cameron Zwarich I->print(*OS); 1266636f15ff04c9188ea3bf91477fda1cc29f2c4a61Cameron Zwarich *OS << " in " << LI << '\n'; 1267636f15ff04c9188ea3bf91477fda1cc29f2c4a61Cameron Zwarich } 12687871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 12697871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 12707871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen 12717871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen // Now check all the basic blocks in this live segment. 12727871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen MachineFunction::const_iterator MFI = MBB; 1273cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich // Is this live range the beginning of a non-PHIDef VN? 1274cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich if (I->start == VNI->def && !VNI->isPHIDef()) { 12757871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen // Not live-in to any blocks. 12767871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen if (MBB == EndMBB) 12777871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen continue; 12787871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen // Skip this block. 12797871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen ++MFI; 12807871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 12817871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen for (;;) { 12827871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen assert(LiveInts->isLiveInToMBB(LI, MFI)); 1283e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen // We don't know how to track physregs into a landing pad. 1284e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(LI.reg) && 1285e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen MFI->isLandingPad()) { 1286e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen if (&*MFI == EndMBB) 1287e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen break; 1288e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen ++MFI; 1289e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen continue; 1290e459d55f2832b52a3cfe0350d791c88a0a45fad8Jakob Stoklund Olesen } 12917871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen // Check that VNI is live-out of all predecessors. 12927871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PI = MFI->pred_begin(), 12937871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen PE = MFI->pred_end(); PI != PE; ++PI) { 1294194eb71a11a77c7fb576780783a77e64924dfb10Jakob Stoklund Olesen SlotIndex PEnd = LiveInts->getMBBEndIdx(*PI); 1295194eb71a11a77c7fb576780783a77e64924dfb10Jakob Stoklund Olesen const VNInfo *PVNI = LI.getVNInfoBefore(PEnd); 12964eee42cb282753ad43e929b0955d7d44c1580905Cameron Zwarich 1297df8412c4c1a3a798c5a849ebc3f56904568d40c4Jakob Stoklund Olesen if (VNI->isPHIDef() && VNI->def == LiveInts->getMBBStartIdx(MFI)) 12984eee42cb282753ad43e929b0955d7d44c1580905Cameron Zwarich continue; 12994eee42cb282753ad43e929b0955d7d44c1580905Cameron Zwarich 1300cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich if (!PVNI) { 1301cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich report("Register not marked live out of predecessor", *PI); 1302cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich *OS << "Valno #" << VNI->id << " live into BB#" << MFI->getNumber() 1303194eb71a11a77c7fb576780783a77e64924dfb10Jakob Stoklund Olesen << '@' << LiveInts->getMBBStartIdx(MFI) << ", not live before " 1304cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich << PEnd << " in " << LI << '\n'; 1305cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich continue; 1306cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich } 1307cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich 13084eee42cb282753ad43e929b0955d7d44c1580905Cameron Zwarich if (PVNI != VNI) { 13097871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen report("Different value live out of predecessor", *PI); 13107871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen *OS << "Valno #" << PVNI->id << " live out of BB#" 13117871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen << (*PI)->getNumber() << '@' << PEnd 13127871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen << "\nValno #" << VNI->id << " live into BB#" << MFI->getNumber() 13137871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen << '@' << LiveInts->getMBBStartIdx(MFI) << " in " << LI << '\n'; 13147871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 13157871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 13167871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen if (&*MFI == EndMBB) 13177871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen break; 13187871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen ++MFI; 13197871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 132058e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 1321501dc4224586d3cee61101ed6cd0ccc8ba74c43cJakob Stoklund Olesen 1322501dc4224586d3cee61101ed6cd0ccc8ba74c43cJakob Stoklund Olesen // Check the LI only has one connected component. 13238c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(LI.reg)) { 13248c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen ConnectedVNInfoEqClasses ConEQ(*LiveInts); 13258c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen unsigned NumComp = ConEQ.Classify(&LI); 13268c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen if (NumComp > 1) { 13278c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen report("Multiple connected components in live interval", MF); 13288c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen *OS << NumComp << " components in " << LI << '\n'; 1329cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen for (unsigned comp = 0; comp != NumComp; ++comp) { 1330cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen *OS << comp << ": valnos"; 1331cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen for (LiveInterval::const_vni_iterator I = LI.vni_begin(), 1332cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen E = LI.vni_end(); I!=E; ++I) 1333cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen if (comp == ConEQ.getEqClass(*I)) 1334cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen *OS << ' ' << (*I)->id; 1335cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen *OS << '\n'; 1336cb367778c0fb3200292df4f3982f54167444d1f6Jakob Stoklund Olesen } 13378c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen } 1338501dc4224586d3cee61101ed6cd0ccc8ba74c43cJakob Stoklund Olesen } 133958e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 134058e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen} 13418f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 1342