Do back propagation of types(classes) for checks in load and store indexed.

runtime/vm/opt_code_generator_ia32.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/opt_code_generator.h"
 
 #include "vm/assembler_macros.h"
@@ skipping 682 matching lines @@
 }
 
 
 // SHL: Implement with slow case so that it works both with Smi and Mint types.
 // Result is in EAX. Mangles ECX, EBX, EDX.
 void OptimizingCodeGenerator::GenerateSmiShiftBinaryOp(BinaryOpNode* node) {
   if (node->kind() == Token::kSAR) {
     // TODO(srdjan): Implement for Mint?
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EAX, ECX, kDeoptSAR);
+    CodeGenInfo left_info(node->left());
+    CodeGenInfo right_info(node->right());
     // EAX: value to shift, ECX: amount to shift.
     VisitLoadTwo(node->left(), node->right(), EAX, ECX);
-    // Check if both Smi.
-    __ movl(EBX, EAX);
-    __ orl(EBX, ECX);
-    __ testl(EBX, Immediate(kSmiTagMask));
-    __ j(NOT_ZERO, deopt_blob->label());
+    if (!left_info.IsClass(smi_class_) || !right_info.IsClass(smi_class_)) {
+      // Check if both Smi.
+      __ movl(EBX, EAX);
+      __ orl(EBX, ECX);
+      __ testl(EBX, Immediate(kSmiTagMask));
+      __ j(NOT_ZERO, deopt_blob->label());
+      PropagateBackLocalClass(node->left(), smi_class_);
+      PropagateBackLocalClass(node->right(), smi_class_);
+    }
     Immediate count_limit = Immediate(0x1F);
     __ SmiUntag(ECX);
     __ cmpl(ECX, count_limit);
     Label shift_count_ok;
     __ j(LESS_EQUAL, &shift_count_ok, Assembler::kNearJump);
     __ movl(ECX, count_limit);
     __ Bind(&shift_count_ok);
     // Shift amount must be in ECX.
     __ SmiUntag(EAX);  // Value.
     __ sarl(EAX, ECX);
     __ SmiTag(EAX);
     return;
   }
   ASSERT(node->kind() == Token::kSHL);
   if (node->right()->IsLiteralNode() &&
       node->right()->AsLiteralNode()->literal().IsSmi()) {
     Label done;
     // Shift count is a Smi literal.
     Smi& smi = Smi::Handle();
     smi ^= node->right()->AsLiteralNode()->literal().raw();
     if (smi.Value() < Smi::kBits) {
       Label slow_case;
+      CodeGenInfo left_info(node->left());
       VisitLoadOne(node->left(), EAX);
-      __ testl(EAX, Immediate(kSmiTagMask));
-      __ j(NOT_ZERO, &slow_case, Assembler::kNearJump);  // left not smi
+      if (!left_info.IsClass(smi_class_)) {
+        __ testl(EAX, Immediate(kSmiTagMask));
+        __ j(NOT_ZERO, &slow_case, Assembler::kNearJump);  // left not smi
+      }
       // Overflow test.
       __ movl(EBX, EAX);
       Immediate imm(smi.Value());
       __ shll(EBX, imm);
       __ sarl(EBX, imm);
       __ cmpl(EAX, EBX);
       __ j(NOT_EQUAL, &slow_case, Assembler::kNearJump);  // Overflow.
       __ shll(EAX, imm);  // Shift for result now we know there is no overflow.
       __ jmp(&done);
       __ Bind(&slow_case);
       __ pushl(EAX);
       __ pushl(Immediate(reinterpret_cast<int32_t>(smi.raw())));
       const int number_of_arguments = 2;
       const Array& no_optional_argument_names = Array::Handle();
       GenerateCheckedInstanceCalls(node,
                                    node->left(),
                                    node->id(),
                                    node->token_index(),
                                    number_of_arguments,
                                    no_optional_argument_names);
       __ Bind(&done);
       return;
     }
   }
 
   Label slow_case, done;
+  CodeGenInfo left_info(node->left());
+  CodeGenInfo right_info(node->right());
   VisitLoadTwo(node->left(), node->right(), EAX, EDX);
   // TODO(srdjan): Better code for count being a Smi literal.
   // EAX: value, EDX: shift amount. Preserve them for slow case.
   // Fast case only if both ar Smi.
-  __ movl(EBX, EAX);
-  __ orl(EBX, EDX);
-  __ testl(EBX, Immediate(kSmiTagMask));
-  __ j(NOT_ZERO, &slow_case, Assembler::kNearJump);
+  if (!left_info.IsClass(smi_class_) || !right_info.IsClass(smi_class_)) {
+    __ movl(EBX, EAX);
+    __ orl(EBX, EDX);
+    __ testl(EBX, Immediate(kSmiTagMask));
+    __ j(NOT_ZERO, &slow_case, Assembler::kNearJump);
+  }
   // Check if count too large for handling it inlined.
   __ cmpl(EDX, Immediate(reinterpret_cast<int32_t>(Smi::New(Smi::kBits))));
   __ j(ABOVE_EQUAL, &slow_case, Assembler::kNearJump);
   // Shift amount must be in ECX.
   __ movl(ECX, EDX);
   __ movl(EBX, EAX);
   __ SmiUntag(ECX);
   // Overflow test.
   __ shll(EBX, ECX);
   __ sarl(EBX, ECX);
@@ skipping 27 matching lines @@
   DeoptimizationBlob* deopt_blob =
       AddDeoptimizationBlob(node, EAX, deopt_reason_id);
   CodeGenInfo info(node->operand());
   VisitLoadOne(node->operand(), EAX);
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback.
     __ jmp(deopt_blob->label());
     return;
   }
   ASSERT(ic_data.NumberOfChecks() == 1);
-  __ testl(EAX, Immediate(kSmiTagMask));
-  __ j(NOT_ZERO, deopt_blob->label());
+  if (!info.IsClass(smi_class_)) {
+    __ testl(EAX, Immediate(kSmiTagMask));
+    __ j(NOT_ZERO, deopt_blob->label());
+    PropagateBackLocalClass(node->operand(), smi_class_);
+  }
   if (node->kind() == Token::kSUB) {
     __ negl(EAX);
     __ j(OVERFLOW, deopt_blob->label());
   } else {
     ASSERT(node->kind() == Token::kBIT_NOT);
     __ notl(EAX);
     __ andl(EAX, Immediate(~kSmiTagMask));  // Remove inverted smi-tag.
   }
   HandleResult(node, EAX);
 }
@@ skipping 1539 matching lines @@
 void OptimizingCodeGenerator::VisitLoadIndexedNode(LoadIndexedNode* node) {
   const char* kMessage = "Inline indexed access";
   ObjectStore* object_store = Isolate::Current()->object_store();
   const Class& object_array_class =
       Class::ZoneHandle(object_store->array_class());
   const Class& immutable_object_array_class =
       Class::ZoneHandle(object_store->immutable_array_class());
   if (AtIdNodeHasClassAt(node, node->id(), object_array_class, 0) ||
       AtIdNodeHasClassAt(node, node->id(),
           immutable_object_array_class, 0)) {
+    CodeGenInfo array_info(node->array());
+    CodeGenInfo index_info(node->index_expr());
     VisitLoadTwo(node->array(), node->index_expr(), EBX, EDX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EBX, EDX, kDeoptLoadIndexedFixedArray);
     const Class& test_class =
         AtIdNodeHasClassAt(node, node->id(), object_array_class, 0) ?
             object_array_class : immutable_object_array_class;
     // Type checks of array.
-    __ testl(EBX, Immediate(kSmiTagMask));  // Deoptimize if Smi.
-    __ j(ZERO, deopt_blob->label());
-    __ movl(EAX, FieldAddress(EBX, Object::class_offset()));
-    __ CompareObject(EAX, test_class);
-    __ j(NOT_EQUAL, deopt_blob->label());
+    if (!array_info.IsClass(test_class)) {
+      __ testl(EBX, Immediate(kSmiTagMask));  // Deoptimize if Smi.
+      __ j(ZERO, deopt_blob->label());
+      __ movl(EAX, FieldAddress(EBX, Object::class_offset()));
+      __ CompareObject(EAX, test_class);
+      __ j(NOT_EQUAL, deopt_blob->label());
+      PropagateBackLocalClass(node->array(), test_class);
+    }
 
     // Type check of index.
-    __ testl(EDX, Immediate(kSmiTagMask));
-    __ j(NOT_ZERO, deopt_blob->label());
+    if (!index_info.IsClass(smi_class_)) {
+      __ testl(EDX, Immediate(kSmiTagMask));
+      __ j(NOT_ZERO, deopt_blob->label());
+      PropagateBackLocalClass(node->index_expr(), smi_class_);
+    }
     // Range check.
     __ cmpl(EDX, FieldAddress(EBX, Array::length_offset()));
     __ j(ABOVE_EQUAL, deopt_blob->label());
     // Note that EDX is Smi, i.e, times 2.
     ASSERT(kSmiTagShift == 1);
     __ movl(EAX, FieldAddress(EBX, EDX, TIMES_2, sizeof(RawArray)));
     HandleResult(node, EAX);
     TraceOpt(node, kMessage);
     return;
   }
 
   const String& growable_object_array_class_name = String::Handle(
       String::NewSymbol(kGrowableArrayClassName));
   const Class& growable_array_class = Class::ZoneHandle(
       Library::Handle(Library::CoreImplLibrary()).
           LookupClass(growable_object_array_class_name));
   ASSERT(!growable_array_class.IsNull());
   if (AtIdNodeHasClassAt(node, node->id(), growable_array_class, 0)) {
     const String& growable_array_length_field_name =
         String::Handle(String::NewSymbol(kGrowableArrayLengthFieldName));
     const String& growable_array_array_field_name =
         String::Handle(String::NewSymbol(kGrowableArrayArrayFieldName));
     intptr_t length_offset = GetFieldOffset(growable_array_class,
                                             growable_array_length_field_name);
     intptr_t array_offset = GetFieldOffset(growable_array_class,
                                            growable_array_array_field_name);
+    CodeGenInfo array_info(node->array());
+    CodeGenInfo index_info(node->index_expr());
     VisitLoadTwo(node->array(), node->index_expr(), EDX, EAX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EDX, EAX, kDeoptLoadIndexedGrowableArray);
-    // TODO(srdjan): Use CodeGenInfo to eliminate Smi test if possible.
     // EAX: index, EDX: array.
-    __ testl(EAX, Immediate(kSmiTagMask));
-    __ j(NOT_ZERO, deopt_blob->label());  // Not Smi index.
-    __ testl(EDX, Immediate(kSmiTagMask));
-    __ j(ZERO, deopt_blob->label());  // Array is Smi.
-    __ movl(EBX, FieldAddress(EDX, Object::class_offset()));
-    __ CompareObject(EBX, growable_array_class);
-    __ j(NOT_EQUAL, deopt_blob->label());  // Array is not GrowableObjectArray.
+    if (!index_info.IsClass(smi_class_)) {
+      __ testl(EAX, Immediate(kSmiTagMask));
+      __ j(NOT_ZERO, deopt_blob->label());  // Not Smi index.
+      PropagateBackLocalClass(node->index_expr(), smi_class_);
+    }
+    if (!array_info.IsClass(growable_array_class)) {
+      __ testl(EDX, Immediate(kSmiTagMask));
+      __ j(ZERO, deopt_blob->label());  // Array is Smi.
+      __ movl(EBX, FieldAddress(EDX, Object::class_offset()));
+      __ CompareObject(EBX, growable_array_class);
+      __ j(NOT_EQUAL, deopt_blob->label());  // Not GrowableObjectArray.
+      PropagateBackLocalClass(node->array(), growable_array_class);
+    }
     // Range check: deoptimize if out of bounds.
     __ cmpl(EAX, FieldAddress(EDX, length_offset));
     __ j(ABOVE_EQUAL, deopt_blob->label());
     __ movl(EDX, FieldAddress(EDX, array_offset));  // backingArray.
     // Note that EAX is Smi, i.e, times 2.
     ASSERT(kSmiTagShift == 1);
     __ movl(EAX, FieldAddress(EDX, EAX, TIMES_2, sizeof(RawArray)));
     HandleResult(node, EAX);
     return;
   } else {
@@ skipping 16 matching lines @@
       Class::ZoneHandle(object_store->array_class());
   const ICData& ic_data = node->ICDataAtId(node->id());
   if (ic_data.NumberOfChecks() == 0) {
     VisitLoadTwo(node->index_expr(), node->value(), EBX, ECX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EBX, ECX, kDeoptNoTypeFeedback);
     __ jmp(deopt_blob->label());
     return;
   }
 
+  CodeGenInfo array_info(node->array());
+  CodeGenInfo index_info(node->index_expr());
+
   if (AtIdNodeHasClassAt(node, node->id(), object_array_class, 0)) {
     VisitLoadTwo(node->index_expr(), node->value(), EBX, ECX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EAX, EBX, ECX, kDeoptStoreIndexed);
     __ popl(EAX);  // array.
     // ECX: value, EBX:index, EAX: array.
     // Check class of array.
-    __ testl(EAX, Immediate(kSmiTagMask));
-    __ j(ZERO, deopt_blob->label());  // Array is smi -> deopt.
-    __ movl(EDX, FieldAddress(EAX, Object::class_offset()));
-    __ CompareObject(EDX, object_array_class);
-    __ j(NOT_EQUAL, deopt_blob->label());  // Not ObjectArray -> deopt.
+    if (!array_info.IsClass(object_array_class)) {
+      __ testl(EAX, Immediate(kSmiTagMask));
+      __ j(ZERO, deopt_blob->label());  // Array is smi -> deopt.
+      __ movl(EDX, FieldAddress(EAX, Object::class_offset()));
+      __ CompareObject(EDX, object_array_class);
+      __ j(NOT_EQUAL, deopt_blob->label());  // Not ObjectArray -> deopt.
+      PropagateBackLocalClass(node->array(), object_array_class);
+    }
     // Check class of index.
-    __ testl(EBX, Immediate(kSmiTagMask));
-    __ j(NOT_ZERO, deopt_blob->label());  // Index not Smi -> deopt.
+    if (!index_info.IsClass(smi_class_)) {
+      __ testl(EBX, Immediate(kSmiTagMask));
+      __ j(NOT_ZERO, deopt_blob->label());  // Index not Smi -> deopt.
+      PropagateBackLocalClass(node->index_expr(), smi_class_);
+    }
     // Range check.
     __ cmpl(EBX, FieldAddress(EAX, Array::length_offset()));
     __ j(ABOVE_EQUAL, deopt_blob->label());  // Range error -> deopt.
     ASSERT(kSmiTagShift == 1);
     __ StoreIntoObject(EAX,
                        FieldAddress(EAX, EBX, TIMES_2, sizeof(RawArray)),
                        ECX);
     HandleResult(node, ECX);
     return;
   }
@@ skipping 12 matching lines @@
     intptr_t length_offset = GetFieldOffset(growable_array_class,
                                             growable_array_length_field_name);
     intptr_t array_offset = GetFieldOffset(growable_array_class,
                                            growable_array_array_field_name);
     VisitLoadTwo(node->index_expr(), node->value(), EBX, ECX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EAX, EBX, ECX, kDeoptStoreIndexed);
     __ popl(EAX);  // Array.
     // ECX: value, EBX:index, EAX: array, EDX: scratch.
     // Check class of array.
-    __ testl(EAX, Immediate(kSmiTagMask));
-    __ j(ZERO, deopt_blob->label());  // Array is smi -> deopt.
-    __ movl(EDX, FieldAddress(EAX, Object::class_offset()));
-    __ CompareObject(EDX, growable_array_class);
-    __ j(NOT_EQUAL, deopt_blob->label());  // Not GrowableObjectArray -> deopt.
+    if (!array_info.IsClass(growable_array_class)) {
+      __ testl(EAX, Immediate(kSmiTagMask));
+      __ j(ZERO, deopt_blob->label());  // Array is smi -> deopt.
+      __ movl(EDX, FieldAddress(EAX, Object::class_offset()));
+      __ CompareObject(EDX, growable_array_class);
+      __ j(NOT_EQUAL, deopt_blob->label());  // Not GrowableObjectArray.
+      PropagateBackLocalClass(node->array(), growable_array_class);
+    }
     // Check class of index.
-    __ testl(EBX, Immediate(kSmiTagMask));
-    __ j(NOT_ZERO, deopt_blob->label());  // Index not Smi -> deopt.
+    if (!index_info.IsClass(smi_class_)) {
+      __ testl(EBX, Immediate(kSmiTagMask));
+      __ j(NOT_ZERO, deopt_blob->label());  // Index not Smi -> deopt.
+      PropagateBackLocalClass(node->index_expr(), smi_class_);
+    }
     // Range check: deoptimize if out of bounds.
     __ cmpl(EBX, FieldAddress(EAX, length_offset));
     __ j(ABOVE_EQUAL, deopt_blob->label());
     __ movl(EDX, FieldAddress(EAX, array_offset));  // backingArray.
     // Note that EAX is Smi, i.e, times 2.
     ASSERT(kSmiTagShift == 1);
     __ StoreIntoObject(EDX,
                        FieldAddress(EDX, EBX, TIMES_2, sizeof(RawArray)),
                        ECX);
     HandleResult(node, ECX);
@@ skipping 543 matching lines @@
     }
   }
   // TODO(srdjan): Implement unary kSUB (negate) Mint.
   CodeGenerator::VisitUnaryOpNode(node);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32