Allow div and cmp to work in uint32 mode

src/hydrogen.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 3295 matching lines @@
   bool IsSafeUint32Use(HValue* val, HValue* use);
   bool Uint32UsesAreSafe(HValue* uint32val);
   bool CheckPhiOperands(HPhi* phi);
   void UnmarkPhi(HPhi* phi, ZoneList<HPhi*>* worklist);
 
   Zone* zone_;
   ZoneList<HPhi*> phis_;
 };
 
 
+bool IsUint32Operation(HValue* instr) {
+  if (instr->IsShr()) return true;
+  if (instr->IsLoadKeyed() &&
+      HLoadKeyed::cast(instr)->elements_kind() ==
+          EXTERNAL_UNSIGNED_INT_ELEMENTS) {
+    return true;
+  }
+  if (instr->IsInteger32Constant() && instr->GetInteger32Constant() >= 0) {
+    return true;
+  }
+  return false;
+}
+
+
 bool Uint32Analysis::IsSafeUint32Use(HValue* val, HValue* use) {
-  // Operations that operatate on bits are safe.
+  // Operations that operate on bits are safe.
   if (use->IsBitwise() ||
       use->IsShl() ||
       use->IsSar() ||
       use->IsShr() ||
       use->IsBitNot()) {
     return true;
   } else if (use->IsChange() || use->IsSimulate()) {
     // Conversions and deoptimization have special support for unt32.
     return true;
   } else if (use->IsStoreKeyed()) {
     HStoreKeyed* store = HStoreKeyed::cast(use);
     if (store->is_external()) {
       // Storing a value into an external integer array is a bit level
       // operation.
       if (store->value() == val) {
         // Clamping or a conversion to double should have beed inserted.
         ASSERT(store->elements_kind() != EXTERNAL_PIXEL_ELEMENTS);
         ASSERT(store->elements_kind() != EXTERNAL_FLOAT_ELEMENTS);
         ASSERT(store->elements_kind() != EXTERNAL_DOUBLE_ELEMENTS);
         return true;
       }
     }
+  } else if (use->IsCompareIDAndBranch()) {
+    for (int i = 0; i < use->OperandCount(); ++i) {
+      if (!IsUint32Operation(use->OperandAt(i))) return false;
+    }
+    return true;
+  } else if (use->IsDiv()) {
+    // Skip OperandAt(0) which is the context.
+    for (int i = 1; i < use->OperandCount(); ++i) {
+      if (!IsUint32Operation(use->OperandAt(i))) {
+        if (FLAG_trace_representation) {
+          HValue* op = use->OperandAt(i);
+          printf("#%d %s is not a safe uint32 use because of operand #%d %s\n",
+                 use->id(), use->Mnemonic(), op->id(), op->Mnemonic());
+        }
+        return false;
+      }
+    }
+    for (HUseIterator it(use->uses()); !it.Done(); it.Advance()) {
+      if (!IsSafeUint32Use(use, it.value())) {
+        if (FLAG_trace_representation) {
+          HValue* op = it.value();
+          printf("#%d %s is not a safe uint32 use because of use #%d %s\n",
+                 use->id(), use->Mnemonic(), op->id(), op->Mnemonic());
+        }
+        return false;
+      }
+    }
+    if (FLAG_trace_representation) {
+      printf("#%d %s is a safe uint32 use :-)\n", use->id(), use->Mnemonic());
+    }
+    return true;
   }
 
   return false;
 }
 
 
 // Iterate over all uses and verify that they are uint32 safe: either don't
 // distinguish between int32 and uint32 due to their bitwise nature or
 // have special support for uint32 values.
-// Encountered phis are optimisitically treated as safe uint32 uses,
+// Encountered phis are optimistically treated as safe uint32 uses,
 // marked with kUint32 flag and collected in the phis_ list. A separate
-// path will be performed later by UnmarkUnsafePhis to clear kUint32 from
-// phis that are not actually uint32-safe (it requries fix point iteration).
+// pass will be performed later by UnmarkUnsafePhis to clear kUint32 from
+// phis that are not actually uint32-safe (it requires fix point iteration).
 bool Uint32Analysis::Uint32UsesAreSafe(HValue* uint32val) {
   bool collect_phi_uses = false;
   for (HUseIterator it(uint32val->uses()); !it.Done(); it.Advance()) {
     HValue* use = it.value();
 
     if (use->IsPhi()) {
       if (!use->CheckFlag(HInstruction::kUint32)) {
         // There is a phi use of this value from a phis that is not yet
         // collected in phis_ array. Separate pass is required.
         collect_phi_uses = true;
@@ skipping 35 matching lines @@
 // Check if all operands to the given phi are marked with kUint32 flag.
 bool Uint32Analysis::CheckPhiOperands(HPhi* phi) {
   if (!phi->CheckFlag(HInstruction::kUint32)) {
     // This phi is not uint32 safe. No need to check operands.
     return false;
   }
 
   for (int j = 0; j < phi->OperandCount(); j++) {
     HValue* operand = phi->OperandAt(j);
     if (!operand->CheckFlag(HInstruction::kUint32)) {
-      // Lazyly mark constants that fit into uint32 range with kUint32 flag.
+      // Lazily mark constants that fit into uint32 range with kUint32 flag.
       if (operand->IsInteger32Constant() &&
           operand->GetInteger32Constant() >= 0) {
         operand->SetFlag(HInstruction::kUint32);
         continue;
       }
 
       // This phi is not safe, some operands are not uint32 values.
       return false;
     }
   }
@@ skipping 42 matching lines @@
 
     if (CheckPhiOperands(phi) && Uint32UsesAreSafe(phi)) {
       phis_[phi_count++] = phi;
     } else {
       UnmarkPhi(phi, &worklist);
     }
   }
 
   // Now phis array contains only those phis that have safe
   // non-phi uses. Start transitively clearing kUint32 flag
-  // from phi operands of discovered non-safe phies until
-  // only safe phies are left.
+  // from phi operands of discovered non-safe phis until
+  // only safe phis are left.
   while (!worklist.is_empty())  {
     while (!worklist.is_empty()) {
       HPhi* phi = worklist.RemoveLast();
       UnmarkPhi(phi, &worklist);
     }
 
-    // Check if any operands to safe phies were unmarked
+    // Check if any operands to safe phis were unmarked
     // turning a safe phi into unsafe. The same value
     // can flow into several phis.
     int new_phi_count = 0;
     for (int i = 0; i < phi_count; i++) {
       HPhi* phi = phis_[i];
 
       if (CheckPhiOperands(phi)) {
         phis_[new_phi_count++] = phi;
       } else {
         UnmarkPhi(phi, &worklist);
@@ skipping 14 matching lines @@
     if (current->IsLinked() && current->representation().IsInteger32()) {
       analysis.Analyze(current);
     }
   }
 
   // Some phis might have been optimistically marked with kUint32 flag.
   // Remove this flag from those phis that are unsafe and propagate
   // this information transitively potentially clearing kUint32 flag
   // from some non-phi operations that are used as operands to unsafe phis.
   analysis.UnmarkUnsafePhis();
+
+  // Inform possible uint32 instructions that the decision has been
+  // finalized.
+  for (int i = 0; i < uint32_instructions_->length(); ++i) {
+    HInstruction* current = uint32_instructions_->at(i);
+    if (FLAG_trace_representation) {
+      printf("Notifying uint32 instr: #%d %s\n",
+             current->id(), current->Mnemonic());
+    }
+    if (current->IsLinked() && current->CheckFlag(HInstruction::kUint32)) {
+      for (HUseIterator it(current->uses()); !it.Done(); it.Advance()) {
+        HValue* use = it.value();
+        // Only care about special-cased instructions here.
+        if (!use->IsDiv() && !use->IsCompareIDAndBranch()) continue;
+        use->SetFlag(HInstruction::kUint32);
+        use->AssumeRepresentation(Representation::Integer32());
+
+        if (FLAG_trace_representation) {
+          printf("Setting kUint32 flag on #%d %s\n",
+                 use->id(), use->Mnemonic());
+        }
+      }
+    }
+  }
 }
 
 
 void HGraph::ComputeMinusZeroChecks() {
   HPhase phase("H_Compute minus zero checks", this);
   BitVector visited(GetMaximumValueID(), zone());
   for (int i = 0; i < blocks_.length(); ++i) {
     for (HInstruction* current = blocks_[i]->first();
          current != NULL;
          current = current->next()) {
@@ skipping 8092 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal