Subzero: Separate "\t" from "opcode" in asm emission.

src/IceInstX86BaseImpl.h

 //===- subzero/src/IceInstX86BaseImpl.h - Generic X86 instructions -*- C++ -*=//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 418 matching lines @@
   }
 
   if (Label) {
     Str << "\t" << Label->getName(Func);
   } else {
     if (Condition == InstX86Base<Machine>::Traits::Cond::Br_None) {
       Str << "\t" << getTargetFalse()->getAsmName();
     } else {
       Str << "\t" << getTargetTrue()->getAsmName();
       if (getTargetFalse()) {
-        Str << "\n\tjmp\t" << getTargetFalse()->getAsmName();
+        Str << "\n\t"
+               "jmp\t" << getTargetFalse()->getAsmName();
       }
     }
   }
 }
 
 template <class Machine>
 void InstX86Br<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   if (Label) {
@@ skipping 46 matching lines @@
   }
 
   Str << " // (" << (isNear() ? "near" : "far") << " jump)";
 }
 
 template <class Machine> void InstX86Jmp<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 1);
-  Str << "\tjmp\t*";
+  Str << "\t"
+         "jmp\t*";
   getJmpTarget()->emit(Func);
 }
 
 template <class Machine>
 void InstX86Jmp<Machine>::emitIAS(const Cfg *Func) const {
   // Note: Adapted (mostly copied) from InstX86Call<Machine>::emitIAS().
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   Operand *Target = getJmpTarget();
   if (const auto *Var = llvm::dyn_cast<Variable>(Target)) {
@@ skipping 36 matching lines @@
   Str << "jmp ";
   getJmpTarget()->dump(Func);
 }
 
 template <class Machine>
 void InstX86Call<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 1);
-  Str << "\tcall\t";
+  Str << "\t"
+         "call\t";
   Operand *CallTarget = getCallTarget();
   auto *Target = InstX86Base<Machine>::getTarget(Func);
   if (const auto *CI = llvm::dyn_cast<ConstantInteger32>(CallTarget)) {
     // Emit without a leading '$'.
     Str << CI->getValue();
   } else if (const auto DirectCallTarget =
                  llvm::dyn_cast<ConstantRelocatable>(CallTarget)) {
     DirectCallTarget->emitWithoutPrefix(Target);
   } else {
     Str << "*";
@@ skipping 416 matching lines @@
 }
 
 template <class Machine>
 void InstX86Sqrtss<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 1);
   Type Ty = this->getSrc(0)->getType();
   assert(isScalarFloatingType(Ty));
-  Str << "\tsqrt" << InstX86Base<Machine>::Traits::TypeAttributes[Ty].SdSsString
+  Str << "\t"
+         "sqrt" << InstX86Base<Machine>::Traits::TypeAttributes[Ty].SdSsString
       << "\t";
   this->getSrc(0)->emit(Func);
   Str << ", ";
   this->getDest()->emit(Func);
 }
 
 template <class Machine>
 void InstX86Addss<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
@@ skipping 230 matching lines @@
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 2);
   Variable *Dest = this->getDest();
   if (isByteSizedArithType(Dest->getType())) {
     // The 8-bit version of imul only allows the form "imul r/m8".
     const auto *Src0Var = llvm::dyn_cast<Variable>(this->getSrc(0));
     (void)Src0Var;
     assert(Src0Var->getRegNum() ==
            InstX86Base<Machine>::Traits::RegisterSet::Reg_al);
-    Str << "\timulb\t";
+    Str << "\t"
+           "imulb\t";
     this->getSrc(1)->emit(Func);
   } else if (llvm::isa<Constant>(this->getSrc(1))) {
-    Str << "\timul" << this->getWidthString(Dest->getType()) << "\t";
+    Str << "\t"
+           "imul" << this->getWidthString(Dest->getType()) << "\t";
     this->getSrc(1)->emit(Func);
     Str << ", ";
     this->getSrc(0)->emit(Func);
     Str << ", ";
     Dest->emit(Func);
   } else {
     this->emitTwoAddress("imul", this, Func);
   }
 }
 
@@ skipping 29 matching lines @@
 
 template <class Machine>
 void InstX86ImulImm<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 2);
   Variable *Dest = this->getDest();
   assert(Dest->getType() == IceType_i16 || Dest->getType() == IceType_i32);
   assert(llvm::isa<Constant>(this->getSrc(1)));
-  Str << "\timul" << this->getWidthString(Dest->getType()) << "\t";
+  Str << "\t"
+         "imul" << this->getWidthString(Dest->getType()) << "\t";
   this->getSrc(1)->emit(Func);
   Str << ", ";
   this->getSrc(0)->emit(Func);
   Str << ", ";
   Dest->emit(Func);
 }
 
 template <class Machine>
 void InstX86ImulImm<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 2);
@@ skipping 49 matching lines @@
   (void)SrcReg;
   switch (Src0->getType()) {
   default:
     llvm_unreachable("unexpected source type!");
     break;
   case IceType_i8:
     assert(SrcReg == InstX86Base<Machine>::Traits::RegisterSet::Reg_al);
     assert(DestReg == InstX86Base<Machine>::Traits::RegisterSet::Reg_ax ||
            DestReg == InstX86Base<Machine>::Traits::RegisterSet::Reg_ah);
     Str << "\t"
-        << "cbtw";
+           "cbtw";
     break;
   case IceType_i16:
     assert(SrcReg == InstX86Base<Machine>::Traits::RegisterSet::Reg_ax);
     assert(DestReg == InstX86Base<Machine>::Traits::RegisterSet::Reg_dx);
     Str << "\t"
-        << "cwtd";
+           "cwtd";
     break;
   case IceType_i32:
     assert(SrcReg == InstX86Base<Machine>::Traits::RegisterSet::Reg_eax);
     assert(DestReg == InstX86Base<Machine>::Traits::RegisterSet::Reg_edx);
     Str << "\t"
-        << "cltd";
+           "cltd";
     break;
   case IceType_i64:
     assert(DestReg == InstX86Base<Machine>::Traits::RegisterSet::Reg_edx);
     Str << "\t"
-        << "cdto";
+           "cdto";
     break;
   }
 }
 
 template <class Machine>
 void InstX86Cbwdq<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   assert(this->getSrcSize() == 1);
   Operand *Src0 = this->getSrc(0);
@@ skipping 32 matching lines @@
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 2);
   assert(llvm::isa<Variable>(this->getSrc(0)));
   assert(llvm::cast<Variable>(this->getSrc(0))->getRegNum() ==
          InstX86Base<Machine>::Traits::RegisterSet::Reg_eax);
   assert(
       this->getDest()->getRegNum() ==
       InstX86Base<Machine>::Traits::RegisterSet::Reg_eax); // TODO: allow edx?
-  Str << "\tmul" << this->getWidthString(this->getDest()->getType()) << "\t";
+  Str << "\t"
+         "mul" << this->getWidthString(this->getDest()->getType()) << "\t";
   this->getSrc(1)->emit(Func);
 }
 
 template <class Machine>
 void InstX86Mul<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 2);
   assert(llvm::isa<Variable>(this->getSrc(0)));
   assert(llvm::cast<Variable>(this->getSrc(0))->getRegNum() ==
          InstX86Base<Machine>::Traits::RegisterSet::Reg_eax);
   assert(
@@ skipping 17 matching lines @@
 }
 
 template <class Machine>
 void InstX86Shld<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   Variable *Dest = this->getDest();
   assert(this->getSrcSize() == 3);
   assert(Dest == this->getSrc(0));
-  Str << "\tshld" << this->getWidthString(Dest->getType()) << "\t";
+  Str << "\t"
+         "shld" << this->getWidthString(Dest->getType()) << "\t";
   this->getSrc(2)->emit(Func);
   Str << ", ";
   this->getSrc(1)->emit(Func);
   Str << ", ";
   Dest->emit(Func);
 }
 
 template <class Machine>
 void InstX86Shld<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 3);
@@ skipping 19 matching lines @@
 }
 
 template <class Machine>
 void InstX86Shrd<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   Variable *Dest = this->getDest();
   assert(this->getSrcSize() == 3);
   assert(Dest == this->getSrc(0));
-  Str << "\tshrd" << this->getWidthString(Dest->getType()) << "\t";
+  Str << "\t"
+         "shrd" << this->getWidthString(Dest->getType()) << "\t";
   this->getSrc(2)->emit(Func);
   Str << ", ";
   this->getSrc(1)->emit(Func);
   Str << ", ";
   Dest->emit(Func);
 }
 
 template <class Machine>
 void InstX86Shrd<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 3);
@@ skipping 84 matching lines @@
   this->dumpSources(Func);
 }
 
 template <class Machine>
 void InstX86Cmpps<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 2);
   assert(Condition < InstX86Base<Machine>::Traits::Cond::Cmpps_Invalid);
-  Str << "\t";
-  Str << "cmp"
+  Str << "\t"
+         "cmp"
       << InstX86Base<Machine>::Traits::InstCmppsAttributes[Condition].EmitString
       << "ps"
-      << "\t";
+         "\t";
   this->getSrc(1)->emit(Func);
   Str << ", ";
   this->getDest()->emit(Func);
 }
 
 template <class Machine>
 void InstX86Cmpps<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   assert(this->getSrcSize() == 2);
@@ skipping 20 matching lines @@
 template <class Machine>
 void InstX86Cmpps<Machine>::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   assert(Condition < InstX86Base<Machine>::Traits::Cond::Cmpps_Invalid);
   this->dumpDest(Func);
   Str << " = cmp"
       << InstX86Base<Machine>::Traits::InstCmppsAttributes[Condition].EmitString
       << "ps"
-      << "\t";
+         "\t";
   this->dumpSources(Func);
 }
 
 template <class Machine>
 void InstX86Cmpxchg<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 3);
   if (this->Locked) {
-    Str << "\tlock";
+    Str << "\t"
+           "lock";
   }
-  Str << "\tcmpxchg" << this->getWidthString(this->getSrc(0)->getType())
-      << "\t";
+  Str << "\t"
+         "cmpxchg" << this->getWidthString(this->getSrc(0)->getType()) << "\t";
   this->getSrc(2)->emit(Func);
   Str << ", ";
   this->getSrc(0)->emit(Func);
 }
 
 template <class Machine>
 void InstX86Cmpxchg<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 3);
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
@@ skipping 25 matching lines @@
   this->dumpSources(Func);
 }
 
 template <class Machine>
 void InstX86Cmpxchg8b<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 5);
   if (this->Locked) {
-    Str << "\tlock";
+    Str << "\t"
+           "lock";
   }
-  Str << "\tcmpxchg8b\t";
+  Str << "\t"
+         "cmpxchg8b\t";
   this->getSrc(0)->emit(Func);
 }
 
 template <class Machine>
 void InstX86Cmpxchg8b<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 5);
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   const auto Mem =
       llvm::cast<typename InstX86Base<Machine>::Traits::X86OperandMem>(
@@ skipping 16 matching lines @@
   }
   Str << "cmpxchg8b ";
   this->dumpSources(Func);
 }
 
 template <class Machine> void InstX86Cvt<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 1);
-  Str << "\tcvt";
+  Str << "\t"
+         "cvt";
   if (isTruncating())
     Str << "t";
   Str << InstX86Base<Machine>::Traits::TypeAttributes[this->getSrc(0)
                                                           ->getType()]
              .CvtString << "2"
       << InstX86Base<
              Machine>::Traits::TypeAttributes[this->getDest()->getType()]
              .CvtString << "\t";
   this->getSrc(0)->emit(Func);
   Str << ", ";
@@ skipping 104 matching lines @@
              .CvtString << " ";
   this->dumpSources(Func);
 }
 
 template <class Machine>
 void InstX86Icmp<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 2);
-  Str << "\tcmp" << this->getWidthString(this->getSrc(0)->getType()) << "\t";
+  Str << "\t"
+         "cmp" << this->getWidthString(this->getSrc(0)->getType()) << "\t";
   this->getSrc(1)->emit(Func);
   Str << ", ";
   this->getSrc(0)->emit(Func);
 }
 
 template <class Machine>
 void InstX86Icmp<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 2);
   const Operand *Src0 = this->getSrc(0);
   const Operand *Src1 = this->getSrc(1);
@@ skipping 23 matching lines @@
   Str << "cmp." << this->getSrc(0)->getType() << " ";
   this->dumpSources(Func);
 }
 
 template <class Machine>
 void InstX86Ucomiss<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 2);
-  Str << "\tucomi"
+  Str << "\t"
+         "ucomi"
       << InstX86Base<Machine>::Traits::TypeAttributes[this->getSrc(0)
                                                           ->getType()]
              .SdSsString << "\t";
   this->getSrc(1)->emit(Func);
   Str << ", ";
   this->getSrc(0)->emit(Func);
 }
 
 template <class Machine>
 void InstX86Ucomiss<Machine>::emitIAS(const Cfg *Func) const {
@@ skipping 16 matching lines @@
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "ucomiss." << this->getSrc(0)->getType() << " ";
   this->dumpSources(Func);
 }
 
 template <class Machine> void InstX86UD2<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 0);
-  Str << "\tud2";
+  Str << "\t"
+         "ud2";
 }
 
 template <class Machine>
 void InstX86UD2<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   Asm->ud2();
 }
 
 template <class Machine> void InstX86UD2<Machine>::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "ud2";
 }
 
 template <class Machine>
 void InstX86Test<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 2);
-  Str << "\ttest" << this->getWidthString(this->getSrc(0)->getType()) << "\t";
+  Str << "\t"
+         "test" << this->getWidthString(this->getSrc(0)->getType()) << "\t";
   this->getSrc(1)->emit(Func);
   Str << ", ";
   this->getSrc(0)->emit(Func);
 }
 
 template <class Machine>
 void InstX86Test<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 2);
   const Operand *Src0 = this->getSrc(0);
   const Operand *Src1 = this->getSrc(1);
@@ skipping 23 matching lines @@
   Str << "test." << this->getSrc(0)->getType() << " ";
   this->dumpSources(Func);
 }
 
 template <class Machine>
 void InstX86Mfence<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 0);
-  Str << "\tmfence";
+  Str << "\t"
+         "mfence";
 }
 
 template <class Machine>
 void InstX86Mfence<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   Asm->mfence();
 }
 
 template <class Machine>
 void InstX86Mfence<Machine>::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "mfence";
 }
 
 template <class Machine>
 void InstX86Store<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 2);
   Type Ty = this->getSrc(0)->getType();
-  Str << "\tmov" << this->getWidthString(Ty)
+  Str << "\t"
+         "mov" << this->getWidthString(Ty)
       << InstX86Base<Machine>::Traits::TypeAttributes[Ty].SdSsString << "\t";
   this->getSrc(0)->emit(Func);
   Str << ", ";
   this->getSrc(1)->emit(Func);
 }
 
 template <class Machine>
 void InstX86Store<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 2);
   const Operand *Dest = this->getSrc(1);
@@ skipping 43 matching lines @@
   this->getSrc(0)->dump(Func);
 }
 
 template <class Machine>
 void InstX86StoreP<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 2);
   assert(isVectorType(this->getSrc(1)->getType()));
-  Str << "\tmovups\t";
+  Str << "\t"
+         "movups\t";
   this->getSrc(0)->emit(Func);
   Str << ", ";
   this->getSrc(1)->emit(Func);
 }
 
 template <class Machine>
 void InstX86StoreP<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   assert(this->getSrcSize() == 2);
@@ skipping 22 matching lines @@
 
 template <class Machine>
 void InstX86StoreQ<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 2);
   assert(this->getSrc(1)->getType() == IceType_i64 ||
          this->getSrc(1)->getType() == IceType_f64 ||
          isVectorType(this->getSrc(1)->getType()));
-  Str << "\tmovq\t";
+  Str << "\t"
+         "movq\t";
   this->getSrc(0)->emit(Func);
   Str << ", ";
   this->getSrc(1)->emit(Func);
 }
 
 template <class Machine>
 void InstX86StoreQ<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   assert(this->getSrcSize() == 2);
@@ skipping 19 matching lines @@
   Str << ", ";
   this->getSrc(0)->dump(Func);
 }
 
 template <class Machine> void InstX86Lea<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 1);
   assert(this->getDest()->hasReg());
-  Str << "\tleal\t";
+  Str << "\t"
+         "leal\t";
   Operand *Src0 = this->getSrc(0);
   if (const auto *Src0Var = llvm::dyn_cast<Variable>(Src0)) {
     Type Ty = Src0Var->getType();
     // lea on x86-32 doesn't accept mem128 operands, so cast VSrc0 to an
     // acceptable type.
     Src0Var->asType(isVectorType(Ty) ? IceType_i32 : Ty, Variable::NoRegister)
         ->emit(Func);
   } else {
     Src0->emit(Func);
   }
   Str << ", ";
   this->getDest()->emit(Func);
 }
 
 inline bool isIntegerConstant(const Operand *Op) {
   return llvm::isa<ConstantInteger32>(Op) || llvm::isa<ConstantInteger64>(Op);
 }
 
 template <class Machine> void InstX86Mov<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 1);
   Operand *Src = this->getSrc(0);
   Type SrcTy = Src->getType();
   Type DestTy = this->getDest()->getType();
   if (InstX86Base<Machine>::Traits::Is64Bit && DestTy == IceType_i64 &&
       isIntegerConstant(Src)) {
-    Str << "\tmovabs\t";
+    Str << "\t"
+           "movabs\t";
   } else {
-    Str << "\tmov"
-        << (!isScalarFloatingType(DestTy)
-                ? this->getWidthString(DestTy)
-                : InstX86Base<Machine>::Traits::TypeAttributes[DestTy]
-                      .SdSsString) << "\t";
+    Str << "\t"
+           "mov" << (!isScalarFloatingType(DestTy)
+                         ? this->getWidthString(DestTy)
+                         : InstX86Base<Machine>::Traits::TypeAttributes[DestTy]
+                               .SdSsString) << "\t";
   }
   // For an integer truncation operation, src is wider than dest. In this case,
   // we use a mov instruction whose data width matches the narrower dest.
   // TODO: This assert disallows usages such as copying a floating
   // point value between a vector and a scalar (which movss is used for). Clean
   // this up.
   assert(
       InstX86Base<Machine>::getTarget(Func)->typeWidthInBytesOnStack(DestTy) ==
       InstX86Base<Machine>::getTarget(Func)->typeWidthInBytesOnStack(SrcTy));
   const Operand *NewSrc = Src;
@@ skipping 149 matching lines @@
 
 template <class Machine>
 void InstX86Movp<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   // TODO(wala,stichnot): movups works with all vector operands, but there
   // exist other instructions (movaps, movdqa, movdqu) that may perform better,
   // depending on the data type and alignment of the operands.
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 1);
-  Str << "\tmovups\t";
+  Str << "\t"
+         "movups\t";
   this->getSrc(0)->emit(Func);
   Str << ", ";
   this->getDest()->emit(Func);
 }
 
 template <class Machine>
 void InstX86Movp<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 1);
   assert(isVectorType(this->getDest()->getType()));
   const Variable *Dest = this->getDest();
   const Operand *Src = this->getSrc(0);
   static const typename InstX86Base<
       Machine>::Traits::Assembler::XmmEmitterMovOps Emitter = {
       &InstX86Base<Machine>::Traits::Assembler::movups,
       &InstX86Base<Machine>::Traits::Assembler::movups,
       &InstX86Base<Machine>::Traits::Assembler::movups};
   emitIASMovlikeXMM<Machine>(Func, Dest, Src, Emitter);
 }
 
 template <class Machine>
 void InstX86Movq<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 1);
   assert(this->getDest()->getType() == IceType_i64 ||
          this->getDest()->getType() == IceType_f64);
-  Str << "\tmovq\t";
+  Str << "\t"
+         "movq\t";
   this->getSrc(0)->emit(Func);
   Str << ", ";
   this->getDest()->emit(Func);
 }
 
 template <class Machine>
 void InstX86Movq<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 1);
   assert(this->getDest()->getType() == IceType_i64 ||
          this->getDest()->getType() == IceType_f64);
@@ skipping 48 matching lines @@
   assert(typeWidthInBytes(Dest->getType()) > typeWidthInBytes(SrcTy));
   emitIASRegOpTyGPR<Machine, false, true>(Func, SrcTy, Dest, Src,
                                           this->Emitter);
 }
 
 template <class Machine> void InstX86Nop<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   // TODO: Emit the right code for each variant.
-  Str << "\tnop\t# variant = " << Variant;
+  Str << "\t"
+         "nop\t# variant = " << Variant;
 }
 
 template <class Machine>
 void InstX86Nop<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   // TODO: Emit the right code for the variant.
   Asm->nop();
 }
 
 template <class Machine> void InstX86Nop<Machine>::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "nop (variant = " << Variant << ")";
 }
 
 template <class Machine> void InstX86Fld<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 1);
   Type Ty = this->getSrc(0)->getType();
   const auto *Var = llvm::dyn_cast<Variable>(this->getSrc(0));
   if (Var && Var->hasReg()) {
     // This is a physical xmm register, so we need to spill it to a temporary
     // stack slot.  Function prolog emission guarantees that there is sufficient
     // space to do this.
-    Str << "\tmov"
-        << InstX86Base<Machine>::Traits::TypeAttributes[Ty].SdSsString << "\t";
+    Str << "\t"
+           "mov" << InstX86Base<Machine>::Traits::TypeAttributes[Ty].SdSsString
+        << "\t";
     Var->emit(Func);
-    Str << ", (%esp)\n";
-    Str << "\tfld" << this->getFldString(Ty) << "\t"
-        << "(%esp)";
+    Str << ", (%esp)\n"
+           "\t"
+           "fld" << this->getFldString(Ty) << "\t"
+                                              "(%esp)";
     return;
   }
-  Str << "\tfld" << this->getFldString(Ty) << "\t";
+  Str << "\t"
+         "fld" << this->getFldString(Ty) << "\t";
   this->getSrc(0)->emit(Func);
 }
 
 template <class Machine>
 void InstX86Fld<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   assert(this->getSrcSize() == 1);
   const Operand *Src = this->getSrc(0);
   auto *Target = InstX86Base<Machine>::getTarget(Func);
@@ skipping 38 matching lines @@
 template <class Machine>
 void InstX86Fstp<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 0);
   // TODO(jvoung,stichnot): Utilize this by setting Dest to nullptr to
   // "partially" delete the fstp if the Dest is unused. Even if Dest is unused,
   // the fstp should be kept for the SideEffects of popping the stack.
   if (!this->getDest()) {
-    Str << "\tfstp\tst(0)";
+    Str << "\t"
+           "fstp\t"
+           "st(0)";
     return;
   }
   Type Ty = this->getDest()->getType();
   if (!this->getDest()->hasReg()) {
-    Str << "\tfstp" << this->getFldString(Ty) << "\t";
+    Str << "\t"
+           "fstp" << this->getFldString(Ty) << "\t";
     this->getDest()->emit(Func);
     return;
   }
   // Dest is a physical (xmm) register, so st(0) needs to go through memory.
   // Hack this by using caller-reserved memory at the top of stack, spilling
   // st(0) there, and loading it into the xmm register.
-  Str << "\tfstp" << this->getFldString(Ty) << "\t"
-      << "(%esp)\n";
-  Str << "\tmov" << InstX86Base<Machine>::Traits::TypeAttributes[Ty].SdSsString
+  Str << "\t"
+         "fstp" << this->getFldString(Ty) << "\t"
+                                             "(%esp)\n";
+  Str << "\t"
+         "mov" << InstX86Base<Machine>::Traits::TypeAttributes[Ty].SdSsString
       << "\t"
-      << "(%esp), ";
+         "(%esp), ";
   this->getDest()->emit(Func);
 }
 
 template <class Machine>
 void InstX86Fstp<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   assert(this->getSrcSize() == 0);
   const Variable *Dest = this->getDest();
   // TODO(jvoung,stichnot): Utilize this by setting Dest to nullptr to
@@ skipping 224 matching lines @@
       InstX86Base<Machine>::Traits::getEncodedXmm,
       InstX86Base<Machine>::Traits::getEncodedXmm>(
       Func, Ty, Dest, this->getSrc(1), this->getSrc(2), Emitter);
 }
 
 template <class Machine> void InstX86Pop<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 0);
-  Str << "\tpop\t";
+  Str << "\t"
+         "pop\t";
   this->getDest()->emit(Func);
 }
 
 template <class Machine>
 void InstX86Pop<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 0);
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   if (this->getDest()->hasReg()) {
     Asm->popl(InstX86Base<Machine>::Traits::getEncodedGPR(
@@ skipping 14 matching lines @@
 
 template <class Machine>
 void InstX86Push<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 1);
   // Push is currently only used for saving GPRs.
   const auto *Var = llvm::cast<Variable>(this->getSrc(0));
   assert(Var->hasReg());
-  Str << "\tpush\t";
+  Str << "\t"
+         "push\t";
   Var->emit(Func);
 }
 
 template <class Machine>
 void InstX86Push<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 1);
   // Push is currently only used for saving GPRs.
   const auto *Var = llvm::cast<Variable>(this->getSrc(0));
   assert(Var->hasReg());
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
@@ skipping 51 matching lines @@
       buf, llvm::array_lengthof(buf), "psrl%s",
       InstX86Base<Machine>::Traits::TypeAttributes[this->getDest()->getType()]
           .PackString);
   this->emitTwoAddress(buf, this, Func);
 }
 
 template <class Machine> void InstX86Ret<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
-  Str << "\tret";
+  Str << "\t"
+         "ret";
 }
 
 template <class Machine>
 void InstX86Ret<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   Asm->ret();
 }
 
 template <class Machine> void InstX86Ret<Machine>::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Type Ty =
       (this->getSrcSize() == 0 ? IceType_void : this->getSrc(0)->getType());
   Str << "ret." << Ty << " ";
   this->dumpSources(Func);
 }
 
 template <class Machine>
 void InstX86Setcc<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
-  Str << "\tset"
+  Str << "\t"
+         "set"
       << InstX86Base<Machine>::Traits::InstBrAttributes[Condition].DisplayString
       << "\t";
   this->Dest->emit(Func);
 }
 
 template <class Machine>
 void InstX86Setcc<Machine>::emitIAS(const Cfg *Func) const {
   assert(Condition != InstX86Base<Machine>::Traits::Cond::Br_None);
   assert(this->getDest()->getType() == IceType_i1);
   assert(this->getSrcSize() == 0);
@@ skipping 18 matching lines @@
       << " ";
   this->dumpDest(Func);
 }
 
 template <class Machine>
 void InstX86Xadd<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   if (this->Locked) {
-    Str << "\tlock";
+    Str << "\t"
+           "lock";
   }
-  Str << "\txadd" << this->getWidthString(this->getSrc(0)->getType()) << "\t";
+  Str << "\t"
+         "xadd" << this->getWidthString(this->getSrc(0)->getType()) << "\t";
   this->getSrc(1)->emit(Func);
   Str << ", ";
   this->getSrc(0)->emit(Func);
 }
 
 template <class Machine>
 void InstX86Xadd<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 2);
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
@@ skipping 24 matching lines @@
   Type Ty = this->getSrc(0)->getType();
   Str << "xadd." << Ty << " ";
   this->dumpSources(Func);
 }
 
 template <class Machine>
 void InstX86Xchg<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
-  Str << "\txchg" << this->getWidthString(this->getSrc(0)->getType()) << "\t";
+  Str << "\t"
+         "xchg" << this->getWidthString(this->getSrc(0)->getType()) << "\t";
   this->getSrc(1)->emit(Func);
   Str << ", ";
   this->getSrc(0)->emit(Func);
 }
 
 template <class Machine>
 void InstX86Xchg<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 2);
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
@@ skipping 31 matching lines @@
   Str << "xchg." << Ty << " ";
   this->dumpSources(Func);
 }
 
 template <class Machine>
 void InstX86IacaStart<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << "\t# IACA_START\n"
-      << "\t.byte 0x0F, 0x0B\n"
-      << "\tmovl\t$111, %ebx\n"
-      << "\t.byte 0x64, 0x67, 0x90";
+         "\t.byte 0x0F, 0x0B\n"
+         "\t"
+         "movl\t$111, %ebx\n"
+         "\t.byte 0x64, 0x67, 0x90";
 }
 
 template <class Machine>
 void InstX86IacaStart<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   Asm->iaca_start();
 }
 
 template <class Machine>
 void InstX86IacaStart<Machine>::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "IACA_START";
 }
 
 template <class Machine>
 void InstX86IacaEnd<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << "\t# IACA_END\n"
-      << "\tmovl\t$222, %ebx\n"
-      << "\t.byte 0x64, 0x67, 0x90\n"
-      << "\t.byte 0x0F, 0x0B";
+         "\t"
+         "movl\t$222, %ebx\n"
+         "\t.byte 0x64, 0x67, 0x90\n"
+         "\t.byte 0x0F, 0x0B";
 }
 
 template <class Machine>
 void InstX86IacaEnd<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   Asm->iaca_end();
 }
 
 template <class Machine>
 void InstX86IacaEnd<Machine>::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "IACA_END";
 }
 
 } // end of namespace X86Internal
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX86BASEIMPL_H