Subzero. Performance tweaks.

src/IceOperand.cpp

 //===- subzero/src/IceOperand.cpp - High-level operand implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Implements the Operand class and its target-independent subclasses,
 /// primarily for the methods of the Variable class.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceOperand.h"
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceInst.h"
 #include "IceInstVarIter.h"
+#include "IceMemory.h"
 #include "IceTargetLowering.h" // dumping stack/frame pointer register
 
 namespace Ice {
 
 bool operator==(const RelocatableTuple &A, const RelocatableTuple &B) {
   // A and B are the same if:
   //   (1) they have the same name; and
   //   (2) they have the same offset.
   //
   // (1) is trivial to check, but (2) requires some care.
   //
   // For (2):
   //  if A and B have known offsets (i.e., no symbolic references), then
   //     A == B -> A.Offset == B.Offset.
   //  else each element i in A.OffsetExpr[i] must be the same (or have the same
   //    value) as B.OffsetExpr[i].
   if (A.Name != B.Name) {
     return false;
   }
 
   bool BothHaveKnownOffsets = true;
-  RelocOffsetT OffsetA = 0;
-  RelocOffsetT OffsetB = 0;
+  RelocOffsetT OffsetA = A.Offset;
+  RelocOffsetT OffsetB = B.Offset;
   for (SizeT i = 0; i < A.OffsetExpr.size() && BothHaveKnownOffsets; ++i) {
     BothHaveKnownOffsets = A.OffsetExpr[i]->hasOffset();
     if (BothHaveKnownOffsets) {
       OffsetA += A.OffsetExpr[i]->getOffset();
     }
   }
   for (SizeT i = 0; i < B.OffsetExpr.size() && BothHaveKnownOffsets; ++i) {
     BothHaveKnownOffsets = B.OffsetExpr[i]->hasOffset();
     if (BothHaveKnownOffsets) {
       OffsetB += B.OffsetExpr[i]->getOffset();
@@ skipping 135 matching lines @@
   if (Func && NameIndex >= 0)
     return Func->getIdentifierName(NameIndex);
   return "__" + std::to_string(getIndex());
 }
 
 const Variable *Variable::asType(Type Ty, RegNumT NewRegNum) const {
   // Note: This returns a Variable, even if the "this" object is a subclass of
   // Variable.
   if (!BuildDefs::dump() || getType() == Ty)
     return this;
-  Variable *V = new (getCurrentCfgAllocator()->Allocate<Variable>())
+  static constexpr SizeT One = 1;
+  Variable *V = new (CfgLocalAllocator<Variable>().allocate(One))
       Variable(kVariable, Ty, Number);
   V->NameIndex = NameIndex;
   V->RegNum = NewRegNum.hasValue() ? NewRegNum : RegNum;
   V->StackOffset = StackOffset;
   return V;
 }
 
 RegWeight Variable::getWeight(const Cfg *Func) const {
   VariablesMetadata *VMetadata = Func->getVMetadata();
   return mustHaveReg() ? RegWeight(RegWeight::Inf)
@@ skipping 405 matching lines @@
   if (getType() != IceType_i32 && getType() != IceType_i16 &&
       getType() != IceType_i8)
     return false;
   // The Following checks if the signed representation of Value is between
   // -Threshold/2 and +Threshold/2
   bool largerThanThreshold = Threshold / 2 + Value >= Threshold;
   return largerThanThreshold;
 }
 
 } // end of namespace Ice