Prevent deopt when assigning double values to typed arrays

src/hydrogen.cc

 // Copyright 2011 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 901 matching lines @@
   }
 
   RollBackTo(last_changed_range);
 }
 
 
 void HRangeAnalysis::InferControlFlowRange(HTest* test, HBasicBlock* dest) {
   ASSERT((test->FirstSuccessor() == dest) == (test->SecondSuccessor() != dest));
   if (test->value()->IsCompare()) {
     HCompare* compare = HCompare::cast(test->value());
-    if (compare->GetInputRepresentation().IsInteger32()) {
+    if (compare->GetInputRepresentation().IsInteger()) {
       Token::Value op = compare->token();
       if (test->SecondSuccessor() == dest) {
         op = Token::NegateCompareOp(op);
       }
       Token::Value inverted_op = Token::InvertCompareOp(op);
       InferControlFlowRange(op, compare->left(), compare->right());
       InferControlFlowRange(inverted_op, compare->right(), compare->left());
     }
   }
 }
@@ skipping 565 matching lines @@
 
   Zone* zone() { return graph_->zone(); }
 
   HGraph* graph_;
   ZoneList<HValue*> worklist_;
   BitVector in_worklist_;
 };
 
 
 void HInferRepresentation::AddToWorklist(HValue* current) {
-  if (current->representation().IsSpecialization()) return;
+  if (current->representation().IsTerminalSpecialization()) return;
   if (!current->CheckFlag(HValue::kFlexibleRepresentation)) return;
   if (in_worklist_.Contains(current->id())) return;
   worklist_.Add(current);
   in_worklist_.Add(current->id());
 }
 
 
 // This method tries to specialize the representation type of the value
 // given as a parameter. The value is asked to infer its representation type
 // based on its inputs. If the inferred type is more specialized, then this
 // becomes the new representation type of the node.
 void HInferRepresentation::InferBasedOnInputs(HValue* current) {
   Representation r = current->representation();
-  if (r.IsSpecialization()) return;
+  if (r.IsTerminalSpecialization()) return;
   ASSERT(current->CheckFlag(HValue::kFlexibleRepresentation));
   Representation inferred = current->InferredRepresentation();
-  if (inferred.IsSpecialization()) {
+  if (!inferred.Equals(r)) {
     current->ChangeRepresentation(inferred);
     AddDependantsToWorklist(current);
   }
 }
 
 
 void HInferRepresentation::AddDependantsToWorklist(HValue* current) {
   for (int i = 0; i < current->uses()->length(); ++i) {
     AddToWorklist(current->uses()->at(i));
   }
   for (int i = 0; i < current->OperandCount(); ++i) {
     AddToWorklist(current->OperandAt(i));
   }
 }
 
 
 // This method calculates whether specializing the representation of the value
 // given as the parameter has a benefit in terms of less necessary type
 // conversions. If there is a benefit, then the representation of the value is
 // specialized.
 void HInferRepresentation::InferBasedOnUses(HValue* current) {
   Representation r = current->representation();
-  if (r.IsSpecialization() || current->HasNoUses()) return;
+  if (r.IsTerminalSpecialization() || current->HasNoUses()) return;
   ASSERT(current->CheckFlag(HValue::kFlexibleRepresentation));
   Representation new_rep = TryChange(current);
   if (!new_rep.IsNone()) {
     if (!current->representation().Equals(new_rep)) {
       current->ChangeRepresentation(new_rep);
       AddDependantsToWorklist(current);
     }
   }
 }
 
@@ skipping 12 matching lines @@
     if (req_rep.IsNone()) continue;
     if (use->IsPhi()) {
       HPhi* phi = HPhi::cast(use);
       phi->AddIndirectUsesTo(&use_count[0]);
     }
     use_count[req_rep.kind()]++;
   }
   int tagged_count = use_count[Representation::kTagged];
   int double_count = use_count[Representation::kDouble];
   int int32_count = use_count[Representation::kInteger32];
-  int non_tagged_count = double_count + int32_count;
+  int trunc_int32_count = use_count[Representation::kTruncatedInteger32];
+  int clamped_rounded_int8_count =
+      use_count[Representation::kClampedRoundedUInteger8];
+  int non_tagged_count = double_count + int32_count +
+      trunc_int32_count + clamped_rounded_int8_count;
+  int total_use_count = tagged_count + non_tagged_count;
 
   // If a non-loop phi has tagged uses, don't convert it to untagged.
   if (current->IsPhi() && !current->block()->IsLoopHeader()) {
     if (tagged_count > 0) return Representation::None();
   }
 
   if (non_tagged_count >= tagged_count) {
     // More untagged than tagged.
     if (double_count > 0) {
       // There is at least one usage that is a double => guess that the
       // correct representation is double.
       return Representation::Double();
     } else if (int32_count > 0) {
       return Representation::Integer32();
+    } else if (clamped_rounded_int8_count > 0 &&
+               clamped_rounded_int8_count == total_use_count) {
+        return Representation::ClampedRoundedUInteger8();
+    } else if (trunc_int32_count > 0 &&
+               trunc_int32_count == total_use_count) {
+        return Representation::TruncatedInteger32();
+    } else {
+      return Representation::None();
     }
   }
   return Representation::None();
 }
 
 
 void HInferRepresentation::Analyze() {
   HPhase phase("Infer representations", graph_);
 
   // (1) Initialize bit vectors and count real uses. Each phi
@@ skipping 151 matching lines @@
     next = use->block()->predecessors()->at(index)->end();
   } else {
     next = HInstruction::cast(use);
   }
 
   // For constants we try to make the representation change at compile
   // time. When a representation change is not possible without loss of
   // information we treat constants like normal instructions and insert the
   // change instructions for them.
   HInstruction* new_value = NULL;
-  bool is_truncating = use->CheckFlag(HValue::kTruncatingToInt32);
   if (value->IsConstant()) {
     HConstant* constant = HConstant::cast(value);
     // Try to create a new copy of the constant with the new representation.
-    new_value = is_truncating
+    new_value = to.IsTruncatedInteger32()
         ? constant->CopyToTruncatedInt32()
-        : constant->CopyToRepresentation(to);
+        : to.IsClampedRoundedInteger8()
+            ? constant->CopyToClampedRoundedUInt8()
+            : constant->CopyToRepresentation(to);
   }
 
   if (new_value == NULL) {
+    Representation from = value->representation();
+    // Don't create changes for representation differences that
+    // won't generate code.
+    if (from.IsInteger() && (to.IsInteger32X() || to.IsTruncatedInteger32())) {
+      return;
+    }
+
     new_value =
-        new(zone()) HChange(value, value->representation(), to, is_truncating);
+        new(zone()) HChange(value,
+                            from,
+                            to);
   }
 
   new_value->InsertBefore(next);
   value->ReplaceFirstAtUse(use, new_value, to);
 }
 
 
-int CompareConversionUses(HValue* a,
-                          HValue* b,
-                          Representation a_rep,
-                          Representation b_rep) {
-  if (a_rep.kind() > b_rep.kind()) {
-    // Make sure specializations are separated in the result array.
-    return 1;
-  }
-  // Put truncating conversions before non-truncating conversions.
-  bool a_truncate = a->CheckFlag(HValue::kTruncatingToInt32);
-  bool b_truncate = b->CheckFlag(HValue::kTruncatingToInt32);
-  if (a_truncate != b_truncate) {
-    return a_truncate ? -1 : 1;
-  }
-  // Sort by increasing block ID.
-  return a->block()->block_id() - b->block()->block_id();
-}
-
-
 void HGraph::InsertRepresentationChangesForValue(
     HValue* current,
     ZoneList<HValue*>* to_convert,
     ZoneList<Representation>* to_convert_reps) {
   Representation r = current->representation();
   if (r.IsNone()) return;
   if (current->uses()->is_empty()) return;
 
   // Collect the representation changes in a sorted list.  This allows
   // us to avoid duplicate changes without searching the list.
   ASSERT(to_convert->is_empty());
   ASSERT(to_convert_reps->is_empty());
+  int index = 0;
   for (int i = 0; i < current->uses()->length(); ++i) {
     HValue* use = current->uses()->at(i);
     // The occurrences index means the index within the operand array of "use"
     // at which "current" is used. While iterating through the use array we
     // also have to iterate over the different occurrence indices.
     int occurrence_index = 0;
     if (use->UsesMultipleTimes(current)) {
       occurrence_index = current->uses()->CountOccurrences(use, 0, i - 1);
       if (FLAG_trace_representation) {
         PrintF("Instruction %d is used multiple times at %d; occurrence=%d\n",
                current->id(),
                use->id(),
                occurrence_index);
       }
     }
     int operand_index = use->LookupOperandIndex(occurrence_index, current);
     Representation req = use->RequiredInputRepresentation(operand_index);
     if (req.IsNone() || req.Equals(r)) continue;
-    int index = 0;
-    while (index < to_convert->length() &&
-           CompareConversionUses(to_convert->at(index),

[fschneider, 2011/05/10 10:44:53]

Thanks for cleaning this up!

-                                 use,
-                                 to_convert_reps->at(index),
-                                 req) < 0) {
-      ++index;
-    }
-    if (FLAG_trace_representation) {
-      PrintF("Inserting a representation change to %s of %d for use at %d\n",
-             req.Mnemonic(),
-             current->id(),
-             use->id());
-    }
     to_convert->InsertAt(index, use);
     to_convert_reps->InsertAt(index, req);
+    ++index;
   }
 
   for (int i = 0; i < to_convert->length(); ++i) {
     HValue* use = to_convert->at(i);
     Representation r_to = to_convert_reps->at(i);
+    if (FLAG_trace_representation) {
+      PrintF("Inserting a representation change to %s of %d for use at %d\n",
+             r_to.Mnemonic(),
+             current->id(),
+             use->id());
+    }
     InsertRepresentationChangeForUse(current, use, r_to);
   }
 
   if (current->uses()->is_empty()) {
     ASSERT(current->IsConstant());
     current->Delete();
   }
   to_convert->Rewind(0);
   to_convert_reps->Rewind(0);
 }
 
 
 void HGraph::InsertRepresentationChanges() {
   HPhase phase("Insert representation changes", this);

[fschneider, 2011/05/10 10:44:53]

Not sure that the representation computation does the right thing. Why can you
just remove this part?

Maybe we can do something a little simpler without introducing completely
separate representations for ClampedUint8 and TruncatedInt32.

All values for ClampedUint8, int8, int16, int32, uint8 and uint16 can be
precisely represented as our current Representation::Integer32.

How about attaching the additional information to the range-information and let
the HStoreKeyedSpecialized decide whether to generate conversion code based on
the range and the representation of the input value.

This would avoid the complications with having phi-instructions and phi-uses of
even more different representations.

We still have a small problem with Uint32 values since they are outside the
int32 range - but probably we should deal with this one in a separate change
anyway.

-
-
-  // Compute truncation flag for phis: Initially assume that all
-  // int32-phis allow truncation and iteratively remove the ones that
-  // are used in an operation that does not allow a truncating
-  // conversion.
-  // TODO(fschneider): Replace this with a worklist-based iteration.
-  for (int i = 0; i < phi_list()->length(); i++) {
-    HPhi* phi = phi_list()->at(i);
-    if (phi->representation().IsInteger32()) {
-      phi->SetFlag(HValue::kTruncatingToInt32);
-    }
-  }
-  bool change = true;
-  while (change) {
-    change = false;
-    for (int i = 0; i < phi_list()->length(); i++) {
-      HPhi* phi = phi_list()->at(i);
-      if (!phi->CheckFlag(HValue::kTruncatingToInt32)) continue;
-      for (int j = 0; j < phi->uses()->length(); j++) {
-        HValue* use = phi->uses()->at(j);
-        if (!use->CheckFlag(HValue::kTruncatingToInt32)) {
-          phi->ClearFlag(HValue::kTruncatingToInt32);
-          change = true;
-          break;
-        }
-      }
-    }
-  }
-
   ZoneList<HValue*> value_list(4);
   ZoneList<Representation> rep_list(4);
   for (int i = 0; i < blocks_.length(); ++i) {
     // Process phi instructions first.
     for (int j = 0; j < blocks_[i]->phis()->length(); j++) {
       HPhi* phi = blocks_[i]->phis()->at(j);
       InsertRepresentationChangesForValue(phi, &value_list, &rep_list);
     }
 
     // Process normal instructions.
@@ skipping 11 matching lines @@
   for (int i = 0; i < blocks_.length(); ++i) {
     for (HInstruction* current = blocks_[i]->first();
          current != NULL;
          current = current->next()) {
       if (current->IsChange()) {
         HChange* change = HChange::cast(current);
         // Propagate flags for negative zero checks upwards from conversions
         // int32-to-tagged and int32-to-double.
         Representation from = change->value()->representation();
         ASSERT(from.Equals(change->from()));
-        if (from.IsInteger32()) {
+        if (from.IsInteger() && !change->to().IsInteger()) {
           ASSERT(change->to().IsTagged() || change->to().IsDouble());
           ASSERT(visited.IsEmpty());
           PropagateMinusZeroChecks(change->value(), &visited);
           visited.Clear();
         }
       }
     }
   }
 }
 
@@ skipping 4208 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal