Implement basic array prefetching hints in Hydrogen.

src/ia32/lithium-codegen-ia32.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 2831 matching lines @@
       case FAST_DOUBLE_ELEMENTS:
       case FAST_HOLEY_SMI_ELEMENTS:
       case FAST_HOLEY_ELEMENTS:
       case FAST_HOLEY_DOUBLE_ELEMENTS:
       case DICTIONARY_ELEMENTS:
       case NON_STRICT_ARGUMENTS_ELEMENTS:
         UNREACHABLE();
         break;
     }
   }
+
+  if (instr->prefetch_distance() != NULL) {
+    InsertArrayPrefetch(
+        operand,
+        instr->prefetch_distance(),
+        elements_kind,
+        ToRegister(instr->temp()));
+  }
 }
 
 
 void LCodeGen::DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr) {
   XMMRegister result = ToDoubleRegister(instr->result());
 
   if (instr->hydrogen()->RequiresHoleCheck()) {
     int offset = FixedDoubleArray::kHeaderSize - kHeapObjectTag +
         sizeof(kHoleNanLower32);
     Operand hole_check_operand = BuildFastArrayOperand(
         instr->elements(), instr->key(),
         instr->hydrogen()->key()->representation(),
         FAST_DOUBLE_ELEMENTS,
         offset,
         instr->additional_index());
     __ cmp(hole_check_operand, Immediate(kHoleNanUpper32));
     DeoptimizeIf(equal, instr->environment());
   }
 
   Operand double_load_operand = BuildFastArrayOperand(
       instr->elements(),
       instr->key(),
       instr->hydrogen()->key()->representation(),
       FAST_DOUBLE_ELEMENTS,
       FixedDoubleArray::kHeaderSize - kHeapObjectTag,
       instr->additional_index());
   __ movdbl(result, double_load_operand);
+
+  if (instr->prefetch_distance() != NULL) {
+    InsertArrayPrefetch(
+        double_load_operand,
+        instr->prefetch_distance(),
+        FAST_DOUBLE_ELEMENTS,
+        ToRegister(instr->temp()));
+  }
 }
 
 
 void LCodeGen::DoLoadKeyedFixedArray(LLoadKeyed* instr) {
   Register result = ToRegister(instr->result());
 
+  Operand load_operand = BuildFastArrayOperand(
+      instr->elements(),
+      instr->key(),
+      instr->hydrogen()->key()->representation(),
+      FAST_ELEMENTS,
+      FixedArray::kHeaderSize - kHeapObjectTag,
+      instr->additional_index());
+
   // Load the result.
-  __ mov(result,
-         BuildFastArrayOperand(instr->elements(),
-                               instr->key(),
-                               instr->hydrogen()->key()->representation(),
-                               FAST_ELEMENTS,
-                               FixedArray::kHeaderSize - kHeapObjectTag,
-                               instr->additional_index()));
+  __ mov(result, load_operand);
 
   // Check for the hole value.
   if (instr->hydrogen()->RequiresHoleCheck()) {
     if (IsFastSmiElementsKind(instr->hydrogen()->elements_kind())) {
       __ test(result, Immediate(kSmiTagMask));
       DeoptimizeIf(not_equal, instr->environment());
     } else {
       __ cmp(result, factory()->the_hole_value());
       DeoptimizeIf(equal, instr->environment());
     }
   }
+
+  if (instr->prefetch_distance() != NULL) {
+    InsertArrayPrefetch(
+        load_operand,
+        instr->prefetch_distance(),
+        FAST_ELEMENTS,
+        ToRegister(instr->temp()));
+  }
 }
 
 
 void LCodeGen::DoLoadKeyed(LLoadKeyed* instr) {
   if (instr->is_external()) {
     DoLoadKeyedExternalArray(instr);
   } else if (instr->hydrogen()->representation().IsDouble()) {
     DoLoadKeyedFixedDoubleArray(instr);
   } else {
     DoLoadKeyedFixedArray(instr);
   }
 }
 
 
+void LCodeGen::InsertArrayPrefetch(
+    const Operand& operand,
+    LOperand* prefetch_distance,
+    ElementsKind elements_kind,
+    Register scratch) {
+  __ lea(scratch, operand);
+  int shift_size = ElementsKindToShiftSize(elements_kind);
+  if (prefetch_distance->IsConstantOperand()) {
+    __ prefetch(Operand(scratch,
+        ToInteger32(LConstantOperand::cast(prefetch_distance)) << shift_size),
+        1);
+  } else {
+    ASSERT(prefetch_distance->IsRegister());
+    ScaleFactor scale_factor = static_cast<ScaleFactor>(shift_size);
+    __ prefetch(
+        Operand(scratch, ToRegister(prefetch_distance), scale_factor, 0), 1);
+  }
+}
+
+
 Operand LCodeGen::BuildFastArrayOperand(
     LOperand* elements_pointer,
     LOperand* key,
     Representation key_representation,
     ElementsKind elements_kind,
     uint32_t offset,
     uint32_t additional_index) {
   Register elements_pointer_reg = ToRegister(elements_pointer);
   int shift_size = ElementsKindToShiftSize(elements_kind);
   // Even though the HLoad/StoreKeyed instructions force the input
@@ skipping 2684 matching lines @@
                               FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32