Basic support for tracking smi-only arrays on ia32.

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 3911 matching lines @@
       case EXTERNAL_INT_ELEMENTS:
       case EXTERNAL_UNSIGNED_INT_ELEMENTS: {
         HToInt32* floor_val = new(zone()) HToInt32(val);
         AddInstruction(floor_val);
         val = floor_val;
         break;
       }
       case EXTERNAL_FLOAT_ELEMENTS:
       case EXTERNAL_DOUBLE_ELEMENTS:
         break;
+      case FAST_SMI_ONLY_ELEMENTS:
       case FAST_ELEMENTS:
       case FAST_DOUBLE_ELEMENTS:
       case DICTIONARY_ELEMENTS:
       case NON_STRICT_ARGUMENTS_ELEMENTS:
         UNREACHABLE();
         break;
     }
     return new(zone()) HStoreKeyedSpecializedArrayElement(
         external_elements, checked_key, val, elements_kind);
   } else {
@@ skipping 91 matching lines @@
 
   HBasicBlock* join = graph()->CreateBasicBlock();
 
   HInstruction* elements_kind_instr =
       AddInstruction(new(zone()) HElementsKind(object));
   HCompareConstantEqAndBranch* elements_kind_branch = NULL;
   HInstruction* elements = AddInstruction(new(zone()) HLoadElements(object));
   HLoadExternalArrayPointer* external_elements = NULL;
   HInstruction* checked_key = NULL;
 
-  // FAST_ELEMENTS is assumed to be the first case.
-  STATIC_ASSERT(FAST_ELEMENTS == 0);
+  // FAST_SMI_ONLY_ELEMENTS is assumed to be the first case.
+  STATIC_ASSERT(FAST_SMI_ONLY_ELEMENTS == 0);
 
-  for (ElementsKind elements_kind = FAST_ELEMENTS;
+  for (ElementsKind elements_kind = FAST_SMI_ONLY_ELEMENTS;

[Rico, 2011/09/16 09:40:10]

Use FIRST_ELEMENTS_KIND instead and remove assert? (or am I missing something
subtle here?

[Jakob Kummerow, 2011/09/16 16:30:34]

The point is that fast elements are handled before external elements. You could
express that with a different assert, but some assert is necessary.

[danno, 2011/09/21 14:32:04]

Done.

        elements_kind <= LAST_ELEMENTS_KIND;
        elements_kind = ElementsKind(elements_kind + 1)) {
     // After having handled FAST_ELEMENTS and DICTIONARY_ELEMENTS, we

[Jakob Kummerow, 2011/09/16 16:30:34]

Update this comment please (either "FAST_SMI_ONLY_ELEMENTS, FAST_ELEMENTS and
DICT...", or just "fast elements and DICT..."

[danno, 2011/09/21 14:32:04]

Done.

     // need to add some code that's executed for all external array cases.
     STATIC_ASSERT(LAST_EXTERNAL_ARRAY_ELEMENTS_KIND ==
                   LAST_ELEMENTS_KIND);
     if (elements_kind == FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND
         && todo_external_array) {
       HInstruction* length =
           AddInstruction(new(zone()) HFixedArrayBaseLength(elements));
       checked_key = AddInstruction(new(zone()) HBoundsCheck(key, length));
       external_elements = new(zone()) HLoadExternalArrayPointer(elements);
       AddInstruction(external_elements);
     }
     if (type_todo[elements_kind]) {
       HBasicBlock* if_true = graph()->CreateBasicBlock();
       HBasicBlock* if_false = graph()->CreateBasicBlock();
       elements_kind_branch = new(zone()) HCompareConstantEqAndBranch(
           elements_kind_instr, elements_kind, Token::EQ_STRICT);
       elements_kind_branch->SetSuccessorAt(0, if_true);
       elements_kind_branch->SetSuccessorAt(1, if_false);
       current_block()->Finish(elements_kind_branch);
 
       set_current_block(if_true);
       HInstruction* access;
-      if (elements_kind == FAST_ELEMENTS ||
+      if (elements_kind == FAST_SMI_ONLY_ELEMENTS ||
+          elements_kind == FAST_ELEMENTS ||
           elements_kind == FAST_DOUBLE_ELEMENTS) {
         bool fast_double_elements =
             elements_kind == FAST_DOUBLE_ELEMENTS;
-        if (is_store && elements_kind == FAST_ELEMENTS) {
+        if (is_store && (elements_kind == FAST_ELEMENTS ||

[Rico, 2011/09/16 09:40:10]

is_store && !fast_double_elements ?

[danno, 2011/09/21 14:32:04]

Done.

+                         elements_kind == FAST_SMI_ONLY_ELEMENTS)) {
           AddInstruction(new(zone()) HCheckMap(
               elements, isolate()->factory()->fixed_array_map(),
               elements_kind_branch));
         }
         HBasicBlock* if_jsarray = graph()->CreateBasicBlock();
         HBasicBlock* if_fastobject = graph()->CreateBasicBlock();
         HHasInstanceTypeAndBranch* typecheck =
             new(zone()) HHasInstanceTypeAndBranch(object, JS_ARRAY_TYPE);
         typecheck->SetSuccessorAt(0, if_jsarray);
         typecheck->SetSuccessorAt(1, if_fastobject);
         current_block()->Finish(typecheck);
 
         set_current_block(if_jsarray);
         HInstruction* length = new(zone()) HJSArrayLength(object, typecheck);
         AddInstruction(length);
         checked_key = AddInstruction(new(zone()) HBoundsCheck(key, length));
         if (is_store) {
           if (fast_double_elements) {
             access = AddInstruction(
                 new(zone()) HStoreKeyedFastDoubleElement(elements,
                                                          checked_key,
                                                          val));
           } else {
+            ASSERT(elements_kind != FAST_SMI_ONLY_ELEMENTS);

[Rico, 2011/09/16 09:40:10]

Why can't we end up here with FAST_SMI_ONLY_ELEMENTS ?

[danno, 2011/09/21 14:32:04]

Done.

             access = AddInstruction(
-                new(zone()) HStoreKeyedFastElement(elements, checked_key, val));
+                new(zone()) HStoreKeyedFastElement(elements,

[Jakob Kummerow, 2011/09/16 16:30:34]

Why the line breaks?

[danno, 2011/09/21 14:32:04]

Done.

+                                                   checked_key,
+                                                   val));
           }
         } else {
           if (fast_double_elements) {
             access = AddInstruction(
                 new(zone()) HLoadKeyedFastDoubleElement(elements, checked_key));
           } else {
             access = AddInstruction(
                 new(zone()) HLoadKeyedFastElement(elements, checked_key));
           }
           Push(access);
@@ skipping 2702 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal