Subzero. X8664. Fixes filetype=asm.

src/IceTargetLoweringX86Base.h

 //===- subzero/src/IceTargetLoweringX86Base.h - x86 lowering ----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 204 matching lines @@
   /// Copy memory of given type from Src to Dest using OffsetAmt on both.
   void copyMemory(Type Ty, Variable *Dest, Variable *Src, int32_t OffsetAmt);
   /// Replace some calls to memcpy with inline instructions.
   void lowerMemcpy(Operand *Dest, Operand *Src, Operand *Count);
   /// Replace some calls to memmove with inline instructions.
   void lowerMemmove(Operand *Dest, Operand *Src, Operand *Count);
   /// Replace some calls to memset with inline instructions.
   void lowerMemset(Operand *Dest, Operand *Val, Operand *Count);
 
   /// Lower an indirect jump adding sandboxing when needed.
-  void lowerIndirectJump(Variable *Target);
+  void lowerIndirectJump(Variable *JumpTarget);
 
   /// Check the comparison is in [Min,Max]. The flags register will be modified
   /// with:
   ///   - below equal, if in range
   ///   - above, set if not in range
   /// The index into the range is returned.
   Operand *lowerCmpRange(Operand *Comparison, uint64_t Min, uint64_t Max);
   /// Lowering of a cluster of switch cases. If the case is not matched control
   /// will pass to the default label provided. If the default label is nullptr
   /// then control will fall through to the next instruction. DoneCmp should be
   /// true if the flags contain the result of a comparison with the Comparison.
   void lowerCaseCluster(const CaseCluster &Case, Operand *Src0, bool DoneCmp,
                         CfgNode *DefaultLabel = nullptr);
 
   using LowerBinOp = void (TargetX86Base::*)(Variable *, Operand *);
   void expandAtomicRMWAsCmpxchg(LowerBinOp op_lo, LowerBinOp op_hi,
                                 Variable *Dest, Operand *Ptr, Operand *Val);
 
   void eliminateNextVectorSextInstruction(Variable *SignExtendedResult);
 
   void scalarizeArithmetic(InstArithmetic::OpKind K, Variable *Dest,
                            Operand *Src0, Operand *Src1);
 
   /// Emit a fake use of esp to make sure esp stays alive for the entire
   /// function. Otherwise some esp adjustments get dead-code eliminated.
   void keepEspLiveAtExit() {
-    Variable *esp = Func->getTarget()->getPhysicalRegister(getStackReg());
+    Variable *esp =
+        Func->getTarget()->getPhysicalRegister(getStackReg(), Traits::WordType);
     Context.insert<InstFakeUse>(esp);
   }
 
   /// Operand legalization helpers. To deal with address mode constraints, the
   /// helpers will create a new Operand and emit instructions that guarantee
   /// that the Operand kind is one of those indicated by the LegalMask (a
   /// bitmask of allowed kinds). If the input Operand is known to already meet
   /// the constraints, it may be simply returned as the result, without creating
   /// any new instructions or operands.
   enum OperandLegalization {
@@ skipping 548 matching lines @@
   lowerIcmp64(const InstIcmp *Icmp, const Inst *Consumer);
 
   BoolFolding FoldingInfo;
 };
 } // end of namespace X86Internal
 } // end of namespace Ice
 
 #include "IceTargetLoweringX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASE_H