Short Circuit Evaluation

src/IceInst.h

 //===- subzero/src/IceInst.h - High-level 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 85 matching lines @@
   void setDead(bool Value = true) { Dead = Value; }
   void deleteIfDead();
 
   bool hasSideEffects() const { return HasSideEffects; }
 
   bool isDestRedefined() const { return IsDestRedefined; }
   void setDestRedefined() { IsDestRedefined = true; }
 
   Variable *getDest() const { return Dest; }
 
-  SizeT getSrcSize() const { return NumSrcs; }
+  SizeT getSrcSize() const { return Srcs.size(); }
   Operand *getSrc(SizeT I) const {
     assert(I < getSrcSize());
     return Srcs[I];
   }
   void replaceSource(SizeT Index, Operand *Replacement) {
-    assert(Index < NumSrcs);
+    assert(Index < getSrcSize());
     assert(!isDeleted());
     assert(LiveRangesEnded == 0);
     // Invalidates liveness info because the use Srcs[Index] is removed.
     Srcs[Index] = Replacement;
   }
 
   bool isLastUse(const Operand *Src) const;
   void spliceLivenessInfo(Inst *OrigInst, Inst *SpliceAssn);
 
   /// Returns a list of out-edges corresponding to a terminator instruction,
@@ skipping 59 matching lines @@
   void dumpSources(const Cfg *Func) const;
   void dumpDest(const Cfg *Func) const;
   virtual bool isRedundantAssign() const { return false; }
 
   virtual ~Inst() = default;
 
 protected:
   Inst(Cfg *Func, InstKind Kind, SizeT MaxSrcs, Variable *Dest);
   void addSource(Operand *Src) {
     assert(Src);
-    assert(NumSrcs < MaxSrcs);
-    Srcs[NumSrcs++] = Src;
+    Srcs.push_back(Src);
   }
   void setLastUse(SizeT VarIndex) {
     if (VarIndex < CHAR_BIT * sizeof(LiveRangesEnded))
       LiveRangesEnded |= (((LREndedBits)1u) << VarIndex);
   }
   void resetLastUses() { LiveRangesEnded = 0; }
   /// The destroy() method lets the instruction cleanly release any memory that
   /// was allocated via the Cfg's allocator.
-  virtual void destroy(Cfg *Func) { Func->deallocateArrayOf<Operand *>(Srcs); }
+  virtual void destroy(Cfg *) {}
 
   const InstKind Kind;
   /// Number is the instruction number for describing live ranges.
   InstNumberT Number;
   /// Deleted means irrevocably deleted.
   bool Deleted = false;
   /// Dead means one of two things depending on context: (1) pending deletion
   /// after liveness analysis converges, or (2) marked for deletion during
   /// lowering due to a folded bool operation.
   bool Dead = false;
   /// HasSideEffects means the instruction is something like a function call or
   /// a volatile load that can't be removed even if its Dest variable is not
   /// live.
   bool HasSideEffects = false;
   /// IsDestRedefined indicates that this instruction is not the first
   /// definition of Dest in the basic block.  The effect is that liveness
   /// analysis shouldn't consider this instruction to be the start of Dest's
   /// live range; rather, there is some other instruction earlier in the basic
   /// block with the same Dest.  This is maintained because liveness analysis
   /// has an invariant (primarily for performance reasons) that any Variable's
   /// live range recorded in a basic block has at most one start and at most one
   /// end.
   bool IsDestRedefined = false;
 
   Variable *Dest;
   const SizeT MaxSrcs; // only used for assert
-  SizeT NumSrcs = 0;
-  Operand **Srcs;
+
+  CfgVector<Operand *> Srcs;
 
   /// LiveRangesEnded marks which Variables' live ranges end in this
   /// instruction. An instruction can have an arbitrary number of source
   /// operands (e.g. a call instruction), and each source operand can contain 0
   /// or 1 Variable (and target-specific operands could contain more than 1
   /// Variable). All the variables in an instruction are conceptually flattened
   /// and each variable is mapped to one bit position of the LiveRangesEnded bit
   /// vector. Only the first CHAR_BIT * sizeof(LREndedBits) variables are
   /// tracked this way.
   using LREndedBits = uint32_t; // only first 32 src operands tracked, sorry
@@ skipping 418 matching lines @@
   void setLabel(SizeT Index, CfgNode *Label) { Labels[Index] = Label; }
   void livenessPhiOperand(LivenessBV &Live, CfgNode *Target,
                           Liveness *Liveness);
   Inst *lower(Cfg *Func);
   bool isMemoryWrite() const override { return false; }
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Instr) { return Instr->getKind() == Phi; }
 
 private:
   InstPhi(Cfg *Func, SizeT MaxSrcs, Variable *Dest);
-  void destroy(Cfg *Func) override {
-    Func->deallocateArrayOf<CfgNode *>(Labels);
-    Inst::destroy(Func);
-  }
+  void destroy(Cfg *Func) override { Inst::destroy(Func); }
 
   /// Labels[] duplicates the InEdges[] information in the enclosing CfgNode,
   /// but the Phi instruction is created before InEdges[] is available, so it's
   /// more complicated to share the list.
-  CfgNode **Labels;
+  CfgVector<CfgNode *> Labels;
 };
 
 /// Ret instruction. The return value is captured in getSrc(0), but if there is
 /// no return value (void-type function), then getSrcSize()==0 and
 /// hasRetValue()==false.
 class InstRet : public InstHighLevel {
   InstRet() = delete;
   InstRet(const InstRet &) = delete;
   InstRet &operator=(const InstRet &) = delete;
 
@@ skipping 462 matching lines @@
 
 inline Inst *iteratorToInst(InstList::iterator Iter) { return &*Iter; }
 
 inline const Inst *iteratorToInst(InstList::const_iterator Iter) {
   return &*Iter;
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINST_H