Preserve Smi representation of non-escaping fields.

src/hydrogen-escape-analysis.cc

 // Copyright 2013 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 143 matching lines @@
   HValue* value = state->map_value();
   // TODO(mstarzinger): This will narrow a map check against a set of maps
   // down to the first element in the set. Revisit and fix this.
   HCheckValue* check = HCheckValue::New(
       zone, NULL, value, mapcheck->first_map(), false);
   check->InsertBefore(mapcheck);
   return check;
 }
 
 
+// Replace a field load with a given value, forcing Smi representation if
+// necessary.
+void HEscapeAnalysisPhase::ReplaceFieldLoadWithValue(
+    HLoadNamedField* load, HValue* load_value) {
+  HValue* replacement = load_value;
+  Representation representation = load->representation();
+  if (representation.IsSmi()) {
+    Zone* zone = graph()->zone();
+    HInstruction* new_instr =
+        HForceRepresentation::New(zone, NULL, load_value, representation);
+    new_instr->InsertAfter(load);
+    replacement = new_instr;
+  }
+  load->DeleteAndReplaceWith(replacement);

[Michael Starzinger, 2014/04/25 11:08:09]

nit: I was actually thinking along the lines of having the DeleteAndReplaceWith
plus the printing outside. And the helper would really just be a
"NewLoadReplacement" that returns some other node as a replacement. Thereby
mutation of the existing graph is in the data-flow analysis code.

+  if (FLAG_trace_escape_analysis) {
+    PrintF("Replacing load #%d with #%d (%s)\n", load->id(),
+           replacement->id(), replacement->Mnemonic());
+  }
+}
+
+
 // Performs a forward data-flow analysis of all loads and stores on the
 // given captured allocation. This uses a reverse post-order iteration
 // over affected basic blocks. All non-escaping instructions are handled
 // and replaced during the analysis.
 void HEscapeAnalysisPhase::AnalyzeDataFlow(HInstruction* allocate) {
   HBasicBlock* allocate_block = allocate->block();
   block_states_.AddBlock(NULL, graph()->blocks()->length(), zone());
 
   // Iterate all blocks starting with the allocation block, since the
   // allocation cannot dominate blocks that come before.
@@ skipping 15 matching lines @@
         case HValue::kAllocate: {
           if (instr != allocate) continue;
           state = NewStateForAllocation(allocate);
           break;
         }
         case HValue::kLoadNamedField: {
           HLoadNamedField* load = HLoadNamedField::cast(instr);
           int index = load->access().offset() / kPointerSize;
           if (load->object() != allocate) continue;
           ASSERT(load->access().IsInobject());
-          HValue* replacement = state->OperandAt(index);
-          load->DeleteAndReplaceWith(replacement);
-          if (FLAG_trace_escape_analysis) {
-            PrintF("Replacing load #%d with #%d (%s)\n", instr->id(),
-                   replacement->id(), replacement->Mnemonic());
-          }
+          ReplaceFieldLoadWithValue(load, state->OperandAt(index));
           break;
         }
         case HValue::kStoreNamedField: {
           HStoreNamedField* store = HStoreNamedField::cast(instr);
           int index = store->access().offset() / kPointerSize;
           if (store->object() != allocate) continue;
           ASSERT(store->access().IsInobject());
           state = NewStateCopy(store->previous(), state);
           state->SetOperandAt(index, store->value());
           if (store->has_transition()) {
@@ skipping 109 matching lines @@
   for (int i = 0; i < max_fixpoint_iteration_count; i++) {
     CollectCapturedValues();
     if (captured_.is_empty()) break;
     PerformScalarReplacement();
     captured_.Clear();
   }
 }
 
 
 } }  // namespace v8::internal