MachineInstr: Remove parameter from dump()

[MatzeB]

Summary

The primary use of the dump() functions in LLVM is for use in a debugger. Unfortunately lldb does not seem to handle default arguments so using p SomeMI.dump() fails and you have to type the longer p SomeMI.dump(nullptr). Remove the paramter to make the most common use easy. (You can always construct something like p SomeMI.print(dbgs(),MyTII) if you need more features).

[sebpop]

I don't mind reverting this part of the patch for now to help users of lldb.
In the long run lldb should be fixed to accept the c++ construct.

llvm/trunk/include/llvm/CodeGen/MachineInstr.h

 
   //
   // Debugging support
   //
   void print(raw_ostream &OS, bool SkipOpers = false,
              const TargetInstrInfo *TII = nullptr) const;
   void print(raw_ostream &OS, ModuleSlotTracker &MST, bool SkipOpers = false,
              const TargetInstrInfo *TII = nullptr) const;
-  void dump(const TargetInstrInfo *TII = nullptr) const;
+  void dump() const;
 
   //===--------------------------------------------------------------------===//
   // Accessors used to build up machine instructions.
 
   /// Add the specified operand to the instruction.  If it is an implicit
   /// operand, it is added to the end of the operand list.  If it is an
   /// explicit operand it is added at the end of the explicit operand list
   /// (before the first implicit operand).

llvm/trunk/lib/CodeGen/MachineCombiner.cpp

MachineCombiner::getDepth(SmallVectorImpl<MachineInstr *> &InsInstrs,
   assert(TSchedModel.hasInstrSchedModelOrItineraries() &&
          "Missing machine model\n");
 
   // For each instruction in the new sequence compute the depth based on the
   // operands. Use the trace information when possible. For new operands which
   // are tracked in the InstrIdxForVirtReg map depth is looked up in InstrDepth
   for (auto *InstrPtr : InsInstrs) { // for each Use
     unsigned IDepth = 0;
-    DEBUG(dbgs() << "NEW INSTR "; InstrPtr->dump(TII); dbgs() << "\n";);
+    DEBUG(dbgs() << "NEW INSTR ";
+          InstrPtr->print(dbgs(), TII);
+          dbgs() << "\n";);
     for (const MachineOperand &MO : InstrPtr->operands()) {
       // Check for virtual register operand.
       if (!(MO.isReg() && TargetRegisterInfo::isVirtualRegister(MO.getReg())))
         continue;
       if (!MO.isUse())
         continue;
       unsigned DepthOp = 0;
       unsigned LatencyOp = 0;

llvm/trunk/lib/CodeGen/MachineInstr.cpp

for (unsigned i = MI.getDesc().getNumOperands(), e = MI.getNumOperands();
        i != e; ++i) {
     const MachineOperand &MO = MI.getOperand(i);
     if ((MO.isReg() && MO.isImplicit()) || MO.isRegMask())
       addOperand(MF, MO);
   }
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MachineInstr::dump(const TargetInstrInfo *TII) const {
+LLVM_DUMP_METHOD void MachineInstr::dump() const {
   dbgs() << "  ";
-  print(dbgs(), false /* SkipOpers */, TII);
+  print(dbgs());
 }
 #endif
 
 void MachineInstr::print(raw_ostream &OS, bool SkipOpers,
                          const TargetInstrInfo *TII) const {
   const Module *M = nullptr;
   if (const MachineBasicBlock *MBB = getParent())
     if (const MachineFunction *MF = MBB->getParent())