remove this == null

src/hydrogen-load-elimination.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/hydrogen-alias-analysis.h"
 #include "src/hydrogen-load-elimination.h"
 #include "src/hydrogen-instructions.h"
 #include "src/hydrogen-flow-engine.h"
 
 namespace v8 {
 namespace internal {
 
 #define GLOBAL true
 #define TRACE(x) if (FLAG_trace_load_elimination) PrintF x
 
 static const int kMaxTrackedFields = 16;
 static const int kMaxTrackedObjects = 5;
 
 // An element in the field approximation list.
 class HFieldApproximation : public ZoneObject {
  public:  // Just a data blob.
   HValue* object_;
   HValue* last_value_;
   HFieldApproximation* next_;
 
   // Recursively copy the entire linked list of field approximations.
   HFieldApproximation* Copy(Zone* zone) {
-    if (this == NULL) return NULL;
     HFieldApproximation* copy = new(zone) HFieldApproximation();
     copy->object_ = this->object_;
     copy->last_value_ = this->last_value_;
-    copy->next_ = this->next_->Copy(zone);
+    copy->next_ = this->next_ == NULL ? NULL : this->next_->Copy(zone);
     return copy;
   }
 };
 
 
 // The main datastructure used during load/store elimination. Each in-object
 // field is tracked separately. For each field, store a list of known field
 // values for known objects.
 class HLoadEliminationTable : public ZoneObject {
  public:
@@ skipping 98 matching lines @@
   }
 
  private:
   // Copy state to successor block.
   HLoadEliminationTable* Copy(HBasicBlock* succ, HBasicBlock* from_block,
                               Zone* zone) {
     HLoadEliminationTable* copy =
         new(zone) HLoadEliminationTable(zone, aliasing_);
     copy->EnsureFields(fields_.length());
     for (int i = 0; i < fields_.length(); i++) {
-      copy->fields_[i] = fields_[i]->Copy(zone);
+      copy->fields_[i] = fields_[i] == NULL ? NULL : fields_[i]->Copy(zone);
     }
     if (FLAG_trace_load_elimination) {
       TRACE((" copy-to B%d\n", succ->block_id()));
       copy->Print();
     }
     return copy;
   }
 
   // Merge this state with the other incoming state.
   HLoadEliminationTable* Merge(HBasicBlock* succ, HLoadEliminationTable* that,
@@ skipping 341 matching lines @@
   } else {
     // Perform only local analysis.
     for (int i = 0; i < graph()->blocks()->length(); i++) {
       table->Kill();
       engine.AnalyzeOneBlock(graph()->blocks()->at(i), table);
     }
   }
 }
 
 } }  // namespace v8::internal