Improve dead code elimination by transitively marking live code and removing all dead code. Replace…

src/hydrogen-instructions.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 792 matching lines @@
     // HGraph::ComputeSafeUint32Operations is responsible for setting this
     // flag.
     kUint32,
     // If a phi is involved in the evaluation of a numeric constraint the
     // recursion can cause an endless cycle: we use this flag to exit the loop.
     kNumericConstraintEvaluationInProgress,
     // This flag is set to true after the SetupInformativeDefinitions() pass
     // has processed this instruction.
     kIDefsProcessingDone,
     kHasNoObservableSideEffects,
+    // used during dead code elimination to indicate the instruction is live

[Jakob Kummerow, 2013/05/08 12:07:24]

nit: Our style guide demands that comments be proper sentences, beginning with a
capital letter and ending with appropriate punctuation.
This remark applies to most comments introduced in this CL.

[titzer, 2013/05/13 13:29:38]

Done.

+    kIsNotDead,

[Sven Panne, 2013/05/07 13:32:10]

I don't like negated things, especially when the uses are negated, too.
Something like kAlive or kReachable (choose some positive formulation) is
better.

http://www.refactoring.com/catalog/removeDoubleNegative.html

[titzer, 2013/05/13 13:29:38]

Done.

     kLastFlag = kIDefsProcessingDone
   };
 
   STATIC_ASSERT(kLastFlag < kBitsPerInt);
 
   static const int kChangesToDependsFlagsLeftShift = 1;
 
   static GVNFlag ChangesFlagFromInt(int x) {
     return static_cast<GVNFlag>(x * 2);
   }
@@ skipping 242 matching lines @@
 
   virtual HType CalculateInferredType();
 
   // This function must be overridden for instructions which have the
   // kTrackSideEffectDominators flag set, to track instructions that are
   // dominating side effects.
   virtual void SetSideEffectDominator(GVNFlag side_effect, HValue* dominator) {
     UNREACHABLE();
   }
 
   bool IsDead() const {

[Jakob Kummerow, 2013/05/08 12:07:24]

I think this can be removed. It only had two call sites AFAICS, and both are
deleted in this CL.

[titzer, 2013/05/13 13:29:38]

Done.

     return HasNoUses() && !HasObservableSideEffects() && IsDeletable();
   }
 
+  // has side effects or otherwise cannot be dead code eliminated
+  bool IsNotDeletable() const {
+    return HasObservableSideEffects() || !IsDeletable();

[Sven Panne, 2013/05/07 13:32:10]

Hmmm, do we really need IsDead *and* IsNotDeletable? !IsNotDeletable is a part
of IsDead, BTW. Again, negated things are not nice, see above.

[titzer, 2013/05/13 13:29:38]

Done.

+  }
+
 #ifdef DEBUG
   virtual void Verify() = 0;
 #endif
 
   bool IsRelationTrue(NumericRelation relation,
                       HValue* other,
                       int offset = 0,
                       int scale = 0);
 
   bool TryGuaranteeRange(HValue* upper_bound);
@@ skipping 1869 matching lines @@
   virtual bool DataEquals(HValue* other) { return true; }
 };
 
 
 class HPhi: public HValue {
  public:
   HPhi(int merged_index, Zone* zone)
       : inputs_(2, zone),
         merged_index_(merged_index),
         phi_id_(-1),
-        is_live_(false),
         is_convertible_to_integer_(true) {
     for (int i = 0; i < Representation::kNumRepresentations; i++) {
       non_phi_uses_[i] = 0;
       indirect_uses_[i] = 0;
     }
     ASSERT(merged_index >= 0);
     SetFlag(kFlexibleRepresentation);
   }
 
   virtual Representation RepresentationFromInputs();
@@ skipping 39 matching lines @@
   int tagged_indirect_uses() const {
     return indirect_uses_[Representation::kTagged];
   }
   int int32_indirect_uses() const {
     return indirect_uses_[Representation::kInteger32];
   }
   int double_indirect_uses() const {
     return indirect_uses_[Representation::kDouble];
   }
   int phi_id() { return phi_id_; }
-  bool is_live() { return is_live_; }
-  void set_is_live(bool b) { is_live_ = b; }
 
   static HPhi* cast(HValue* value) {
     ASSERT(value->IsPhi());
     return reinterpret_cast<HPhi*>(value);
   }
   virtual Opcode opcode() const { return HValue::kPhi; }
 
   virtual bool IsConvertibleToInteger() const {
     return is_convertible_to_integer_;
   }
@@ skipping 29 matching lines @@
                                       int offset = 0,
                                       int scale = 0);
 
  private:
   ZoneList<HValue*> inputs_;
   int merged_index_;
 
   int non_phi_uses_[Representation::kNumRepresentations];
   int indirect_uses_[Representation::kNumRepresentations];
   int phi_id_;
-  bool is_live_;
   bool is_convertible_to_integer_;
 };
 
 
 class HInductionVariableAnnotation : public HUnaryOperation {
  public:
   static HInductionVariableAnnotation* AddToGraph(HPhi* phi,
                                                   NumericRelation relation,
                                                   int operand_index);
 
@@ skipping 3432 matching lines @@
   virtual bool IsDeletable() const { return true; }
 };
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_