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 26d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/CodeGen/Passes.h" 27d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/DenseSet.h" 287310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren#include "llvm/ADT/DepthFirstIterator.h" 29d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SetOperations.h" 30d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SmallVector.h" 311fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen#include "llvm/CodeGen/LiveIntervalAnalysis.h" 32e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen#include "llvm/CodeGen/LiveStackAnalysis.h" 33d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/CodeGen/LiveVariables.h" 34a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen#include "llvm/CodeGen/MachineFrameInfo.h" 35d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/CodeGen/MachineFunctionPass.h" 362dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman#include "llvm/CodeGen/MachineMemOperand.h" 3748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/CodeGen/MachineRegisterInfo.h" 380b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/BasicBlock.h" 390b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/InlineAsm.h" 400b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 41d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling#include "llvm/MC/MCAsmInfo.h" 4248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen#include "llvm/Support/Debug.h" 437d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/ErrorHandling.h" 44dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#include "llvm/Support/FileSystem.h" 457d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/raw_ostream.h" 46d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetInstrInfo.h" 47d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetMachine.h" 48d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetRegisterInfo.h" 4948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenusing namespace llvm; 5048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 5148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesennamespace { 528f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen struct MachineVerifier { 5348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 5489cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen MachineVerifier(Pass *pass, const char *b) : 558f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen PASS(pass), 5689cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen Banner(b), 5748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen OutFileName(getenv("LLVM_VERIFY_MACHINEINSTRS")) 588f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen {} 5948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 6048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool runOnMachineFunction(MachineFunction &MF); 6148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 628f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen Pass *const PASS; 6389cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen const char *Banner; 6448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const char *const OutFileName; 6517e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner raw_ostream *OS; 6648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineFunction *MF; 6748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const TargetMachine *TM; 6815993f83a419950f06d2879d6701530ae6449317Evan Cheng const TargetInstrInfo *TII; 6948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const TargetRegisterInfo *TRI; 7048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineRegisterInfo *MRI; 7148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 7248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned foundErrors; 7348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 7448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen typedef SmallVector<unsigned, 16> RegVector; 759ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen typedef SmallVector<const uint32_t*, 4> RegMaskVector; 7648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen typedef DenseSet<unsigned> RegSet; 7748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen typedef DenseMap<unsigned, const MachineInstr*> RegMap; 78b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen typedef SmallPtrSet<const MachineBasicBlock*, 8> BlockSet; 7948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 805adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen const MachineInstr *FirstTerminator; 81b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen BlockSet FunctionBlocks; 825adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen 8348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BitVector regsReserved; 8448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet regsLive; 85710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen RegVector regsDefined, regsDead, regsKilled; 869ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen RegMaskVector regMasks; 87710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen RegSet regsLiveInButUnused; 8848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 89fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen SlotIndex lastIndex; 90fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen 9148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Add Reg and any sub-registers to RV 9248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void addRegWithSubRegs(RegVector &RV, unsigned Reg) { 9348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RV.push_back(Reg); 9448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Reg)) 95396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen for (MCSubRegIterator SubRegs(Reg, TRI); SubRegs.isValid(); ++SubRegs) 96396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen RV.push_back(*SubRegs); 9748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 9848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 9948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen struct BBInfo { 10048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Is this MBB reachable from the MF entry point? 10148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool reachable; 10248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 10348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Vregs that must be live in because they are used without being 10448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // defined. Map value is the user. 10548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegMap vregsLiveIn; 10648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 10748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Regs killed in MBB. They may be defined again, and will then be in both 10848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // regsKilled and regsLiveOut. 10948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet regsKilled; 11048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 11148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Regs defined in MBB and live out. Note that vregs passing through may 11248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // be live out without being mentioned here. 11348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet regsLiveOut; 11448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 11548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Vregs that pass through MBB untouched. This set is disjoint from 11648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // regsKilled and regsLiveOut. 11748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen RegSet vregsPassed; 11848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 1198f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Vregs that must pass through MBB because they are needed by a successor 1208f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // block. This set is disjoint from regsLiveOut. 1218f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen RegSet vregsRequired; 1228f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 123b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen // Set versions of block's predecessor and successor lists. 124b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen BlockSet Preds, Succs; 125b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen 12648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo() : reachable(false) {} 12748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 12848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Add register to vregsPassed if it belongs there. Return true if 12948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // anything changed. 13048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool addPassed(unsigned Reg) { 13148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!TargetRegisterInfo::isVirtualRegister(Reg)) 13248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return false; 13348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (regsKilled.count(Reg) || regsLiveOut.count(Reg)) 13448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return false; 13548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return vregsPassed.insert(Reg).second; 13648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 13748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 13848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Same for a full set. 13948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool addPassed(const RegSet &RS) { 14048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool changed = false; 14148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (RegSet::const_iterator I = RS.begin(), E = RS.end(); I != E; ++I) 14248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (addPassed(*I)) 14348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen changed = true; 14448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return changed; 14548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 14648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 1478f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Add register to vregsRequired if it belongs there. Return true if 1488f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // anything changed. 1498f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool addRequired(unsigned Reg) { 1508f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (!TargetRegisterInfo::isVirtualRegister(Reg)) 1518f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return false; 1528f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (regsLiveOut.count(Reg)) 1538f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return false; 1548f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return vregsRequired.insert(Reg).second; 1558f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 1568f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 1578f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Same for a full set. 1588f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool addRequired(const RegSet &RS) { 1598f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool changed = false; 1608f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (RegSet::const_iterator I = RS.begin(), E = RS.end(); I != E; ++I) 1618f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (addRequired(*I)) 1628f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen changed = true; 1638f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return changed; 1648f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 1658f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 1668f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Same for a full map. 1678f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool addRequired(const RegMap &RM) { 1688f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen bool changed = false; 1698f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (RegMap::const_iterator I = RM.begin(), E = RM.end(); I != E; ++I) 1708f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (addRequired(I->first)) 1718f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen changed = true; 1728f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return changed; 1738f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 1748f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 17548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Live-out registers are either in regsLiveOut or vregsPassed. 17648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool isLiveOut(unsigned Reg) const { 17748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return regsLiveOut.count(Reg) || vregsPassed.count(Reg); 17848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 17948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen }; 18048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 18148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Extra register info per MBB. 18248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen DenseMap<const MachineBasicBlock*, BBInfo> MBBInfoMap; 18348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 18448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen bool isReserved(unsigned Reg) { 185d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen return Reg < regsReserved.size() && regsReserved.test(Reg); 18648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 18748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 18803698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames bool isAllocatable(unsigned Reg) { 189feab72c20acc97f8942148189c06e443b29df841Jakob Stoklund Olesen return Reg < TRI->getNumRegs() && MRI->isAllocatable(Reg); 19003698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames } 19103698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames 1928f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Analysis information if available 1938f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen LiveVariables *LiveVars; 194501dc4224586d3cee61101ed6cd0ccc8ba74c43cJakob Stoklund Olesen LiveIntervals *LiveInts; 195e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveStacks *LiveStks; 196f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen SlotIndexes *Indexes; 1978f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 19848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineFunctionBefore(); 19948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineBasicBlockBefore(const MachineBasicBlock *MBB); 2001f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen void visitMachineBundleBefore(const MachineInstr *MI); 20148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineInstrBefore(const MachineInstr *MI); 20248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineOperand(const MachineOperand *MO, unsigned MONum); 20348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineInstrAfter(const MachineInstr *MI); 2041f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen void visitMachineBundleAfter(const MachineInstr *MI); 20548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineBasicBlockAfter(const MachineBasicBlock *MBB); 20648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void visitMachineFunctionAfter(); 20748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 20848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineFunction *MF); 20948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineBasicBlock *MBB); 21048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineInstr *MI); 21148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void report(const char *msg, const MachineOperand *MO, unsigned MONum); 21279240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen void report(const char *msg, const MachineFunction *MF, 21379240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen const LiveInterval &LI); 21479240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen void report(const char *msg, const MachineBasicBlock *MBB, 21579240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen const LiveInterval &LI); 216a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun void report(const char *msg, const MachineFunction *MF, 217a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun const LiveRange &LR); 218a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun void report(const char *msg, const MachineBasicBlock *MBB, 219a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun const LiveRange &LR); 22048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 22190a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen void verifyInlineAsm(const MachineInstr *MI); 22290a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen 223948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen void checkLiveness(const MachineOperand *MO, unsigned MONum); 22448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void markReachable(const MachineBasicBlock *MBB); 225b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen void calcRegsPassed(); 22648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen void checkPHIOps(const MachineBasicBlock *MBB); 2278f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 2288f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen void calcRegsRequired(); 2298f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen void verifyLiveVariables(); 23058e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen void verifyLiveIntervals(); 231e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen void verifyLiveInterval(const LiveInterval&); 232a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun void verifyLiveRangeValue(const LiveRange&, const VNInfo*, unsigned); 233a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun void verifyLiveRangeSegment(const LiveRange&, 234a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun const LiveRange::const_iterator I, unsigned); 235a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun void verifyLiveRange(const LiveRange&, unsigned); 2367310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 2377310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren void verifyStackFrame(); 2388f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen }; 2398f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 2408f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen struct MachineVerifierPass : public MachineFunctionPass { 2418f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen static char ID; // Pass ID, replacement for typeid 24289cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen const char *const Banner; 2438f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 244dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MachineVerifierPass(const char *b = nullptr) 24589cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen : MachineFunctionPass(ID), Banner(b) { 246081c34b725980f995be9080eaec24cd3dfaaf065Owen Anderson initializeMachineVerifierPassPass(*PassRegistry::getPassRegistry()); 247081c34b725980f995be9080eaec24cd3dfaaf065Owen Anderson } 2488f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 24936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void getAnalysisUsage(AnalysisUsage &AU) const override { 2508f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen AU.setPreservesAll(); 2518f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen MachineFunctionPass::getAnalysisUsage(AU); 2528f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 2538f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 25436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool runOnMachineFunction(MachineFunction &MF) override { 25589cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen MF.verify(this, Banner); 2568f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen return false; 2578f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 25848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen }; 2598f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 26048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 26148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 2628f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesenchar MachineVerifierPass::ID = 0; 26302dd53e1c5b941ca5f60fca1b95ebcaf9ccd1dfcOwen AndersonINITIALIZE_PASS(MachineVerifierPass, "machineverifier", 264ce665bd2e2b581ab0858d1afe359192bac96b868Owen Anderson "Verify generated machine code", false, false) 26548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 26689cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund OlesenFunctionPass *llvm::createMachineVerifierPass(const char *Banner) { 26789cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen return new MachineVerifierPass(Banner); 26848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 26948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 27089cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesenvoid MachineFunction::verify(Pass *p, const char *Banner) const { 27189cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen MachineVerifier(p, Banner) 27289cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen .runOnMachineFunction(const_cast<MachineFunction&>(*this)); 273ce727d0da006ca59bbd8c9ddc86e2fa71217d293Jakob Stoklund Olesen} 274ce727d0da006ca59bbd8c9ddc86e2fa71217d293Jakob Stoklund Olesen 27517e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattnerbool MachineVerifier::runOnMachineFunction(MachineFunction &MF) { 276dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines raw_ostream *OutFile = nullptr; 27748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (OutFileName) { 27817e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner std::string ErrorInfo; 27936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines OutFile = new raw_fd_ostream(OutFileName, ErrorInfo, 28036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines sys::fs::F_Append | sys::fs::F_Text); 28117e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner if (!ErrorInfo.empty()) { 28217e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner errs() << "Error opening '" << OutFileName << "': " << ErrorInfo << '\n'; 28317e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner exit(1); 28417e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner } 285b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesen 28617e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner OS = OutFile; 28748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 28817e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner OS = &errs(); 28948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 29048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 29148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen foundErrors = 0; 29248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 29348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen this->MF = &MF; 29448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen TM = &MF.getTarget(); 29515993f83a419950f06d2879d6701530ae6449317Evan Cheng TII = TM->getInstrInfo(); 29648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen TRI = TM->getRegisterInfo(); 29748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MRI = &MF.getRegInfo(); 29848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 299dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines LiveVars = nullptr; 300dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines LiveInts = nullptr; 301dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines LiveStks = nullptr; 302dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Indexes = nullptr; 3038f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (PASS) { 3041fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen LiveInts = PASS->getAnalysisIfAvailable<LiveIntervals>(); 305c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen // We don't want to verify LiveVariables if LiveIntervals is available. 306c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen if (!LiveInts) 307c910c8d2fa6e73e8f9875e871a2f3a44574a0b01Jakob Stoklund Olesen LiveVars = PASS->getAnalysisIfAvailable<LiveVariables>(); 308e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveStks = PASS->getAnalysisIfAvailable<LiveStacks>(); 309f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen Indexes = PASS->getAnalysisIfAvailable<SlotIndexes>(); 3108f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 3118f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 31248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineFunctionBefore(); 31348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineFunction::const_iterator MFI = MF.begin(), MFE = MF.end(); 31448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MFI!=MFE; ++MFI) { 31548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineBasicBlockBefore(MFI); 3161f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen // Keep track of the current bundle header. 317dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const MachineInstr *CurBundle = nullptr; 3189466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen // Do we expect the next instruction to be part of the same bundle? 3199466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen bool InBundle = false; 3209466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen 321ddfd1377d2e4154d44dc3ad217735adc15af2e3fEvan Cheng for (MachineBasicBlock::const_instr_iterator MBBI = MFI->instr_begin(), 322ddfd1377d2e4154d44dc3ad217735adc15af2e3fEvan Cheng MBBE = MFI->instr_end(); MBBI != MBBE; ++MBBI) { 3237bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen if (MBBI->getParent() != MFI) { 3247bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen report("Bad instruction parent pointer", MFI); 3257bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen *OS << "Instruction: " << *MBBI; 3267bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen continue; 3277bd46dae9c0e7e93df27186a4885293f8295b093Jakob Stoklund Olesen } 3289466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen 3299466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen // Check for consistent bundle flags. 3309466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen if (InBundle && !MBBI->isBundledWithPred()) 3319466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen report("Missing BundledPred flag, " 3329466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen "BundledSucc was set on predecessor", MBBI); 3339466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen if (!InBundle && MBBI->isBundledWithPred()) 3349466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen report("BundledPred flag is set, " 3359466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen "but BundledSucc not set on predecessor", MBBI); 3369466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen 3371f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen // Is this a bundle header? 3381f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen if (!MBBI->isInsideBundle()) { 3391f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen if (CurBundle) 3401f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen visitMachineBundleAfter(CurBundle); 3411f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen CurBundle = MBBI; 3421f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen visitMachineBundleBefore(CurBundle); 3431f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen } else if (!CurBundle) 3441f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen report("No bundle header", MBBI); 34548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineInstrBefore(MBBI); 34648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (unsigned I = 0, E = MBBI->getNumOperands(); I != E; ++I) 34748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineOperand(&MBBI->getOperand(I), I); 34848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineInstrAfter(MBBI); 3499466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen 3509466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen // Was this the last bundled instruction? 3519466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen InBundle = MBBI->isBundledWithSucc(); 35248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 3531f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen if (CurBundle) 3541f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen visitMachineBundleAfter(CurBundle); 3559466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen if (InBundle) 3569466bdebb7a239c0f469ae5c9aa1b94d2e2700f9Jakob Stoklund Olesen report("BundledSucc flag set on last instruction in block", &MFI->back()); 35748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineBasicBlockAfter(MFI); 35848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 35948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen visitMachineFunctionAfter(); 36048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 36117e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner if (OutFile) 36217e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner delete OutFile; 36317e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner else if (foundErrors) 36475361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("Found "+Twine(foundErrors)+" machine code errors."); 36548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 3666349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen // Clean up. 3676349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsLive.clear(); 3686349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsDefined.clear(); 3696349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsDead.clear(); 3706349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsKilled.clear(); 3719ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen regMasks.clear(); 3726349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen regsLiveInButUnused.clear(); 3736349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen MBBInfoMap.clear(); 3746349668fca491cfe1bf7c754fa0d7eb4255023b1Jakob Stoklund Olesen 37548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return false; // no changes 37648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 37748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 378372fefe8d24e40df2390fffeea0dc2dec611f88bChris Lattnervoid MachineVerifier::report(const char *msg, const MachineFunction *MF) { 37948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MF); 38017e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner *OS << '\n'; 38189cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen if (!foundErrors++) { 38289cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen if (Banner) 38389cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen *OS << "# " << Banner << '\n'; 384f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen MF->print(*OS, Indexes); 38589cab93fe999f6d81b4b99a71ac797b7ecfec277Jakob Stoklund Olesen } 38648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "*** Bad machine code: " << msg << " ***\n" 38796601ca332ab388754ca4673be8973396fea2dddCraig Topper << "- function: " << MF->getName() << "\n"; 38848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 38948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 390b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, const MachineBasicBlock *MBB) { 39148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MBB); 39248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report(msg, MBB->getParent()); 39379240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen *OS << "- basic block: BB#" << MBB->getNumber() 39479240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen << ' ' << MBB->getName() 39559324297650c12a8dccf1a7ad650a9e895fdc17eRoman Divacky << " (" << (const void*)MBB << ')'; 396f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen if (Indexes) 397f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen *OS << " [" << Indexes->getMBBStartIdx(MBB) 398f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen << ';' << Indexes->getMBBEndIdx(MBB) << ')'; 399f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen *OS << '\n'; 40048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 40148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 402b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, const MachineInstr *MI) { 40348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MI); 40448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report(msg, MI->getParent()); 40548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "- instruction: "; 406f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen if (Indexes && Indexes->hasIndex(MI)) 407f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen *OS << Indexes->getInstructionIndex(MI) << '\t'; 408705e07f578e2b3af47ddab610feb4e7f2d3063a5Chris Lattner MI->print(*OS, TM); 40948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 41048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 411b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, 412b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesen const MachineOperand *MO, unsigned MONum) { 41348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen assert(MO); 41448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report(msg, MO->getParent()); 41548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "- operand " << MONum << ": "; 41648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MO->print(*OS, TM); 41748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "\n"; 41848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 41948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 42079240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, const MachineFunction *MF, 42179240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen const LiveInterval &LI) { 42279240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen report(msg, MF); 42303d9609c6154ed91daefb4e4f89b7298c11961f3Matthias Braun *OS << "- interval: " << LI << '\n'; 42479240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen} 42579240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen 42679240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesenvoid MachineVerifier::report(const char *msg, const MachineBasicBlock *MBB, 42779240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen const LiveInterval &LI) { 42879240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen report(msg, MBB); 42903d9609c6154ed91daefb4e4f89b7298c11961f3Matthias Braun *OS << "- interval: " << LI << '\n'; 43079240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen} 43179240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen 432a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braunvoid MachineVerifier::report(const char *msg, const MachineBasicBlock *MBB, 433a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun const LiveRange &LR) { 434a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report(msg, MBB); 435a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << "- liverange: " << LR << "\n"; 436a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun} 437a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun 438a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braunvoid MachineVerifier::report(const char *msg, const MachineFunction *MF, 439a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun const LiveRange &LR) { 440a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report(msg, MF); 441a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << "- liverange: " << LR << "\n"; 442a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun} 443a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun 444b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::markReachable(const MachineBasicBlock *MBB) { 44548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MBB]; 44648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) { 44748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MInfo.reachable = true; 44848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator SuI = MBB->succ_begin(), 44948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen SuE = MBB->succ_end(); SuI != SuE; ++SuI) 45048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen markReachable(*SuI); 45148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 45248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 45348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 454b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineFunctionBefore() { 455fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen lastIndex = SlotIndex(); 456fb9ebbf236974beac31705eaeb9f50ab585af6abJakob Stoklund Olesen regsReserved = MRI->getReservedRegs(); 457d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen 458d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen // A sub-register of a reserved register is also reserved 459d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen for (int Reg = regsReserved.find_first(); Reg>=0; 460d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen Reg = regsReserved.find_next(Reg)) { 461396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen for (MCSubRegIterator SubRegs(Reg, TRI); SubRegs.isValid(); ++SubRegs) { 462d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen // FIXME: This should probably be: 463396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen // assert(regsReserved.test(*SubRegs) && "Non-reserved sub-register"); 464396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen regsReserved.set(*SubRegs); 465d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen } 466d37bc5a27b2d40b05614587d61bbecb4017bdf23Jakob Stoklund Olesen } 46703698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames 46848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen markReachable(&MF->front()); 469b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen 470b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen // Build a set of the basic blocks in the function. 471b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen FunctionBlocks.clear(); 472dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (const auto &MBB : *MF) { 473dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines FunctionBlocks.insert(&MBB); 474dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BBInfo &MInfo = MBBInfoMap[&MBB]; 475dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 476dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MInfo.Preds.insert(MBB.pred_begin(), MBB.pred_end()); 477dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (MInfo.Preds.size() != MBB.pred_size()) 478dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines report("MBB has duplicate entries in its predecessor list.", &MBB); 479dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 480dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MInfo.Succs.insert(MBB.succ_begin(), MBB.succ_end()); 481dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (MInfo.Succs.size() != MBB.succ_size()) 482dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines report("MBB has duplicate entries in its successor list.", &MBB); 483b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen } 484a58d67af29d38fa37c94f59af37db9df75f349beJakob Stoklund Olesen 485a58d67af29d38fa37c94f59af37db9df75f349beJakob Stoklund Olesen // Check that the register use lists are sane. 486a58d67af29d38fa37c94f59af37db9df75f349beJakob Stoklund Olesen MRI->verifyUseLists(); 4877310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 4887310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren verifyStackFrame(); 48948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 49048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 4911dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen// Does iterator point to a and b as the first two elements? 492b35798347ea87b8b6d36155b211016a7769f01abDan Gohmanstatic bool matchPair(MachineBasicBlock::const_succ_iterator i, 493b35798347ea87b8b6d36155b211016a7769f01abDan Gohman const MachineBasicBlock *a, const MachineBasicBlock *b) { 4941dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen if (*i == a) 4951dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen return *++i == b; 4961dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen if (*i == b) 4971dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen return *++i == a; 4981dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen return false; 4991dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen} 5001dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen 5011dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesenvoid 5021dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund OlesenMachineVerifier::visitMachineBasicBlockBefore(const MachineBasicBlock *MBB) { 503dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines FirstTerminator = nullptr; 5045adc07ebe80688a4b4b96dc088341a7d87eb614fJakob Stoklund Olesen 50503698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames if (MRI->isSSA()) { 50603698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames // If this block has allocatable physical registers live-in, check that 50703698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames // it is an entry block or landing pad. 50803698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames for (MachineBasicBlock::livein_iterator LI = MBB->livein_begin(), 50903698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames LE = MBB->livein_end(); 51003698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames LI != LE; ++LI) { 51103698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames unsigned reg = *LI; 51203698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames if (isAllocatable(reg) && !MBB->isLandingPad() && 51303698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames MBB != MBB->getParent()->begin()) { 51403698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames report("MBB has allocable live-in, but isn't entry or landing-pad.", MBB); 51503698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames } 51603698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames } 51703698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames } 51803698deb25215bf3b4aa2e3ff731ea38923a928cLang Hames 5190a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen // Count the number of landing pad successors. 5202100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich SmallPtrSet<MachineBasicBlock*, 4> LandingPadSuccs; 5210a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator I = MBB->succ_begin(), 5222100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich E = MBB->succ_end(); I != E; ++I) { 5232100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich if ((*I)->isLandingPad()) 5242100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich LandingPadSuccs.insert(*I); 525b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen if (!FunctionBlocks.count(*I)) 526b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen report("MBB has successor that isn't part of the function.", MBB); 527b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen if (!MBBInfoMap[*I].Preds.count(MBB)) { 528b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen report("Inconsistent CFG", MBB); 529b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen *OS << "MBB is not in the predecessor list of the successor BB#" 530b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen << (*I)->getNumber() << ".\n"; 531b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen } 532b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen } 533b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen 534b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen // Check the predecessor list. 535b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator I = MBB->pred_begin(), 536b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen E = MBB->pred_end(); I != E; ++I) { 537b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen if (!FunctionBlocks.count(*I)) 538b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen report("MBB has predecessor that isn't part of the function.", MBB); 539b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen if (!MBBInfoMap[*I].Succs.count(MBB)) { 540b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen report("Inconsistent CFG", MBB); 541b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen *OS << "MBB is not in the successor list of the predecessor BB#" 542b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen << (*I)->getNumber() << ".\n"; 543b254c6d77a042ac175e101f6e06aa667446e1b77Jakob Stoklund Olesen } 5442100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich } 545d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling 546d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling const MCAsmInfo *AsmInfo = TM->getMCAsmInfo(); 547d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling const BasicBlock *BB = MBB->getBasicBlock(); 548d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling if (LandingPadSuccs.size() > 1 && 549d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling !(AsmInfo && 550d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling AsmInfo->getExceptionHandlingType() == ExceptionHandling::SjLj && 551d29052bf26fec78a35665b6ccd563b62d2d1cf14Bill Wendling BB && isa<SwitchInst>(BB->getTerminator()))) 5520a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen report("MBB has more than one landing pad successor", MBB); 5530a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen 55427920594b940d824038d16b13846aa76cac493cfDan Gohman // Call AnalyzeBranch. If it succeeds, there several more conditions to check. 555dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MachineBasicBlock *TBB = nullptr, *FBB = nullptr; 55627920594b940d824038d16b13846aa76cac493cfDan Gohman SmallVector<MachineOperand, 4> Cond; 55727920594b940d824038d16b13846aa76cac493cfDan Gohman if (!TII->AnalyzeBranch(*const_cast<MachineBasicBlock *>(MBB), 55827920594b940d824038d16b13846aa76cac493cfDan Gohman TBB, FBB, Cond)) { 55927920594b940d824038d16b13846aa76cac493cfDan Gohman // Ok, AnalyzeBranch thinks it knows what's going on with this block. Let's 56027920594b940d824038d16b13846aa76cac493cfDan Gohman // check whether its answers match up with reality. 56127920594b940d824038d16b13846aa76cac493cfDan Gohman if (!TBB && !FBB) { 56227920594b940d824038d16b13846aa76cac493cfDan Gohman // Block falls through to its successor. 56327920594b940d824038d16b13846aa76cac493cfDan Gohman MachineFunction::const_iterator MBBI = MBB; 56427920594b940d824038d16b13846aa76cac493cfDan Gohman ++MBBI; 56527920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBBI == MF->end()) { 566a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // It's possible that the block legitimately ends with a noreturn 567a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // call or an unreachable, in which case it won't actually fall 568a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // out the bottom of the function. 5692100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich } else if (MBB->succ_size() == LandingPadSuccs.size()) { 570a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // It's possible that the block legitimately ends with a noreturn 571a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // call or an unreachable, in which case it won't actuall fall 572a01a80fa6c0c6e9c92ecfa951e974b98c3ba1783Dan Gohman // out of the block. 5732100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich } else if (MBB->succ_size() != 1+LandingPadSuccs.size()) { 57427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but doesn't have " 57527920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly one CFG successor!", MBB); 5760a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen } else if (!MBB->isSuccessor(MBBI)) { 57727920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but its successor " 57827920594b940d824038d16b13846aa76cac493cfDan Gohman "differs from its CFG successor!", MBB); 57927920594b940d824038d16b13846aa76cac493cfDan Gohman } 580dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!MBB->empty() && MBB->back().isBarrier() && 581dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines !TII->isPredicated(&MBB->back())) { 58227920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but ends with a " 58327920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 58427920594b940d824038d16b13846aa76cac493cfDan Gohman } 58527920594b940d824038d16b13846aa76cac493cfDan Gohman if (!Cond.empty()) { 58627920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional fall-through but has a condition!", 58727920594b940d824038d16b13846aa76cac493cfDan Gohman MBB); 58827920594b940d824038d16b13846aa76cac493cfDan Gohman } 58927920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (TBB && !FBB && Cond.empty()) { 59027920594b940d824038d16b13846aa76cac493cfDan Gohman // Block unconditionally branches somewhere. 5912100d21f39a9471254564e359ab8c5901c7aecffCameron Zwarich if (MBB->succ_size() != 1+LandingPadSuccs.size()) { 59227920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but doesn't have " 59327920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly one CFG successor!", MBB); 5940a7bbcb0cc3c6f1905cd26697c5baf4859ac6443Jakob Stoklund Olesen } else if (!MBB->isSuccessor(TBB)) { 59527920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but the CFG " 59627920594b940d824038d16b13846aa76cac493cfDan Gohman "successor doesn't match the actual successor!", MBB); 59727920594b940d824038d16b13846aa76cac493cfDan Gohman } 59827920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 59927920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but doesn't contain " 60027920594b940d824038d16b13846aa76cac493cfDan Gohman "any instructions!", MBB); 601dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (!MBB->back().isBarrier()) { 60227920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but doesn't end with a " 60327920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 604dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (!MBB->back().isTerminator()) { 60527920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via unconditional branch but the branch isn't a " 60627920594b940d824038d16b13846aa76cac493cfDan Gohman "terminator instruction!", MBB); 60727920594b940d824038d16b13846aa76cac493cfDan Gohman } 60827920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (TBB && !FBB && !Cond.empty()) { 60927920594b940d824038d16b13846aa76cac493cfDan Gohman // Block conditionally branches somewhere, otherwise falls through. 61027920594b940d824038d16b13846aa76cac493cfDan Gohman MachineFunction::const_iterator MBBI = MBB; 61127920594b940d824038d16b13846aa76cac493cfDan Gohman ++MBBI; 61227920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBBI == MF->end()) { 61327920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB conditionally falls through out of function!", MBB); 614344df79cc073032cfc35cd00406907d67b537087Dmitri Gribenko } else if (MBB->succ_size() == 1) { 615e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen // A conditional branch with only one successor is weird, but allowed. 616e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen if (&*MBBI != TBB) 617e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen report("MBB exits via conditional branch/fall-through but only has " 618e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen "one CFG successor!", MBB); 619e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen else if (TBB != *MBB->succ_begin()) 620e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen report("MBB exits via conditional branch/fall-through but the CFG " 621e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen "successor don't match the actual successor!", MBB); 622e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen } else if (MBB->succ_size() != 2) { 62327920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but doesn't have " 62427920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly two CFG successors!", MBB); 6251dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen } else if (!matchPair(MBB->succ_begin(), TBB, MBBI)) { 62627920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but the CFG " 62727920594b940d824038d16b13846aa76cac493cfDan Gohman "successors don't match the actual successors!", MBB); 62827920594b940d824038d16b13846aa76cac493cfDan Gohman } 62927920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 63027920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but doesn't " 63127920594b940d824038d16b13846aa76cac493cfDan Gohman "contain any instructions!", MBB); 632dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (MBB->back().isBarrier()) { 63327920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but ends with a " 63427920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 635dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (!MBB->back().isTerminator()) { 63627920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/fall-through but the branch " 63727920594b940d824038d16b13846aa76cac493cfDan Gohman "isn't a terminator instruction!", MBB); 63827920594b940d824038d16b13846aa76cac493cfDan Gohman } 63927920594b940d824038d16b13846aa76cac493cfDan Gohman } else if (TBB && FBB) { 64027920594b940d824038d16b13846aa76cac493cfDan Gohman // Block conditionally branches somewhere, otherwise branches 64127920594b940d824038d16b13846aa76cac493cfDan Gohman // somewhere else. 642e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen if (MBB->succ_size() == 1) { 643e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen // A conditional branch with only one successor is weird, but allowed. 644e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen if (FBB != TBB) 645e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen report("MBB exits via conditional branch/branch through but only has " 646e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen "one CFG successor!", MBB); 647e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen else if (TBB != *MBB->succ_begin()) 648e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen report("MBB exits via conditional branch/branch through but the CFG " 649e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen "successor don't match the actual successor!", MBB); 650e7fdef420d0c8a825555d246da259342c48bd527Jakob Stoklund Olesen } else if (MBB->succ_size() != 2) { 65127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but doesn't have " 65227920594b940d824038d16b13846aa76cac493cfDan Gohman "exactly two CFG successors!", MBB); 6531dc0fcbaed01ed6510f067bc408f8bd2efd8ac68Jakob Stoklund Olesen } else if (!matchPair(MBB->succ_begin(), TBB, FBB)) { 65427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but the CFG " 65527920594b940d824038d16b13846aa76cac493cfDan Gohman "successors don't match the actual successors!", MBB); 65627920594b940d824038d16b13846aa76cac493cfDan Gohman } 65727920594b940d824038d16b13846aa76cac493cfDan Gohman if (MBB->empty()) { 65827920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but doesn't " 65927920594b940d824038d16b13846aa76cac493cfDan Gohman "contain any instructions!", MBB); 660dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (!MBB->back().isBarrier()) { 66127920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but doesn't end with a " 66227920594b940d824038d16b13846aa76cac493cfDan Gohman "barrier instruction!", MBB); 663dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (!MBB->back().isTerminator()) { 66427920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditional branch/branch but the branch " 66527920594b940d824038d16b13846aa76cac493cfDan Gohman "isn't a terminator instruction!", MBB); 66627920594b940d824038d16b13846aa76cac493cfDan Gohman } 66727920594b940d824038d16b13846aa76cac493cfDan Gohman if (Cond.empty()) { 66827920594b940d824038d16b13846aa76cac493cfDan Gohman report("MBB exits via conditinal branch/branch but there's no " 66927920594b940d824038d16b13846aa76cac493cfDan Gohman "condition!", MBB); 67027920594b940d824038d16b13846aa76cac493cfDan Gohman } 67127920594b940d824038d16b13846aa76cac493cfDan Gohman } else { 67227920594b940d824038d16b13846aa76cac493cfDan Gohman report("AnalyzeBranch returned invalid data!", MBB); 67327920594b940d824038d16b13846aa76cac493cfDan Gohman } 67427920594b940d824038d16b13846aa76cac493cfDan Gohman } 67527920594b940d824038d16b13846aa76cac493cfDan Gohman 67648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.clear(); 67781bf03eb5cd68243eabb52505105aa5f4a831bf3Dan Gohman for (MachineBasicBlock::livein_iterator I = MBB->livein_begin(), 67848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen E = MBB->livein_end(); I != E; ++I) { 67948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!TargetRegisterInfo::isPhysicalRegister(*I)) { 68048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("MBB live-in list contains non-physical register", MBB); 68148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 68248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 68362c320a755ac27ac2b7f64e927892249e0f486e0Chad Rosier for (MCSubRegIterator SubRegs(*I, TRI, /*IncludeSelf=*/true); 68462c320a755ac27ac2b7f64e927892249e0f486e0Chad Rosier SubRegs.isValid(); ++SubRegs) 685396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen regsLive.insert(*SubRegs); 68648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 687710b13b2c2257d65779fd6380e27b823b06a74a9Jakob Stoklund Olesen regsLiveInButUnused = regsLive; 688a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen 689a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen const MachineFrameInfo *MFI = MF->getFrameInfo(); 690a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen assert(MFI && "Function has no frame info"); 691a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen BitVector PR = MFI->getPristineRegs(MBB); 692a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen for (int I = PR.find_first(); I>0; I = PR.find_next(I)) { 69362c320a755ac27ac2b7f64e927892249e0f486e0Chad Rosier for (MCSubRegIterator SubRegs(I, TRI, /*IncludeSelf=*/true); 69462c320a755ac27ac2b7f64e927892249e0f486e0Chad Rosier SubRegs.isValid(); ++SubRegs) 695396618b43a85e12d290a90b181c6af5d7c0c5f11Jakob Stoklund Olesen regsLive.insert(*SubRegs); 696a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen } 697a6b677d209013d82b03fa8da937296b6faae7de0Jakob Stoklund Olesen 69848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsKilled.clear(); 69948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsDefined.clear(); 700fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen 701fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen if (Indexes) 702fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen lastIndex = Indexes->getMBBStartIdx(MBB); 70348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 70448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 7051f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen// This function gets called for all bundle headers, including normal 7061f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen// stand-alone unbundled instructions. 7071f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesenvoid MachineVerifier::visitMachineBundleBefore(const MachineInstr *MI) { 7081f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen if (Indexes && Indexes->hasIndex(MI)) { 7091f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen SlotIndex idx = Indexes->getInstructionIndex(MI); 7101f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen if (!(idx > lastIndex)) { 7111f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen report("Instruction index out of order", MI); 7121f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen *OS << "Last instruction was at " << lastIndex << '\n'; 7131f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen } 7141f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen lastIndex = idx; 7151f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen } 71683569cb062930a62e96ba87a47b002366e00124dPete Cooper 71783569cb062930a62e96ba87a47b002366e00124dPete Cooper // Ensure non-terminators don't follow terminators. 71883569cb062930a62e96ba87a47b002366e00124dPete Cooper // Ignore predicated terminators formed by if conversion. 71983569cb062930a62e96ba87a47b002366e00124dPete Cooper // FIXME: If conversion shouldn't need to violate this rule. 72083569cb062930a62e96ba87a47b002366e00124dPete Cooper if (MI->isTerminator() && !TII->isPredicated(MI)) { 72183569cb062930a62e96ba87a47b002366e00124dPete Cooper if (!FirstTerminator) 72283569cb062930a62e96ba87a47b002366e00124dPete Cooper FirstTerminator = MI; 72383569cb062930a62e96ba87a47b002366e00124dPete Cooper } else if (FirstTerminator) { 72483569cb062930a62e96ba87a47b002366e00124dPete Cooper report("Non-terminator instruction after the first terminator", MI); 72583569cb062930a62e96ba87a47b002366e00124dPete Cooper *OS << "First terminator was:\t" << *FirstTerminator; 72683569cb062930a62e96ba87a47b002366e00124dPete Cooper } 7271f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen} 7281f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen 72990a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen// The operands on an INLINEASM instruction must follow a template. 73090a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen// Verify that the flag operands make sense. 73190a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesenvoid MachineVerifier::verifyInlineAsm(const MachineInstr *MI) { 73290a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen // The first two operands on INLINEASM are the asm string and global flags. 73390a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen if (MI->getNumOperands() < 2) { 73490a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen report("Too few operands on inline asm", MI); 73590a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen return; 73690a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen } 73790a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen if (!MI->getOperand(0).isSymbol()) 73890a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen report("Asm string must be an external symbol", MI); 73990a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen if (!MI->getOperand(1).isImm()) 74090a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen report("Asm flags must be an immediate", MI); 7413d71688476951d56ac00a81b17c2f83fd781b208Chad Rosier // Allowed flags are Extra_HasSideEffects = 1, Extra_IsAlignStack = 2, 7423d71688476951d56ac00a81b17c2f83fd781b208Chad Rosier // Extra_AsmDialect = 4, Extra_MayLoad = 8, and Extra_MayStore = 16. 7433d71688476951d56ac00a81b17c2f83fd781b208Chad Rosier if (!isUInt<5>(MI->getOperand(1).getImm())) 74490a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen report("Unknown asm flags", &MI->getOperand(1), 1); 74590a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen 74690a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen assert(InlineAsm::MIOp_FirstOperand == 2 && "Asm format changed"); 74790a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen 74890a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen unsigned OpNo = InlineAsm::MIOp_FirstOperand; 74990a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen unsigned NumOps; 75090a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen for (unsigned e = MI->getNumOperands(); OpNo < e; OpNo += NumOps) { 75190a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen const MachineOperand &MO = MI->getOperand(OpNo); 75290a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen // There may be implicit ops after the fixed operands. 75390a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen if (!MO.isImm()) 75490a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen break; 75590a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen NumOps = 1 + InlineAsm::getNumOperandRegisters(MO.getImm()); 75648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 7572dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman 75890a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen if (OpNo > MI->getNumOperands()) 75990a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen report("Missing operands in last group", MI); 76090a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen 76190a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen // An optional MDNode follows the groups. 76290a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen if (OpNo < MI->getNumOperands() && MI->getOperand(OpNo).isMetadata()) 76390a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen ++OpNo; 76490a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen 76590a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen // All trailing operands must be implicit registers. 76690a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen for (unsigned e = MI->getNumOperands(); OpNo < e; ++OpNo) { 76790a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen const MachineOperand &MO = MI->getOperand(OpNo); 76890a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen if (!MO.isReg() || !MO.isImplicit()) 76990a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen report("Expected implicit register after groups", &MO, OpNo); 77090a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen } 77190a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen} 77290a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen 77390a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesenvoid MachineVerifier::visitMachineInstrBefore(const MachineInstr *MI) { 77490a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen const MCInstrDesc &MCID = MI->getDesc(); 77590a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen if (MI->getNumOperands() < MCID.getNumOperands()) { 77690a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen report("Too few operands", MI); 77790a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen *OS << MCID.getNumOperands() << " operands expected, but " 77817d4ac8c461fb3c32483cf7a37bc52937caeb650Matt Arsenault << MI->getNumOperands() << " given.\n"; 77990a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen } 78090a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen 78190a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen // Check the tied operands. 78290a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen if (MI->isInlineAsm()) 78390a4f78d3b23576da92a60a731cb34767fd75db8Jakob Stoklund Olesen verifyInlineAsm(MI); 784ca71c5debe0467646ca1f359073948d5353393a0Jakob Stoklund Olesen 7852dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman // Check the MachineMemOperands for basic consistency. 7862dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman for (MachineInstr::mmo_iterator I = MI->memoperands_begin(), 7872dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman E = MI->memoperands_end(); I != E; ++I) { 7885a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if ((*I)->isLoad() && !MI->mayLoad()) 7892dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman report("Missing mayLoad flag", MI); 7905a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if ((*I)->isStore() && !MI->mayStore()) 7912dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman report("Missing mayStore flag", MI); 7922dbc4c84f6de55deeea6631201c5df943d5327c0Dan Gohman } 7931fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen 7941fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen // Debug values must not have a slot index. 795121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen // Other instructions must have one, unless they are inside a bundle. 7961fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (LiveInts) { 7971fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen bool mapped = !LiveInts->isNotInMIMap(MI); 7981fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (MI->isDebugValue()) { 7991fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (mapped) 8001fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen report("Debug instruction has a slot index", MI); 801121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } else if (MI->isInsideBundle()) { 802121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen if (mapped) 803121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen report("Instruction inside bundle has a slot index", MI); 8041fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } else { 8051fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen if (!mapped) 8061fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen report("Missing slot index", MI); 8071fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 8081fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen } 8091fe9c34d3f55399dee2c41617d8af4f09e5509e7Jakob Stoklund Olesen 8103be654f8082dcbdff011a6716a7c90486e28fc9eAndrew Trick StringRef ErrorInfo; 8113be654f8082dcbdff011a6716a7c90486e28fc9eAndrew Trick if (!TII->verifyInstruction(MI, ErrorInfo)) 8123be654f8082dcbdff011a6716a7c90486e28fc9eAndrew Trick report(ErrorInfo.data(), MI); 81348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 81448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 81548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenvoid 816b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund OlesenMachineVerifier::visitMachineOperand(const MachineOperand *MO, unsigned MONum) { 81748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineInstr *MI = MO->getParent(); 818e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &MCID = MI->getDesc(); 81944b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen 820e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng // The first MCID.NumDefs operands must be explicit register defines 821e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MONum < MCID.getNumDefs()) { 82211a4fa452305eeaeaaaf9c4fd83d043da081bd11Richard Smith const MCOperandInfo &MCOI = MCID.OpInfo[MONum]; 82344b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen if (!MO->isReg()) 82444b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen report("Explicit definition must be a register", MO, MONum); 825cac58aa80ea9450d5e5b0499ac598b646f419b51Evan Cheng else if (!MO->isDef() && !MCOI.isOptionalDef()) 82644b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen report("Explicit definition marked as use", MO, MONum); 82744b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen else if (MO->isImplicit()) 82844b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen report("Explicit definition marked as implicit", MO, MONum); 829e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng } else if (MONum < MCID.getNumOperands()) { 83011a4fa452305eeaeaaaf9c4fd83d043da081bd11Richard Smith const MCOperandInfo &MCOI = MCID.OpInfo[MONum]; 831113a06cff443f5d73c4f1f89bd31b0efb4222227Eric Christopher // Don't check if it's the last operand in a variadic instruction. See, 832113a06cff443f5d73c4f1f89bd31b0efb4222227Eric Christopher // e.g., LDM_RET in the arm back end. 833e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MO->isReg() && 8345a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng !(MI->isVariadic() && MONum == MCID.getNumOperands()-1)) { 835e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MO->isDef() && !MCOI.isOptionalDef()) 836b38d9877f490e6bd65a38048d7e00877c0a670f0Matthias Braun report("Explicit operand marked as def", MO, MONum); 83739523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen if (MO->isImplicit()) 83839523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen report("Explicit operand marked as implicit", MO, MONum); 83939523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen } 840ca71c5debe0467646ca1f359073948d5353393a0Jakob Stoklund Olesen 841daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen int TiedTo = MCID.getOperandConstraint(MONum, MCOI::TIED_TO); 842daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen if (TiedTo != -1) { 843ca71c5debe0467646ca1f359073948d5353393a0Jakob Stoklund Olesen if (!MO->isReg()) 844ca71c5debe0467646ca1f359073948d5353393a0Jakob Stoklund Olesen report("Tied use must be a register", MO, MONum); 845ca71c5debe0467646ca1f359073948d5353393a0Jakob Stoklund Olesen else if (!MO->isTied()) 846ca71c5debe0467646ca1f359073948d5353393a0Jakob Stoklund Olesen report("Operand should be tied", MO, MONum); 847daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen else if (unsigned(TiedTo) != MI->findTiedOperandIdx(MONum)) 848daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen report("Tied def doesn't match MCInstrDesc", MO, MONum); 849ca71c5debe0467646ca1f359073948d5353393a0Jakob Stoklund Olesen } else if (MO->isReg() && MO->isTied()) 850ca71c5debe0467646ca1f359073948d5353393a0Jakob Stoklund Olesen report("Explicit operand should not be tied", MO, MONum); 85139523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen } else { 8525711564b091c39188775aee2768ad36a9b9a99b2Jakob Stoklund Olesen // ARM adds %reg0 operands to indicate predicates. We'll allow that. 8535a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (MO->isReg() && !MO->isImplicit() && !MI->isVariadic() && MO->getReg()) 85439523e2cfb625d90aa122252b041e2311a9a8ca5Jakob Stoklund Olesen report("Extra explicit operand on non-variadic instruction", MO, MONum); 85544b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen } 85644b27e5c7522e0e2e1a48efefceab8508db711b9Jakob Stoklund Olesen 85748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen switch (MO->getType()) { 85848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen case MachineOperand::MO_Register: { 85948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const unsigned Reg = MO->getReg(); 86048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!Reg) 86148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return; 862948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MRI->tracksLiveness() && !MI->isDebugValue()) 863948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen checkLiveness(MO, MONum); 86448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 865daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen // Verify the consistency of tied operands. 866daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen if (MO->isTied()) { 867daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen unsigned OtherIdx = MI->findTiedOperandIdx(MONum); 868daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen const MachineOperand &OtherMO = MI->getOperand(OtherIdx); 869daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen if (!OtherMO.isReg()) 870daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen report("Must be tied to a register", MO, MONum); 871daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen if (!OtherMO.isTied()) 872daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen report("Missing tie flags on tied operand", MO, MONum); 873daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen if (MI->findTiedOperandIdx(OtherIdx) != MONum) 874daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen report("Inconsistent tie links", MO, MONum); 875daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen if (MONum < MCID.getNumDefs()) { 876daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen if (OtherIdx < MCID.getNumOperands()) { 877daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen if (-1 == MCID.getOperandConstraint(OtherIdx, MCOI::TIED_TO)) 878daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen report("Explicit def tied to explicit use without tie constraint", 879daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen MO, MONum); 880daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen } else { 881daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen if (!OtherMO.isImplicit()) 882daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen report("Explicit def should be tied to implicit use", MO, MONum); 883daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen } 884daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen } 885daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen } 886daddf07497af2849868105264bd5f95c362041e5Jakob Stoklund Olesen 887eba2bbb58cafcb1ec0fa50d5e8a1c6a8cac2f780Jakob Stoklund Olesen // Verify two-address constraints after leaving SSA form. 888eba2bbb58cafcb1ec0fa50d5e8a1c6a8cac2f780Jakob Stoklund Olesen unsigned DefIdx; 889eba2bbb58cafcb1ec0fa50d5e8a1c6a8cac2f780Jakob Stoklund Olesen if (!MRI->isSSA() && MO->isUse() && 890eba2bbb58cafcb1ec0fa50d5e8a1c6a8cac2f780Jakob Stoklund Olesen MI->isRegTiedToDefOperand(MONum, &DefIdx) && 891eba2bbb58cafcb1ec0fa50d5e8a1c6a8cac2f780Jakob Stoklund Olesen Reg != MI->getOperand(DefIdx).getReg()) 892eba2bbb58cafcb1ec0fa50d5e8a1c6a8cac2f780Jakob Stoklund Olesen report("Two-address instruction operands must be identical", MO, MONum); 89348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 89448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Check register classes. 895e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MONum < MCID.getNumOperands() && !MO->isImplicit()) { 89648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen unsigned SubIdx = MO->getSubReg(); 89748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 89848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Reg)) { 89948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SubIdx) { 900b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen report("Illegal subregister index for physical register", MO, MONum); 901b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen return; 90248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 903397fc4874efe9c17e737d4c5c50bd19dc3bf27f5Jakob Stoklund Olesen if (const TargetRegisterClass *DRC = 904397fc4874efe9c17e737d4c5c50bd19dc3bf27f5Jakob Stoklund Olesen TII->getRegClass(MCID, MONum, TRI, *MF)) { 905b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (!DRC->contains(Reg)) { 90648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Illegal physical register for instruction", MO, MONum); 907b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen *OS << TRI->getName(Reg) << " is not a " 90848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << DRC->getName() << " register.\n"; 90948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 91048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 91148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } else { 91248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Virtual register. 91348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const TargetRegisterClass *RC = MRI->getRegClass(Reg); 91448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SubIdx) { 915b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen const TargetRegisterClass *SRC = 916b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen TRI->getSubClassWithSubReg(RC, SubIdx); 9176a8d2c6119aeb32ac914c3dd9b1263ebd0baa51fJakob Stoklund Olesen if (!SRC) { 91848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Invalid subregister index for virtual register", MO, MONum); 9196a8d2c6119aeb32ac914c3dd9b1263ebd0baa51fJakob Stoklund Olesen *OS << "Register class " << RC->getName() 9206a8d2c6119aeb32ac914c3dd9b1263ebd0baa51fJakob Stoklund Olesen << " does not support subreg index " << SubIdx << "\n"; 92148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen return; 92248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 923b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (RC != SRC) { 924b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen report("Invalid register class for subregister index", MO, MONum); 925b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen *OS << "Register class " << RC->getName() 926b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen << " does not fully support subreg index " << SubIdx << "\n"; 927b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen return; 928b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen } 92948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 930397fc4874efe9c17e737d4c5c50bd19dc3bf27f5Jakob Stoklund Olesen if (const TargetRegisterClass *DRC = 931397fc4874efe9c17e737d4c5c50bd19dc3bf27f5Jakob Stoklund Olesen TII->getRegClass(MCID, MONum, TRI, *MF)) { 932b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (SubIdx) { 933b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen const TargetRegisterClass *SuperRC = 934b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen TRI->getLargestLegalSuperClass(RC); 935b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (!SuperRC) { 936b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen report("No largest legal super class exists.", MO, MONum); 937b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen return; 938b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen } 939b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen DRC = TRI->getMatchingSuperRegClass(SuperRC, DRC, SubIdx); 940b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen if (!DRC) { 941b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen report("No matching super-reg register class.", MO, MONum); 942b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen return; 943b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen } 944b4a0221e85eeb4015a37f30738099dc680ac32d7Jakob Stoklund Olesen } 945fa226bccaa90c520cac154df74069bbabb976eabJakob Stoklund Olesen if (!RC->hasSuperClassEq(DRC)) { 94648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("Illegal virtual register for instruction", MO, MONum); 94748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen *OS << "Expected a " << DRC->getName() << " register, but got a " 94848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << RC->getName() << " register\n"; 94948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 95048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 95148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 95248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 95348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen break; 95448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 955a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen 9569ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen case MachineOperand::MO_RegisterMask: 9579ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen regMasks.push_back(MO->getRegMask()); 9589ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen break; 9599ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen 960a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen case MachineOperand::MO_MachineBasicBlock: 961518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner if (MI->isPHI() && !MO->getMBB()->isSuccessor(MI->getParent())) 962518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner report("PHI operand is not in the CFG", MO, MONum); 963a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen break; 964a5ba07c3d14ffdf288af2513d4ab39464fb7e20dJakob Stoklund Olesen 965e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen case MachineOperand::MO_FrameIndex: 966e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen if (LiveStks && LiveStks->hasInterval(MO->getIndex()) && 967e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveInts && !LiveInts->isNotInMIMap(MI)) { 968e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen LiveInterval &LI = LiveStks->getInterval(MO->getIndex()); 969e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen SlotIndex Idx = LiveInts->getInstructionIndex(MI); 9705a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (MI->mayLoad() && !LI.liveAt(Idx.getRegSlot(true))) { 971e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen report("Instruction loads from dead spill slot", MO, MONum); 972e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen *OS << "Live stack: " << LI << '\n'; 973e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen } 9745a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (MI->mayStore() && !LI.liveAt(Idx.getRegSlot())) { 975e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen report("Instruction stores to dead spill slot", MO, MONum); 976e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen *OS << "Live stack: " << LI << '\n'; 977e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen } 978e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen } 979e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen break; 980e8f0823a68cfc0201fffb100c7e4a1a2940cf9a9Jakob Stoklund Olesen 98148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen default: 98248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen break; 98348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 98448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 98548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 986948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesenvoid MachineVerifier::checkLiveness(const MachineOperand *MO, unsigned MONum) { 987948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen const MachineInstr *MI = MO->getParent(); 988948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen const unsigned Reg = MO->getReg(); 989948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 990948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Both use and def operands can read a register. 991948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MO->readsReg()) { 992948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen regsLiveInButUnused.erase(Reg); 993948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 994eba2bbb58cafcb1ec0fa50d5e8a1c6a8cac2f780Jakob Stoklund Olesen if (MO->isKill()) 995948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen addRegWithSubRegs(regsKilled, Reg); 996948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 997948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Check that LiveVars knows this kill. 998948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (LiveVars && TargetRegisterInfo::isVirtualRegister(Reg) && 999948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen MO->isKill()) { 1000948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen LiveVariables::VarInfo &VI = LiveVars->getVarInfo(Reg); 1001948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (std::find(VI.Kills.begin(), VI.Kills.end(), MI) == VI.Kills.end()) 1002948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Kill missing from LiveVariables", MO, MONum); 1003948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1004948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 1005948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Check LiveInts liveness and kill. 1006a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen if (LiveInts && !LiveInts->isNotInMIMap(MI)) { 1007a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen SlotIndex UseIdx = LiveInts->getInstructionIndex(MI); 1008a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen // Check the cached regunit intervals. 1009a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Reg) && !isReserved(Reg)) { 1010a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen for (MCRegUnitIterator Units(Reg, TRI); Units.isValid(); ++Units) { 10114f3b5e8c9232e43d1291aab8db5f5698d7ee0ea4Matthias Braun if (const LiveRange *LR = LiveInts->getCachedRegUnit(*Units)) { 10124f3b5e8c9232e43d1291aab8db5f5698d7ee0ea4Matthias Braun LiveQueryResult LRQ = LR->Query(UseIdx); 1013a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen if (!LRQ.valueIn()) { 1014331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun report("No live segment at use", MO, MONum); 1015a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen *OS << UseIdx << " is not live in " << PrintRegUnit(*Units, TRI) 10164f3b5e8c9232e43d1291aab8db5f5698d7ee0ea4Matthias Braun << ' ' << *LR << '\n'; 1017a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen } 1018a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen if (MO->isKill() && !LRQ.isKill()) { 1019a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen report("Live range continues after kill flag", MO, MONum); 10204f3b5e8c9232e43d1291aab8db5f5698d7ee0ea4Matthias Braun *OS << PrintRegUnit(*Units, TRI) << ' ' << *LR << '\n'; 1021a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen } 1022a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen } 1023948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1024a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen } 1025a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen 1026a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(Reg)) { 1027a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen if (LiveInts->hasInterval(Reg)) { 1028a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen // This is a virtual register interval. 1029a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen const LiveInterval &LI = LiveInts->getInterval(Reg); 10305649e25ce86b9d89d228ae7c392413571b0f8c19Matthias Braun LiveQueryResult LRQ = LI.Query(UseIdx); 1031a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen if (!LRQ.valueIn()) { 1032331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun report("No live segment at use", MO, MONum); 1033a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen *OS << UseIdx << " is not live in " << LI << '\n'; 1034a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen } 1035a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen // Check for extra kill flags. 1036a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen // Note that we allow missing kill flags for now. 1037a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen if (MO->isKill() && !LRQ.isKill()) { 1038a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen report("Live range continues after kill flag", MO, MONum); 1039a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen *OS << "Live range: " << LI << '\n'; 1040a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen } 1041a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen } else { 1042a62e1e8bc6df16174ae613914d876d335970ef4fJakob Stoklund Olesen report("Virtual register has no live interval", MO, MONum); 1043948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1044948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1045948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1046948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 1047948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Use of a dead register. 1048948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (!regsLive.count(Reg)) { 1049948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Reg)) { 1050948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Reserved registers may be used even when 'dead'. 1051948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (!isReserved(Reg)) 1052948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Using an undefined physical register", MO, MONum); 1053b97c57a8b7dc268958924b8bcc0e97f70437dff6Pete Cooper } else if (MRI->def_empty(Reg)) { 1054b97c57a8b7dc268958924b8bcc0e97f70437dff6Pete Cooper report("Reading virtual register without a def", MO, MONum); 1055948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } else { 1056948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MI->getParent()]; 1057948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // We don't know which virtual registers are live in, so only complain 1058948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // if vreg was killed in this MBB. Otherwise keep track of vregs that 1059948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // must be live in. PHI instructions are handled separately. 1060948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MInfo.regsKilled.count(Reg)) 1061948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Using a killed virtual register", MO, MONum); 1062948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen else if (!MI->isPHI()) 1063948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen MInfo.vregsLiveIn.insert(std::make_pair(Reg, MI)); 1064948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1065948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1066948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1067948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 1068948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MO->isDef()) { 1069948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Register defined. 1070948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // TODO: verify that earlyclobber ops are not used. 1071948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MO->isDead()) 1072948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen addRegWithSubRegs(regsDead, Reg); 1073948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen else 1074948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen addRegWithSubRegs(regsDefined, Reg); 1075948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 1076948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen // Verify SSA form. 1077948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (MRI->isSSA() && TargetRegisterInfo::isVirtualRegister(Reg) && 107836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines std::next(MRI->def_begin(Reg)) != MRI->def_end()) 1079948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Multiple virtual register defs in SSA form", MO, MONum); 1080948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 1081331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // Check LiveInts for a live segment, but only for virtual registers. 1082948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (LiveInts && TargetRegisterInfo::isVirtualRegister(Reg) && 1083948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen !LiveInts->isNotInMIMap(MI)) { 1084f935e945c0fc0444324347882ac41104b12204c2Jakob Stoklund Olesen SlotIndex DefIdx = LiveInts->getInstructionIndex(MI); 1085f935e945c0fc0444324347882ac41104b12204c2Jakob Stoklund Olesen DefIdx = DefIdx.getRegSlot(MO->isEarlyClobber()); 1086948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (LiveInts->hasInterval(Reg)) { 1087948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen const LiveInterval &LI = LiveInts->getInterval(Reg); 1088948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen if (const VNInfo *VNI = LI.getVNInfoAt(DefIdx)) { 1089948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen assert(VNI && "NULL valno is not allowed"); 1090f935e945c0fc0444324347882ac41104b12204c2Jakob Stoklund Olesen if (VNI->def != DefIdx) { 1091948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Inconsistent valno->def", MO, MONum); 1092948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen *OS << "Valno " << VNI->id << " is not defined at " 1093948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen << DefIdx << " in " << LI << '\n'; 1094948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1095948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } else { 1096331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun report("No live segment at def", MO, MONum); 1097948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen *OS << DefIdx << " is not live in " << LI << '\n'; 1098948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1099d900b1179535298510490030a5d2ecce93f79eb0Pedro Artigas // Check that, if the dead def flag is present, LiveInts agree. 1100d900b1179535298510490030a5d2ecce93f79eb0Pedro Artigas if (MO->isDead()) { 1101d900b1179535298510490030a5d2ecce93f79eb0Pedro Artigas LiveQueryResult LRQ = LI.Query(DefIdx); 1102d900b1179535298510490030a5d2ecce93f79eb0Pedro Artigas if (!LRQ.isDeadDef()) { 1103d900b1179535298510490030a5d2ecce93f79eb0Pedro Artigas report("Live range continues after dead def flag", MO, MONum); 1104d900b1179535298510490030a5d2ecce93f79eb0Pedro Artigas *OS << "Live range: " << LI << '\n'; 1105d900b1179535298510490030a5d2ecce93f79eb0Pedro Artigas } 1106d900b1179535298510490030a5d2ecce93f79eb0Pedro Artigas } 1107948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } else { 1108948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen report("Virtual register has no Live interval", MO, MONum); 1109948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1110948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1111948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen } 1112948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen} 1113948a44458c2965e6c2924bbd47c4d41bda0d78f0Jakob Stoklund Olesen 1114b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineInstrAfter(const MachineInstr *MI) { 11151f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen} 11161f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen 11171f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen// This function gets called after visiting all instructions in a bundle. The 11181f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen// argument points to the bundle header. 11191f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen// Normal stand-alone instructions are also considered 'bundles', and this 11201f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesen// function is called for all of them. 11211f9c3ec831cf63f7833680c38362c1e92c251affJakob Stoklund Olesenvoid MachineVerifier::visitMachineBundleAfter(const MachineInstr *MI) { 112248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MI->getParent()]; 112348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen set_union(MInfo.regsKilled, regsKilled); 112473cf709a08d480c4315dc4aa9f644cf86494c4cfJakob Stoklund Olesen set_subtract(regsLive, regsKilled); regsKilled.clear(); 11259ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen // Kill any masked registers. 11269ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen while (!regMasks.empty()) { 11279ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen const uint32_t *Mask = regMasks.pop_back_val(); 11289ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen for (RegSet::iterator I = regsLive.begin(), E = regsLive.end(); I != E; ++I) 11299ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(*I) && 11309ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen MachineOperand::clobbersPhysReg(Mask, *I)) 11319ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen regsDead.push_back(*I); 11329ca12d2e2f14b0b59c839943e58d8aa5d1a271cbJakob Stoklund Olesen } 113373cf709a08d480c4315dc4aa9f644cf86494c4cfJakob Stoklund Olesen set_subtract(regsLive, regsDead); regsDead.clear(); 113473cf709a08d480c4315dc4aa9f644cf86494c4cfJakob Stoklund Olesen set_union(regsLive, regsDefined); regsDefined.clear(); 113548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 113648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 113748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesenvoid 1138b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund OlesenMachineVerifier::visitMachineBasicBlockAfter(const MachineBasicBlock *MBB) { 113948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen MBBInfoMap[MBB].regsLiveOut = regsLive; 114048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen regsLive.clear(); 1141fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen 1142fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen if (Indexes) { 1143fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen SlotIndex stop = Indexes->getMBBEndIdx(MBB); 1144fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen if (!(stop > lastIndex)) { 1145fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen report("Block ends before last instruction index", MBB); 1146fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen *OS << "Block ends at " << stop 1147fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen << " last instruction was at " << lastIndex << '\n'; 1148fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen } 1149fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen lastIndex = stop; 1150fc69c370e165958d7d9a6d756a32479674d83888Jakob Stoklund Olesen } 115148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 115248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 115348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Calculate the largest possible vregsPassed sets. These are the registers that 115448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// can pass through an MBB live, but may not be live every time. It is assumed 115548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// that all vregsPassed sets are empty before the call. 1156b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesenvoid MachineVerifier::calcRegsPassed() { 115748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // First push live-out regs to successors' vregsPassed. Remember the MBBs that 115848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // have any vregsPassed. 11591efd6b94a917449da5007fd332cd895692aa0319Jakob Stoklund Olesen SmallPtrSet<const MachineBasicBlock*, 8> todo; 1160dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (const auto &MBB : *MF) { 116148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[&MBB]; 116248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) 116348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 116448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator SuI = MBB.succ_begin(), 116548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen SuE = MBB.succ_end(); SuI != SuE; ++SuI) { 116648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &SInfo = MBBInfoMap[*SuI]; 116748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SInfo.addPassed(MInfo.regsLiveOut)) 116848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.insert(*SuI); 116948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 117048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 117148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 117248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Iteratively push vregsPassed to successors. This will converge to the same 117348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // final state regardless of DenseSet iteration order. 117448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen while (!todo.empty()) { 117548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen const MachineBasicBlock *MBB = *todo.begin(); 117648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.erase(MBB); 117748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MBB]; 117848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_succ_iterator SuI = MBB->succ_begin(), 117948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen SuE = MBB->succ_end(); SuI != SuE; ++SuI) { 118048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (*SuI == MBB) 118148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 118248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &SInfo = MBBInfoMap[*SuI]; 118348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (SInfo.addPassed(MInfo.vregsPassed)) 118448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen todo.insert(*SuI); 118548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 118648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 118748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 118848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 11898f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen// Calculate the set of virtual registers that must be passed through each basic 11908f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen// block in order to satisfy the requirements of successor blocks. This is very 1191b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen// similar to calcRegsPassed, only backwards. 11928f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesenvoid MachineVerifier::calcRegsRequired() { 11938f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // First push live-in regs to predecessors' vregsRequired. 11941efd6b94a917449da5007fd332cd895692aa0319Jakob Stoklund Olesen SmallPtrSet<const MachineBasicBlock*, 8> todo; 1195dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (const auto &MBB : *MF) { 11968f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[&MBB]; 11978f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MBB.pred_begin(), 11988f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen PrE = MBB.pred_end(); PrI != PrE; ++PrI) { 11998f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &PInfo = MBBInfoMap[*PrI]; 12008f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (PInfo.addRequired(MInfo.vregsLiveIn)) 12018f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen todo.insert(*PrI); 12028f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 12038f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 12048f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 12058f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Iteratively push vregsRequired to predecessors. This will converge to the 12068f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // same final state regardless of DenseSet iteration order. 12078f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen while (!todo.empty()) { 12088f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen const MachineBasicBlock *MBB = *todo.begin(); 12098f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen todo.erase(MBB); 12108f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[MBB]; 12118f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MBB->pred_begin(), 12128f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen PrE = MBB->pred_end(); PrI != PrE; ++PrI) { 12138f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (*PrI == MBB) 12148f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen continue; 12158f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen BBInfo &SInfo = MBBInfoMap[*PrI]; 12168f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (SInfo.addRequired(MInfo.vregsRequired)) 12178f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen todo.insert(*PrI); 12188f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 12198f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 12208f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen} 12218f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 122248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen// Check PHI instructions at the beginning of MBB. It is assumed that 1223b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen// calcRegsPassed has been run so BBInfo::isLiveOut is valid. 1224b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::checkPHIOps(const MachineBasicBlock *MBB) { 12251efd6b94a917449da5007fd332cd895692aa0319Jakob Stoklund Olesen SmallPtrSet<const MachineBasicBlock*, 8> seen; 1226dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (const auto &BBI : *MBB) { 1227dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!BBI.isPHI()) 1228dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines break; 12291efd6b94a917449da5007fd332cd895692aa0319Jakob Stoklund Olesen seen.clear(); 123048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 1231dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (unsigned i = 1, e = BBI.getNumOperands(); i != e; i += 2) { 1232dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned Reg = BBI.getOperand(i).getReg(); 1233dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const MachineBasicBlock *Pre = BBI.getOperand(i + 1).getMBB(); 123448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!Pre->isSuccessor(MBB)) 123548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 123648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen seen.insert(Pre); 123748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen BBInfo &PrInfo = MBBInfoMap[Pre]; 123848872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (PrInfo.reachable && !PrInfo.isLiveOut(Reg)) 123948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen report("PHI operand is not live-out from predecessor", 1240dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines &BBI.getOperand(i), i); 124148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 124248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 124348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Did we see all predecessors? 124448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PrI = MBB->pred_begin(), 124548872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen PrE = MBB->pred_end(); PrI != PrE; ++PrI) { 124648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!seen.count(*PrI)) { 1247dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines report("Missing PHI operand", &BBI); 12480ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman *OS << "BB#" << (*PrI)->getNumber() 124948872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen << " is a predecessor according to the CFG.\n"; 125048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 125148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 125248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 125348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 125448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 1255b44fad7f95b9c0c65d5c772f6ed5084cf46283e9Jakob Stoklund Olesenvoid MachineVerifier::visitMachineFunctionAfter() { 1256b31defe94caac68561344f78696be3a048413ec9Jakob Stoklund Olesen calcRegsPassed(); 125748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 1258dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (const auto &MBB : *MF) { 1259dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BBInfo &MInfo = MBBInfoMap[&MBB]; 126048872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 126148872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen // Skip unreachable MBBs. 126248872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen if (!MInfo.reachable) 126348872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen continue; 126448872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 1265dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines checkPHIOps(&MBB); 126648872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen } 126748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen 126858e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen // Now check liveness info if available 126964ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen calcRegsRequired(); 127064ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen 1271bb0721680c329625f47c090f48dcafb2fe14101cJakob Stoklund Olesen // Check for killed virtual registers that should be live out. 1272dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (const auto &MBB : *MF) { 1273dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BBInfo &MInfo = MBBInfoMap[&MBB]; 1274bb0721680c329625f47c090f48dcafb2fe14101cJakob Stoklund Olesen for (RegSet::iterator 1275bb0721680c329625f47c090f48dcafb2fe14101cJakob Stoklund Olesen I = MInfo.vregsRequired.begin(), E = MInfo.vregsRequired.end(); I != E; 1276bb0721680c329625f47c090f48dcafb2fe14101cJakob Stoklund Olesen ++I) 1277bb0721680c329625f47c090f48dcafb2fe14101cJakob Stoklund Olesen if (MInfo.regsKilled.count(*I)) { 1278dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines report("Virtual register killed in block, but needed live out.", &MBB); 127996cb1128528a512f1ef9c28ae5e1b78a98dcc505Bill Wendling *OS << "Virtual register " << PrintReg(*I) 1280bb0721680c329625f47c090f48dcafb2fe14101cJakob Stoklund Olesen << " is used after the block.\n"; 1281bb0721680c329625f47c090f48dcafb2fe14101cJakob Stoklund Olesen } 1282bb0721680c329625f47c090f48dcafb2fe14101cJakob Stoklund Olesen } 1283bb0721680c329625f47c090f48dcafb2fe14101cJakob Stoklund Olesen 1284a4e6397fd9f2fbbd6affdfb0738813918cb21da0Jakob Stoklund Olesen if (!MF->empty()) { 128564ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen BBInfo &MInfo = MBBInfoMap[&MF->front()]; 128664ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen for (RegSet::iterator 128764ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen I = MInfo.vregsRequired.begin(), E = MInfo.vregsRequired.end(); I != E; 1288ff0275ea53842101645000d1d7fefe85e007fb03Jakob Stoklund Olesen ++I) 1289ff0275ea53842101645000d1d7fefe85e007fb03Jakob Stoklund Olesen report("Virtual register def doesn't dominate all uses.", 1290ff0275ea53842101645000d1d7fefe85e007fb03Jakob Stoklund Olesen MRI->getVRegDef(*I)); 129164ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen } 129264ffa83c9bf5a1f0c064295de9b3eba7b0f09a99Jakob Stoklund Olesen 129358e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen if (LiveVars) 12948f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen verifyLiveVariables(); 129558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen if (LiveInts) 129658e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen verifyLiveIntervals(); 129748872e0d84b47769be6c13ae98bf88468b59d921Jakob Stoklund Olesen} 12988f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 12998f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesenvoid MachineVerifier::verifyLiveVariables() { 13008f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen assert(LiveVars && "Don't call verifyLiveVariables without LiveVars"); 130198c54760704878cf5290a9a3b23876b7550c5560Jakob Stoklund Olesen for (unsigned i = 0, e = MRI->getNumVirtRegs(); i != e; ++i) { 130298c54760704878cf5290a9a3b23876b7550c5560Jakob Stoklund Olesen unsigned Reg = TargetRegisterInfo::index2VirtReg(i); 13038f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen LiveVariables::VarInfo &VI = LiveVars->getVarInfo(Reg); 1304dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (const auto &MBB : *MF) { 1305dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BBInfo &MInfo = MBBInfoMap[&MBB]; 13068f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 13078f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen // Our vregsRequired should be identical to LiveVariables' AliveBlocks 13088f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen if (MInfo.vregsRequired.count(Reg)) { 1309dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!VI.AliveBlocks.test(MBB.getNumber())) { 1310dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines report("LiveVariables: Block missing from AliveBlocks", &MBB); 13114314268128be6d54c9a7f0709680e5a5b40f3ab3Jakob Stoklund Olesen *OS << "Virtual register " << PrintReg(Reg) 13128f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen << " must be live through the block.\n"; 13138f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 13148f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } else { 1315dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (VI.AliveBlocks.test(MBB.getNumber())) { 1316dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines report("LiveVariables: Block should not be in AliveBlocks", &MBB); 13174314268128be6d54c9a7f0709680e5a5b40f3ab3Jakob Stoklund Olesen *OS << "Virtual register " << PrintReg(Reg) 13188f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen << " is not needed live through the block.\n"; 13198f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 13208f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 13218f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 13228f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen } 13238f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen} 13248f16e02fc95c9b197d38bcd681f2612d36ed5c11Jakob Stoklund Olesen 132558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesenvoid MachineVerifier::verifyLiveIntervals() { 132658e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen assert(LiveInts && "Don't call verifyLiveIntervals without LiveInts"); 132712a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen for (unsigned i = 0, e = MRI->getNumVirtRegs(); i != e; ++i) { 132812a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen unsigned Reg = TargetRegisterInfo::index2VirtReg(i); 1329893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen 1330893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen // Spilling and splitting may leave unused registers around. Skip them. 133112a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen if (MRI->reg_nodbg_empty(Reg)) 1332893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen continue; 1333893ab5d7014dd112fb111a67504bd556be9bd393Jakob Stoklund Olesen 133412a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen if (!LiveInts->hasInterval(Reg)) { 133512a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen report("Missing live interval for virtual register", MF); 133612a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen *OS << PrintReg(Reg, TRI) << " still has defs or uses\n"; 13378c4564287d5231421d5358d71d23f46cd0be18c7Jakob Stoklund Olesen continue; 133812a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen } 13398c4564287d5231421d5358d71d23f46cd0be18c7Jakob Stoklund Olesen 134012a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen const LiveInterval &LI = LiveInts->getInterval(Reg); 134112a7be9ba4263a283ca14e277a90cb64fe0e6f62Jakob Stoklund Olesen assert(Reg == LI.reg && "Invalid reg to interval mapping"); 1342e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen verifyLiveInterval(LI); 1343e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1344804468916a93bb2914c28687829ccb065a97e1d9Jakob Stoklund Olesen 1345804468916a93bb2914c28687829ccb065a97e1d9Jakob Stoklund Olesen // Verify all the cached regunit intervals. 1346804468916a93bb2914c28687829ccb065a97e1d9Jakob Stoklund Olesen for (unsigned i = 0, e = TRI->getNumRegUnits(); i != e; ++i) 13474f3b5e8c9232e43d1291aab8db5f5698d7ee0ea4Matthias Braun if (const LiveRange *LR = LiveInts->getCachedRegUnit(i)) 13484f3b5e8c9232e43d1291aab8db5f5698d7ee0ea4Matthias Braun verifyLiveRange(*LR, i); 1349e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen} 135058e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1351a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braunvoid MachineVerifier::verifyLiveRangeValue(const LiveRange &LR, 1352a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun const VNInfo *VNI, 1353a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun unsigned Reg) { 1354e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (VNI->isUnused()) 1355e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen return; 135658e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1357a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun const VNInfo *DefVNI = LR.getVNInfoAt(VNI->def); 135858e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1359e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (!DefVNI) { 1360a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Valno not live at def and not marked unused", MF, LR); 136179240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << '\n'; 1362e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen return; 1363e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 136458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1365e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (DefVNI != VNI) { 1366a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Live segment at def has different valno", MF, LR); 1367e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 136879240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen << " where valno #" << DefVNI->id << " is live\n"; 1369e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen return; 1370e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 137158e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1372e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen const MachineBasicBlock *MBB = LiveInts->getMBBFromIndex(VNI->def); 1373e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (!MBB) { 1374a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Invalid definition index", MF, LR); 1375e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 1376a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun << " in " << LR << '\n'; 1377e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen return; 1378e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 13793bf7cf9f0e5a34ade5e44c47f39e3f46c8ae2c76Jakob Stoklund Olesen 1380e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (VNI->isPHIDef()) { 1381e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (VNI->def != LiveInts->getMBBStartIdx(MBB)) { 1382a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("PHIDef value is not defined at MBB start", MBB, LR); 1383e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def 138479240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen << ", not at the beginning of BB#" << MBB->getNumber() << '\n'; 1385e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1386e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen return; 1387e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 13880b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich 1389e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // Non-PHI def. 1390e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen const MachineInstr *MI = LiveInts->getInstructionFromIndex(VNI->def); 1391e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (!MI) { 1392a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("No instruction at def index", MBB, LR); 139379240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def << '\n'; 1394e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen return; 1395e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1396121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1397a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (Reg != 0) { 1398a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun bool hasDef = false; 1399a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun bool isEarlyClobber = false; 1400a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun for (ConstMIBundleOperands MOI(MI); MOI.isValid(); ++MOI) { 1401a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (!MOI->isReg() || !MOI->isDef()) 1402e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen continue; 1403a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (TargetRegisterInfo::isVirtualRegister(Reg)) { 1404a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (MOI->getReg() != Reg) 1405a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun continue; 1406a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun } else { 1407a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (!TargetRegisterInfo::isPhysicalRegister(MOI->getReg()) || 1408a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun !TRI->hasRegUnit(MOI->getReg(), Reg)) 1409a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun continue; 1410a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun } 1411a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun hasDef = true; 1412a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (MOI->isEarlyClobber()) 1413a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun isEarlyClobber = true; 1414e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 14150b13d7db281d1c64194269822713ae30a1f921d5Cameron Zwarich 1416a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (!hasDef) { 1417a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Defining instruction does not modify register", MI); 1418a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << "Valno #" << VNI->id << " in " << LR << '\n'; 1419a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun } 1420e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen 1421a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun // Early clobber defs begin at USE slots, but other defs must begin at 1422a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun // DEF slots. 1423a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (isEarlyClobber) { 1424a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (!VNI->def.isEarlyClobber()) { 1425a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Early clobber def must be at an early-clobber slot", MBB, LR); 1426a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << "Valno #" << VNI->id << " is defined at " << VNI->def << '\n'; 1427a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun } 1428a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun } else if (!VNI->def.isRegister()) { 1429a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Non-PHI, non-early clobber def must be at a register slot", 1430a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun MBB, LR); 143179240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " is defined at " << VNI->def << '\n'; 143258e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 1433e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1434e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen} 143558e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1436a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braunvoid MachineVerifier::verifyLiveRangeSegment(const LiveRange &LR, 1437a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun const LiveRange::const_iterator I, 1438a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun unsigned Reg) { 1439a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun const LiveRange::Segment &S = *I; 1440a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun const VNInfo *VNI = S.valno; 1441331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun assert(VNI && "Live segment has no valno"); 1442e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen 1443a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (VNI->id >= LR.getNumValNums() || VNI != LR.getValNumInfo(VNI->id)) { 1444a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Foreign valno in live segment", MF, LR); 1445a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << S << " has a bad valno\n"; 1446e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 144758e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1448e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (VNI->isUnused()) { 1449a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Live segment valno is marked unused", MF, LR); 1450a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << S << '\n'; 1451e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 145258e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1453a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun const MachineBasicBlock *MBB = LiveInts->getMBBFromIndex(S.start); 1454e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (!MBB) { 1455a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Bad start of live segment, no basic block", MF, LR); 1456a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << S << '\n'; 1457e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen return; 1458e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1459e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen SlotIndex MBBStartIdx = LiveInts->getMBBStartIdx(MBB); 1460a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (S.start != MBBStartIdx && S.start != VNI->def) { 1461a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Live segment must begin at MBB entry or valno def", MBB, LR); 1462a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << S << '\n'; 1463e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 146458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen 1465e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen const MachineBasicBlock *EndMBB = 1466a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun LiveInts->getMBBFromIndex(S.end.getPrevSlot()); 1467e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (!EndMBB) { 1468a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Bad end of live segment, no basic block", MF, LR); 1469a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << S << '\n'; 1470e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen return; 1471e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 14727871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen 1473e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // No more checks for live-out segments. 1474a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (S.end == LiveInts->getMBBEndIdx(EndMBB)) 1475e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen return; 1476e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen 1477804468916a93bb2914c28687829ccb065a97e1d9Jakob Stoklund Olesen // RegUnit intervals are allowed dead phis. 1478a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (!TargetRegisterInfo::isVirtualRegister(Reg) && VNI->isPHIDef() && 1479a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun S.start == VNI->def && S.end == VNI->def.getDeadSlot()) 1480804468916a93bb2914c28687829ccb065a97e1d9Jakob Stoklund Olesen return; 1481804468916a93bb2914c28687829ccb065a97e1d9Jakob Stoklund Olesen 1482e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // The live segment is ending inside EndMBB 1483e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen const MachineInstr *MI = 1484a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun LiveInts->getInstructionFromIndex(S.end.getPrevSlot()); 1485e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (!MI) { 1486a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Live segment doesn't end at a valid instruction", EndMBB, LR); 1487a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << S << '\n'; 1488e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen return; 1489e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1490121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1491e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // The block slot must refer to a basic block boundary. 1492a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (S.end.isBlock()) { 1493a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Live segment ends at B slot of an instruction", EndMBB, LR); 1494a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << S << '\n'; 1495e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1496121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1497a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (S.end.isDead()) { 1498e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // Segment ends on the dead slot. 1499e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // That means there must be a dead def. 1500a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (!SlotIndex::isSameInstr(S.start, S.end)) { 1501a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Live segment ending at dead slot spans instructions", EndMBB, LR); 1502a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << S << '\n'; 1503e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1504e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1505e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen 1506e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // A live segment can only end at an early-clobber slot if it is being 1507e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // redefined by an early-clobber def. 1508a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (S.end.isEarlyClobber()) { 1509a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (I+1 == LR.end() || (I+1)->start != S.end) { 1510e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen report("Live segment ending at early clobber slot must be " 1511a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun "redefined by an EC def in the same instruction", EndMBB, LR); 1512a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << S << '\n'; 1513e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1514e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1515e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen 1516e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // The following checks only apply to virtual registers. Physreg liveness 1517e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // is too weird to check. 1518a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (TargetRegisterInfo::isVirtualRegister(Reg)) { 1519331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // A live segment can end with either a redefinition, a kill flag on a 1520e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // use, or a dead flag on a def. 1521e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen bool hasRead = false; 1522e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen for (ConstMIBundleOperands MOI(MI); MOI.isValid(); ++MOI) { 1523a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (!MOI->isReg() || MOI->getReg() != Reg) 1524121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen continue; 1525e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (MOI->readsReg()) 1526e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen hasRead = true; 1527e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1528d900b1179535298510490030a5d2ecce93f79eb0Pedro Artigas if (!S.end.isDead()) { 1529e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (!hasRead) { 1530331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun report("Instruction ending live segment doesn't read the register", MI); 1531a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun *OS << S << " in " << LR << '\n'; 1532121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen } 1533e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1534e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1535121b179edf28040b8fa4c99e0835e4560cf3a5d4Jakob Stoklund Olesen 1536e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // Now check all the basic blocks in this live segment. 1537e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen MachineFunction::const_iterator MFI = MBB; 1538331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // Is this live segment the beginning of a non-PHIDef VN? 1539a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (S.start == VNI->def && !VNI->isPHIDef()) { 1540e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // Not live-in to any blocks. 1541e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (MBB == EndMBB) 1542e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen return; 1543e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // Skip this block. 1544e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen ++MFI; 1545e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1546e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen for (;;) { 1547a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun assert(LiveInts->isLiveInToMBB(LR, MFI)); 1548e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // We don't know how to track physregs into a landing pad. 1549a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun if (!TargetRegisterInfo::isVirtualRegister(Reg) && 1550e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen MFI->isLandingPad()) { 1551e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (&*MFI == EndMBB) 1552e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen break; 1553e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen ++MFI; 1554e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen continue; 1555e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 15567871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen 1557e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // Is VNI a PHI-def in the current block? 1558e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen bool IsPHI = VNI->isPHIDef() && 1559e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen VNI->def == LiveInts->getMBBStartIdx(MFI); 1560e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen 1561e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // Check that VNI is live-out of all predecessors. 1562e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen for (MachineBasicBlock::const_pred_iterator PI = MFI->pred_begin(), 1563e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen PE = MFI->pred_end(); PI != PE; ++PI) { 1564e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen SlotIndex PEnd = LiveInts->getMBBEndIdx(*PI); 1565a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun const VNInfo *PVNI = LR.getVNInfoBefore(PEnd); 1566e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen 1567e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // All predecessors must have a live-out value. 1568e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (!PVNI) { 1569a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Register not marked live out of predecessor", *PI, LR); 1570e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen *OS << "Valno #" << VNI->id << " live into BB#" << MFI->getNumber() 1571e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen << '@' << LiveInts->getMBBStartIdx(MFI) << ", not live before " 157279240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen << PEnd << '\n'; 1573e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen continue; 15747871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 1575cb584d08c0734d64f95b0f762aa31ea8ce3de2d9Cameron Zwarich 1576e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // Only PHI-defs can take different predecessor values. 1577e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (!IsPHI && PVNI != VNI) { 1578a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun report("Different value live out of predecessor", *PI, LR); 1579e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen *OS << "Valno #" << PVNI->id << " live out of BB#" 1580e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen << (*PI)->getNumber() << '@' << PEnd 1581e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen << "\nValno #" << VNI->id << " live into BB#" << MFI->getNumber() 158279240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen << '@' << LiveInts->getMBBStartIdx(MFI) << '\n'; 15837871687604944d68455a777c3047ff2a6ca5985fJakob Stoklund Olesen } 158458e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 1585e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (&*MFI == EndMBB) 1586e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen break; 1587e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen ++MFI; 1588e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen } 1589e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen} 1590501dc4224586d3cee61101ed6cd0ccc8ba74c43cJakob Stoklund Olesen 1591a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braunvoid MachineVerifier::verifyLiveRange(const LiveRange &LR, unsigned Reg) { 1592a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun for (LiveRange::const_vni_iterator I = LR.vni_begin(), E = LR.vni_end(); 1593a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun I != E; ++I) 1594a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun verifyLiveRangeValue(LR, *I, Reg); 1595e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen 1596a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun for (LiveRange::const_iterator I = LR.begin(), E = LR.end(); I != E; ++I) 1597a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun verifyLiveRangeSegment(LR, I, Reg); 1598a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun} 1599a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun 1600a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braunvoid MachineVerifier::verifyLiveInterval(const LiveInterval &LI) { 1601a4aed9ae392b30147745bd27e5fea7b0cebc1702Matthias Braun verifyLiveRange(LI, LI.reg); 1602e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen 1603e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen // Check the LI only has one connected component. 1604e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(LI.reg)) { 1605e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen ConnectedVNInfoEqClasses ConEQ(*LiveInts); 1606e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen unsigned NumComp = ConEQ.Classify(&LI); 1607e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (NumComp > 1) { 160879240f9539ab187f5e25cec44e0250a89dfe1d59Jakob Stoklund Olesen report("Multiple connected components in live interval", MF, LI); 1609e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen for (unsigned comp = 0; comp != NumComp; ++comp) { 1610e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen *OS << comp << ": valnos"; 1611e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen for (LiveInterval::const_vni_iterator I = LI.vni_begin(), 1612e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen E = LI.vni_end(); I!=E; ++I) 1613e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen if (comp == ConEQ.getEqClass(*I)) 1614e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen *OS << ' ' << (*I)->id; 1615e5c79a5c2542fa0d852df28b5ee9de8dfef694d8Jakob Stoklund Olesen *OS << '\n'; 16168c593f9173bb3b4474c8de964478f213e90764b9Jakob Stoklund Olesen } 1617501dc4224586d3cee61101ed6cd0ccc8ba74c43cJakob Stoklund Olesen } 161858e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen } 161958e1248dd2b3d76bbc78a9cb84cd022a35e83955Jakob Stoklund Olesen} 16207310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 16217310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Rennamespace { 16227310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // FrameSetup and FrameDestroy can have zero adjustment, so using a single 16237310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // integer, we can't tell whether it is a FrameSetup or FrameDestroy if the 16247310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // value is zero. 16257310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // We use a bool plus an integer to capture the stack state. 16267310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren struct StackStateOfBB { 16277310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren StackStateOfBB() : EntryValue(0), ExitValue(0), EntryIsSetup(false), 16287310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren ExitIsSetup(false) { } 16297310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren StackStateOfBB(int EntryVal, int ExitVal, bool EntrySetup, bool ExitSetup) : 16307310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren EntryValue(EntryVal), ExitValue(ExitVal), EntryIsSetup(EntrySetup), 16317310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren ExitIsSetup(ExitSetup) { } 16327310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // Can be negative, which means we are setting up a frame. 16337310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren int EntryValue; 16347310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren int ExitValue; 16357310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren bool EntryIsSetup; 16367310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren bool ExitIsSetup; 16377310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren }; 16387310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren} 16397310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 16407310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren/// Make sure on every path through the CFG, a FrameSetup <n> is always followed 16417310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren/// by a FrameDestroy <n>, stack adjustments are identical on all 16427310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren/// CFG edges to a merge point, and frame is destroyed at end of a return block. 16437310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Renvoid MachineVerifier::verifyStackFrame() { 16447310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren int FrameSetupOpcode = TII->getCallFrameSetupOpcode(); 16457310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren int FrameDestroyOpcode = TII->getCallFrameDestroyOpcode(); 16467310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 16477310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren SmallVector<StackStateOfBB, 8> SPState; 16487310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren SPState.resize(MF->getNumBlockIDs()); 16497310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren SmallPtrSet<const MachineBasicBlock*, 8> Reachable; 16507310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 16517310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // Visit the MBBs in DFS order. 16527310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren for (df_ext_iterator<const MachineFunction*, 16537310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren SmallPtrSet<const MachineBasicBlock*, 8> > 16547310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren DFI = df_ext_begin(MF, Reachable), DFE = df_ext_end(MF, Reachable); 16557310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren DFI != DFE; ++DFI) { 16567310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren const MachineBasicBlock *MBB = *DFI; 16577310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 16587310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren StackStateOfBB BBState; 16597310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // Check the exit state of the DFS stack predecessor. 16607310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren if (DFI.getPathLength() >= 2) { 16617310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren const MachineBasicBlock *StackPred = DFI.getPath(DFI.getPathLength() - 2); 16627310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren assert(Reachable.count(StackPred) && 16637310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren "DFS stack predecessor is already visited.\n"); 16647310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren BBState.EntryValue = SPState[StackPred->getNumber()].ExitValue; 16657310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren BBState.EntryIsSetup = SPState[StackPred->getNumber()].ExitIsSetup; 16667310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren BBState.ExitValue = BBState.EntryValue; 16677310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren BBState.ExitIsSetup = BBState.EntryIsSetup; 16687310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren } 16697310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 16707310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // Update stack state by checking contents of MBB. 1671dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (const auto &I : *MBB) { 1672dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (I.getOpcode() == FrameSetupOpcode) { 16737310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // The first operand of a FrameOpcode should be i32. 1674dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines int Size = I.getOperand(0).getImm(); 16757310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren assert(Size >= 0 && 16767310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren "Value should be non-negative in FrameSetup and FrameDestroy.\n"); 16777310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 16787310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren if (BBState.ExitIsSetup) 1679dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines report("FrameSetup is after another FrameSetup", &I); 16807310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren BBState.ExitValue -= Size; 16817310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren BBState.ExitIsSetup = true; 16827310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren } 16837310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 1684dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (I.getOpcode() == FrameDestroyOpcode) { 16857310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // The first operand of a FrameOpcode should be i32. 1686dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines int Size = I.getOperand(0).getImm(); 16877310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren assert(Size >= 0 && 16887310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren "Value should be non-negative in FrameSetup and FrameDestroy.\n"); 16897310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 16907310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren if (!BBState.ExitIsSetup) 1691dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines report("FrameDestroy is not after a FrameSetup", &I); 16927310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren int AbsSPAdj = BBState.ExitValue < 0 ? -BBState.ExitValue : 16937310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren BBState.ExitValue; 16947310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren if (BBState.ExitIsSetup && AbsSPAdj != Size) { 1695dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines report("FrameDestroy <n> is after FrameSetup <m>", &I); 16967310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren *OS << "FrameDestroy <" << Size << "> is after FrameSetup <" 16977310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren << AbsSPAdj << ">.\n"; 16987310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren } 16997310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren BBState.ExitValue += Size; 17007310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren BBState.ExitIsSetup = false; 17017310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren } 17027310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren } 17037310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren SPState[MBB->getNumber()] = BBState; 17047310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 17057310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // Make sure the exit state of any predecessor is consistent with the entry 17067310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // state. 17077310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren for (MachineBasicBlock::const_pred_iterator I = MBB->pred_begin(), 17087310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren E = MBB->pred_end(); I != E; ++I) { 17097310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren if (Reachable.count(*I) && 17107310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren (SPState[(*I)->getNumber()].ExitValue != BBState.EntryValue || 17117310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren SPState[(*I)->getNumber()].ExitIsSetup != BBState.EntryIsSetup)) { 17127310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren report("The exit stack state of a predecessor is inconsistent.", MBB); 17137310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren *OS << "Predecessor BB#" << (*I)->getNumber() << " has exit state (" 17147310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren << SPState[(*I)->getNumber()].ExitValue << ", " 17157310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren << SPState[(*I)->getNumber()].ExitIsSetup 17167310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren << "), while BB#" << MBB->getNumber() << " has entry state (" 17177310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren << BBState.EntryValue << ", " << BBState.EntryIsSetup << ").\n"; 17187310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren } 17197310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren } 17207310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 17217310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // Make sure the entry state of any successor is consistent with the exit 17227310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // state. 17237310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren for (MachineBasicBlock::const_succ_iterator I = MBB->succ_begin(), 17247310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren E = MBB->succ_end(); I != E; ++I) { 17257310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren if (Reachable.count(*I) && 17267310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren (SPState[(*I)->getNumber()].EntryValue != BBState.ExitValue || 17277310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren SPState[(*I)->getNumber()].EntryIsSetup != BBState.ExitIsSetup)) { 17287310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren report("The entry stack state of a successor is inconsistent.", MBB); 17297310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren *OS << "Successor BB#" << (*I)->getNumber() << " has entry state (" 17307310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren << SPState[(*I)->getNumber()].EntryValue << ", " 17317310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren << SPState[(*I)->getNumber()].EntryIsSetup 17327310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren << "), while BB#" << MBB->getNumber() << " has exit state (" 17337310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren << BBState.ExitValue << ", " << BBState.ExitIsSetup << ").\n"; 17347310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren } 17357310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren } 17367310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren 17377310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren // Make sure a basic block with return ends with zero stack adjustment. 17387310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren if (!MBB->empty() && MBB->back().isReturn()) { 17397310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren if (BBState.ExitIsSetup) 17407310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren report("A return block ends with a FrameSetup.", MBB); 17417310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren if (BBState.ExitValue) 17427310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren report("A return block ends with a nonzero stack adjustment.", MBB); 17437310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren } 17447310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren } 17457310b75c8b6cc0f73d114dc0beccbb96a6942547Manman Ren} 1746