Subzero: Cleanup Inst==>Instr.

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 183 matching lines @@
                         const char *Suffix = "") const;
 
     static TargetLowering *getTarget(const Cfg *Func) {
       return static_cast<TargetLowering *>(Func->getTarget());
     }
 
   protected:
     InstX86Base(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);
+    static bool isClassof(const Inst *Instr, InstKindX86 MyKind) {
+      return Instr->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).
@@ skipping 33 matching lines @@
       return new (Func->allocate<InstX86FakeRMW>())
           InstX86FakeRMW(Func, Data, Addr, Op, Beacon);
     }
     Operand *getAddr() const { return this->getSrc(1); }
     Operand *getData() const { return this->getSrc(0); }
     InstArithmetic::OpKind getOp() const { return Op; }
     Variable *getBeacon() const {
       return llvm::cast<Variable>(this->getSrc(2));
     }
     void dump(const Cfg *Func) const override;
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::FakeRMW);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::FakeRMW);
     }
 
   private:
     InstArithmetic::OpKind Op;
     InstX86FakeRMW(Cfg *Func, Operand *Data, Operand *Addr,
                    InstArithmetic::OpKind Op, Variable *Beacon);
   };
 
   class InstX86GetIP final : public InstX86Base {
     InstX86GetIP() = delete;
     InstX86GetIP(const InstX86GetIP &) = delete;
     InstX86GetIP &operator=(const InstX86GetIP &) = delete;
 
   public:
     static InstX86GetIP *create(Cfg *Func, Variable *Dest) {
       return new (Func->allocate<InstX86GetIP>()) InstX86GetIP(Func, Dest);
     }
     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::isClassof(Inst, InstX86Base::GetIP);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::GetIP);
     }
 
   private:
     InstX86GetIP(Cfg *Func, Variable *Dest);
   };
 
   /// 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
@@ skipping 112 matching lines @@
         ++Sum;
       return Sum;
     }
     bool isUnconditionalBranch() const override {
       return !Label && Condition == Cond::Br_None;
     }
     bool repointEdges(CfgNode *OldNode, CfgNode *NewNode) override;
     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::isClassof(Inst, InstX86Base::Br);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Br);
     }
 
   private:
     InstX86Br(Cfg *Func, const CfgNode *TargetTrue, const CfgNode *TargetFalse,
               const InstX86Label *Label, BrCond Condition, Mode Kind);
 
     BrCond Condition;
     const CfgNode *TargetTrue;
     const CfgNode *TargetFalse;
     const InstX86Label *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.
   class InstX86Jmp final : public InstX86Base {
     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::isClassof(Inst, InstX86Base::Jmp);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Jmp);
     }
 
   private:
     InstX86Jmp(Cfg *Func, Operand *Target);
   };
 
   /// Call instruction. Arguments should have already been pushed.
   class InstX86Call final : public InstX86Base {
     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);
     }
     Operand *getCallTarget() 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::isClassof(Inst, InstX86Base::Call);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Call);
     }
 
   private:
     InstX86Call(Cfg *Func, Variable *Dest, Operand *CallTarget);
   };
 
   /// Emit a one-operand (GPR) instruction.
   static void emitIASOpTyGPR(const Cfg *Func, Type Ty, const Operand *Var,
                              const GPREmitterOneOp &Emitter);
 
@@ skipping 29 matching lines @@
             SReg_t (*srcEnc)(int32_t)>
   static void
   emitIASThreeOpImmOps(const Cfg *Func, Type DispatchTy, const Variable *Dest,
                        const Operand *Src0, const Operand *Src1,
                        const ThreeOpImmEmitter<DReg_t, SReg_t> Emitter);
 
   static void emitIASMovlikeXMM(const Cfg *Func, const Variable *Dest,
                                 const Operand *Src,
                                 const XmmEmitterMovOps Emitter);
 
-  static void emitVariableBlendInst(const char *Opcode, const Inst *Inst,
+  static void emitVariableBlendInst(const char *Opcode, const Inst *Instr,
                                     const Cfg *Func);
 
-  static void emitIASVariableBlendInst(const Inst *Inst, const Cfg *Func,
+  static void emitIASVariableBlendInst(const Inst *Instr, const Cfg *Func,
                                        const XmmEmitterRegOp &Emitter);
 
   static void emitIASXmmShift(const Cfg *Func, Type Ty, const Variable *Var,
                               const Operand *Src,
                               const XmmEmitterShiftOp &Emitter);
 
   /// Emit a two-operand (GPR) instruction, where the dest operand is a Variable
   /// that's guaranteed to be a register.
   template <bool VarCanBeByte = true, bool SrcCanBeByte = true>
   static void emitIASRegOpTyGPR(const Cfg *Func, bool IsLea, Type Ty,
@@ skipping 26 matching lines @@
       emitIASOpTyGPR(Func, Ty, Var, Emitter);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       this->dumpDest(Func);
       Str << " = " << Opcode << "." << this->getDest()->getType() << " ";
       this->dumpSources(Func);
     }
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::K);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::K);
     }
 
   protected:
     InstX86BaseInplaceopGPR(Cfg *Func, Operand *SrcDest)
         : InstX86Base(Func, K, 1, llvm::dyn_cast<Variable>(SrcDest)) {
       this->addSource(SrcDest);
     }
 
   private:
     static const char *Opcode;
@@ skipping 37 matching lines @@
       emitIASRegOpTyGPR(Func, IsLea, Ty, Var, Src, Emitter);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       this->dumpDest(Func);
       Str << " = " << Opcode << "." << this->getSrc(0)->getType() << " ";
       this->dumpSources(Func);
     }
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::K);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::K);
     }
 
   protected:
     InstX86BaseUnaryopGPR(Cfg *Func, Variable *Dest, Operand *Src)
         : InstX86Base(Func, K, 1, Dest) {
       this->addSource(Src);
     }
 
     static const char *Opcode;
     static const GPREmitterRegOp Emitter;
@@ skipping 24 matching lines @@
       emitIASRegOpTyXMM(Func, Ty, this->getDest(), this->getSrc(0), Emitter);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       this->dumpDest(Func);
       Str << " = " << Opcode << "." << this->getDest()->getType() << " ";
       this->dumpSources(Func);
     }
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::K);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::K);
     }
 
   protected:
     InstX86BaseUnaryopXmm(Cfg *Func, Variable *Dest, Operand *Src)
         : InstX86Base(Func, K, 1, Dest) {
       this->addSource(Src);
     }
 
     static const char *Opcode;
     static const XmmEmitterRegOp Emitter;
@@ skipping 20 matching lines @@
       emitIASGPRShift(Func, Ty, this->getDest(), this->getSrc(1), Emitter);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       this->dumpDest(Func);
       Str << " = " << Opcode << "." << this->getDest()->getType() << " ";
       this->dumpSources(Func);
     }
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::K);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::K);
     }
 
   protected:
     InstX86BaseBinopGPRShift(Cfg *Func, Variable *Dest, Operand *Source)
         : InstX86Base(Func, K, 2, Dest) {
       this->addSource(Dest);
       this->addSource(Source);
     }
 
     static const char *Opcode;
@@ skipping 23 matching lines @@
                         Emitter);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       this->dumpDest(Func);
       Str << " = " << Opcode << "." << this->getDest()->getType() << " ";
       this->dumpSources(Func);
     }
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::K);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::K);
     }
 
   protected:
     InstX86BaseBinopGPR(Cfg *Func, Variable *Dest, Operand *Source)
         : InstX86Base(Func, K, 2, Dest) {
       this->addSource(Dest);
       this->addSource(Source);
     }
 
     static const char *Opcode;
@@ skipping 19 matching lines @@
       assert(this->getSrcSize() == 2);
       emitIASAsAddrOpTyGPR(Func, Ty, this->getSrc(0), this->getSrc(1), Emitter);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       Str << Opcode << "." << this->getSrc(0)->getType() << " ";
       this->dumpSources(Func);
     }
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::K);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::K);
     }
 
   protected:
     InstX86BaseBinopRMW(Cfg *Func, X86OperandMem *DestSrc0, Operand *Src1)
         : InstX86Base(Func, K, 2, nullptr) {
       this->addSource(DestSrc0);
       this->addSource(Src1);
     }
 
     static const char *Opcode;
@@ skipping 42 matching lines @@
       emitIASRegOpTyXMM(Func, Ty, this->getDest(), this->getSrc(1), Emitter);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       this->dumpDest(Func);
       Str << " = " << Opcode << "." << this->getDest()->getType() << " ";
       this->dumpSources(Func);
     }
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::K);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::K);
     }
 
   protected:
     InstX86BaseBinopXmm(Cfg *Func, Variable *Dest, Operand *Source,
                         Type ArithmeticTypeOverride = IceType_void)
         : InstX86Base(Func, K, 2, Dest),
           ArithmeticTypeOverride(ArithmeticTypeOverride) {
       this->addSource(Dest);
       this->addSource(Source);
     }
@@ skipping 32 matching lines @@
                       Emitter);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       this->dumpDest(Func);
       Str << " = " << Opcode << "." << this->getDest()->getType() << " ";
       this->dumpSources(Func);
     }
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::K);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::K);
     }
 
   protected:
     InstX86BaseBinopXmmShift(Cfg *Func, Variable *Dest, Operand *Source)
         : InstX86Base(Func, K, 2, Dest) {
       this->addSource(Dest);
       this->addSource(Source);
     }
 
     static const char *Opcode;
@@ skipping 22 matching lines @@
       this->getDest()->emit(Func);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       this->dumpDest(Func);
       Str << " = " << Opcode << "." << this->getDest()->getType() << " ";
       this->dumpSources(Func);
     }
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::K);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::K);
     }
 
   protected:
     InstX86BaseTernop(Cfg *Func, Variable *Dest, Operand *Source1,
                       Operand *Source2)
         : InstX86Base(Func, K, 3, Dest) {
       this->addSource(Dest);
       this->addSource(Source1);
       this->addSource(Source2);
     }
@@ skipping 25 matching lines @@
       this->getDest()->emit(Func);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       this->dumpDest(Func);
       Str << " = " << Opcode << "." << this->getDest()->getType() << " ";
       this->dumpSources(Func);
     }
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::K);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::K);
     }
 
   protected:
     InstX86BaseThreeAddressop(Cfg *Func, Variable *Dest, Operand *Source0,
                               Operand *Source1)
         : InstX86Base(Func, K, 2, Dest) {
       this->addSource(Source0);
       this->addSource(Source1);
     }
 
@@ skipping 35 matching lines @@
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       Str << Opcode << "." << this->getDest()->getType() << " ";
       this->dumpDest(Func);
       Str << ", ";
       this->dumpSources(Func);
     }
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::K);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::K);
     }
 
   protected:
     InstX86BaseMovlike(Cfg *Func, Variable *Dest, Operand *Source)
         : InstX86Base(Func, K, 1, Dest) {
       this->addSource(Source);
       // For an integer assignment, make sure it's either a same-type assignment
       // or a truncation.
       assert(!isScalarIntegerType(Dest->getType()) ||
              (typeWidthInBytes(Dest->getType()) <=
@@ skipping 1099 matching lines @@
 
   public:
     static InstX86Mul *create(Cfg *Func, Variable *Dest, Variable *Source1,
                               Operand *Source2) {
       return new (Func->allocate<InstX86Mul>())
           InstX86Mul(Func, Dest, Source1, Source2);
     }
     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::isClassof(Inst, InstX86Base::Mul);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Mul);
     }
 
   private:
     InstX86Mul(Cfg *Func, Variable *Dest, Variable *Source1, Operand *Source2);
   };
 
   /// Shld instruction - shift across a pair of operands.
   class InstX86Shld final : public InstX86Base {
     InstX86Shld() = delete;
     InstX86Shld(const InstX86Shld &) = delete;
     InstX86Shld &operator=(const InstX86Shld &) = delete;
 
   public:
     static InstX86Shld *create(Cfg *Func, Variable *Dest, Variable *Source1,
                                Operand *Source2) {
       return new (Func->allocate<InstX86Shld>())
           InstX86Shld(Func, Dest, Source1, Source2);
     }
     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::isClassof(Inst, InstX86Base::Shld);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Shld);
     }
 
   private:
     InstX86Shld(Cfg *Func, Variable *Dest, Variable *Source1, Operand *Source2);
   };
 
   /// Shrd instruction - shift across a pair of operands.
   class InstX86Shrd final : public InstX86Base {
     InstX86Shrd() = delete;
     InstX86Shrd(const InstX86Shrd &) = delete;
     InstX86Shrd &operator=(const InstX86Shrd &) = delete;
 
   public:
     static InstX86Shrd *create(Cfg *Func, Variable *Dest, Variable *Source1,
                                Operand *Source2) {
       return new (Func->allocate<InstX86Shrd>())
           InstX86Shrd(Func, Dest, Source1, Source2);
     }
     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::isClassof(Inst, InstX86Base::Shrd);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Shrd);
     }
 
   private:
     InstX86Shrd(Cfg *Func, Variable *Dest, Variable *Source1, Operand *Source2);
   };
 
   /// Conditional move instruction.
   class InstX86Cmov final : public InstX86Base {
     InstX86Cmov() = delete;
     InstX86Cmov(const InstX86Cmov &) = delete;
     InstX86Cmov &operator=(const InstX86Cmov &) = delete;
 
   public:
     static InstX86Cmov *create(Cfg *Func, Variable *Dest, Operand *Source,
                                BrCond Cond) {
       return new (Func->allocate<InstX86Cmov>())
           InstX86Cmov(Func, Dest, Source, Cond);
     }
     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::isClassof(Inst, InstX86Base::Cmov);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Cmov);
     }
 
   private:
     InstX86Cmov(Cfg *Func, Variable *Dest, Operand *Source, BrCond Cond);
 
     BrCond Condition;
   };
 
   /// Cmpps instruction - compare packed singled-precision floating point values
   class InstX86Cmpps final : public InstX86Base {
     InstX86Cmpps() = delete;
     InstX86Cmpps(const InstX86Cmpps &) = delete;
     InstX86Cmpps &operator=(const InstX86Cmpps &) = delete;
 
   public:
     static InstX86Cmpps *create(Cfg *Func, Variable *Dest, Operand *Source,
                                 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::isClassof(Inst, InstX86Base::Cmpps);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Cmpps);
     }
 
   private:
     InstX86Cmpps(Cfg *Func, Variable *Dest, Operand *Source, CmppsCond 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 responsibility to mark eax with a FakeDef.
   class InstX86Cmpxchg final : public InstX86BaseLockable {
     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::isClassof(Inst, InstX86Base::Cmpxchg);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::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.
   class InstX86Cmpxchg8b final : public InstX86BaseLockable {
     InstX86Cmpxchg8b() = delete;
     InstX86Cmpxchg8b(const InstX86Cmpxchg8b &) = delete;
     InstX86Cmpxchg8b &operator=(const InstX86Cmpxchg8b &) = delete;
 
   public:
     static InstX86Cmpxchg8b *create(Cfg *Func, 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::isClassof(Inst, InstX86Base::Cmpxchg8b);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Cmpxchg8b);
     }
 
   private:
     InstX86Cmpxchg8b(Cfg *Func, 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.
   class InstX86Cvt final : public InstX86Base {
     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>())
           InstX86Cvt(Func, Dest, Source, Variant);
     }
     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::isClassof(Inst, InstX86Base::Cvt);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Cvt);
     }
     bool isTruncating() const { return Variant == Tss2si || Variant == Tps2dq; }
 
   private:
     CvtVariant Variant;
     InstX86Cvt(Cfg *Func, Variable *Dest, Operand *Source, CvtVariant Variant);
   };
 
   /// cmp - Integer compare instruction.
   class InstX86Icmp final : public InstX86Base {
     InstX86Icmp() = delete;
     InstX86Icmp(const InstX86Icmp &) = delete;
     InstX86Icmp &operator=(const InstX86Icmp &) = delete;
 
   public:
     static InstX86Icmp *create(Cfg *Func, Operand *Src1, Operand *Src2) {
       return new (Func->allocate<InstX86Icmp>()) InstX86Icmp(Func, Src1, Src2);
     }
     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::isClassof(Inst, InstX86Base::Icmp);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Icmp);
     }
 
   private:
     InstX86Icmp(Cfg *Func, Operand *Src1, Operand *Src2);
   };
 
   /// ucomiss/ucomisd - floating-point compare instruction.
   class InstX86Ucomiss final : public InstX86Base {
     InstX86Ucomiss() = delete;
     InstX86Ucomiss(const InstX86Ucomiss &) = delete;
     InstX86Ucomiss &operator=(const InstX86Ucomiss &) = delete;
 
   public:
     static InstX86Ucomiss *create(Cfg *Func, Operand *Src1, Operand *Src2) {
       return new (Func->allocate<InstX86Ucomiss>())
           InstX86Ucomiss(Func, Src1, Src2);
     }
     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::isClassof(Inst, InstX86Base::Ucomiss);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Ucomiss);
     }
 
   private:
     InstX86Ucomiss(Cfg *Func, Operand *Src1, Operand *Src2);
   };
 
   /// UD2 instruction.
   class InstX86UD2 final : public InstX86Base {
     InstX86UD2() = delete;
     InstX86UD2(const InstX86UD2 &) = delete;
     InstX86UD2 &operator=(const InstX86UD2 &) = delete;
 
   public:
     static InstX86UD2 *create(Cfg *Func) {
       return new (Func->allocate<InstX86UD2>()) InstX86UD2(Func);
     }
     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::isClassof(Inst, InstX86Base::UD2);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::UD2);
     }
 
   private:
     explicit InstX86UD2(Cfg *Func);
   };
 
   /// Test instruction.
   class InstX86Test final : public InstX86Base {
     InstX86Test() = delete;
     InstX86Test(const InstX86Test &) = delete;
     InstX86Test &operator=(const InstX86Test &) = delete;
 
   public:
     static InstX86Test *create(Cfg *Func, Operand *Source1, Operand *Source2) {
       return new (Func->allocate<InstX86Test>())
           InstX86Test(Func, Source1, Source2);
     }
     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::isClassof(Inst, InstX86Base::Test);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Test);
     }
 
   private:
     InstX86Test(Cfg *Func, Operand *Source1, Operand *Source2);
   };
 
   /// Mfence instruction.
   class InstX86Mfence final : public InstX86Base {
     InstX86Mfence() = delete;
     InstX86Mfence(const InstX86Mfence &) = delete;
     InstX86Mfence &operator=(const InstX86Mfence &) = delete;
 
   public:
     static InstX86Mfence *create(Cfg *Func) {
       return new (Func->allocate<InstX86Mfence>()) InstX86Mfence(Func);
     }
     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::isClassof(Inst, InstX86Base::Mfence);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Mfence);
     }
 
   private:
     explicit InstX86Mfence(Cfg *Func);
   };
 
   /// This is essentially a "mov" instruction with anX86OperandMem operand
   /// instead of Variable as the destination. It's important for liveness that
   /// there is no Dest operand.
   class InstX86Store final : public InstX86Base {
     InstX86Store() = delete;
     InstX86Store(const InstX86Store &) = delete;
     InstX86Store &operator=(const InstX86Store &) = delete;
 
   public:
     static InstX86Store *create(Cfg *Func, Operand *Value, 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::isClassof(Inst, InstX86Base::Store);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Store);
     }
 
   private:
     InstX86Store(Cfg *Func, Operand *Value, X86Operand *Mem);
   };
 
   /// This is essentially a vector "mov" instruction with an typename
   /// 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.
   class InstX86StoreP final : public InstX86Base {
     InstX86StoreP() = delete;
     InstX86StoreP(const InstX86StoreP &) = delete;
     InstX86StoreP &operator=(const InstX86StoreP &) = delete;
 
   public:
     static InstX86StoreP *create(Cfg *Func, Variable *Value,
                                  X86OperandMem *Mem) {
       return new (Func->allocate<InstX86StoreP>())
           InstX86StoreP(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::isClassof(Inst, InstX86Base::StoreP);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::StoreP);
     }
 
   private:
     InstX86StoreP(Cfg *Func, Variable *Value, X86OperandMem *Mem);
   };
 
   class InstX86StoreQ final : public InstX86Base {
     InstX86StoreQ() = delete;
     InstX86StoreQ(const InstX86StoreQ &) = delete;
     InstX86StoreQ &operator=(const InstX86StoreQ &) = delete;
 
   public:
     static InstX86StoreQ *create(Cfg *Func, Variable *Value,
                                  X86OperandMem *Mem) {
       return new (Func->allocate<InstX86StoreQ>())
           InstX86StoreQ(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::isClassof(Inst, InstX86Base::StoreQ);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::StoreQ);
     }
 
   private:
     InstX86StoreQ(Cfg *Func, Variable *Value, X86OperandMem *Mem);
   };
 
   /// Nop instructions of varying length
   class InstX86Nop final : public InstX86Base {
     InstX86Nop() = delete;
     InstX86Nop(const InstX86Nop &) = delete;
     InstX86Nop &operator=(const InstX86Nop &) = delete;
 
   public:
     // TODO: Replace with enum.
     using NopVariant = unsigned;
 
     static InstX86Nop *create(Cfg *Func, NopVariant Variant) {
       return new (Func->allocate<InstX86Nop>()) InstX86Nop(Func, Variant);
     }
     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::isClassof(Inst, InstX86Base::Nop);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Nop);
     }
 
   private:
     InstX86Nop(Cfg *Func, SizeT Length);
 
     NopVariant Variant;
   };
 
   /// Fld - load a value onto the x87 FP stack.
   class InstX86Fld final : public InstX86Base {
     InstX86Fld() = delete;
     InstX86Fld(const InstX86Fld &) = delete;
     InstX86Fld &operator=(const InstX86Fld &) = delete;
 
   public:
     static InstX86Fld *create(Cfg *Func, Operand *Src) {
       return new (Func->allocate<InstX86Fld>()) InstX86Fld(Func, Src);
     }
     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::isClassof(Inst, InstX86Base::Fld);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Fld);
     }
 
   private:
     InstX86Fld(Cfg *Func, Operand *Src);
   };
 
   /// Fstp - store x87 st(0) into memory and pop st(0).
   class InstX86Fstp final : public InstX86Base {
     InstX86Fstp() = delete;
     InstX86Fstp(const InstX86Fstp &) = delete;
     InstX86Fstp &operator=(const InstX86Fstp &) = delete;
 
   public:
     static InstX86Fstp *create(Cfg *Func, Variable *Dest) {
       return new (Func->allocate<InstX86Fstp>()) InstX86Fstp(Func, Dest);
     }
     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::isClassof(Inst, InstX86Base::Fstp);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Fstp);
     }
 
   private:
     InstX86Fstp(Cfg *Func, Variable *Dest);
   };
 
   class InstX86Pop final : public InstX86Base {
     InstX86Pop() = delete;
     InstX86Pop(const InstX86Pop &) = delete;
     InstX86Pop &operator=(const InstX86Pop &) = delete;
 
   public:
     static InstX86Pop *create(Cfg *Func, Variable *Dest) {
       return new (Func->allocate<InstX86Pop>()) InstX86Pop(Func, Dest);
     }
     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::isClassof(Inst, InstX86Base::Pop);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Pop);
     }
 
   private:
     InstX86Pop(Cfg *Func, Variable *Dest);
   };
 
   class InstX86Push final : public InstX86Base {
     InstX86Push() = delete;
     InstX86Push(const InstX86Push &) = delete;
     InstX86Push &operator=(const InstX86Push &) = delete;
 
   public:
     static InstX86Push *create(Cfg *Func, InstX86Label *Label) {
       return new (Func->allocate<InstX86Push>()) InstX86Push(Func, Label);
     }
     static InstX86Push *create(Cfg *Func, Operand *Source) {
       return new (Func->allocate<InstX86Push>()) InstX86Push(Func, Source);
     }
     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::isClassof(Inst, InstX86Base::Push);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Push);
     }
 
   private:
     InstX86Label *Label = nullptr;
 
     InstX86Push(Cfg *Func, Operand *Source);
     InstX86Push(Cfg *Func, InstX86Label *Label);
   };
 
   /// 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.
   class InstX86Ret final : public InstX86Base {
     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;
     void emitIAS(const Cfg *Func) const override;
     void dump(const Cfg *Func) const override;
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::Ret);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Ret);
     }
 
   private:
     InstX86Ret(Cfg *Func, Variable *Source);
   };
 
   /// Conditional set-byte instruction.
   class InstX86Setcc final : public InstX86Base {
     InstX86Setcc() = delete;
     InstX86Setcc(const InstX86Cmov &) = delete;
     InstX86Setcc &operator=(const InstX86Setcc &) = delete;
 
   public:
     static InstX86Setcc *create(Cfg *Func, Variable *Dest, BrCond Cond) {
       return new (Func->allocate<InstX86Setcc>())
           InstX86Setcc(Func, Dest, Cond);
     }
     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::isClassof(Inst, InstX86Base::Setcc);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Setcc);
     }
 
   private:
     InstX86Setcc(Cfg *Func, Variable *Dest, BrCond Cond);
 
     const 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.
   ///
   /// Both the dest and source are updated. The caller should then insert a
   /// FakeDef to reflect the second udpate.
   class InstX86Xadd final : public InstX86BaseLockable {
     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::isClassof(Inst, InstX86Base::Xadd);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::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.
   class InstX86Xchg final : public InstX86Base {
     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;
     void emitIAS(const Cfg *Func) const override;
     void dump(const Cfg *Func) const override;
-    static bool classof(const Inst *Inst) {
-      return InstX86Base::isClassof(Inst, InstX86Base::Xchg);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::Xchg);
     }
 
   private:
     InstX86Xchg(Cfg *Func, Operand *Dest, Variable *Source);
   };
 
   /// Start marker for the Intel Architecture Code Analyzer. This is not an
   /// executable instruction and must only be used for analysis.
   class InstX86IacaStart final : public InstX86Base {
     InstX86IacaStart() = delete;
     InstX86IacaStart(const InstX86IacaStart &) = delete;
     InstX86IacaStart &operator=(const InstX86IacaStart &) = delete;
 
   public:
     static InstX86IacaStart *create(Cfg *Func) {
       return new (Func->allocate<InstX86IacaStart>()) InstX86IacaStart(Func);
     }
     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::isClassof(Inst, InstX86Base::IacaStart);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::IacaStart);
     }
 
   private:
     InstX86IacaStart(Cfg *Func);
   };
 
   /// End marker for the Intel Architecture Code Analyzer. This is not an
   /// executable instruction and must only be used for analysis.
   class InstX86IacaEnd final : public InstX86Base {
     InstX86IacaEnd() = delete;
     InstX86IacaEnd(const InstX86IacaEnd &) = delete;
     InstX86IacaEnd &operator=(const InstX86IacaEnd &) = delete;
 
   public:
     static InstX86IacaEnd *create(Cfg *Func) {
       return new (Func->allocate<InstX86IacaEnd>()) InstX86IacaEnd(Func);
     }
     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::isClassof(Inst, InstX86Base::IacaEnd);
+    static bool classof(const Inst *Instr) {
+      return InstX86Base::isClassof(Instr, InstX86Base::IacaEnd);
     }
 
   private:
     InstX86IacaEnd(Cfg *Func);
   };
 }; // struct InstImpl
 
 /// struct Insts is a template that can be used to instantiate all the X86
 /// instructions for a target with a simple
 ///
@@ skipping 704 matching lines @@
           &InstImpl<TraitsType>::Assembler::psrl};                             \
   }                                                                            \
   }
 
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H