Subzero: Cleanup Inst==>Instr.

src/IceInstARM32.h

 //===- subzero/src/IceInstARM32.h - ARM32 machine 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 431 matching lines @@
   static const char *getVecWidthString(Type Ty);
   static CondARM32::Cond getOppositeCondition(CondARM32::Cond Cond);
 
   /// Called inside derived methods emit() to communicate that multiple
   /// instructions are being generated. Used by emitIAS() methods to
   /// generate textual fixups for instructions that are not yet
   /// implemented.
   void startNextInst(const Cfg *Func) const;
 
   /// Shared emit routines for common forms of instructions.
-  static void emitThreeAddrFP(const char *Opcode, const InstARM32 *Inst,
+  static void emitThreeAddrFP(const char *Opcode, const InstARM32 *Instr,
                               const Cfg *Func);
-  static void emitFourAddrFP(const char *Opcode, const InstARM32 *Inst,
+  static void emitFourAddrFP(const char *Opcode, const InstARM32 *Instr,
                              const Cfg *Func);
 
   void dump(const Cfg *Func) const override;
 
   void emitIAS(const Cfg *Func) const override;
 
 protected:
   InstARM32(Cfg *Func, InstKindARM32 Kind, SizeT Maxsrcs, Variable *Dest)
       : InstTarget(Func, static_cast<InstKind>(Kind), Maxsrcs, Dest) {}
 
-  static bool isClassof(const Inst *Inst, InstKindARM32 MyKind) {
-    return Inst->getKind() == static_cast<InstKind>(MyKind);
+  static bool isClassof(const Inst *Instr, InstKindARM32 MyKind) {
+    return Instr->getKind() == static_cast<InstKind>(MyKind);
   }
 
   // Generates text of assembly instruction using method emit(), and then adds
   // to the assembly buffer as a Fixup.
   void emitUsingTextFixup(const Cfg *Func) const;
 };
 
 /// A predicable ARM instruction.
 class InstARM32Pred : public InstARM32 {
   InstARM32Pred() = delete;
   InstARM32Pred(const InstARM32Pred &) = delete;
   InstARM32Pred &operator=(const InstARM32Pred &) = delete;
 
 public:
   InstARM32Pred(Cfg *Func, InstKindARM32 Kind, SizeT Maxsrcs, Variable *Dest,
                 CondARM32::Cond Predicate)
       : InstARM32(Func, Kind, Maxsrcs, Dest), Predicate(Predicate) {}
 
   CondARM32::Cond getPredicate() const { return Predicate; }
   void setPredicate(CondARM32::Cond Pred) { Predicate = Pred; }
 
   static const char *predString(CondARM32::Cond Predicate);
   void dumpOpcodePred(Ostream &Str, const char *Opcode, Type Ty) const;
 
   /// Shared emit routines for common forms of instructions.
-  static void emitUnaryopGPR(const char *Opcode, const InstARM32Pred *Inst,
+  static void emitUnaryopGPR(const char *Opcode, const InstARM32Pred *Instr,
                              const Cfg *Func, bool NeedsWidthSuffix);
-  static void emitUnaryopFP(const char *Opcode, const InstARM32Pred *Inst,
+  static void emitUnaryopFP(const char *Opcode, const InstARM32Pred *Instr,
                             const Cfg *Func);
-  static void emitTwoAddr(const char *Opcode, const InstARM32Pred *Inst,
+  static void emitTwoAddr(const char *Opcode, const InstARM32Pred *Instr,
                           const Cfg *Func);
-  static void emitThreeAddr(const char *Opcode, const InstARM32Pred *Inst,
+  static void emitThreeAddr(const char *Opcode, const InstARM32Pred *Instr,
                             const Cfg *Func, bool SetFlags);
-  static void emitFourAddr(const char *Opcode, const InstARM32Pred *Inst,
+  static void emitFourAddr(const char *Opcode, const InstARM32Pred *Instr,
                            const Cfg *Func);
-  static void emitCmpLike(const char *Opcode, const InstARM32Pred *Inst,
+  static void emitCmpLike(const char *Opcode, const InstARM32Pred *Instr,
                           const Cfg *Func);
 
 protected:
   CondARM32::Cond Predicate;
 };
 
 template <typename StreamType>
 inline StreamType &operator<<(StreamType &Stream, CondARM32::Cond Predicate) {
   Stream << InstARM32Pred::predString(Predicate);
   return Stream;
@@ skipping 21 matching lines @@
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = ";
     dumpOpcodePred(Str, Opcode, getDest()->getType());
     Str << " ";
     dumpSources(Func);
   }
-  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, K); }
 
 private:
   InstARM32UnaryopGPR(Cfg *Func, Variable *Dest, Operand *Src,
                       CondARM32::Cond Predicate)
       : InstARM32Pred(Func, K, 1, Dest, Predicate) {
     addSource(Src);
   }
 
   static const char *Opcode;
 };
@@ skipping 20 matching lines @@
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = ";
     dumpOpcodePred(Str, Opcode, getDest()->getType());
     Str << " ";
     dumpSources(Func);
   }
-  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, K); }
 
 private:
   InstARM32UnaryopFP(Cfg *Func, Variable *Dest, Operand *Src,
                      CondARM32::Cond Predicate)
       : InstARM32Pred(Func, K, 1, Dest, Predicate) {
     addSource(Src);
   }
 
   static const char *Opcode;
 };
@@ skipping 21 matching lines @@
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = ";
     dumpOpcodePred(Str, Opcode, getDest()->getType());
     Str << " ";
     dumpSources(Func);
   }
-  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, K); }
 
 private:
   InstARM32TwoAddrGPR(Cfg *Func, Variable *Dest, Operand *Src,
                       CondARM32::Cond Predicate)
       : InstARM32Pred(Func, K, 2, Dest, Predicate) {
     addSource(Dest);
     addSource(Src);
   }
 
   static const char *Opcode;
@@ skipping 17 matching lines @@
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpOpcodePred(Str, Opcode, getDest()->getType());
     Str << " ";
     dumpDest(Func);
     Str << ", ";
     dumpSources(Func);
   }
-  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, K); }
 
 private:
   InstARM32LoadBase(Cfg *Func, Variable *Dest, Operand *Source,
                     CondARM32::Cond Predicate)
       : InstARM32Pred(Func, K, 1, Dest, Predicate) {
     addSource(Source);
   }
 
   static const char *Opcode;
 };
@@ skipping 25 matching lines @@
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = ";
     dumpOpcodePred(Str, Opcode, getDest()->getType());
     Str << (SetFlags ? ".s " : " ");
     dumpSources(Func);
   }
-  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, K); }
 
 private:
   InstARM32ThreeAddrGPR(Cfg *Func, Variable *Dest, Variable *Src0,
                         Operand *Src1, CondARM32::Cond Predicate, bool SetFlags)
       : InstARM32Pred(Func, K, 2, Dest, Predicate), SetFlags(SetFlags) {
     HasSideEffects = SetFlags;
     addSource(Src0);
     addSource(Src1);
   }
 
@@ skipping 27 matching lines @@
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = ";
     Str << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
-  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, K); }
 
 private:
   InstARM32ThreeAddrFP(Cfg *Func, Variable *Dest, Variable *Src0,
                        Variable *Src1)
       : InstARM32(Func, K, 2, Dest) {
     addSource(Src0);
     addSource(Src1);
   }
 
   static const char *Opcode;
@@ skipping 23 matching lines @@
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = ";
     dumpOpcodePred(Str, Opcode, getDest()->getType());
     Str << " ";
     dumpSources(Func);
   }
-  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, K); }
 
 private:
   InstARM32FourAddrGPR(Cfg *Func, Variable *Dest, Variable *Src0,
                        Variable *Src1, Variable *Src2,
                        CondARM32::Cond Predicate)
       : InstARM32Pred(Func, K, 3, Dest, Predicate) {
     addSource(Src0);
     addSource(Src1);
     addSource(Src2);
   }
@@ skipping 29 matching lines @@
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = ";
     Str << Opcode << "." << getDest()->getType() << " ";
     dumpDest(Func);
     Str << ", ";
     dumpSources(Func);
   }
-  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, K); }
 
 private:
   InstARM32FourAddrFP(Cfg *Func, Variable *Dest, Variable *Src0, Variable *Src1)
       : InstARM32(Func, K, 3, Dest) {
     addSource(Dest);
     addSource(Src0);
     addSource(Src1);
   }
 
   static const char *Opcode;
@@ skipping 19 matching lines @@
   }
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpOpcodePred(Str, Opcode, getSrc(0)->getType());
     Str << " ";
     dumpSources(Func);
   }
-  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, K); }
 
 private:
   InstARM32CmpLike(Cfg *Func, Variable *Src0, Operand *Src1,
                    CondARM32::Cond Predicate)
       : InstARM32Pred(Func, K, 2, nullptr, Predicate) {
     HasSideEffects = true;
     addSource(Src0);
     addSource(Src1);
   }
 
@@ skipping 127 matching lines @@
       ++Sum;
     return Sum;
   }
   bool isUnconditionalBranch() const override {
     return getPredicate() == CondARM32::AL;
   }
   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 isClassof(Inst, Br); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Br); }
 
 private:
   InstARM32Br(Cfg *Func, const CfgNode *TargetTrue, const CfgNode *TargetFalse,
               const InstARM32Label *Label, CondARM32::Cond Predicate);
 
   const CfgNode *TargetTrue;
   const CfgNode *TargetFalse;
   const InstARM32Label *Label; // Intra-block branch target
 };
 
 /// Call instruction (bl/blx). Arguments should have already been pushed.
 /// Technically bl and the register form of blx can be predicated, but we'll
 /// leave that out until needed.
 class InstARM32Call : public InstARM32 {
   InstARM32Call() = delete;
   InstARM32Call(const InstARM32Call &) = delete;
   InstARM32Call &operator=(const InstARM32Call &) = delete;
 
 public:
   static InstARM32Call *create(Cfg *Func, Variable *Dest, Operand *CallTarget) {
     return new (Func->allocate<InstARM32Call>())
         InstARM32Call(Func, Dest, CallTarget);
   }
   Operand *getCallTarget() const { return 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 isClassof(Inst, Call); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Call); }
 
 private:
   InstARM32Call(Cfg *Func, Variable *Dest, Operand *CallTarget);
 };
 
 class InstARM32RegisterStackOp : public InstARM32 {
   InstARM32RegisterStackOp() = delete;
   InstARM32RegisterStackOp(const InstARM32RegisterStackOp &) = delete;
   InstARM32RegisterStackOp &
   operator=(const InstARM32RegisterStackOp &) = delete;
@@ skipping 28 matching lines @@
 /// regs, but not both. In any case, the list must be sorted.
 class InstARM32Pop : public InstARM32RegisterStackOp {
   InstARM32Pop() = delete;
   InstARM32Pop(const InstARM32Pop &) = delete;
   InstARM32Pop &operator=(const InstARM32Pop &) = delete;
 
 public:
   static InstARM32Pop *create(Cfg *Func, const VarList &Dests) {
     return new (Func->allocate<InstARM32Pop>()) InstARM32Pop(Func, Dests);
   }
-  static bool classof(const Inst *Inst) { return isClassof(Inst, Pop); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Pop); }
 
 private:
   InstARM32Pop(Cfg *Func, const VarList &Dests);
   virtual const char *getGPROpcode() const final;
   virtual const char *getSRegOpcode() const final;
   Variable *getStackReg(SizeT Index) const final;
   SizeT getNumStackRegs() const final;
   void emitSingleGPR(const Cfg *Func, const EmitForm Form,
                      const Variable *Reg) const final;
   void emitMultipleGPRs(const Cfg *Func, const EmitForm Form,
                         IValueT Registers) const final;
   void emitSRegs(const Cfg *Func, const EmitForm Form, const Variable *BaseReg,
                  SizeT RegCount) const final;
 
   VarList Dests;
 };
 
 /// Pushes a list of registers. Just like Pop (see above), the list may be of
 /// GPRs, or VFP "s" registers, but not both.
 class InstARM32Push : public InstARM32RegisterStackOp {
   InstARM32Push() = delete;
   InstARM32Push(const InstARM32Push &) = delete;
   InstARM32Push &operator=(const InstARM32Push &) = delete;
 
 public:
   static InstARM32Push *create(Cfg *Func, const VarList &Srcs) {
     return new (Func->allocate<InstARM32Push>()) InstARM32Push(Func, Srcs);
   }
-  static bool classof(const Inst *Inst) { return isClassof(Inst, Push); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Push); }
 
 private:
   InstARM32Push(Cfg *Func, const VarList &Srcs);
   const char *getGPROpcode() const final;
   const char *getSRegOpcode() const final;
   Variable *getStackReg(SizeT Index) const final;
   SizeT getNumStackRegs() const final;
   void emitSingleGPR(const Cfg *Func, const EmitForm Form,
                      const Variable *Reg) const final;
   void emitMultipleGPRs(const Cfg *Func, const EmitForm Form,
@@ skipping 17 matching lines @@
   InstARM32Ret &operator=(const InstARM32Ret &) = delete;
 
 public:
   static InstARM32Ret *create(Cfg *Func, Variable *LR,
                               Variable *Source = nullptr) {
     return new (Func->allocate<InstARM32Ret>()) InstARM32Ret(Func, LR, 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 isClassof(Inst, Ret); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Ret); }
 
 private:
   InstARM32Ret(Cfg *Func, Variable *LR, Variable *Source);
 };
 
 /// Store instruction. It's important for liveness that there is no Dest operand
 /// (OperandARM32Mem instead of Dest Variable).
 class InstARM32Str final : public InstARM32Pred {
   InstARM32Str() = delete;
   InstARM32Str(const InstARM32Str &) = delete;
   InstARM32Str &operator=(const InstARM32Str &) = delete;
 
 public:
   /// Value must be a register.
   static InstARM32Str *create(Cfg *Func, Variable *Value, OperandARM32Mem *Mem,
                               CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Str>())
         InstARM32Str(Func, Value, Mem, Predicate);
   }
   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 isClassof(Inst, Str); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Str); }
 
 private:
   InstARM32Str(Cfg *Func, Variable *Value, OperandARM32Mem *Mem,
                CondARM32::Cond Predicate);
 };
 
 /// Exclusive Store instruction. Like its non-exclusive sibling, it's important
 /// for liveness that there is no Dest operand (OperandARM32Mem instead of Dest
 /// Variable).
 class InstARM32Strex final : public InstARM32Pred {
   InstARM32Strex() = delete;
   InstARM32Strex(const InstARM32Strex &) = delete;
   InstARM32Strex &operator=(const InstARM32Strex &) = delete;
 
 public:
   /// Value must be a register.
   static InstARM32Strex *create(Cfg *Func, Variable *Dest, Variable *Value,
                                 OperandARM32Mem *Mem,
                                 CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Strex>())
         InstARM32Strex(Func, Dest, Value, Mem, Predicate);
   }
   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 isClassof(Inst, Strex); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Strex); }
 
 private:
   InstARM32Strex(Cfg *Func, Variable *Dest, Variable *Value,
                  OperandARM32Mem *Mem, CondARM32::Cond Predicate);
 };
 
 class InstARM32Trap : public InstARM32 {
   InstARM32Trap() = delete;
   InstARM32Trap(const InstARM32Trap &) = delete;
   InstARM32Trap &operator=(const InstARM32Trap &) = delete;
 
 public:
   static InstARM32Trap *create(Cfg *Func) {
     return new (Func->allocate<InstARM32Trap>()) InstARM32Trap(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 isClassof(Inst, Trap); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Trap); }
 
 private:
   explicit InstARM32Trap(Cfg *Func);
 };
 
 /// Unsigned Multiply Long: d.lo, d.hi := x * y
 class InstARM32Umull : public InstARM32Pred {
   InstARM32Umull() = delete;
   InstARM32Umull(const InstARM32Umull &) = delete;
   InstARM32Umull &operator=(const InstARM32Umull &) = delete;
 
 public:
   /// Everything must be a register.
   static InstARM32Umull *create(Cfg *Func, Variable *DestLo, Variable *DestHi,
                                 Variable *Src0, Variable *Src1,
                                 CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Umull>())
         InstARM32Umull(Func, DestLo, DestHi, Src0, Src1, Predicate);
   }
   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 isClassof(Inst, Umull); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Umull); }
 
 private:
   InstARM32Umull(Cfg *Func, Variable *DestLo, Variable *DestHi, Variable *Src0,
                  Variable *Src1, CondARM32::Cond Predicate);
 
   Variable *DestHi;
 };
 
 /// Handles fp2int, int2fp, and fp2fp conversions.
 class InstARM32Vcvt final : public InstARM32Pred {
   InstARM32Vcvt() = delete;
   InstARM32Vcvt(const InstARM32Vcvt &) = delete;
   InstARM32Vcvt &operator=(const InstARM32Vcvt &) = delete;
 
 public:
   enum VcvtVariant { S2si, S2ui, Si2s, Ui2s, D2si, D2ui, Si2d, Ui2d, S2d, D2s };
   static InstARM32Vcvt *create(Cfg *Func, Variable *Dest, Variable *Src,
                                VcvtVariant Variant, CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Vcvt>())
         InstARM32Vcvt(Func, Dest, Src, Variant, Predicate);
   }
   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 isClassof(Inst, Vcvt); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Vcvt); }
 
 private:
   InstARM32Vcvt(Cfg *Func, Variable *Dest, Variable *Src, VcvtVariant Variant,
                 CondARM32::Cond Predicate);
 
   const VcvtVariant Variant;
 };
 
 /// Handles (some of) vmov's various formats.
 class InstARM32Mov final : public InstARM32Pred {
   InstARM32Mov() = delete;
   InstARM32Mov(const InstARM32Mov &) = delete;
   InstARM32Mov &operator=(const InstARM32Mov &) = delete;
 
 public:
   static InstARM32Mov *create(Cfg *Func, Variable *Dest, Operand *Src,
                               CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Mov>())
         InstARM32Mov(Func, Dest, Src, Predicate);
   }
   bool isRedundantAssign() const override {
     return !isMultiDest() && !isMultiSource() &&
            getPredicate() == CondARM32::AL &&
            checkForRedundantAssign(getDest(), getSrc(0));
   }
   bool isVarAssign() const override { return llvm::isa<Variable>(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 isClassof(Inst, Mov); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Mov); }
 
   bool isMultiDest() const { return DestHi != nullptr; }
 
   bool isMultiSource() const {
     assert(getSrcSize() == 1 || getSrcSize() == 2);
     return getSrcSize() == 2;
   }
 
   Variable *getDestHi() const { return DestHi; }
 
@@ skipping 25 matching lines @@
   }
   static InstARM32Vcmp *create(Cfg *Func, Variable *Src0,
                                OperandARM32FlexFpZero *Src1,
                                CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Vcmp>())
         InstARM32Vcmp(Func, Src0, Src1, Predicate);
   }
   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 isClassof(Inst, Vcmp); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Vcmp); }
 
 private:
   InstARM32Vcmp(Cfg *Func, Variable *Src0, Operand *Src1,
                 CondARM32::Cond Predicate);
 };
 
 /// Copies the FP Status and Control Register the core flags.
 class InstARM32Vmrs final : public InstARM32Pred {
   InstARM32Vmrs() = delete;
   InstARM32Vmrs(const InstARM32Vmrs &) = delete;
   InstARM32Vmrs &operator=(const InstARM32Vmrs &) = delete;
 
 public:
   static InstARM32Vmrs *create(Cfg *Func, CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Vmrs>()) InstARM32Vmrs(Func, Predicate);
   }
   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 isClassof(Inst, Vmrs); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Vmrs); }
 
 private:
   InstARM32Vmrs(Cfg *Func, CondARM32::Cond Predicate);
 };
 
 class InstARM32Vabs final : public InstARM32Pred {
   InstARM32Vabs() = delete;
   InstARM32Vabs(const InstARM32Vabs &) = delete;
   InstARM32Vabs &operator=(const InstARM32Vabs &) = delete;
 
 public:
   static InstARM32Vabs *create(Cfg *Func, Variable *Dest, Variable *Src,
                                CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Vabs>())
         InstARM32Vabs(Func, Dest, Src, Predicate);
   }
   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 isClassof(Inst, Vabs); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Vabs); }
 
 private:
   InstARM32Vabs(Cfg *Func, Variable *Dest, Variable *Src,
                 CondARM32::Cond Predicate);
 };
 
 class InstARM32Dmb final : public InstARM32Pred {
   InstARM32Dmb() = delete;
   InstARM32Dmb(const InstARM32Dmb &) = delete;
   InstARM32Dmb &operator=(const InstARM32Dmb &) = delete;
 
 public:
   static InstARM32Dmb *create(Cfg *Func) {
     return new (Func->allocate<InstARM32Dmb>()) InstARM32Dmb(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 isClassof(Inst, Dmb); }
+  static bool classof(const Inst *Instr) { return isClassof(Instr, Dmb); }
 
 private:
   explicit InstARM32Dmb(Cfg *Func);
 };
 
 // Declare partial template specializations of emit() methods that already have
 // default implementations. Without this, there is the possibility of ODR
 // violations and link errors.
 
 template <> void InstARM32Ldr::emit(const Cfg *Func) const;
 template <> void InstARM32Movw::emit(const Cfg *Func) const;
 template <> void InstARM32Movt::emit(const Cfg *Func) const;
 
 } // end of namespace ARM32
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTARM32_H