Subzero: For filetype=asm, don't print a blank line for pseudo instrs.

src/IceCfgNode.cpp

 //===- subzero/src/IceCfgNode.cpp - Basic block (node) implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 936 matching lines @@
     for (Variable *Var : LiveRegs) {
       if (!First)
         Str << ",";
       First = false;
       Var->emit(Func);
     }
   }
   Str << "\n";
 }
 
-void emitLiveRangesEnded(Ostream &Str, const Cfg *Func, const Inst *Instr,
+/// Returns true if some text was emitted - in which case the caller definitely
+/// needs to emit a newline character.
+bool emitLiveRangesEnded(Ostream &Str, const Cfg *Func, const Inst *Instr,
                          CfgVector<SizeT> &LiveRegCount) {
+  bool Printed = false;
   if (!BuildDefs::dump())
-    return;
-  bool First = true;
+    return Printed;
   Variable *Dest = Instr->getDest();
   // Normally we increment the live count for the dest register. But we
   // shouldn't if the instruction's IsDestRedefined flag is set, because this
   // means that the target lowering created this instruction as a non-SSA
   // assignment; i.e., a different, previous instruction started the dest
   // variable's live range.
   if (!Instr->isDestRedefined() && Dest && Dest->hasReg())
     ++LiveRegCount[Dest->getRegNum()];
   FOREACH_VAR_IN_INST(Var, *Instr) {
     bool ShouldReport = Instr->isLastUse(Var);
     if (ShouldReport && Var->hasReg()) {
       // Don't report end of live range until the live count reaches 0.
       SizeT NewCount = --LiveRegCount[Var->getRegNum()];
       if (NewCount)
         ShouldReport = false;
     }
     if (ShouldReport) {
-      if (First)
+      if (Printed)
+        Str << ",";
+      else
         Str << " \t# END=";
-      else
-        Str << ",";
       Var->emit(Func);
-      First = false;
+      Printed = true;
     }
   }
+  return Printed;
 }
 
 void updateStats(Cfg *Func, const Inst *I) {
   if (!BuildDefs::dump())
     return;
   // Update emitted instruction count, plus fill/spill count for Variable
   // operands without a physical register.
   if (uint32_t Count = I->getEmitInstCount()) {
     Func->getContext()->statsUpdateEmitted(Count);
     if (Variable *Dest = I->getDest()) {
@@ skipping 64 matching lines @@
       // but that isn't called for redundant assignments.
       Variable *Dest = I.getDest();
       if (DecorateAsm && Dest->hasReg()) {
         ++LiveRegCount[Dest->getRegNum()];
         if (I.isLastUse(I.getSrc(0)))
           --LiveRegCount[llvm::cast<Variable>(I.getSrc(0))->getRegNum()];
       }
       continue;
     }
     I.emit(Func);
+    bool Printed = false;
     if (DecorateAsm)
-      emitLiveRangesEnded(Str, Func, &I, LiveRegCount);
-    Str << "\n";
+      Printed = emitLiveRangesEnded(Str, Func, &I, LiveRegCount);
+    if (Printed || llvm::isa<InstTarget>(&I))
+      Str << "\n";
     updateStats(Func, &I);
   }
   if (DecorateAsm) {
     constexpr bool IsLiveIn = false;
     emitRegisterUsage(Str, Func, this, IsLiveIn, LiveRegCount);
   }
 }
 
 // Helper class for emitIAS().
 namespace {
@@ skipping 322 matching lines @@
   InstIntrinsicCall *Inst = InstIntrinsicCall::create(
       Func, 5, Func->makeVariable(IceType_i64), RMWI64Name, Info->Info);
   Inst->addArg(AtomicRMWOp);
   Inst->addArg(Counter);
   Inst->addArg(One);
   Inst->addArg(OrderAcquireRelease);
   Insts.push_front(Inst);
 }
 
 } // end of namespace Ice