Subzero: Simplify the FakeKill instruction.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Operand class and its target-independent
@@ skipping 291 matching lines @@
 bool operator<=(const RegWeight &A, const RegWeight &B);
 bool operator==(const RegWeight &A, const RegWeight &B);
 
 // LiveRange is a set of instruction number intervals representing
 // a variable's live range.  Generally there is one interval per basic
 // block where the variable is live, but adjacent intervals get
 // coalesced into a single interval.  LiveRange also includes a
 // weight, in case e.g. we want a live range to have higher weight
 // inside a loop.
 class LiveRange {
-  // LiveRange(const LiveRange &) = delete;
-  // LiveRange &operator=(const LiveRange &) = delete;
-
 public:
-  LiveRange() : Weight(0), IsNonpoints(false) {}
+  LiveRange() : Weight(0) {}
+  LiveRange(const LiveRange &) = default;
+  LiveRange &operator=(const LiveRange &) = default;
 
   void reset() {
     Range.clear();
     Weight.setWeight(0);
     untrim();
-    IsNonpoints = false;
   }
   void addSegment(InstNumberT Start, InstNumberT End);
 
   bool endsBefore(const LiveRange &Other) const;
   bool overlaps(const LiveRange &Other, bool UseTrimmed = false) const;
   bool overlapsInst(InstNumberT OtherBegin, bool UseTrimmed = false) const;
   bool containsValue(InstNumberT Value, bool IsDest) const;
   bool isEmpty() const { return Range.empty(); }
-  bool isNonpoints() const { return IsNonpoints; }
   InstNumberT getStart() const {
     return Range.empty() ? -1 : Range.begin()->first;
   }
 
   void untrim() { TrimmedBegin = Range.begin(); }
   void trim(InstNumberT Lower);
 
   RegWeight getWeight() const { return Weight; }
   void setWeight(const RegWeight &NewWeight) { Weight = NewWeight; }
   void addWeight(uint32_t Delta) { Weight.addWeight(Delta); }
@@ skipping 16 matching lines @@
   RegWeight Weight;
   // TrimmedBegin is an optimization for the overlaps() computation.
   // Since the linear-scan algorithm always calls it as overlaps(Cur)
   // and Cur advances monotonically according to live range start, we
   // can optimize overlaps() by ignoring all segments that end before
   // the start of Cur's range.  The linear-scan code enables this by
   // calling trim() on the ranges of interest as Cur advances.  Note
   // that linear-scan also has to initialize TrimmedBegin at the
   // beginning by calling untrim().
   RangeType::const_iterator TrimmedBegin;
-  // IsNonpoints keeps track of whether the live range contains at
-  // least one interval where Start!=End.  If it is empty or has the
-  // form [x,x),[y,y),...,[z,z), then overlaps(InstNumberT) is
-  // trivially false.
-  bool IsNonpoints;
 };
 
 Ostream &operator<<(Ostream &Str, const LiveRange &L);
 
 // Variable represents an operand that is register-allocated or
 // stack-allocated.  If it is register-allocated, it will ultimately
 // have a non-negative RegNum field.
 class Variable : public Operand {
   Variable(const Variable &) = delete;
   Variable &operator=(const Variable &) = delete;
@@ skipping 245 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H