Reflow comments to use the full width.

src/IceInstX86Base.h

 //===- subzero/src/IceInstX86Base.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 128 matching lines @@
     IacaStart,
     IacaEnd
   };
 
   static const char *getWidthString(Type Ty);
   static const char *getFldString(Type Ty);
   static typename Traits::Cond::BrCond
   getOppositeCondition(typename Traits::Cond::BrCond Cond);
   void dump(const Cfg *Func) const override;
 
-  // Shared emit routines for common forms of instructions.
-  // See the definition of emitTwoAddress() for a description of
-  // ShiftHack.
+  // Shared emit routines for common forms of instructions. See the definition
+  // of emitTwoAddress() for a description of ShiftHack.
   static void emitTwoAddress(const char *Opcode, const Inst *Inst,
                              const Cfg *Func, bool ShiftHack = false);
 
   static void
   emitIASGPRShift(const Cfg *Func, Type Ty, const Variable *Var,
                   const Operand *Src,
                   const typename Traits::Assembler::GPREmitterShiftOp &Emitter);
 
 protected:
   InstX86Base<Machine>(Cfg *Func, InstKindX86 Kind, SizeT Maxsrcs,
                        Variable *Dest)
       : InstTarget(Func, static_cast<InstKind>(Kind), Maxsrcs, Dest) {}
 
   static bool isClassof(const Inst *Inst, InstKindX86 MyKind) {
     return Inst->getKind() == static_cast<InstKind>(MyKind);
   }
-  // Most instructions that operate on vector arguments require vector
-  // memory operands to be fully aligned (16-byte alignment for PNaCl
-  // vector types).  The stack frame layout and call ABI ensure proper
-  // alignment for stack operands, but memory operands (originating
-  // from load/store bitcode instructions) only have element-size
-  // alignment guarantees.  This function validates that none of the
-  // operands is a memory operand of vector type, calling
-  // report_fatal_error() if one is found.  This function should be
-  // called during emission, and maybe also in the ctor (as long as
-  // that fits the lowering style).
+  // Most instructions that operate on vector arguments require vector memory
+  // operands to be fully aligned (16-byte alignment for PNaCl vector types).
+  // The stack frame layout and call ABI ensure proper alignment for stack
+  // operands, but memory operands (originating from load/store bitcode
+  // instructions) only have element-size alignment guarantees. This function
+  // validates that none of the operands is a memory operand of vector type,
+  // calling report_fatal_error() if one is found. This function should be
+  // called during emission, and maybe also in the ctor (as long as that fits
+  // the lowering style).
   void validateVectorAddrMode() const {
     if (this->getDest())
       this->validateVectorAddrModeOpnd(this->getDest());
     for (SizeT i = 0; i < this->getSrcSize(); ++i) {
       this->validateVectorAddrModeOpnd(this->getSrc(i));
     }
   }
 
 private:
   static void validateVectorAddrModeOpnd(const Operand *Opnd) {
     if (llvm::isa<typename InstX86Base<Machine>::Traits::X86OperandMem>(Opnd) &&
         isVectorType(Opnd->getType())) {
       llvm::report_fatal_error("Possible misaligned vector memory operation");
     }
   }
 };
 
 /// InstX86FakeRMW represents a non-atomic read-modify-write operation on a
-/// memory location.  An InstX86FakeRMW is a "fake" instruction in that it
-/// still needs to be lowered to some actual RMW instruction.
+/// memory location. An InstX86FakeRMW is a "fake" instruction in that it still
+/// needs to be lowered to some actual RMW instruction.
 ///
 /// If A is some memory address, D is some data value to apply, and OP is an
 /// arithmetic operator, the instruction operates as: (*A) = (*A) OP D
 template <class Machine>
 class InstX86FakeRMW final : public InstX86Base<Machine> {
   InstX86FakeRMW() = delete;
   InstX86FakeRMW(const InstX86FakeRMW &) = delete;
   InstX86FakeRMW &operator=(const InstX86FakeRMW &) = delete;
 
 public:
@@ skipping 13 matching lines @@
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst, InstX86Base<Machine>::FakeRMW);
   }
 
 private:
   InstArithmetic::OpKind Op;
   InstX86FakeRMW(Cfg *Func, Operand *Data, Operand *Addr,
                  InstArithmetic::OpKind Op, Variable *Beacon);
 };
 
-/// InstX86Label represents an intra-block label that is the target
-/// of an intra-block branch.  The offset between the label and the
-/// branch must be fit into one byte (considered "near").  These are
-/// used for lowering i1 calculations, Select instructions, and 64-bit
-/// compares on a 32-bit architecture, without basic block splitting.
-/// Basic block splitting is not so desirable for several reasons, one
-/// of which is the impact on decisions based on whether a variable's
-/// live range spans multiple basic blocks.
+/// InstX86Label represents an intra-block label that is the target of an
+/// intra-block branch. The offset between the label and the branch must be fit
+/// into one byte (considered "near"). These are used for lowering i1
+/// calculations, Select instructions, and 64-bit compares on a 32-bit
+/// architecture, without basic block splitting. Basic block splitting is not so
+/// desirable for several reasons, one of which is the impact on decisions based
+/// on whether a variable's live range spans multiple basic blocks.
 ///
-/// Intra-block control flow must be used with caution.  Consider the
-/// sequence for "c = (a >= b ? x : y)".
+/// Intra-block control flow must be used with caution. Consider the sequence
+/// for "c = (a >= b ? x : y)".
 ///     cmp a, b
 ///     br lt, L1
 ///     mov c, x
 ///     jmp L2
 ///   L1:
 ///     mov c, y
 ///   L2:
 ///
-/// Labels L1 and L2 are intra-block labels.  Without knowledge of the
-/// intra-block control flow, liveness analysis will determine the "mov
-/// c, x" instruction to be dead.  One way to prevent this is to insert
-/// a "FakeUse(c)" instruction anywhere between the two "mov c, ..."
-/// instructions, e.g.:
+/// Labels L1 and L2 are intra-block labels. Without knowledge of the
+/// intra-block control flow, liveness analysis will determine the "mov c, x"
+/// instruction to be dead. One way to prevent this is to insert a "FakeUse(c)"
+/// instruction anywhere between the two "mov c, ..." instructions, e.g.:
 ///
 ///     cmp a, b
 ///     br lt, L1
 ///     mov c, x
 ///     jmp L2
 ///     FakeUse(c)
 ///   L1:
 ///     mov c, y
 ///   L2:
 ///
-/// The down-side is that "mov c, x" can never be dead-code eliminated
-/// even if there are no uses of c.  As unlikely as this situation is,
-/// it may be prevented by running dead code elimination before
-/// lowering.
+/// The down-side is that "mov c, x" can never be dead-code eliminated even if
+/// there are no uses of c. As unlikely as this situation is, it may be
+/// prevented by running dead code elimination before lowering.
 template <class Machine>
 class InstX86Label final : public InstX86Base<Machine> {
   InstX86Label() = delete;
   InstX86Label(const InstX86Label &) = delete;
   InstX86Label &operator=(const InstX86Label &) = delete;
 
 public:
   static InstX86Label *
   create(Cfg *Func,
          typename InstX86Base<Machine>::Traits::TargetLowering *Target) {
@@ skipping 33 matching lines @@
         InstX86Br(Func, TargetTrue, TargetFalse, NoLabel, Condition, Kind);
   }
   /// Create an unconditional branch to a node.
   static InstX86Br *create(Cfg *Func, CfgNode *Target, Mode Kind) {
     const CfgNode *NoCondTarget = nullptr;
     const InstX86Label<Machine> *NoLabel = nullptr;
     return new (Func->allocate<InstX86Br>())
         InstX86Br(Func, NoCondTarget, Target, NoLabel,
                   InstX86Base<Machine>::Traits::Cond::Br_None, Kind);
   }
-  /// Create a non-terminator conditional branch to a node, with a
-  /// fallthrough to the next instruction in the current node.  This is
-  /// used for switch lowering.
+  /// Create a non-terminator conditional branch to a node, with a fallthrough
+  /// to the next instruction in the current node. This is used for switch
+  /// lowering.
   static InstX86Br *
   create(Cfg *Func, CfgNode *Target,
          typename InstX86Base<Machine>::Traits::Cond::BrCond Condition,
          Mode Kind) {
     assert(Condition != InstX86Base<Machine>::Traits::Cond::Br_None);
     const CfgNode *NoUncondTarget = nullptr;
     const InstX86Label<Machine> *NoLabel = nullptr;
     return new (Func->allocate<InstX86Br>())
         InstX86Br(Func, Target, NoUncondTarget, NoLabel, Condition, Kind);
   }
@@ skipping 39 matching lines @@
             typename InstX86Base<Machine>::Traits::Cond::BrCond Condition,
             Mode Kind);
 
   typename InstX86Base<Machine>::Traits::Cond::BrCond Condition;
   const CfgNode *TargetTrue;
   const CfgNode *TargetFalse;
   const InstX86Label<Machine> *Label; // Intra-block branch target
   const Mode Kind;
 };
 
-/// Jump to a target outside this function, such as tailcall, nacljump,
-/// naclret, unreachable.  This is different from a Branch instruction
-/// in that there is no intra-function control flow to represent.
+/// Jump to a target outside this function, such as tailcall, nacljump, naclret,
+/// unreachable. This is different from a Branch instruction in that there is no
+/// intra-function control flow to represent.
 template <class Machine> class InstX86Jmp final : public InstX86Base<Machine> {
   InstX86Jmp() = delete;
   InstX86Jmp(const InstX86Jmp &) = delete;
   InstX86Jmp &operator=(const InstX86Jmp &) = delete;
 
 public:
   static InstX86Jmp *create(Cfg *Func, Operand *Target) {
     return new (Func->allocate<InstX86Jmp>()) InstX86Jmp(Func, Target);
   }
   Operand *getJmpTarget() const { return this->getSrc(0); }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst, InstX86Base<Machine>::Jmp);
   }
 
 private:
   InstX86Jmp(Cfg *Func, Operand *Target);
 };
 
-/// AdjustStack instruction - subtracts esp by the given amount and
-/// updates the stack offset during code emission.
+/// AdjustStack instruction - subtracts esp by the given amount and updates the
+/// stack offset during code emission.
 template <class Machine>
 class InstX86AdjustStack final : public InstX86Base<Machine> {
   InstX86AdjustStack() = delete;
   InstX86AdjustStack(const InstX86AdjustStack &) = delete;
   InstX86AdjustStack &operator=(const InstX86AdjustStack &) = delete;
 
 public:
   static InstX86AdjustStack *create(Cfg *Func, SizeT Amount, Variable *Esp) {
     return new (Func->allocate<InstX86AdjustStack>())
         InstX86AdjustStack(Func, Amount, Esp);
   }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst,
                                            InstX86Base<Machine>::Adjuststack);
   }
 
 private:
   InstX86AdjustStack(Cfg *Func, SizeT Amount, Variable *Esp);
   SizeT Amount;
 };
 
-/// Call instruction.  Arguments should have already been pushed.
+/// Call instruction. Arguments should have already been pushed.
 template <class Machine> class InstX86Call final : public InstX86Base<Machine> {
   InstX86Call() = delete;
   InstX86Call(const InstX86Call &) = delete;
   InstX86Call &operator=(const InstX86Call &) = delete;
 
 public:
   static InstX86Call *create(Cfg *Func, Variable *Dest, Operand *CallTarget) {
     return new (Func->allocate<InstX86Call>())
         InstX86Call(Func, Dest, CallTarget);
   }
@@ skipping 62 matching lines @@
       : InstX86Base<Machine>(Func, K, 1, llvm::dyn_cast<Variable>(SrcDest)) {
     this->addSource(SrcDest);
   }
 
 private:
   static const char *Opcode;
   static const typename InstX86Base<Machine>::Traits::Assembler::GPREmitterOneOp
       Emitter;
 };
 
-/// Emit a two-operand (GPR) instruction, where the dest operand is a
-/// Variable that's guaranteed to be a register.
+/// Emit a two-operand (GPR) instruction, where the dest operand is a Variable
+/// that's guaranteed to be a register.
 template <class Machine, bool VarCanBeByte = true, bool SrcCanBeByte = true>
 void emitIASRegOpTyGPR(
     const Cfg *Func, Type Ty, const Variable *Dst, const Operand *Src,
     const typename InstX86Base<Machine>::Traits::Assembler::GPREmitterRegOp
         &Emitter);
 
 /// Instructions of the form x := op(y).
 template <class Machine, typename InstX86Base<Machine>::InstKindX86 K>
 class InstX86BaseUnaryopGPR : public InstX86Base<Machine> {
   InstX86BaseUnaryopGPR() = delete;
   InstX86BaseUnaryopGPR(const InstX86BaseUnaryopGPR &) = delete;
   InstX86BaseUnaryopGPR &operator=(const InstX86BaseUnaryopGPR &) = delete;
 
 public:
   using Base = InstX86BaseUnaryopGPR<Machine, K>;
 
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(this->getSrcSize() == 1);
     Type SrcTy = this->getSrc(0)->getType();
     Type DestTy = this->getDest()->getType();
     Str << "\t" << Opcode << this->getWidthString(SrcTy);
-    // Movsx and movzx need both the source and dest type width letter
-    // to define the operation.  The other unary operations have the
-    // same source and dest type and as a result need only one letter.
+    // Movsx and movzx need both the source and dest type width letter to
+    // define the operation. The other unary operations have the same source
+    // and dest type and as a result need only one letter.
     if (SrcTy != DestTy)
       Str << this->getWidthString(DestTy);
     Str << "\t";
     this->getSrc(0)->emit(Func);
     Str << ", ";
     this->getDest()->emit(Func);
   }
   void emitIAS(const Cfg *Func) const override {
     assert(this->getSrcSize() == 1);
     const Variable *Var = this->getDest();
@@ skipping 618 matching lines @@
 
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
 
 private:
   InstX86Mov(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseMovlike<Machine, InstX86Base<Machine>::Mov>(Func, Dest,
                                                                Source) {}
 };
 
-/// Move packed - copy 128 bit values between XMM registers, or mem128
-/// and XMM registers.
+/// Move packed - copy 128 bit values between XMM registers, or mem128 and XMM
+/// registers.
 template <class Machine>
 class InstX86Movp
     : public InstX86BaseMovlike<Machine, InstX86Base<Machine>::Movp> {
 public:
   static InstX86Movp *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Movp>()) InstX86Movp(Func, Dest, Source);
   }
 
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
@@ skipping 662 matching lines @@
   }
 
   void emit(const Cfg *Func) const override;
 
 private:
   InstX86Pcmpgt(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpgt, true>(
             Func, Dest, Source) {}
 };
 
-/// movss is only a binary operation when the source and dest
-/// operands are both registers (the high bits of dest are left untouched).
-/// In other cases, it behaves like a copy (mov-like) operation (and the
-/// high bits of dest are cleared).
-/// InstX86Movss will assert that both its source and dest operands are
-/// registers, so the lowering code should use _mov instead of _movss
-/// in cases where a copy operation is intended.
+/// movss is only a binary operation when the source and dest operands are both
+/// registers (the high bits of dest are left untouched). In other cases, it
+/// behaves like a copy (mov-like) operation (and the high bits of dest are
+/// cleared). InstX86Movss will assert that both its source and dest operands
+/// are registers, so the lowering code should use _mov instead of _movss in
+/// cases where a copy operation is intended.
 template <class Machine>
 class InstX86MovssRegs
     : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::MovssRegs,
                                  false> {
 public:
   static InstX86MovssRegs *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86MovssRegs>())
         InstX86MovssRegs(Func, Dest, Source);
   }
 
@@ skipping 180 matching lines @@
   InstX86BaseLockable(const InstX86BaseLockable &) = delete;
   InstX86BaseLockable &operator=(const InstX86BaseLockable &) = delete;
 
 protected:
   bool Locked;
 
   InstX86BaseLockable(Cfg *Func,
                       typename InstX86Base<Machine>::InstKindX86 Kind,
                       SizeT Maxsrcs, Variable *Dest, bool Locked)
       : InstX86Base<Machine>(Func, Kind, Maxsrcs, Dest), Locked(Locked) {
-    // Assume that such instructions are used for Atomics and be careful
-    // with optimizations.
+    // Assume that such instructions are used for Atomics and be careful with
+    // optimizations.
     this->HasSideEffects = Locked;
   }
 };
 
 /// Mul instruction - unsigned multiply.
 template <class Machine> class InstX86Mul final : public InstX86Base<Machine> {
   InstX86Mul() = delete;
   InstX86Mul(const InstX86Mul &) = delete;
   InstX86Mul &operator=(const InstX86Mul &) = delete;
 
@@ skipping 80 matching lines @@
     return InstX86Base<Machine>::isClassof(Inst, InstX86Base<Machine>::Cmov);
   }
 
 private:
   InstX86Cmov(Cfg *Func, Variable *Dest, Operand *Source,
               typename InstX86Base<Machine>::Traits::Cond::BrCond Cond);
 
   typename InstX86Base<Machine>::Traits::Cond::BrCond Condition;
 };
 
-/// Cmpps instruction - compare packed singled-precision floating point
-/// values
+/// Cmpps instruction - compare packed singled-precision floating point values
 template <class Machine>
 class InstX86Cmpps final : public InstX86Base<Machine> {
   InstX86Cmpps() = delete;
   InstX86Cmpps(const InstX86Cmpps &) = delete;
   InstX86Cmpps &operator=(const InstX86Cmpps &) = delete;
 
 public:
   static InstX86Cmpps *
   create(Cfg *Func, Variable *Dest, Operand *Source,
          typename InstX86Base<Machine>::Traits::Cond::CmppsCond Condition) {
     return new (Func->allocate<InstX86Cmpps>())
         InstX86Cmpps(Func, Dest, Source, Condition);
   }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst, InstX86Base<Machine>::Cmpps);
   }
 
 private:
   InstX86Cmpps(Cfg *Func, Variable *Dest, Operand *Source,
                typename InstX86Base<Machine>::Traits::Cond::CmppsCond Cond);
 
   typename InstX86Base<Machine>::Traits::Cond::CmppsCond Condition;
 };
 
 /// Cmpxchg instruction - cmpxchg <dest>, <desired> will compare if <dest>
-/// equals eax. If so, the ZF is set and <desired> is stored in <dest>.
-/// If not, ZF is cleared and <dest> is copied to eax (or subregister).
-/// <dest> can be a register or memory, while <desired> must be a register.
-/// It is the user's responsiblity to mark eax with a FakeDef.
+/// equals eax. If so, the ZF is set and <desired> is stored in <dest>. If not,
+/// ZF is cleared and <dest> is copied to eax (or subregister). <dest> can be a
+/// register or memory, while <desired> must be a register. It is the user's
+/// responsiblity to mark eax with a FakeDef.

[Jim Stichnoth, 2015/09/16 00:01:29]

responsibility

[ascull, 2015/09/16 18:30:09]

Done.

 template <class Machine>
 class InstX86Cmpxchg final : public InstX86BaseLockable<Machine> {
   InstX86Cmpxchg() = delete;
   InstX86Cmpxchg(const InstX86Cmpxchg &) = delete;
   InstX86Cmpxchg &operator=(const InstX86Cmpxchg &) = delete;
 
 public:
   static InstX86Cmpxchg *create(Cfg *Func, Operand *DestOrAddr, Variable *Eax,
                                 Variable *Desired, bool Locked) {
     return new (Func->allocate<InstX86Cmpxchg>())
         InstX86Cmpxchg(Func, DestOrAddr, Eax, Desired, Locked);
   }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst, InstX86Base<Machine>::Cmpxchg);
   }
 
 private:
   InstX86Cmpxchg(Cfg *Func, Operand *DestOrAddr, Variable *Eax,
                  Variable *Desired, bool Locked);
 };
 
-/// Cmpxchg8b instruction - cmpxchg8b <m64> will compare if <m64>
-/// equals edx:eax. If so, the ZF is set and ecx:ebx is stored in <m64>.
-/// If not, ZF is cleared and <m64> is copied to edx:eax.
-/// The caller is responsible for inserting FakeDefs to mark edx
-/// and eax as modified.
-/// <m64> must be a memory operand.
+/// Cmpxchg8b instruction - cmpxchg8b <m64> will compare if <m64> equals
+/// edx:eax. If so, the ZF is set and ecx:ebx is stored in <m64>. If not, ZF is
+/// cleared and <m64> is copied to edx:eax. The caller is responsible for
+/// inserting FakeDefs to mark edx and eax as modified. <m64> must be a memory
+/// operand.
 template <class Machine>
 class InstX86Cmpxchg8b final : public InstX86BaseLockable<Machine> {
   InstX86Cmpxchg8b() = delete;
   InstX86Cmpxchg8b(const InstX86Cmpxchg8b &) = delete;
   InstX86Cmpxchg8b &operator=(const InstX86Cmpxchg8b &) = delete;
 
 public:
   static InstX86Cmpxchg8b *
   create(Cfg *Func, typename InstX86Base<Machine>::Traits::X86OperandMem *Dest,
          Variable *Edx, Variable *Eax, Variable *Ecx, Variable *Ebx,
          bool Locked) {
     return new (Func->allocate<InstX86Cmpxchg8b>())
         InstX86Cmpxchg8b(Func, Dest, Edx, Eax, Ecx, Ebx, Locked);
   }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst,
                                            InstX86Base<Machine>::Cmpxchg8b);
   }
 
 private:
   InstX86Cmpxchg8b(Cfg *Func,
                    typename InstX86Base<Machine>::Traits::X86OperandMem *Dest,
                    Variable *Edx, Variable *Eax, Variable *Ecx, Variable *Ebx,
                    bool Locked);
 };
 
-/// Cvt instruction - wrapper for cvtsX2sY where X and Y are in {s,d,i}
-/// as appropriate.  s=float, d=double, i=int.  X and Y are determined
-/// from dest/src types.  Sign and zero extension on the integer
-/// operand needs to be done separately.
+/// Cvt instruction - wrapper for cvtsX2sY where X and Y are in {s,d,i} as
+/// appropriate.  s=float, d=double, i=int. X and Y are determined from dest/src
+/// types. Sign and zero extension on the integer operand needs to be done
+/// separately.
 template <class Machine> class InstX86Cvt final : public InstX86Base<Machine> {
   InstX86Cvt() = delete;
   InstX86Cvt(const InstX86Cvt &) = delete;
   InstX86Cvt &operator=(const InstX86Cvt &) = delete;
 
 public:
   enum CvtVariant { Si2ss, Tss2si, Float2float, Dq2ps, Tps2dq };
   static InstX86Cvt *create(Cfg *Func, Variable *Dest, Operand *Source,
                             CvtVariant Variant) {
     return new (Func->allocate<InstX86Cvt>())
@@ skipping 115 matching lines @@
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst, InstX86Base<Machine>::Mfence);
   }
 
 private:
   explicit InstX86Mfence(Cfg *Func);
 };
 
 /// This is essentially a "mov" instruction with an
-/// InstX86Base<Machine>::Traits::X86OperandMem
-/// operand instead of Variable as the destination.  It's important
-/// for liveness that there is no Dest operand.
+/// InstX86Base<Machine>::Traits::X86OperandMem operand instead of Variable as
+/// the destination. It's important for liveness that there is no Dest operand.
 template <class Machine>
 class InstX86Store final : public InstX86Base<Machine> {
   InstX86Store() = delete;
   InstX86Store(const InstX86Store &) = delete;
   InstX86Store &operator=(const InstX86Store &) = delete;
 
 public:
   static InstX86Store *
   create(Cfg *Func, Operand *Value,
          typename InstX86Base<Machine>::Traits::X86Operand *Mem) {
     return new (Func->allocate<InstX86Store>()) InstX86Store(Func, Value, Mem);
   }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst, InstX86Base<Machine>::Store);
   }
 
 private:
   InstX86Store(Cfg *Func, Operand *Value,
                typename InstX86Base<Machine>::Traits::X86Operand *Mem);
 };
 
 /// This is essentially a vector "mov" instruction with an typename
-/// InstX86Base<Machine>::Traits::X86OperandMem
-/// operand instead of Variable as the destination.  It's important
-/// for liveness that there is no Dest operand. The source must be an
-/// Xmm register, since Dest is mem.
+/// InstX86Base<Machine>::Traits::X86OperandMem operand instead of Variable as
+/// the destination. It's important for liveness that there is no Dest operand.
+/// The source must be an Xmm register, since Dest is mem.
 template <class Machine>
 class InstX86StoreP final : public InstX86Base<Machine> {
   InstX86StoreP() = delete;
   InstX86StoreP(const InstX86StoreP &) = delete;
   InstX86StoreP &operator=(const InstX86StoreP &) = delete;
 
 public:
   static InstX86StoreP *
   create(Cfg *Func, Variable *Value,
          typename InstX86Base<Machine>::Traits::X86OperandMem *Mem) {
@@ skipping 138 matching lines @@
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst, InstX86Base<Machine>::Push);
   }
 
 private:
   InstX86Push(Cfg *Func, Variable *Source);
 };
 
-/// Ret instruction.  Currently only supports the "ret" version that
-/// does not pop arguments.  This instruction takes a Source operand
-/// (for non-void returning functions) for liveness analysis, though
-/// a FakeUse before the ret would do just as well.
+/// Ret instruction. Currently only supports the "ret" version that does not pop
+/// arguments. This instruction takes a Source operand (for non-void returning
+/// functions) for liveness analysis, though a FakeUse before the ret would do
+/// just as well.
 template <class Machine> class InstX86Ret final : public InstX86Base<Machine> {
   InstX86Ret() = delete;
   InstX86Ret(const InstX86Ret &) = delete;
   InstX86Ret &operator=(const InstX86Ret &) = delete;
 
 public:
   static InstX86Ret *create(Cfg *Func, Variable *Source = nullptr) {
     return new (Func->allocate<InstX86Ret>()) InstX86Ret(Func, Source);
   }
   void emit(const Cfg *Func) const override;
@@ skipping 27 matching lines @@
     return InstX86Base<Machine>::isClassof(Inst, InstX86Base<Machine>::Setcc);
   }
 
 private:
   InstX86Setcc(Cfg *Func, Variable *Dest,
                typename InstX86Base<Machine>::Traits::Cond::BrCond Cond);
 
   const typename InstX86Base<Machine>::Traits::Cond::BrCond Condition;
 };
 
-/// Exchanging Add instruction.  Exchanges the first operand (destination
-/// operand) with the second operand (source operand), then loads the sum
-/// of the two values into the destination operand. The destination may be
-/// a register or memory, while the source must be a register.
+/// Exchanging Add instruction. Exchanges the first operand (destination
+/// operand) with the second operand (source operand), then loads the sum of the
+/// two values into the destination operand. The destination may be a register
+/// or memory, while the source must be a register.
 ///
 /// Both the dest and source are updated. The caller should then insert a
 /// FakeDef to reflect the second udpate.
 template <class Machine>
 class InstX86Xadd final : public InstX86BaseLockable<Machine> {
   InstX86Xadd() = delete;
   InstX86Xadd(const InstX86Xadd &) = delete;
   InstX86Xadd &operator=(const InstX86Xadd &) = delete;
 
 public:
   static InstX86Xadd *create(Cfg *Func, Operand *Dest, Variable *Source,
                              bool Locked) {
     return new (Func->allocate<InstX86Xadd>())
         InstX86Xadd(Func, Dest, Source, Locked);
   }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst, InstX86Base<Machine>::Xadd);
   }
 
 private:
   InstX86Xadd(Cfg *Func, Operand *Dest, Variable *Source, bool Locked);
 };
 
-/// Exchange instruction.  Exchanges the first operand (destination
-/// operand) with the second operand (source operand). At least one of
-/// the operands must be a register (and the other can be reg or mem).
-/// Both the Dest and Source are updated. If there is a memory operand,
-/// then the instruction is automatically "locked" without the need for
-/// a lock prefix.
+/// Exchange instruction. Exchanges the first operand (destination operand) with
+/// the second operand (source operand). At least one of the operands must be a
+/// register (and the other can be reg or mem). Both the Dest and Source are
+/// updated. If there is a memory operand, then the instruction is automatically
+/// "locked" without the need for a lock prefix.
 template <class Machine> class InstX86Xchg final : public InstX86Base<Machine> {
   InstX86Xchg() = delete;
   InstX86Xchg(const InstX86Xchg &) = delete;
   InstX86Xchg &operator=(const InstX86Xchg &) = delete;
 
 public:
   static InstX86Xchg *create(Cfg *Func, Operand *Dest, Variable *Source) {
     return new (Func->allocate<InstX86Xchg>()) InstX86Xchg(Func, Dest, Source);
   }
   void emit(const Cfg *Func) const override;
@@ skipping 512 matching lines @@
           &InstX86Base<Machine>::Traits::Assembler::psrl};                     \
   }                                                                            \
   }
 
 } // end of namespace X86Internal
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H