Subzero. Performance tweaks.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- 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 Operand class and its target-independent subclasses.
 ///
 /// The main classes are Variable, which represents an LLVM variable that is
 /// either register- or stack-allocated, and the Constant hierarchy, which
 /// represents integer, floating-point, and/or symbolic constants.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEOPERAND_H
 #define SUBZERO_SRC_ICEOPERAND_H
 
+#include "IceDefs.h"
 #include "IceCfg.h"
-#include "IceDefs.h"
 #include "IceGlobalContext.h"
 #include "IceTypes.h"
 
 #include "llvm/Support/Format.h"
 
 #include <limits>
 
 namespace Ice {
 
 class Operand {
@@ skipping 260 matching lines @@
 };
 
 /// RelocatableTuple bundles the parameters that are used to construct an
 /// ConstantRelocatable. It is done this way so that ConstantRelocatable can fit
 /// into the global constant pool template mechanism.
 class RelocatableTuple {
   RelocatableTuple() = delete;
   RelocatableTuple &operator=(const RelocatableTuple &) = delete;
 
 public:
-  RelocatableTuple(const RelocOffsetArray &OffsetExpr, const IceString &Name,
+  RelocatableTuple(const RelocOffsetT Offset,
+                   const RelocOffsetArray &OffsetExpr, const IceString &Name,
                    bool SuppressMangling)
-      : OffsetExpr(OffsetExpr), Name(Name), SuppressMangling(SuppressMangling) {
-  }
+      : Offset(Offset), OffsetExpr(OffsetExpr), Name(Name),
+        SuppressMangling(SuppressMangling) {}
 
-  RelocatableTuple(const RelocOffsetArray &OffsetExpr, const IceString &Name,
+  RelocatableTuple(const RelocOffsetT Offset,
+                   const RelocOffsetArray &OffsetExpr, const IceString &Name,
                    const IceString &EmitString, bool SuppressMangling)
-      : OffsetExpr(OffsetExpr), Name(Name), EmitString(EmitString),
-        SuppressMangling(SuppressMangling) {}
+      : Offset(Offset), OffsetExpr(OffsetExpr), Name(Name),
+        EmitString(EmitString), SuppressMangling(SuppressMangling) {}
 
   RelocatableTuple(const RelocatableTuple &) = default;
 
+  const RelocOffsetT Offset;
   const RelocOffsetArray OffsetExpr;
   const IceString Name;
   const IceString EmitString;
   const bool SuppressMangling;
 };
 
 bool operator==(const RelocatableTuple &A, const RelocatableTuple &B);
 
 /// ConstantRelocatable represents a symbolic constant combined with a fixed
 /// offset.
 class ConstantRelocatable : public Constant {
   ConstantRelocatable() = delete;
   ConstantRelocatable(const ConstantRelocatable &) = delete;
   ConstantRelocatable &operator=(const ConstantRelocatable &) = delete;
 
 public:
   static ConstantRelocatable *create(GlobalContext *Ctx, Type Ty,
                                      const RelocatableTuple &Tuple) {
     return new (Ctx->allocate<ConstantRelocatable>())
-        ConstantRelocatable(Ty, Tuple.OffsetExpr, Tuple.Name, Tuple.EmitString,
-                            Tuple.SuppressMangling);
+        ConstantRelocatable(Ty, Tuple.Offset, Tuple.OffsetExpr, Tuple.Name,
+                            Tuple.EmitString, Tuple.SuppressMangling);
   }
 
   RelocOffsetT getOffset() const {
-    RelocOffsetT Offset = 0;
+    RelocOffsetT Ret = Offset;
     for (const auto *const OffsetReloc : OffsetExpr) {
-      Offset += OffsetReloc->getOffset();
+      Ret += OffsetReloc->getOffset();
     }
-    return Offset;
+    return Ret;
   }
 
   const IceString &getEmitString() const { return EmitString; }
 
   const IceString &getName() const { return Name; }
   bool getSuppressMangling() const { return SuppressMangling; }
   using Constant::emit;
   void emit(TargetLowering *Target) const final;
   void emitWithoutPrefix(const TargetLowering *Target,
                          const char *Suffix = "") const;
   using Constant::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind == kConstRelocatable;
   }
 
 private:
-  ConstantRelocatable(Type Ty, const RelocOffsetArray &OffsetExpr,
-                      const IceString &Name, const IceString &EmitString,
-                      bool SuppressMangling)
-      : Constant(kConstRelocatable, Ty), OffsetExpr(OffsetExpr), Name(Name),
-        EmitString(EmitString), SuppressMangling(SuppressMangling) {}
+  ConstantRelocatable(Type Ty, const RelocOffsetT Offset,
+                      const RelocOffsetArray &OffsetExpr, const IceString &Name,
+                      const IceString &EmitString, bool SuppressMangling)
+      : Constant(kConstRelocatable, Ty), Offset(Offset), OffsetExpr(OffsetExpr),
+        Name(Name), EmitString(EmitString), SuppressMangling(SuppressMangling) {
+  }
 
-  const RelocOffsetArray OffsetExpr; /// fixed offset to add
+  const RelocOffsetT Offset;         /// fixed, known offset to add
+  const RelocOffsetArray OffsetExpr; /// fixed, unknown offset to add
   const IceString Name;              /// optional for debug/dump
   const IceString EmitString;        /// optional for textual emission
   const bool SuppressMangling;
 };
 
 /// ConstantUndef represents an unspecified bit pattern. Although it is legal to
 /// lower ConstantUndef to any value, backends should try to make code
 /// generation deterministic by lowering ConstantUndefs to 0.
 class ConstantUndef : public Constant {
   ConstantUndef() = delete;
@@ skipping 75 matching lines @@
     assert(Value == NoRegisterValue || Value < Limit);
   }
   /// Disallow operators that inappropriately make assumptions about register
   /// enum value ordering.
   bool operator<(const RegNumT &) = delete;
   bool operator<=(const RegNumT &) = delete;
   bool operator>(const RegNumT &) = delete;
   bool operator>=(const RegNumT &) = delete;
 };
 
-/// RegNumBVIter wraps llvm::SmallBitVector so that instead of this pattern:
+/// RegNumBVIter wraps SmallBitVector so that instead of this pattern:
 ///
 ///   for (int i = V.find_first(); i != -1; i = V.find_next(i)) {
 ///     RegNumT RegNum = RegNumT::fromInt(i);
 ///     ...
 ///   }
 ///
 /// this cleaner pattern can be used:
 ///
 ///   for (RegNumT RegNum : RegNumBVIter(V)) {
 ///     ...
 ///   }
-class RegNumBVIter {
-  using T = llvm::SmallBitVector;
+template <class B> class RegNumBVIterImpl {
+  using T = B;
   static constexpr int Sentinel = -1;
-  RegNumBVIter() = delete;
-  RegNumBVIter(const RegNumBVIter &) = delete;
-  RegNumBVIter &operator=(const RegNumBVIter &) = delete;
+  RegNumBVIterImpl() = delete;
 
 public:
   class Iterator {
     Iterator() = delete;
     Iterator &operator=(const Iterator &) = delete;
 
   public:
     explicit Iterator(const T &V) : V(V), Current(V.find_first()) {}
     Iterator(const T &V, int Value) : V(V), Current(Value) {}
     Iterator(const Iterator &) = default;
     RegNumT operator*() {
       assert(Current != Sentinel);
       return RegNumT::fromInt(Current);
     }
     Iterator &operator++() {
       assert(Current != Sentinel);
       Current = V.find_next(Current);
       return *this;
     }
     bool operator!=(Iterator &Other) { return Current != Other.Current; }
 
   private:
     const T &V;
     int Current;
   };
 
-  explicit RegNumBVIter(const T &V) : V(V) {}
+  RegNumBVIterImpl(const RegNumBVIterImpl &) = default;
+  RegNumBVIterImpl &operator=(const RegNumBVIterImpl &) = delete;
+  explicit RegNumBVIterImpl(const T &V) : V(V) {}
   Iterator begin() { return Iterator(V); }
   Iterator end() { return Iterator(V, Sentinel); }
 
 private:
   const T &V;
 };
 
+template <class B> RegNumBVIterImpl<B> RegNumBVIter(const B &BV) {
+  return RegNumBVIterImpl<B>(BV);
+}
+
 /// RegWeight is a wrapper for a uint32_t weight value, with a special value
 /// that represents infinite weight, and an addWeight() method that ensures that
 /// W+infinity=infinity.
 class RegWeight {
 public:
   using BaseType = uint32_t;
   RegWeight() = default;
   explicit RegWeight(BaseType Weight) : Weight(Weight) {}
   RegWeight(const RegWeight &) = default;
   RegWeight &operator=(const RegWeight &) = default;
@@ skipping 396 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H