Subzero. Performance tweaks.

src/IceTargetLowering.h

 //===- subzero/src/IceTargetLowering.h - Lowering interface -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Declares the TargetLowering, LoweringContext, and TargetDataLowering
 /// classes.
 ///
 /// TargetLowering is an abstract class used to drive the translation/lowering
 /// process. LoweringContext maintains a context for lowering each instruction,
 /// offering conveniences such as iterating over non-deleted instructions.
 /// TargetDataLowering is an abstract class used to drive the lowering/emission
 /// of global initializers, external global declarations, and internal constant
 /// pools.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICETARGETLOWERING_H
 #define SUBZERO_SRC_ICETARGETLOWERING_H
 
+#include "IceDefs.h"
+#include "IceBitVector.h"
 #include "IceCfgNode.h"
-#include "IceDefs.h"
 #include "IceInst.h" // for the names of the Inst subtypes
 #include "IceOperand.h"
 #include "IceTypes.h"
 
 #include <utility>
 
 namespace Ice {
 
 // UnimplementedError is defined as a macro so that we can get actual line
 // numbers.
@@ skipping 228 matching lines @@
   enum RegSet {
     RegSet_None = 0,
     RegSet_CallerSave = 1 << 0,
     RegSet_CalleeSave = 1 << 1,
     RegSet_StackPointer = 1 << 2,
     RegSet_FramePointer = 1 << 3,
     RegSet_All = ~RegSet_None
   };
   using RegSetMask = uint32_t;
 
-  virtual llvm::SmallBitVector getRegisterSet(RegSetMask Include,
-                                              RegSetMask Exclude) const = 0;
+  virtual SmallBitVector getRegisterSet(RegSetMask Include,
+                                        RegSetMask Exclude) const = 0;
   /// Get the set of physical registers available for the specified Variable's
   /// register class, applying register restrictions from the command line.
-  virtual const llvm::SmallBitVector &
+  virtual const SmallBitVector &
   getRegistersForVariable(const Variable *Var) const = 0;
   /// Get the set of *all* physical registers available for the specified
   /// Variable's register class, *not* applying register restrictions from the
   /// command line.
-  virtual const llvm::SmallBitVector &
+  virtual const SmallBitVector &
   getAllRegistersForVariable(const Variable *Var) const = 0;
-  virtual const llvm::SmallBitVector &getAliasesForRegister(RegNumT) const = 0;
+  virtual const SmallBitVector &getAliasesForRegister(RegNumT) const = 0;
 
   void regAlloc(RegAllocKind Kind);
 
   virtual void
   makeRandomRegisterPermutation(llvm::SmallVectorImpl<RegNumT> &Permutation,
-                                const llvm::SmallBitVector &ExcludeRegisters,
+                                const SmallBitVector &ExcludeRegisters,
                                 uint64_t Salt) const = 0;
 
   /// Get the minimum number of clusters required for a jump table to be
   /// considered.
   virtual SizeT getMinJumpTableSize() const = 0;
   virtual void emitJumpTable(const Cfg *Func,
                              const InstJumpTable *JumpTable) const = 0;
 
   virtual void emitVariable(const Variable *Var) const = 0;
 
@@ skipping 54 matching lines @@
 
   private:
     TargetLowering *const Target;
     const bool NeedSandboxing;
   };
 
   explicit TargetLowering(Cfg *Func);
   // Applies command line filters to TypeToRegisterSet array.
   static void
   filterTypeToRegisterSet(GlobalContext *Ctx, int32_t NumRegs,
-                          llvm::SmallBitVector TypeToRegisterSet[],
+                          SmallBitVector TypeToRegisterSet[],
                           size_t TypeToRegisterSetSize,
                           std::function<IceString(RegNumT)> getRegName,
                           std::function<IceString(RegClass)> getRegClassName);
   virtual void lowerAlloca(const InstAlloca *Instr) = 0;
   virtual void lowerArithmetic(const InstArithmetic *Instr) = 0;
   virtual void lowerAssign(const InstAssign *Instr) = 0;
   virtual void lowerBr(const InstBr *Instr) = 0;
   virtual void lowerCall(const InstCall *Instr) = 0;
   virtual void lowerCast(const InstCast *Instr) = 0;
   virtual void lowerFcmp(const InstFcmp *Instr) = 0;
@@ skipping 43 matching lines @@
   /// global vs local (otherwise the variable is conservatively global). The
   /// in-args should be initialized to 0.
   ///
   /// This is only a pre-pass and the actual stack slot assignment is handled
   /// separately.
   ///
   /// There may be target-specific Variable types, which will be handled by
   /// TargetVarHook. If the TargetVarHook returns true, then the variable is
   /// skipped and not considered with the rest of the spilled variables.
   void getVarStackSlotParams(VarList &SortedSpilledVariables,
-                             llvm::SmallBitVector &RegsUsed,
-                             size_t *GlobalsSize, size_t *SpillAreaSizeBytes,
+                             SmallBitVector &RegsUsed, size_t *GlobalsSize,
+                             size_t *SpillAreaSizeBytes,
                              uint32_t *SpillAreaAlignmentBytes,
                              uint32_t *LocalsSlotsAlignmentBytes,
                              std::function<bool(Variable *)> TargetVarHook);
 
   /// Calculate the amount of padding needed to align the local and global areas
   /// to the required alignment. This assumes the globals/locals layout used by
   /// getVarStackSlotParams and assignVarStackSlots.
   void alignStackSpillAreas(uint32_t SpillAreaStartOffset,
                             uint32_t SpillAreaAlignmentBytes,
                             size_t GlobalsSize,
@@ skipping 210 matching lines @@
   virtual void lower() {}
 
 protected:
   explicit TargetHeaderLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
   GlobalContext *Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERING_H