Use C++11 nullptr in Hydrogen to replace static_cast<HValue*>(NULL)

src/hydrogen.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.h"
 
 #include <sstream>
 
 #include "src/v8.h"
 
@@ skipping 1199 matching lines @@
   current_block()->FinishExit(instruction, source_position());
   if (instruction->IsReturn() || instruction->IsAbnormalExit()) {
     set_current_block(NULL);
   }
 }
 
 
 void HGraphBuilder::AddIncrementCounter(StatsCounter* counter) {
   if (FLAG_native_code_counters && counter->Enabled()) {
     HValue* reference = Add<HConstant>(ExternalReference(counter));
-    HValue* old_value = Add<HLoadNamedField>(
-        reference, static_cast<HValue*>(NULL), HObjectAccess::ForCounter());
+    HValue* old_value =
+        Add<HLoadNamedField>(reference, nullptr, HObjectAccess::ForCounter());
     HValue* new_value = AddUncasted<HAdd>(old_value, graph()->GetConstant1());
     new_value->ClearFlag(HValue::kCanOverflow);  // Ignore counter overflow
     Add<HStoreNamedField>(reference, HObjectAccess::ForCounter(),
                           new_value, STORE_TO_INITIALIZED_ENTRY);
   }
 }
 
 
 void HGraphBuilder::AddSimulate(BailoutId id,
                                 RemovableSimulate removable) {
@@ skipping 13 matching lines @@
 HBasicBlock* HGraphBuilder::CreateLoopHeaderBlock() {
   HBasicBlock* header = graph()->CreateBasicBlock();
   HEnvironment* entry_env = environment()->CopyAsLoopHeader(header);
   header->SetInitialEnvironment(entry_env);
   header->AttachLoopInformation();
   return header;
 }
 
 
 HValue* HGraphBuilder::BuildGetElementsKind(HValue* object) {
-  HValue* map = Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
-                                     HObjectAccess::ForMap());
+  HValue* map = Add<HLoadNamedField>(object, nullptr, HObjectAccess::ForMap());
 
-  HValue* bit_field2 = Add<HLoadNamedField>(map, static_cast<HValue*>(NULL),
-                                            HObjectAccess::ForMapBitField2());
+  HValue* bit_field2 =
+      Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapBitField2());
   return BuildDecodeField<Map::ElementsKindBits>(bit_field2);
 }
 
 
 HValue* HGraphBuilder::BuildCheckHeapObject(HValue* obj) {
   if (obj->type().IsHeapObject()) return obj;
   return Add<HCheckHeapObject>(obj);
 }
 
 
@@ skipping 138 matching lines @@
         isolate()->factory()->empty_fixed_array());
 
     IfBuilder if_builder(this);
 
     if_builder.IfNot<HCompareObjectEqAndBranch>(elements, empty_fixed_array);
 
     if_builder.Then();
 
     HInstruction* elements_length = AddLoadFixedArrayLength(elements);
 
-    HInstruction* array_length = is_jsarray
-        ? Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
-                               HObjectAccess::ForArrayLength(from_kind))
-        : elements_length;
+    HInstruction* array_length =
+        is_jsarray
+            ? Add<HLoadNamedField>(object, nullptr,
+                                   HObjectAccess::ForArrayLength(from_kind))
+            : elements_length;
 
     BuildGrowElementsCapacity(object, elements, from_kind, to_kind,
                               array_length, elements_length);
 
     if_builder.End();
   }
 
   Add<HStoreNamedField>(object, HObjectAccess::ForMap(), map);
 }
 
 
 void HGraphBuilder::BuildJSObjectCheck(HValue* receiver,
                                        int bit_field_mask) {
   // Check that the object isn't a smi.
   Add<HCheckHeapObject>(receiver);
 
   // Get the map of the receiver.
-  HValue* map = Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
-                                     HObjectAccess::ForMap());
+  HValue* map =
+      Add<HLoadNamedField>(receiver, nullptr, HObjectAccess::ForMap());
 
   // Check the instance type and if an access check is needed, this can be
   // done with a single load, since both bytes are adjacent in the map.
   HObjectAccess access(HObjectAccess::ForMapInstanceTypeAndBitField());
   HValue* instance_type_and_bit_field =
-      Add<HLoadNamedField>(map, static_cast<HValue*>(NULL), access);
+      Add<HLoadNamedField>(map, nullptr, access);
 
   HValue* mask = Add<HConstant>(0x00FF | (bit_field_mask << 8));
   HValue* and_result = AddUncasted<HBitwise>(Token::BIT_AND,
                                              instance_type_and_bit_field,
                                              mask);
   HValue* sub_result = AddUncasted<HSub>(and_result,
                                          Add<HConstant>(JS_OBJECT_TYPE));
   Add<HBoundsCheck>(sub_result,
                     Add<HConstant>(LAST_JS_OBJECT_TYPE + 1 - JS_OBJECT_TYPE));
 }
 
 
 void HGraphBuilder::BuildKeyedIndexCheck(HValue* key,
                                          HIfContinuation* join_continuation) {
   // The sometimes unintuitively backward ordering of the ifs below is
   // convoluted, but necessary.  All of the paths must guarantee that the
   // if-true of the continuation returns a smi element index and the if-false of
   // the continuation returns either a symbol or a unique string key. All other
   // object types cause a deopt to fall back to the runtime.
 
   IfBuilder key_smi_if(this);
   key_smi_if.If<HIsSmiAndBranch>(key);
   key_smi_if.Then();
   {
     Push(key);  // Nothing to do, just continue to true of continuation.
   }
   key_smi_if.Else();
   {
-    HValue* map = Add<HLoadNamedField>(key, static_cast<HValue*>(NULL),
-                                       HObjectAccess::ForMap());
+    HValue* map = Add<HLoadNamedField>(key, nullptr, HObjectAccess::ForMap());
     HValue* instance_type =
-        Add<HLoadNamedField>(map, static_cast<HValue*>(NULL),
-                             HObjectAccess::ForMapInstanceType());
+        Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapInstanceType());
 
     // Non-unique string, check for a string with a hash code that is actually
     // an index.
     STATIC_ASSERT(LAST_UNIQUE_NAME_TYPE == FIRST_NONSTRING_TYPE);
     IfBuilder not_string_or_name_if(this);
     not_string_or_name_if.If<HCompareNumericAndBranch>(
         instance_type,
         Add<HConstant>(LAST_UNIQUE_NAME_TYPE),
         Token::GT);
 
@@ skipping 11 matching lines @@
       IfBuilder not_symbol_if(this);
       not_symbol_if.If<HCompareNumericAndBranch>(
           instance_type,
           Add<HConstant>(SYMBOL_TYPE),
           Token::NE);
 
       not_symbol_if.Then();
       {
         // String: check whether the String is a String of an index. If it is,
         // extract the index value from the hash.
-        HValue* hash =
-            Add<HLoadNamedField>(key, static_cast<HValue*>(NULL),
-                                 HObjectAccess::ForNameHashField());
+        HValue* hash = Add<HLoadNamedField>(key, nullptr,
+                                            HObjectAccess::ForNameHashField());
         HValue* not_index_mask = Add<HConstant>(static_cast<int>(
             String::kContainsCachedArrayIndexMask));
 
         HValue* not_index_test = AddUncasted<HBitwise>(
             Token::BIT_AND, hash, not_index_mask);
 
         IfBuilder string_index_if(this);
         string_index_if.If<HCompareNumericAndBranch>(not_index_test,
                                                      graph()->GetConstant0(),
                                                      Token::EQ);
@@ skipping 38 matching lines @@
     }
     not_string_or_name_if.JoinContinuation(join_continuation);
   }
   key_smi_if.JoinContinuation(join_continuation);
 }
 
 
 void HGraphBuilder::BuildNonGlobalObjectCheck(HValue* receiver) {
   // Get the the instance type of the receiver, and make sure that it is
   // not one of the global object types.
-  HValue* map = Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
-                                     HObjectAccess::ForMap());
+  HValue* map =
+      Add<HLoadNamedField>(receiver, nullptr, HObjectAccess::ForMap());
   HValue* instance_type =
-    Add<HLoadNamedField>(map, static_cast<HValue*>(NULL),
-                         HObjectAccess::ForMapInstanceType());
+      Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapInstanceType());
   STATIC_ASSERT(JS_BUILTINS_OBJECT_TYPE == JS_GLOBAL_OBJECT_TYPE + 1);
   HValue* min_global_type = Add<HConstant>(JS_GLOBAL_OBJECT_TYPE);
   HValue* max_global_type = Add<HConstant>(JS_BUILTINS_OBJECT_TYPE);
 
   IfBuilder if_global_object(this);
   if_global_object.If<HCompareNumericAndBranch>(instance_type,
                                                 max_global_type,
                                                 Token::LTE);
   if_global_object.And();
   if_global_object.If<HCompareNumericAndBranch>(instance_type,
                                                 min_global_type,
                                                 Token::GTE);
   if_global_object.ThenDeopt("receiver was a global object");
   if_global_object.End();
 }
 
 
 void HGraphBuilder::BuildTestForDictionaryProperties(
     HValue* object,
     HIfContinuation* continuation) {
   HValue* properties = Add<HLoadNamedField>(
-      object, static_cast<HValue*>(NULL),
-      HObjectAccess::ForPropertiesPointer());
+      object, nullptr, HObjectAccess::ForPropertiesPointer());
   HValue* properties_map =
-      Add<HLoadNamedField>(properties, static_cast<HValue*>(NULL),
-                           HObjectAccess::ForMap());
+      Add<HLoadNamedField>(properties, nullptr, HObjectAccess::ForMap());
   HValue* hash_map = Add<HLoadRoot>(Heap::kHashTableMapRootIndex);
   IfBuilder builder(this);
   builder.If<HCompareObjectEqAndBranch>(properties_map, hash_map);
   builder.CaptureContinuation(continuation);
 }
 
 
 HValue* HGraphBuilder::BuildKeyedLookupCacheHash(HValue* object,
                                                  HValue* key) {
   // Load the map of the receiver, compute the keyed lookup cache hash
   // based on 32 bits of the map pointer and the string hash.
   HValue* object_map =
-      Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
-                           HObjectAccess::ForMapAsInteger32());
+      Add<HLoadNamedField>(object, nullptr, HObjectAccess::ForMapAsInteger32());
   HValue* shifted_map = AddUncasted<HShr>(
       object_map, Add<HConstant>(KeyedLookupCache::kMapHashShift));
   HValue* string_hash =
-      Add<HLoadNamedField>(key, static_cast<HValue*>(NULL),
-                           HObjectAccess::ForStringHashField());
+      Add<HLoadNamedField>(key, nullptr, HObjectAccess::ForStringHashField());
   HValue* shifted_hash = AddUncasted<HShr>(
       string_hash, Add<HConstant>(String::kHashShift));
   HValue* xor_result = AddUncasted<HBitwise>(Token::BIT_XOR, shifted_map,
                                              shifted_hash);
   int mask = (KeyedLookupCache::kCapacityMask & KeyedLookupCache::kHashMask);
   return AddUncasted<HBitwise>(Token::BIT_AND, xor_result,
                                Add<HConstant>(mask));
 }
 
 
@@ skipping 27 matching lines @@
   // hash = hash ^ (hash >> 16);
   shifted_hash = AddUncasted<HShr>(hash, Add<HConstant>(16));
   return AddUncasted<HBitwise>(Token::BIT_XOR, hash, shifted_hash);
 }
 
 
 HValue* HGraphBuilder::BuildUncheckedDictionaryElementLoad(HValue* receiver,
                                                            HValue* elements,
                                                            HValue* key,
                                                            HValue* hash) {
-  HValue* capacity = Add<HLoadKeyed>(
-      elements,
-      Add<HConstant>(NameDictionary::kCapacityIndex),
-      static_cast<HValue*>(NULL),
-      FAST_ELEMENTS);
+  HValue* capacity =
+      Add<HLoadKeyed>(elements, Add<HConstant>(NameDictionary::kCapacityIndex),
+                      nullptr, FAST_ELEMENTS);
 
   HValue* mask = AddUncasted<HSub>(capacity, graph()->GetConstant1());
   mask->ChangeRepresentation(Representation::Integer32());
   mask->ClearFlag(HValue::kCanOverflow);
 
   HValue* entry = hash;
   HValue* count = graph()->GetConstant1();
   Push(entry);
   Push(count);
 
   HIfContinuation return_or_loop_continuation(graph()->CreateBasicBlock(),
                                               graph()->CreateBasicBlock());
   HIfContinuation found_key_match_continuation(graph()->CreateBasicBlock(),
                                                graph()->CreateBasicBlock());
   LoopBuilder probe_loop(this);
   probe_loop.BeginBody(2);  // Drop entry, count from last environment to
                             // appease live range building without simulates.
 
   count = Pop();
   entry = Pop();
   entry = AddUncasted<HBitwise>(Token::BIT_AND, entry, mask);
   int entry_size = SeededNumberDictionary::kEntrySize;
   HValue* base_index = AddUncasted<HMul>(entry, Add<HConstant>(entry_size));
   base_index->ClearFlag(HValue::kCanOverflow);
   int start_offset = SeededNumberDictionary::kElementsStartIndex;
   HValue* key_index =
       AddUncasted<HAdd>(base_index, Add<HConstant>(start_offset));
   key_index->ClearFlag(HValue::kCanOverflow);
 
-  HValue* candidate_key = Add<HLoadKeyed>(
-      elements, key_index, static_cast<HValue*>(NULL), FAST_ELEMENTS);
+  HValue* candidate_key =
+      Add<HLoadKeyed>(elements, key_index, nullptr, FAST_ELEMENTS);
   IfBuilder if_undefined(this);
   if_undefined.If<HCompareObjectEqAndBranch>(candidate_key,
                                              graph()->GetConstantUndefined());
   if_undefined.Then();
   {
     // element == undefined means "not found". Call the runtime.
     // TODO(jkummerow): walk the prototype chain instead.
     Add<HPushArguments>(receiver, key);
     Push(Add<HCallRuntime>(isolate()->factory()->empty_string(),
                            Runtime::FunctionForId(Runtime::kKeyedGetProperty),
                            2));
   }
   if_undefined.Else();
   {
     IfBuilder if_match(this);
     if_match.If<HCompareObjectEqAndBranch>(candidate_key, key);
     if_match.Then();
     if_match.Else();
 
     // Update non-internalized string in the dictionary with internalized key?
     IfBuilder if_update_with_internalized(this);
     HValue* smi_check =
         if_update_with_internalized.IfNot<HIsSmiAndBranch>(candidate_key);
     if_update_with_internalized.And();
     HValue* map = AddLoadMap(candidate_key, smi_check);
-    HValue* instance_type = Add<HLoadNamedField>(
-        map, static_cast<HValue*>(NULL), HObjectAccess::ForMapInstanceType());
+    HValue* instance_type =
+        Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapInstanceType());
     HValue* not_internalized_bit = AddUncasted<HBitwise>(
         Token::BIT_AND, instance_type,
         Add<HConstant>(static_cast<int>(kIsNotInternalizedMask)));
     if_update_with_internalized.If<HCompareNumericAndBranch>(
         not_internalized_bit, graph()->GetConstant0(), Token::NE);
     if_update_with_internalized.And();
     if_update_with_internalized.IfNot<HCompareObjectEqAndBranch>(
         candidate_key, graph()->GetConstantHole());
     if_update_with_internalized.AndIf<HStringCompareAndBranch>(candidate_key,
                                                                key, Token::EQ);
     if_update_with_internalized.Then();
     // Replace a key that is a non-internalized string by the equivalent
     // internalized string for faster further lookups.
     Add<HStoreKeyed>(elements, key_index, key, FAST_ELEMENTS);
     if_update_with_internalized.Else();
 
     if_update_with_internalized.JoinContinuation(&found_key_match_continuation);
     if_match.JoinContinuation(&found_key_match_continuation);
 
     IfBuilder found_key_match(this, &found_key_match_continuation);
     found_key_match.Then();
     // Key at current probe matches. Relevant bits in the |details| field must
     // be zero, otherwise the dictionary element requires special handling.
     HValue* details_index =
         AddUncasted<HAdd>(base_index, Add<HConstant>(start_offset + 2));
     details_index->ClearFlag(HValue::kCanOverflow);
-    HValue* details = Add<HLoadKeyed>(
-        elements, details_index, static_cast<HValue*>(NULL), FAST_ELEMENTS);
+    HValue* details =
+        Add<HLoadKeyed>(elements, details_index, nullptr, FAST_ELEMENTS);
     int details_mask = PropertyDetails::TypeField::kMask |
                        PropertyDetails::DeletedField::kMask;
     details = AddUncasted<HBitwise>(Token::BIT_AND, details,
                                     Add<HConstant>(details_mask));
     IfBuilder details_compare(this);
     details_compare.If<HCompareNumericAndBranch>(
         details, graph()->GetConstant0(), Token::EQ);
     details_compare.Then();
     HValue* result_index =
         AddUncasted<HAdd>(base_index, Add<HConstant>(start_offset + 1));
     result_index->ClearFlag(HValue::kCanOverflow);
-    Push(Add<HLoadKeyed>(elements, result_index, static_cast<HValue*>(NULL),
-                         FAST_ELEMENTS));
+    Push(Add<HLoadKeyed>(elements, result_index, nullptr, FAST_ELEMENTS));
     details_compare.Else();
     Add<HPushArguments>(receiver, key);
     Push(Add<HCallRuntime>(isolate()->factory()->empty_string(),
                            Runtime::FunctionForId(Runtime::kKeyedGetProperty),
                            2));
     details_compare.End();
 
     found_key_match.Else();
     found_key_match.JoinContinuation(&return_or_loop_continuation);
   }
@@ skipping 31 matching lines @@
   ElementsKind elements_kind = FAST_ELEMENTS;
   HValue* size = BuildCalculateElementsSize(elements_kind, length);
 
   // Allocate the JSRegExpResult and the FixedArray in one step.
   HValue* result = Add<HAllocate>(
       Add<HConstant>(JSRegExpResult::kSize), HType::JSArray(),
       NOT_TENURED, JS_ARRAY_TYPE);
 
   // Initialize the JSRegExpResult header.
   HValue* global_object = Add<HLoadNamedField>(
-      context(), static_cast<HValue*>(NULL),
+      context(), nullptr,
       HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
   HValue* native_context = Add<HLoadNamedField>(
-      global_object, static_cast<HValue*>(NULL),
-      HObjectAccess::ForGlobalObjectNativeContext());
+      global_object, nullptr, HObjectAccess::ForGlobalObjectNativeContext());
   Add<HStoreNamedField>(
       result, HObjectAccess::ForMap(),
       Add<HLoadNamedField>(
-          native_context, static_cast<HValue*>(NULL),
+          native_context, nullptr,
           HObjectAccess::ForContextSlot(Context::REGEXP_RESULT_MAP_INDEX)));
   HConstant* empty_fixed_array =
       Add<HConstant>(isolate()->factory()->empty_fixed_array());
   Add<HStoreNamedField>(
       result, HObjectAccess::ForJSArrayOffset(JSArray::kPropertiesOffset),
       empty_fixed_array);
   Add<HStoreNamedField>(
       result, HObjectAccess::ForJSArrayOffset(JSArray::kElementsOffset),
       empty_fixed_array);
   Add<HStoreNamedField>(
@@ skipping 58 matching lines @@
   // Check whether object is a smi.
   IfBuilder if_objectissmi(this);
   if_objectissmi.If<HIsSmiAndBranch>(object);
   if_objectissmi.Then();
   {
     // Compute hash for smi similar to smi_get_hash().
     HValue* hash = AddUncasted<HBitwise>(Token::BIT_AND, object, mask);
 
     // Load the key.
     HValue* key_index = AddUncasted<HShl>(hash, graph()->GetConstant1());
-    HValue* key = Add<HLoadKeyed>(number_string_cache, key_index,
-                                  static_cast<HValue*>(NULL),
+    HValue* key = Add<HLoadKeyed>(number_string_cache, key_index, nullptr,
                                   FAST_ELEMENTS, ALLOW_RETURN_HOLE);
 
     // Check if object == key.
     IfBuilder if_objectiskey(this);
     if_objectiskey.If<HCompareObjectEqAndBranch>(object, key);
     if_objectiskey.Then();
     {
       // Make the key_index available.
       Push(key_index);
     }
@@ skipping 15 matching lines @@
             object, objectisnumber,
             HObjectAccess::ForHeapNumberValueLowestBits());
         HValue* high = Add<HLoadNamedField>(
             object, objectisnumber,
             HObjectAccess::ForHeapNumberValueHighestBits());
         HValue* hash = AddUncasted<HBitwise>(Token::BIT_XOR, low, high);
         hash = AddUncasted<HBitwise>(Token::BIT_AND, hash, mask);
 
         // Load the key.
         HValue* key_index = AddUncasted<HShl>(hash, graph()->GetConstant1());
-        HValue* key = Add<HLoadKeyed>(number_string_cache, key_index,
-                                      static_cast<HValue*>(NULL),
+        HValue* key = Add<HLoadKeyed>(number_string_cache, key_index, nullptr,
                                       FAST_ELEMENTS, ALLOW_RETURN_HOLE);
 
         // Check if the key is a heap number and compare it with the object.
         IfBuilder if_keyisnotsmi(this);
         HValue* keyisnotsmi = if_keyisnotsmi.IfNot<HIsSmiAndBranch>(key);
         if_keyisnotsmi.Then();
         {
           IfBuilder if_keyisheapnumber(this);
           if_keyisheapnumber.If<HCompareMap>(
               key, isolate()->factory()->heap_number_map());
@@ skipping 32 matching lines @@
   // Check for cache hit.
   IfBuilder if_found(this, &found);
   if_found.Then();
   {
     // Count number to string operation in native code.
     AddIncrementCounter(isolate()->counters()->number_to_string_native());
 
     // Load the value in case of cache hit.
     HValue* key_index = Pop();
     HValue* value_index = AddUncasted<HAdd>(key_index, graph()->GetConstant1());
-    Push(Add<HLoadKeyed>(number_string_cache, value_index,
-                         static_cast<HValue*>(NULL),
+    Push(Add<HLoadKeyed>(number_string_cache, value_index, nullptr,
                          FAST_ELEMENTS, ALLOW_RETURN_HOLE));
   }
   if_found.Else();
   {
     // Cache miss, fallback to runtime.
     Add<HPushArguments>(object);
     Push(Add<HCallRuntime>(
             isolate()->factory()->empty_string(),
             Runtime::FunctionForId(Runtime::kNumberToStringSkipCache),
             1));
@@ skipping 419 matching lines @@
   } else {
     length = AddLoadFixedArrayLength(elements);
   }
   length->set_type(HType::Smi());
   HValue* checked_key = NULL;
   if (IsExternalArrayElementsKind(elements_kind) ||
       IsFixedTypedArrayElementsKind(elements_kind)) {
     HValue* backing_store;
     if (IsExternalArrayElementsKind(elements_kind)) {
       backing_store = Add<HLoadNamedField>(
-          elements, static_cast<HValue*>(NULL),
-          HObjectAccess::ForExternalArrayExternalPointer());
+          elements, nullptr, HObjectAccess::ForExternalArrayExternalPointer());
     } else {
       backing_store = elements;
     }
     if (store_mode == STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS) {
       NoObservableSideEffectsScope no_effects(this);
       IfBuilder length_checker(this);
       length_checker.If<HCompareNumericAndBranch>(key, length, Token::LT);
       length_checker.Then();
       IfBuilder negative_checker(this);
       HValue* bounds_check = negative_checker.If<HCompareNumericAndBranch>(
@@ skipping 385 matching lines @@
   BuildFillElementsWithValue(to_properties, kind, length, capacity,
                              graph()->GetConstantUndefined());
 
   LoopBuilder builder(this, context(), LoopBuilder::kPostDecrement);
 
   HValue* key = builder.BeginBody(length, graph()->GetConstant0(), Token::GT);
 
   key = AddUncasted<HSub>(key, graph()->GetConstant1());
   key->ClearFlag(HValue::kCanOverflow);
 
-  HValue* element =
-      Add<HLoadKeyed>(from_properties, key, static_cast<HValue*>(NULL), kind);
+  HValue* element = Add<HLoadKeyed>(from_properties, key, nullptr, kind);
 
   Add<HStoreKeyed>(to_properties, key, element, kind);
 
   builder.EndBody();
 }
 
 
 void HGraphBuilder::BuildCopyElements(HValue* from_elements,
                                       ElementsKind from_elements_kind,
                                       HValue* to_elements,
@@ skipping 19 matching lines @@
     // consistent state.
     BuildFillElementsWithHole(to_elements, to_elements_kind,
                               graph()->GetConstant0(), NULL);
   }
 
   if (constant_capacity != -1) {
     // Unroll the loop for small elements kinds.
     for (int i = 0; i < constant_capacity; i++) {
       HValue* key_constant = Add<HConstant>(i);
       HInstruction* value = Add<HLoadKeyed>(from_elements, key_constant,
-                                            static_cast<HValue*>(NULL),
-                                            from_elements_kind);
+                                            nullptr, from_elements_kind);
       Add<HStoreKeyed>(to_elements, key_constant, value, to_elements_kind);
     }
   } else {
     if (!pre_fill_with_holes &&
         (capacity == NULL || !length->Equals(capacity))) {
       BuildFillElementsWithHole(to_elements, to_elements_kind,
                                 length, NULL);
     }
 
     LoopBuilder builder(this, context(), LoopBuilder::kPostDecrement);
 
     HValue* key = builder.BeginBody(length, graph()->GetConstant0(),
                                     Token::GT);
 
     key = AddUncasted<HSub>(key, graph()->GetConstant1());
     key->ClearFlag(HValue::kCanOverflow);
 
-    HValue* element = Add<HLoadKeyed>(from_elements, key,
-                                      static_cast<HValue*>(NULL),
-                                      from_elements_kind,
-                                      ALLOW_RETURN_HOLE);
+    HValue* element = Add<HLoadKeyed>(from_elements, key, nullptr,
+                                      from_elements_kind, ALLOW_RETURN_HOLE);
 
     ElementsKind kind = (IsHoleyElementsKind(from_elements_kind) &&
                          IsFastSmiElementsKind(to_elements_kind))
       ? FAST_HOLEY_ELEMENTS : to_elements_kind;
 
     if (IsHoleyElementsKind(from_elements_kind) &&
         from_elements_kind != to_elements_kind) {
       IfBuilder if_hole(this);
       if_hole.If<HCompareHoleAndBranch>(element);
       if_hole.Then();
@@ skipping 90 matching lines @@
   // The allocation for the cloned array above causes register pressure on
   // machines with low register counts. Force a reload of the boilerplate
   // elements here to free up a register for the allocation to avoid unnecessary
   // spillage.
   boilerplate_elements = AddLoadElements(boilerplate);
   boilerplate_elements->SetFlag(HValue::kCantBeReplaced);
 
   // Copy the elements array header.
   for (int i = 0; i < FixedArrayBase::kHeaderSize; i += kPointerSize) {
     HObjectAccess access = HObjectAccess::ForFixedArrayHeader(i);
-    Add<HStoreNamedField>(elements, access,
-        Add<HLoadNamedField>(boilerplate_elements,
-                             static_cast<HValue*>(NULL), access));
+    Add<HStoreNamedField>(
+        elements, access,
+        Add<HLoadNamedField>(boilerplate_elements, nullptr, access));
   }
 
   // And the result of the length
   HValue* length = AddLoadArrayLength(boilerplate, kind);
   Add<HStoreNamedField>(result, HObjectAccess::ForArrayLength(kind), length);
 
   BuildCopyElements(boilerplate_elements, kind, elements,
                     kind, length, NULL);
   return result;
 }
@@ skipping 58 matching lines @@
   DCHECK(allocation_site != NULL);
   HInnerAllocatedObject* allocation_memento = Add<HInnerAllocatedObject>(
       previous_object, previous_object_size, HType::HeapObject());
   AddStoreMapConstant(
       allocation_memento, isolate()->factory()->allocation_memento_map());
   Add<HStoreNamedField>(
       allocation_memento,
       HObjectAccess::ForAllocationMementoSite(),
       allocation_site);
   if (FLAG_allocation_site_pretenuring) {
-    HValue* memento_create_count = Add<HLoadNamedField>(
-        allocation_site, static_cast<HValue*>(NULL),
-        HObjectAccess::ForAllocationSiteOffset(
-            AllocationSite::kPretenureCreateCountOffset));
+    HValue* memento_create_count =
+        Add<HLoadNamedField>(allocation_site, nullptr,
+                             HObjectAccess::ForAllocationSiteOffset(
+                                 AllocationSite::kPretenureCreateCountOffset));
     memento_create_count = AddUncasted<HAdd>(
         memento_create_count, graph()->GetConstant1());
     // This smi value is reset to zero after every gc, overflow isn't a problem
     // since the counter is bounded by the new space size.
     memento_create_count->ClearFlag(HValue::kCanOverflow);
     Add<HStoreNamedField>(
         allocation_site, HObjectAccess::ForAllocationSiteOffset(
             AllocationSite::kPretenureCreateCountOffset), memento_create_count);
   }
 }
 
 
 HInstruction* HGraphBuilder::BuildGetNativeContext(HValue* closure) {
   // Get the global object, then the native context
-  HInstruction* context =
-      Add<HLoadNamedField>(closure, static_cast<HValue*>(NULL),
-                           HObjectAccess::ForFunctionContextPointer());
+  HInstruction* context = Add<HLoadNamedField>(
+      closure, nullptr, HObjectAccess::ForFunctionContextPointer());
   HInstruction* global_object = Add<HLoadNamedField>(
-      context, static_cast<HValue*>(NULL),
+      context, nullptr,
       HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
   HObjectAccess access = HObjectAccess::ForObservableJSObjectOffset(
       GlobalObject::kNativeContextOffset);
-  return Add<HLoadNamedField>(
-      global_object, static_cast<HValue*>(NULL), access);
+  return Add<HLoadNamedField>(global_object, nullptr, access);
 }
 
 
 HInstruction* HGraphBuilder::BuildGetScriptContext(int context_index) {
   HValue* native_context = BuildGetNativeContext();
   HValue* script_context_table = Add<HLoadNamedField>(
-      native_context, static_cast<HValue*>(NULL),
+      native_context, nullptr,
       HObjectAccess::ForContextSlot(Context::SCRIPT_CONTEXT_TABLE_INDEX));
-  return Add<HLoadNamedField>(script_context_table, static_cast<HValue*>(NULL),
+  return Add<HLoadNamedField>(script_context_table, nullptr,
                               HObjectAccess::ForScriptContext(context_index));
 }
 
 
 HInstruction* HGraphBuilder::BuildGetNativeContext() {
   // Get the global object, then the native context
   HValue* global_object = Add<HLoadNamedField>(
-      context(), static_cast<HValue*>(NULL),
+      context(), nullptr,
       HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
-  return Add<HLoadNamedField>(
-      global_object, static_cast<HValue*>(NULL),
-      HObjectAccess::ForObservableJSObjectOffset(
-          GlobalObject::kNativeContextOffset));
+  return Add<HLoadNamedField>(global_object, nullptr,
+                              HObjectAccess::ForObservableJSObjectOffset(
+                                  GlobalObject::kNativeContextOffset));
 }
 
 
 HInstruction* HGraphBuilder::BuildGetArrayFunction() {
   HInstruction* native_context = BuildGetNativeContext();
   HInstruction* index =
       Add<HConstant>(static_cast<int32_t>(Context::ARRAY_FUNCTION_INDEX));
-  return Add<HLoadKeyed>(
-      native_context, index, static_cast<HValue*>(NULL), FAST_ELEMENTS);
+  return Add<HLoadKeyed>(native_context, index, nullptr, FAST_ELEMENTS);
 }
 
 
 HGraphBuilder::JSArrayBuilder::JSArrayBuilder(HGraphBuilder* builder,
     ElementsKind kind,
     HValue* allocation_site_payload,
     HValue* constructor_function,
     AllocationSiteOverrideMode override_mode) :
         builder_(builder),
         kind_(kind),
@@ skipping 24 matching lines @@
     // A constant map is fine.
     Handle<Map> map(builder()->isolate()->get_initial_js_array_map(kind_),
                     builder()->isolate());
     return builder()->Add<HConstant>(map);
   }
 
   if (constructor_function_ != NULL && kind_ == GetInitialFastElementsKind()) {
     // No need for a context lookup if the kind_ matches the initial
     // map, because we can just load the map in that case.
     HObjectAccess access = HObjectAccess::ForPrototypeOrInitialMap();
-    return builder()->Add<HLoadNamedField>(
-        constructor_function_, static_cast<HValue*>(NULL), access);
+    return builder()->Add<HLoadNamedField>(constructor_function_, nullptr,
+                                           access);
   }
 
   // TODO(mvstanton): we should always have a constructor function if we
   // are creating a stub.
   HInstruction* native_context = constructor_function_ != NULL
       ? builder()->BuildGetNativeContext(constructor_function_)
       : builder()->BuildGetNativeContext();
 
   HInstruction* index = builder()->Add<HConstant>(
       static_cast<int32_t>(Context::JS_ARRAY_MAPS_INDEX));
 
-  HInstruction* map_array = builder()->Add<HLoadKeyed>(
-      native_context, index, static_cast<HValue*>(NULL), FAST_ELEMENTS);
+  HInstruction* map_array =
+      builder()->Add<HLoadKeyed>(native_context, index, nullptr, FAST_ELEMENTS);
 
   HInstruction* kind_index = builder()->Add<HConstant>(kind_);
 
-  return builder()->Add<HLoadKeyed>(
-      map_array, kind_index, static_cast<HValue*>(NULL), FAST_ELEMENTS);
+  return builder()->Add<HLoadKeyed>(map_array, kind_index, nullptr,
+                                    FAST_ELEMENTS);
 }
 
 
 HValue* HGraphBuilder::JSArrayBuilder::EmitInternalMapCode() {
   // Find the map near the constructor function
   HObjectAccess access = HObjectAccess::ForPrototypeOrInitialMap();
-  return builder()->Add<HLoadNamedField>(
-      constructor_function_, static_cast<HValue*>(NULL), access);
+  return builder()->Add<HLoadNamedField>(constructor_function_, nullptr,
+                                         access);
 }
 
 
 HAllocate* HGraphBuilder::JSArrayBuilder::AllocateEmptyArray() {
   HConstant* capacity = builder()->Add<HConstant>(initial_capacity());
   return AllocateArray(capacity,
                        capacity,
                        builder()->graph()->GetConstant0());
 }
 
@@ skipping 78 matching lines @@
     builder()->BuildFillElementsWithHole(elements_location_, kind_,
                                          graph()->GetConstant0(), capacity);
   }
 
   return array_object;
 }
 
 
 HValue* HGraphBuilder::AddLoadJSBuiltin(Builtins::JavaScript builtin) {
   HValue* global_object = Add<HLoadNamedField>(
-      context(), static_cast<HValue*>(NULL),
+      context(), nullptr,
       HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
   HObjectAccess access = HObjectAccess::ForObservableJSObjectOffset(
       GlobalObject::kBuiltinsOffset);
-  HValue* builtins = Add<HLoadNamedField>(
-      global_object, static_cast<HValue*>(NULL), access);
+  HValue* builtins = Add<HLoadNamedField>(global_object, nullptr, access);
   HObjectAccess function_access = HObjectAccess::ForObservableJSObjectOffset(
           JSBuiltinsObject::OffsetOfFunctionWithId(builtin));
-  return Add<HLoadNamedField>(
-      builtins, static_cast<HValue*>(NULL), function_access);
+  return Add<HLoadNamedField>(builtins, nullptr, function_access);
 }
 
 
 HOptimizedGraphBuilder::HOptimizedGraphBuilder(CompilationInfo* info)
     : HGraphBuilder(info),
       function_state_(NULL),
       initial_function_state_(this, info, NORMAL_RETURN, 0),
       ast_context_(NULL),
       break_scope_(NULL),
       inlined_count_(0),
@@ skipping 1226 matching lines @@
       }
       VisitDeclarations(scope->declarations());
       AddSimulate(stmt->DeclsId(), REMOVABLE_SIMULATE);
     }
     CHECK_BAILOUT(VisitStatements(stmt->statements()));
   }
   set_scope(outer_scope);
   if (scope != NULL && current_block() != NULL) {
     HValue* inner_context = environment()->context();
     HValue* outer_context = Add<HLoadNamedField>(
-        inner_context, static_cast<HValue*>(NULL),
+        inner_context, nullptr,
         HObjectAccess::ForContextSlot(Context::PREVIOUS_INDEX));
 
     HInstruction* instr = Add<HStoreFrameContext>(outer_context);
     environment()->BindContext(outer_context);
     if (instr->HasObservableSideEffects()) {
       AddSimulate(stmt->ExitId(), REMOVABLE_SIMULATE);
     }
   }
   HBasicBlock* break_block = break_info.break_block();
   if (break_block != NULL) {
@@ skipping 110 matching lines @@
   int drop_extra = 0;
   HBasicBlock* continue_block = break_scope()->Get(
       stmt->target(), BreakAndContinueScope::CONTINUE,
       &outer_scope, &drop_extra);
   HValue* context = environment()->context();
   Drop(drop_extra);
   int context_pop_count = inner_scope->ContextChainLength(outer_scope);
   if (context_pop_count > 0) {
     while (context_pop_count-- > 0) {
       HInstruction* context_instruction = Add<HLoadNamedField>(
-          context, static_cast<HValue*>(NULL),
+          context, nullptr,
           HObjectAccess::ForContextSlot(Context::PREVIOUS_INDEX));
       context = context_instruction;
     }
     HInstruction* instr = Add<HStoreFrameContext>(context);
     if (instr->HasObservableSideEffects()) {
       AddSimulate(stmt->target()->EntryId(), REMOVABLE_SIMULATE);
     }
     environment()->BindContext(context);
   }
 
@@ skipping 11 matching lines @@
   int drop_extra = 0;
   HBasicBlock* break_block = break_scope()->Get(
       stmt->target(), BreakAndContinueScope::BREAK,
       &outer_scope, &drop_extra);
   HValue* context = environment()->context();
   Drop(drop_extra);
   int context_pop_count = inner_scope->ContextChainLength(outer_scope);
   if (context_pop_count > 0) {
     while (context_pop_count-- > 0) {
       HInstruction* context_instruction = Add<HLoadNamedField>(
-          context, static_cast<HValue*>(NULL),
+          context, nullptr,
           HObjectAccess::ForContextSlot(Context::PREVIOUS_INDEX));
       context = context_instruction;
     }
     HInstruction* instr = Add<HStoreFrameContext>(context);
     if (instr->HasObservableSideEffects()) {
       AddSimulate(stmt->target()->ExitId(), REMOVABLE_SIMULATE);
     }
     environment()->BindContext(context);
   }
   Goto(break_block);
@@ skipping 579 matching lines @@
   return kUseGeneric;
 }
 
 
 HValue* HOptimizedGraphBuilder::BuildContextChainWalk(Variable* var) {
   DCHECK(var->IsContextSlot());
   HValue* context = environment()->context();
   int length = scope()->ContextChainLength(var->scope());
   while (length-- > 0) {
     context = Add<HLoadNamedField>(
-        context, static_cast<HValue*>(NULL),
+        context, nullptr,
         HObjectAccess::ForContextSlot(Context::PREVIOUS_INDEX));
   }
   return context;
 }
 
 
 void HOptimizedGraphBuilder::VisitVariableProxy(VariableProxy* expr) {
   if (expr->is_this()) {
     current_info()->set_this_has_uses(true);
   }
@@ skipping 21 matching lines @@
 
       if (FLAG_harmony_scoping) {
         Handle<ScriptContextTable> script_contexts(
             global->native_context()->script_context_table());
         ScriptContextTable::LookupResult lookup;
         if (ScriptContextTable::Lookup(script_contexts, variable->name(),
                                        &lookup)) {
           Handle<Context> script_context = ScriptContextTable::GetContext(
               script_contexts, lookup.context_index);
           HInstruction* result = New<HLoadNamedField>(
-              Add<HConstant>(script_context), static_cast<HValue*>(NULL),
+              Add<HConstant>(script_context), nullptr,
               HObjectAccess::ForContextSlot(lookup.slot_index));
           return ast_context()->ReturnInstruction(result, expr->id());
         }
       }
 
       LookupIterator it(global, variable->name(),
                         LookupIterator::OWN_SKIP_INTERCEPTOR);
       GlobalPropertyAccess type = LookupGlobalProperty(variable, &it, LOAD);
 
       if (type == kUseCell) {
         Handle<PropertyCell> cell = it.GetPropertyCell();
         if (cell->type()->IsConstant()) {
           PropertyCell::AddDependentCompilationInfo(cell, top_info());
           Handle<Object> constant_object = cell->type()->AsConstant()->Value();
           if (constant_object->IsConsString()) {
             constant_object =
                 String::Flatten(Handle<String>::cast(constant_object));
           }
           HConstant* constant = New<HConstant>(constant_object);
           return ast_context()->ReturnInstruction(constant, expr->id());
         } else {
           HLoadGlobalCell* instr =
               New<HLoadGlobalCell>(cell, it.property_details());
           return ast_context()->ReturnInstruction(instr, expr->id());
         }
       } else {
         HValue* global_object = Add<HLoadNamedField>(
-            context(), static_cast<HValue*>(NULL),
+            context(), nullptr,
             HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
         HLoadGlobalGeneric* instr =
             New<HLoadGlobalGeneric>(global_object,
                                     variable->name(),
                                     ast_context()->is_for_typeof());
         if (FLAG_vector_ics) {
           Handle<SharedFunctionInfo> current_shared =
               function_state()->compilation_info()->shared_info();
           instr->SetVectorAndSlot(
               handle(current_shared->feedback_vector(), isolate()),
@@ skipping 431 matching lines @@
         return New<HConstant>(value);
       }
     }
   }
 
   HObjectAccess access = info->access();
   if (access.representation().IsDouble() &&
       (!FLAG_unbox_double_fields || !access.IsInobject())) {
     // Load the heap number.
     checked_object = Add<HLoadNamedField>(
-        checked_object, static_cast<HValue*>(NULL),
+        checked_object, nullptr,
         access.WithRepresentation(Representation::Tagged()));
     // Load the double value from it.
     access = HObjectAccess::ForHeapNumberValue();
   }
 
   SmallMapList* map_list = info->field_maps();
   if (map_list->length() == 0) {
     return New<HLoadNamedField>(checked_object, checked_object, access);
   }
 
@@ skipping 31 matching lines @@
           MUTABLE_HEAP_NUMBER_TYPE);
       AddStoreMapConstant(
           heap_number, isolate()->factory()->mutable_heap_number_map());
       Add<HStoreNamedField>(heap_number, HObjectAccess::ForHeapNumberValue(),
                             value);
       instr = New<HStoreNamedField>(checked_object->ActualValue(),
                                     heap_number_access,
                                     heap_number);
     } else {
       // Already holds a HeapNumber; load the box and write its value field.
-      HInstruction* heap_number = Add<HLoadNamedField>(
-          checked_object, static_cast<HValue*>(NULL), heap_number_access);
+      HInstruction* heap_number =
+          Add<HLoadNamedField>(checked_object, nullptr, heap_number_access);
       instr = New<HStoreNamedField>(heap_number,
                                     HObjectAccess::ForHeapNumberValue(),
                                     value, STORE_TO_INITIALIZED_ENTRY);
     }
   } else {
     if (field_access.representation().IsHeapObject()) {
       BuildCheckHeapObject(value);
     }
 
     if (!info->field_maps()->is_empty()) {
@@ skipping 643 matching lines @@
         builder.End();
       }
     }
     HInstruction* instr =
         Add<HStoreGlobalCell>(value, cell, it.property_details());
     if (instr->HasObservableSideEffects()) {
       Add<HSimulate>(ast_id, REMOVABLE_SIMULATE);
     }
   } else {
     HValue* global_object = Add<HLoadNamedField>(
-        context(), static_cast<HValue*>(NULL),
+        context(), nullptr,
         HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
     HStoreNamedGeneric* instr =
         Add<HStoreNamedGeneric>(global_object, var->name(),
                                  value, function_strict_mode());
     USE(instr);
     DCHECK(instr->HasObservableSideEffects());
     Add<HSimulate>(ast_id, REMOVABLE_SIMULATE);
   }
 }
 
@@ skipping 263 matching lines @@
 
 
 HInstruction* HGraphBuilder::AddLoadStringInstanceType(HValue* string) {
   if (string->IsConstant()) {
     HConstant* c_string = HConstant::cast(string);
     if (c_string->HasStringValue()) {
       return Add<HConstant>(c_string->StringValue()->map()->instance_type());
     }
   }
   return Add<HLoadNamedField>(
-      Add<HLoadNamedField>(string, static_cast<HValue*>(NULL),
-                           HObjectAccess::ForMap()),
-      static_cast<HValue*>(NULL), HObjectAccess::ForMapInstanceType());
+      Add<HLoadNamedField>(string, nullptr, HObjectAccess::ForMap()), nullptr,
+      HObjectAccess::ForMapInstanceType());
 }
 
 
 HInstruction* HGraphBuilder::AddLoadStringLength(HValue* string) {
   if (string->IsConstant()) {
     HConstant* c_string = HConstant::cast(string);
     if (c_string->HasStringValue()) {
       return Add<HConstant>(c_string->StringValue()->length());
     }
   }
-  return Add<HLoadNamedField>(string, static_cast<HValue*>(NULL),
+  return Add<HLoadNamedField>(string, nullptr,
                               HObjectAccess::ForStringLength());
 }
 
 
 HInstruction* HOptimizedGraphBuilder::BuildNamedGeneric(
     PropertyAccessType access_type,
     Expression* expr,
     HValue* object,
     Handle<String> name,
     HValue* value,
@@ skipping 670 matching lines @@
   bool can_invoke_directly =
       dont_adapt_arguments || formal_parameter_count == arity;
   if (can_invoke_directly) {
     if (jsfun.is_identical_to(current_info()->closure())) {
       graph()->MarkRecursive();
     }
     return NewPlainFunctionCall(target, argument_count, dont_adapt_arguments);
   } else {
     HValue* param_count_value = Add<HConstant>(formal_parameter_count);
     HValue* context = Add<HLoadNamedField>(
-        target, static_cast<HValue*>(NULL),
-        HObjectAccess::ForFunctionContextPointer());
+        target, nullptr, HObjectAccess::ForFunctionContextPointer());
     return NewArgumentAdaptorCall(target, context,
         argument_count, param_count_value);
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 class FunctionSorter {
  public:
@@ skipping 766 matching lines @@
       if (!IsFastElementsKind(elements_kind)) return false;
       if (receiver_map->is_observed()) return false;
       if (!receiver_map->is_extensible()) return false;
 
       Drop(args_count_no_receiver);
       HValue* result;
       HValue* reduced_length;
       HValue* receiver = Pop();
 
       HValue* checked_object = AddCheckMap(receiver, receiver_map);
-      HValue* length = Add<HLoadNamedField>(
-          checked_object, static_cast<HValue*>(NULL),
-          HObjectAccess::ForArrayLength(elements_kind));
+      HValue* length =
+          Add<HLoadNamedField>(checked_object, nullptr,
+                               HObjectAccess::ForArrayLength(elements_kind));
 
       Drop(1);  // Function.
 
       { NoObservableSideEffectsScope scope(this);
         IfBuilder length_checker(this);
 
         HValue* bounds_check = length_checker.If<HCompareNumericAndBranch>(
             length, graph()->GetConstant0(), Token::EQ);
         length_checker.Then();
 
@@ skipping 60 matching lines @@
       HValue* value_to_push = Pop();
       HValue* array = Pop();
       Drop(1);  // Drop function.
 
       HInstruction* new_size = NULL;
       HValue* length = NULL;
 
       {
         NoObservableSideEffectsScope scope(this);
 
-        length = Add<HLoadNamedField>(array, static_cast<HValue*>(NULL),
-          HObjectAccess::ForArrayLength(elements_kind));
+        length = Add<HLoadNamedField>(
+            array, nullptr, HObjectAccess::ForArrayLength(elements_kind));
 
         new_size = AddUncasted<HAdd>(length, graph()->GetConstant1());
 
         bool is_array = receiver_map->instance_type() == JS_ARRAY_TYPE;
         BuildUncheckedMonomorphicElementAccess(array, length,
                                                value_to_push, is_array,
                                                elements_kind, STORE,
                                                NEVER_RETURN_HOLE,
                                                STORE_AND_GROW_NO_TRANSITION);
 
@@ skipping 32 matching lines @@
 
       Drop(args_count_no_receiver);
       HValue* receiver = Pop();
       HValue* function = Pop();
       HValue* result;
 
       {
         NoObservableSideEffectsScope scope(this);
 
         HValue* length = Add<HLoadNamedField>(
-            receiver, static_cast<HValue*>(NULL),
-            HObjectAccess::ForArrayLength(kind));
+            receiver, nullptr, HObjectAccess::ForArrayLength(kind));
 
         IfBuilder if_lengthiszero(this);
         HValue* lengthiszero = if_lengthiszero.If<HCompareNumericAndBranch>(
             length, graph()->GetConstant0(), Token::EQ);
         if_lengthiszero.Then();
         {
           if (!ast_context()->IsEffect()) Push(graph()->GetConstantUndefined());
         }
         if_lengthiszero.Else();
         {
@@ skipping 486 matching lines @@
   if (IsFastDoubleElementsKind(kind) || IsFastSmiElementsKind(kind)) {
     // Make sure that we can actually compare numbers correctly below, see
     // https://code.google.com/p/chromium/issues/detail?id=407946 for details.
     search_element = AddUncasted<HForceRepresentation>(
         search_element, IsFastSmiElementsKind(kind) ? Representation::Smi()
                                                     : Representation::Double());
 
     LoopBuilder loop(this, context(), direction);
     {
       HValue* index = loop.BeginBody(initial, terminating, token);
-      HValue* element = AddUncasted<HLoadKeyed>(
-          elements, index, static_cast<HValue*>(NULL),
-          kind, ALLOW_RETURN_HOLE);
+      HValue* element = AddUncasted<HLoadKeyed>(elements, index, nullptr, kind,
+                                                ALLOW_RETURN_HOLE);
       IfBuilder if_issame(this);
       if_issame.If<HCompareNumericAndBranch>(element, search_element,
                                              Token::EQ_STRICT);
       if_issame.Then();
       {
         Drop(1);
         Push(index);
         loop.Break();
       }
       if_issame.End();
     }
     loop.EndBody();
   } else {
     IfBuilder if_isstring(this);
     if_isstring.If<HIsStringAndBranch>(search_element);
     if_isstring.Then();
     {
       LoopBuilder loop(this, context(), direction);
       {
         HValue* index = loop.BeginBody(initial, terminating, token);
-        HValue* element = AddUncasted<HLoadKeyed>(
-            elements, index, static_cast<HValue*>(NULL),
-            kind, ALLOW_RETURN_HOLE);
+        HValue* element = AddUncasted<HLoadKeyed>(elements, index, nullptr,
+                                                  kind, ALLOW_RETURN_HOLE);
         IfBuilder if_issame(this);
         if_issame.If<HIsStringAndBranch>(element);
         if_issame.AndIf<HStringCompareAndBranch>(
             element, search_element, Token::EQ_STRICT);
         if_issame.Then();
         {
           Drop(1);
           Push(index);
           loop.Break();
         }
         if_issame.End();
       }
       loop.EndBody();
     }
     if_isstring.Else();
     {
       IfBuilder if_isnumber(this);
       if_isnumber.If<HIsSmiAndBranch>(search_element);
       if_isnumber.OrIf<HCompareMap>(
           search_element, isolate()->factory()->heap_number_map());
       if_isnumber.Then();
       {
         HValue* search_number =
             AddUncasted<HForceRepresentation>(search_element,
                                               Representation::Double());
         LoopBuilder loop(this, context(), direction);
         {
           HValue* index = loop.BeginBody(initial, terminating, token);
-          HValue* element = AddUncasted<HLoadKeyed>(
-              elements, index, static_cast<HValue*>(NULL),
-              kind, ALLOW_RETURN_HOLE);
+          HValue* element = AddUncasted<HLoadKeyed>(elements, index, nullptr,
+                                                    kind, ALLOW_RETURN_HOLE);
 
           IfBuilder if_element_isnumber(this);
           if_element_isnumber.If<HIsSmiAndBranch>(element);
           if_element_isnumber.OrIf<HCompareMap>(
               element, isolate()->factory()->heap_number_map());
           if_element_isnumber.Then();
           {
             HValue* number =
                 AddUncasted<HForceRepresentation>(element,
                                                   Representation::Double());
@@ skipping 10 matching lines @@
           }
           if_element_isnumber.End();
         }
         loop.EndBody();
       }
       if_isnumber.Else();
       {
         LoopBuilder loop(this, context(), direction);
         {
           HValue* index = loop.BeginBody(initial, terminating, token);
-          HValue* element = AddUncasted<HLoadKeyed>(
-              elements, index, static_cast<HValue*>(NULL),
-              kind, ALLOW_RETURN_HOLE);
+          HValue* element = AddUncasted<HLoadKeyed>(elements, index, nullptr,
+                                                    kind, ALLOW_RETURN_HOLE);
           IfBuilder if_issame(this);
           if_issame.If<HCompareObjectEqAndBranch>(
               element, search_element);
           if_issame.Then();
           {
             Drop(1);
             Push(index);
             loop.Break();
           }
           if_issame.End();
@@ skipping 500 matching lines @@
       obj,
       HObjectAccess::ForJSArrayBufferViewByteLength(),
       byte_length);
 
   if (buffer != NULL) {
     Add<HStoreNamedField>(
         obj,
         HObjectAccess::ForJSArrayBufferViewBuffer(), buffer);
     HObjectAccess weak_first_view_access =
         HObjectAccess::ForJSArrayBufferWeakFirstView();
-    Add<HStoreNamedField>(obj,
-        HObjectAccess::ForJSArrayBufferViewWeakNext(),
-        Add<HLoadNamedField>(buffer,
-                             static_cast<HValue*>(NULL),
-                             weak_first_view_access));
+    Add<HStoreNamedField>(
+        obj, HObjectAccess::ForJSArrayBufferViewWeakNext(),
+        Add<HLoadNamedField>(buffer, nullptr, weak_first_view_access));
     Add<HStoreNamedField>(buffer, weak_first_view_access, obj);
   } else {
     Add<HStoreNamedField>(
         obj,
         HObjectAccess::ForJSArrayBufferViewBuffer(),
         Add<HConstant>(static_cast<int32_t>(0)));
     Add<HStoreNamedField>(obj,
         HObjectAccess::ForJSArrayBufferViewWeakNext(),
         graph()->GetConstantUndefined());
   }
@@ skipping 59 matching lines @@
           Add<HConstant>(ExternalArray::kAlignedSize),
           HType::HeapObject(),
           NOT_TENURED,
           external_array_map->instance_type());
 
   AddStoreMapConstant(elements, external_array_map);
   Add<HStoreNamedField>(elements,
       HObjectAccess::ForFixedArrayLength(), length);
 
   HValue* backing_store = Add<HLoadNamedField>(
-      buffer, static_cast<HValue*>(NULL),
-      HObjectAccess::ForJSArrayBufferBackingStore());
+      buffer, nullptr, HObjectAccess::ForJSArrayBufferBackingStore());
 
   HValue* typed_array_start;
   if (is_zero_byte_offset) {
     typed_array_start = backing_store;
   } else {
     HInstruction* external_pointer =
         AddUncasted<HAdd>(backing_store, byte_offset);
     // Arguments are checked prior to call to TypedArrayInitialize,
     // including byte_offset.
     external_pointer->ClearFlag(HValue::kCanOverflow);
@@ skipping 197 matching lines @@
   return ast_context()->ReturnInstruction(result, expr->id());
 }
 
 
 void HOptimizedGraphBuilder::GenerateArrayBufferGetByteLength(
     CallRuntime* expr) {
   DCHECK(expr->arguments()->length() == 1);
   CHECK_ALIVE(VisitForValue(expr->arguments()->at(0)));
   HValue* buffer = Pop();
   HInstruction* result = New<HLoadNamedField>(
-    buffer,
-    static_cast<HValue*>(NULL),
-    HObjectAccess::ForJSArrayBufferByteLength());
+      buffer, nullptr, HObjectAccess::ForJSArrayBufferByteLength());
   return ast_context()->ReturnInstruction(result, expr->id());
 }
 
 
 void HOptimizedGraphBuilder::GenerateArrayBufferViewGetByteLength(
     CallRuntime* expr) {
   DCHECK(expr->arguments()->length() == 1);
   CHECK_ALIVE(VisitForValue(expr->arguments()->at(0)));
   HValue* buffer = Pop();
   HInstruction* result = New<HLoadNamedField>(
-    buffer,
-    static_cast<HValue*>(NULL),
-    HObjectAccess::ForJSArrayBufferViewByteLength());
+      buffer, nullptr, HObjectAccess::ForJSArrayBufferViewByteLength());
   return ast_context()->ReturnInstruction(result, expr->id());
 }
 
 
 void HOptimizedGraphBuilder::GenerateArrayBufferViewGetByteOffset(
     CallRuntime* expr) {
   DCHECK(expr->arguments()->length() == 1);
   CHECK_ALIVE(VisitForValue(expr->arguments()->at(0)));
   HValue* buffer = Pop();
   HInstruction* result = New<HLoadNamedField>(
-    buffer,
-    static_cast<HValue*>(NULL),
-    HObjectAccess::ForJSArrayBufferViewByteOffset());
+      buffer, nullptr, HObjectAccess::ForJSArrayBufferViewByteOffset());
   return ast_context()->ReturnInstruction(result, expr->id());
 }
 
 
 void HOptimizedGraphBuilder::GenerateTypedArrayGetLength(
     CallRuntime* expr) {
   DCHECK(expr->arguments()->length() == 1);
   CHECK_ALIVE(VisitForValue(expr->arguments()->at(0)));
   HValue* buffer = Pop();
   HInstruction* result = New<HLoadNamedField>(
-    buffer,
-    static_cast<HValue*>(NULL),
-    HObjectAccess::ForJSTypedArrayLength());
+      buffer, nullptr, HObjectAccess::ForJSTypedArrayLength());
   return ast_context()->ReturnInstruction(result, expr->id());
 }
 
 
 void HOptimizedGraphBuilder::VisitCallRuntime(CallRuntime* expr) {
   DCHECK(!HasStackOverflow());
   DCHECK(current_block() != NULL);
   DCHECK(current_block()->HasPredecessor());
   if (expr->is_jsruntime()) {
     return Bailout(kCallToAJavaScriptRuntimeFunction);
@@ skipping 1386 matching lines @@
 
 
 void HOptimizedGraphBuilder::BuildEmitFixedDoubleArray(
     Handle<FixedArrayBase> elements,
     ElementsKind kind,
     HValue* object_elements) {
   HInstruction* boilerplate_elements = Add<HConstant>(elements);
   int elements_length = elements->length();
   for (int i = 0; i < elements_length; i++) {
     HValue* key_constant = Add<HConstant>(i);
-    HInstruction* value_instruction =
-        Add<HLoadKeyed>(boilerplate_elements, key_constant,
-                        static_cast<HValue*>(NULL), kind,
-                        ALLOW_RETURN_HOLE);
+    HInstruction* value_instruction = Add<HLoadKeyed>(
+        boilerplate_elements, key_constant, nullptr, kind, ALLOW_RETURN_HOLE);
     HInstruction* store = Add<HStoreKeyed>(object_elements, key_constant,
                                            value_instruction, kind);
     store->SetFlag(HValue::kAllowUndefinedAsNaN);
   }
 }
 
 
 void HOptimizedGraphBuilder::BuildEmitFixedArray(
     Handle<FixedArrayBase> elements,
     ElementsKind kind,
     HValue* object_elements,
     AllocationSiteUsageContext* site_context) {
   HInstruction* boilerplate_elements = Add<HConstant>(elements);
   int elements_length = elements->length();
   Handle<FixedArray> fast_elements = Handle<FixedArray>::cast(elements);
   for (int i = 0; i < elements_length; i++) {
     Handle<Object> value(fast_elements->get(i), isolate());
     HValue* key_constant = Add<HConstant>(i);
     if (value->IsJSObject()) {
       Handle<JSObject> value_object = Handle<JSObject>::cast(value);
       Handle<AllocationSite> current_site = site_context->EnterNewScope();
       HInstruction* result =
           BuildFastLiteral(value_object, site_context);
       site_context->ExitScope(current_site, value_object);
       Add<HStoreKeyed>(object_elements, key_constant, result, kind);
     } else {
       ElementsKind copy_kind =
           kind == FAST_HOLEY_SMI_ELEMENTS ? FAST_HOLEY_ELEMENTS : kind;
-      HInstruction* value_instruction = Add<HLoadKeyed>(
-          boilerplate_elements, key_constant, static_cast<HValue*>(NULL),
-          copy_kind, ALLOW_RETURN_HOLE);
+      HInstruction* value_instruction =
+          Add<HLoadKeyed>(boilerplate_elements, key_constant, nullptr,
+                          copy_kind, ALLOW_RETURN_HOLE);
       Add<HStoreKeyed>(object_elements, key_constant, value_instruction,
                        copy_kind);
     }
   }
 }
 
 
 void HOptimizedGraphBuilder::VisitThisFunction(ThisFunction* expr) {
   DCHECK(!HasStackOverflow());
   DCHECK(current_block() != NULL);
@@ skipping 230 matching lines @@
 void HOptimizedGraphBuilder::GenerateIsJSProxy(CallRuntime* call) {
   DCHECK(call->arguments()->length() == 1);
   CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
   HValue* value = Pop();
   HIfContinuation continuation;
   IfBuilder if_proxy(this);
 
   HValue* smicheck = if_proxy.IfNot<HIsSmiAndBranch>(value);
   if_proxy.And();
   HValue* map = Add<HLoadNamedField>(value, smicheck, HObjectAccess::ForMap());
-  HValue* instance_type = Add<HLoadNamedField>(
-      map, static_cast<HValue*>(NULL), HObjectAccess::ForMapInstanceType());
+  HValue* instance_type =
+      Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapInstanceType());
   if_proxy.If<HCompareNumericAndBranch>(
       instance_type, Add<HConstant>(FIRST_JS_PROXY_TYPE), Token::GTE);
   if_proxy.And();
   if_proxy.If<HCompareNumericAndBranch>(
       instance_type, Add<HConstant>(LAST_JS_PROXY_TYPE), Token::LTE);
 
   if_proxy.CaptureContinuation(&continuation);
   return ast_context()->ReturnContinuation(&continuation, call->id());
 }
 
@@ skipping 456 matching lines @@
 }
 
 
 template <typename CollectionType>
 HValue* HOptimizedGraphBuilder::BuildOrderedHashTableHashToEntry(
     HValue* table, HValue* hash, HValue* num_buckets) {
   HValue* bucket = BuildOrderedHashTableHashToBucket(hash, num_buckets);
   HValue* entry_index = AddUncasted<HAdd>(
       bucket, Add<HConstant>(CollectionType::kHashTableStartIndex));
   entry_index->ClearFlag(HValue::kCanOverflow);
-  HValue* entry = Add<HLoadKeyed>(table, entry_index,
-                                  static_cast<HValue*>(NULL), FAST_ELEMENTS);
+  HValue* entry = Add<HLoadKeyed>(table, entry_index, nullptr, FAST_ELEMENTS);
   entry->set_type(HType::Smi());
   return entry;
 }
 
 
 template <typename CollectionType>
 HValue* HOptimizedGraphBuilder::BuildOrderedHashTableEntryToIndex(
     HValue* entry, HValue* num_buckets) {
   HValue* index =
       AddUncasted<HMul>(entry, Add<HConstant>(CollectionType::kEntrySize));
   index->ClearFlag(HValue::kCanOverflow);
   index = AddUncasted<HAdd>(index, num_buckets);
   index->ClearFlag(HValue::kCanOverflow);
   index = AddUncasted<HAdd>(
       index, Add<HConstant>(CollectionType::kHashTableStartIndex));
   index->ClearFlag(HValue::kCanOverflow);
   return index;
 }
 
 
 template <typename CollectionType>
 HValue* HOptimizedGraphBuilder::BuildOrderedHashTableFindEntry(HValue* table,
                                                                HValue* key,
                                                                HValue* hash) {
   HValue* num_buckets = Add<HLoadNamedField>(
-      table, static_cast<HValue*>(NULL),
+      table, nullptr,
       HObjectAccess::ForOrderedHashTableNumberOfBuckets<CollectionType>());
 
   HValue* entry = BuildOrderedHashTableHashToEntry<CollectionType>(table, hash,
                                                                    num_buckets);
 
   Push(entry);
 
   LoopBuilder loop(this);
   loop.BeginBody(1);
 
   entry = Pop();
 
   {
     IfBuilder if_not_found(this);
     if_not_found.If<HCompareNumericAndBranch>(
         entry, Add<HConstant>(CollectionType::kNotFound), Token::EQ);
     if_not_found.Then();
     Push(entry);
     loop.Break();
   }
 
   HValue* key_index =
       BuildOrderedHashTableEntryToIndex<CollectionType>(entry, num_buckets);
-  HValue* candidate_key = Add<HLoadKeyed>(
-      table, key_index, static_cast<HValue*>(NULL), FAST_ELEMENTS);
+  HValue* candidate_key =
+      Add<HLoadKeyed>(table, key_index, nullptr, FAST_ELEMENTS);
 
   {
     IfBuilder if_keys_equal(this);
     if_keys_equal.If<HIsStringAndBranch>(candidate_key);
     if_keys_equal.AndIf<HStringCompareAndBranch>(candidate_key, key,
                                                  Token::EQ_STRICT);
     if_keys_equal.Then();
     Push(key_index);
     loop.Break();
   }
 
   // BuildChainAt
   HValue* chain_index = AddUncasted<HAdd>(
       key_index, Add<HConstant>(CollectionType::kChainOffset));
   chain_index->ClearFlag(HValue::kCanOverflow);
-  entry = Add<HLoadKeyed>(table, chain_index, static_cast<HValue*>(NULL),
-                          FAST_ELEMENTS);
+  entry = Add<HLoadKeyed>(table, chain_index, nullptr, FAST_ELEMENTS);
   entry->set_type(HType::Smi());
   Push(entry);
 
   loop.EndBody();
 
   return Pop();
 }
 
 
 void HOptimizedGraphBuilder::GenerateMapGet(CallRuntime* call) {
   DCHECK(call->arguments()->length() == 2);
   CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
   CHECK_ALIVE(VisitForValue(call->arguments()->at(1)));
   HValue* key = Pop();
   HValue* receiver = Pop();
 
   NoObservableSideEffectsScope no_effects(this);
 
   HIfContinuation continuation;
   HValue* hash =
       BuildStringHashLoadIfIsStringAndHashComputed(key, &continuation);
   {
     IfBuilder string_checker(this, &continuation);
     string_checker.Then();
     {
-      HValue* table =
-          Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
-                               HObjectAccess::ForJSCollectionTable());
+      HValue* table = Add<HLoadNamedField>(
+          receiver, nullptr, HObjectAccess::ForJSCollectionTable());
       HValue* key_index =
           BuildOrderedHashTableFindEntry<OrderedHashMap>(table, key, hash);
       IfBuilder if_found(this);
       if_found.If<HCompareNumericAndBranch>(
           key_index, Add<HConstant>(OrderedHashMap::kNotFound), Token::NE);
       if_found.Then();
       {
         HValue* value_index = AddUncasted<HAdd>(
             key_index, Add<HConstant>(OrderedHashMap::kValueOffset));
         value_index->ClearFlag(HValue::kCanOverflow);
-        Push(Add<HLoadKeyed>(table, value_index, static_cast<HValue*>(NULL),
-                             FAST_ELEMENTS));
+        Push(Add<HLoadKeyed>(table, value_index, nullptr, FAST_ELEMENTS));
       }
       if_found.Else();
       Push(graph()->GetConstantUndefined());
       if_found.End();
     }
     string_checker.Else();
     {
       Add<HPushArguments>(receiver, key);
       Push(Add<HCallRuntime>(call->name(),
                              Runtime::FunctionForId(Runtime::kMapGet), 2));
     }
   }
 
   return ast_context()->ReturnValue(Pop());
 }
 
 
 HValue* HOptimizedGraphBuilder::BuildStringHashLoadIfIsStringAndHashComputed(
     HValue* object, HIfContinuation* continuation) {
   IfBuilder string_checker(this);
   string_checker.If<HIsStringAndBranch>(object);
   string_checker.And();
-  HValue* hash = Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
+  HValue* hash = Add<HLoadNamedField>(object, nullptr,
                                       HObjectAccess::ForStringHashField());
   HValue* hash_not_computed_mask = Add<HConstant>(String::kHashNotComputedMask);
   HValue* hash_computed_test =
       AddUncasted<HBitwise>(Token::BIT_AND, hash, hash_not_computed_mask);
   string_checker.If<HCompareNumericAndBranch>(
       hash_computed_test, graph()->GetConstant0(), Token::EQ);
   string_checker.Then();
   HValue* shifted_hash =
       AddUncasted<HShr>(hash, Add<HConstant>(String::kHashShift));
   string_checker.CaptureContinuation(continuation);
@@ skipping 12 matching lines @@
 
   NoObservableSideEffectsScope no_effects(this);
 
   HIfContinuation continuation;
   HValue* hash =
       BuildStringHashLoadIfIsStringAndHashComputed(key, &continuation);
   {
     IfBuilder string_checker(this, &continuation);
     string_checker.Then();
     {
-      HValue* table =
-          Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
-                               HObjectAccess::ForJSCollectionTable());
+      HValue* table = Add<HLoadNamedField>(
+          receiver, nullptr, HObjectAccess::ForJSCollectionTable());
       HValue* key_index =
           BuildOrderedHashTableFindEntry<CollectionType>(table, key, hash);
       {
         IfBuilder if_found(this);
         if_found.If<HCompareNumericAndBranch>(
             key_index, Add<HConstant>(CollectionType::kNotFound), Token::NE);
         if_found.Then();
         Push(graph()->GetConstantTrue());
         if_found.Else();
         Push(graph()->GetConstantFalse());
@@ skipping 20 matching lines @@
   BuildJSCollectionHas<OrderedHashSet>(
       call, Runtime::FunctionForId(Runtime::kSetHas));
 }
 
 
 template <typename CollectionType>
 HValue* HOptimizedGraphBuilder::BuildOrderedHashTableAddEntry(
     HValue* table, HValue* key, HValue* hash,
     HIfContinuation* join_continuation) {
   HValue* num_buckets = Add<HLoadNamedField>(
-      table, static_cast<HValue*>(NULL),
+      table, nullptr,
       HObjectAccess::ForOrderedHashTableNumberOfBuckets<CollectionType>());
   HValue* capacity = AddUncasted<HMul>(
       num_buckets, Add<HConstant>(CollectionType::kLoadFactor));
   capacity->ClearFlag(HValue::kCanOverflow);
   HValue* num_elements = Add<HLoadNamedField>(
-      table, static_cast<HValue*>(NULL),
+      table, nullptr,
       HObjectAccess::ForOrderedHashTableNumberOfElements<CollectionType>());
   HValue* num_deleted = Add<HLoadNamedField>(
-      table, static_cast<HValue*>(NULL),
-      HObjectAccess::ForOrderedHashTableNumberOfDeletedElements<
-          CollectionType>());
+      table, nullptr, HObjectAccess::ForOrderedHashTableNumberOfDeletedElements<
+                          CollectionType>());
   HValue* used = AddUncasted<HAdd>(num_elements, num_deleted);
   used->ClearFlag(HValue::kCanOverflow);
   IfBuilder if_space_available(this);
   if_space_available.If<HCompareNumericAndBranch>(capacity, used, Token::GT);
   if_space_available.Then();
   HValue* bucket = BuildOrderedHashTableHashToBucket(hash, num_buckets);
   HValue* entry = used;
   HValue* key_index =
       BuildOrderedHashTableEntryToIndex<CollectionType>(entry, num_buckets);
 
   HValue* bucket_index = AddUncasted<HAdd>(
       bucket, Add<HConstant>(CollectionType::kHashTableStartIndex));
   bucket_index->ClearFlag(HValue::kCanOverflow);
-  HValue* chain_entry = Add<HLoadKeyed>(
-      table, bucket_index, static_cast<HValue*>(NULL), FAST_ELEMENTS);
+  HValue* chain_entry =
+      Add<HLoadKeyed>(table, bucket_index, nullptr, FAST_ELEMENTS);
   chain_entry->set_type(HType::Smi());
 
   HValue* chain_index = AddUncasted<HAdd>(
       key_index, Add<HConstant>(CollectionType::kChainOffset));
   chain_index->ClearFlag(HValue::kCanOverflow);
 
   Add<HStoreKeyed>(table, bucket_index, entry, FAST_ELEMENTS);
   Add<HStoreKeyed>(table, chain_index, chain_entry, FAST_ELEMENTS);
   Add<HStoreKeyed>(table, key_index, key, FAST_ELEMENTS);
 
@@ skipping 21 matching lines @@
   NoObservableSideEffectsScope no_effects(this);
 
   HIfContinuation return_or_call_runtime_continuation(
       graph()->CreateBasicBlock(), graph()->CreateBasicBlock());
   HIfContinuation got_string_hash;
   HValue* hash =
       BuildStringHashLoadIfIsStringAndHashComputed(key, &got_string_hash);
   IfBuilder string_checker(this, &got_string_hash);
   string_checker.Then();
   {
-    HValue* table = Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
+    HValue* table = Add<HLoadNamedField>(receiver, nullptr,
                                          HObjectAccess::ForJSCollectionTable());
     HValue* key_index =
         BuildOrderedHashTableFindEntry<OrderedHashMap>(table, key, hash);
     {
       IfBuilder if_found(this);
       if_found.If<HCompareNumericAndBranch>(
           key_index, Add<HConstant>(OrderedHashMap::kNotFound), Token::NE);
       if_found.Then();
       {
         HValue* value_index = AddUncasted<HAdd>(
@@ skipping 46 matching lines @@
   NoObservableSideEffectsScope no_effects(this);
 
   HIfContinuation return_or_call_runtime_continuation(
       graph()->CreateBasicBlock(), graph()->CreateBasicBlock());
   HIfContinuation got_string_hash;
   HValue* hash =
       BuildStringHashLoadIfIsStringAndHashComputed(key, &got_string_hash);
   IfBuilder string_checker(this, &got_string_hash);
   string_checker.Then();
   {
-    HValue* table = Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
+    HValue* table = Add<HLoadNamedField>(receiver, nullptr,
                                          HObjectAccess::ForJSCollectionTable());
     HValue* key_index =
         BuildOrderedHashTableFindEntry<OrderedHashSet>(table, key, hash);
     {
       IfBuilder if_not_found(this);
       if_not_found.If<HCompareNumericAndBranch>(
           key_index, Add<HConstant>(OrderedHashSet::kNotFound), Token::EQ);
       if_not_found.Then();
       BuildOrderedHashTableAddEntry<OrderedHashSet>(
           table, key, hash, &return_or_call_runtime_continuation);
@@ skipping 28 matching lines @@
   NoObservableSideEffectsScope no_effects(this);
 
   HIfContinuation return_or_call_runtime_continuation(
       graph()->CreateBasicBlock(), graph()->CreateBasicBlock());
   HIfContinuation got_string_hash;
   HValue* hash =
       BuildStringHashLoadIfIsStringAndHashComputed(key, &got_string_hash);
   IfBuilder string_checker(this, &got_string_hash);
   string_checker.Then();
   {
-    HValue* table = Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
+    HValue* table = Add<HLoadNamedField>(receiver, nullptr,
                                          HObjectAccess::ForJSCollectionTable());
     HValue* key_index =
         BuildOrderedHashTableFindEntry<CollectionType>(table, key, hash);
     {
       IfBuilder if_found(this);
       if_found.If<HCompareNumericAndBranch>(
           key_index, Add<HConstant>(CollectionType::kNotFound), Token::NE);
       if_found.Then();
       {
         // If we're removing an element, we might need to shrink.
         // If we do need to shrink, we'll be bailing out to the runtime.
         HValue* num_elements = Add<HLoadNamedField>(
-            table, static_cast<HValue*>(NULL),
-            HObjectAccess::ForOrderedHashTableNumberOfElements<
-                CollectionType>());
+            table, nullptr, HObjectAccess::ForOrderedHashTableNumberOfElements<
+                                CollectionType>());
         num_elements = AddUncasted<HSub>(num_elements, graph()->GetConstant1());
         num_elements->ClearFlag(HValue::kCanOverflow);
 
         HValue* num_buckets = Add<HLoadNamedField>(
-            table, static_cast<HValue*>(NULL),
-            HObjectAccess::ForOrderedHashTableNumberOfBuckets<
-                CollectionType>());
+            table, nullptr, HObjectAccess::ForOrderedHashTableNumberOfBuckets<
+                                CollectionType>());
         // threshold is capacity >> 2; we simplify this to num_buckets >> 1
         // since kLoadFactor is 2.
         STATIC_ASSERT(CollectionType::kLoadFactor == 2);
         HValue* threshold =
             AddUncasted<HShr>(num_buckets, graph()->GetConstant1());
 
         IfBuilder if_need_not_shrink(this);
         if_need_not_shrink.If<HCompareNumericAndBranch>(num_elements, threshold,
                                                         Token::GTE);
         if_need_not_shrink.Then();
         {
           Add<HStoreKeyed>(table, key_index, graph()->GetConstantHole(),
                            FAST_ELEMENTS);
 
           // For maps, also need to clear the value.
           if (CollectionType::kChainOffset > 1) {
             HValue* value_index =
                 AddUncasted<HAdd>(key_index, graph()->GetConstant1());
             value_index->ClearFlag(HValue::kCanOverflow);
             Add<HStoreKeyed>(table, value_index, graph()->GetConstantHole(),
                              FAST_ELEMENTS);
           }
           STATIC_ASSERT(CollectionType::kChainOffset <= 2);
 
           HValue* num_deleted = Add<HLoadNamedField>(
-              table, static_cast<HValue*>(NULL),
+              table, nullptr,
               HObjectAccess::ForOrderedHashTableNumberOfDeletedElements<
                   CollectionType>());
           num_deleted = AddUncasted<HAdd>(num_deleted, graph()->GetConstant1());
           num_deleted->ClearFlag(HValue::kCanOverflow);
           Add<HStoreNamedField>(
               table, HObjectAccess::ForOrderedHashTableNumberOfElements<
                          CollectionType>(),
               num_elements);
           Add<HStoreNamedField>(
               table, HObjectAccess::ForOrderedHashTableNumberOfDeletedElements<
@@ skipping 35 matching lines @@
 void HOptimizedGraphBuilder::GenerateSetDelete(CallRuntime* call) {
   BuildJSCollectionDelete<OrderedHashSet>(
       call, Runtime::FunctionForId(Runtime::kSetDelete));
 }
 
 
 void HOptimizedGraphBuilder::GenerateSetGetSize(CallRuntime* call) {
   DCHECK(call->arguments()->length() == 1);
   CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
   HValue* receiver = Pop();
-  HValue* table = Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
+  HValue* table = Add<HLoadNamedField>(receiver, nullptr,
                                        HObjectAccess::ForJSCollectionTable());
   HInstruction* result = New<HLoadNamedField>(
-      table, static_cast<HValue*>(NULL),
+      table, nullptr,
       HObjectAccess::ForOrderedHashTableNumberOfElements<OrderedHashSet>());
   return ast_context()->ReturnInstruction(result, call->id());
 }
 
 
 void HOptimizedGraphBuilder::GenerateMapGetSize(CallRuntime* call) {
   DCHECK(call->arguments()->length() == 1);
   CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
   HValue* receiver = Pop();
-  HValue* table = Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
+  HValue* table = Add<HLoadNamedField>(receiver, nullptr,
                                        HObjectAccess::ForJSCollectionTable());
   HInstruction* result = New<HLoadNamedField>(
-      table, static_cast<HValue*>(NULL),
+      table, nullptr,
       HObjectAccess::ForOrderedHashTableNumberOfElements<OrderedHashMap>());
   return ast_context()->ReturnInstruction(result, call->id());
 }
 
 
 template <typename CollectionType>
 HValue* HOptimizedGraphBuilder::BuildAllocateOrderedHashTable() {
   static const int kCapacity = CollectionType::kMinCapacity;
   static const int kBucketCount = kCapacity / CollectionType::kLoadFactor;
   static const int kFixedArrayLength = CollectionType::kHashTableStartIndex +
@@ skipping 66 matching lines @@
 
   NoObservableSideEffectsScope no_effects(this);
   HValue* table = BuildAllocateOrderedHashTable<OrderedHashMap>();
   Add<HStoreNamedField>(receiver, HObjectAccess::ForJSCollectionTable(), table);
   return ast_context()->ReturnValue(receiver);
 }
 
 
 template <typename CollectionType>
 void HOptimizedGraphBuilder::BuildOrderedHashTableClear(HValue* receiver) {
-  HValue* old_table =
-      Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
-                           HObjectAccess::ForJSCollectionTable());
+  HValue* old_table = Add<HLoadNamedField>(
+      receiver, nullptr, HObjectAccess::ForJSCollectionTable());
   HValue* new_table = BuildAllocateOrderedHashTable<CollectionType>();
   Add<HStoreNamedField>(
       old_table, HObjectAccess::ForOrderedHashTableNextTable<CollectionType>(),
       new_table);
   Add<HStoreNamedField>(
       old_table, HObjectAccess::ForOrderedHashTableNumberOfDeletedElements<
                      CollectionType>(),
       Add<HConstant>(CollectionType::kClearedTableSentinel));
   Add<HStoreNamedField>(receiver, HObjectAccess::ForJSCollectionTable(),
                         new_table);
@@ skipping 51 matching lines @@
     CallRuntime* call) {
   Add<HDebugBreak>();
   return ast_context()->ReturnValue(graph()->GetConstant0());
 }
 
 
 void HOptimizedGraphBuilder::GenerateDebugIsActive(CallRuntime* call) {
   DCHECK(call->arguments()->length() == 0);
   HValue* ref =
       Add<HConstant>(ExternalReference::debug_is_active_address(isolate()));
-  HValue* value = Add<HLoadNamedField>(
-      ref, static_cast<HValue*>(NULL), HObjectAccess::ForExternalUInteger8());
+  HValue* value =
+      Add<HLoadNamedField>(ref, nullptr, HObjectAccess::ForExternalUInteger8());
   return ast_context()->ReturnValue(value);
 }
 
 
 void HOptimizedGraphBuilder::GenerateGetPrototype(CallRuntime* call) {
   DCHECK(call->arguments()->length() == 1);
   CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
   HValue* object = Pop();
 
   NoObservableSideEffectsScope no_effects(this);
 
-  HValue* map = Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
-                                     HObjectAccess::ForMap());
-  HValue* bit_field = Add<HLoadNamedField>(map, static_cast<HValue*>(NULL),
-                                           HObjectAccess::ForMapBitField());
+  HValue* map = Add<HLoadNamedField>(object, nullptr, HObjectAccess::ForMap());
+  HValue* bit_field =
+      Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapBitField());
   HValue* is_access_check_needed_mask =
       Add<HConstant>(1 << Map::kIsAccessCheckNeeded);
   HValue* is_access_check_needed_test = AddUncasted<HBitwise>(
       Token::BIT_AND, bit_field, is_access_check_needed_mask);
 
-  HValue* proto = Add<HLoadNamedField>(map, static_cast<HValue*>(NULL),
-                                       HObjectAccess::ForPrototype());
-  HValue* proto_map = Add<HLoadNamedField>(proto, static_cast<HValue*>(NULL),
-                                           HObjectAccess::ForMap());
-  HValue* proto_bit_field = Add<HLoadNamedField>(
-      proto_map, static_cast<HValue*>(NULL), HObjectAccess::ForMapBitField());
+  HValue* proto =
+      Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForPrototype());
+  HValue* proto_map =
+      Add<HLoadNamedField>(proto, nullptr, HObjectAccess::ForMap());
+  HValue* proto_bit_field =
+      Add<HLoadNamedField>(proto_map, nullptr, HObjectAccess::ForMapBitField());
   HValue* is_hidden_prototype_mask =
       Add<HConstant>(1 << Map::kIsHiddenPrototype);
   HValue* is_hidden_prototype_test = AddUncasted<HBitwise>(
       Token::BIT_AND, proto_bit_field, is_hidden_prototype_mask);
 
   {
     IfBuilder needs_runtime(this);
     needs_runtime.If<HCompareNumericAndBranch>(
         is_access_check_needed_test, graph()->GetConstant0(), Token::NE);
     needs_runtime.OrIf<HCompareNumericAndBranch>(
@@ skipping 643 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal