Implement basic array prefetching hints in Hydrogen.

src/ia32/lithium-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 408 matching lines @@
 
 void LLoadKeyed::PrintDataTo(StringStream* stream) {
   elements()->PrintTo(stream);
   stream->Add("[");
   key()->PrintTo(stream);
   if (hydrogen()->IsDehoisted()) {
     stream->Add(" + %d]", additional_index());
   } else {
     stream->Add("]");
   }
+  if (prefetch_distance() != NULL) {
+    stream->Add(" ");
+    prefetch_distance()->PrintTo(stream);
+  }
 }
 
 
 void LStoreKeyed::PrintDataTo(StringStream* stream) {
   elements()->PrintTo(stream);
   stream->Add("[");
   key()->PrintTo(stream);
   if (hydrogen()->IsDehoisted()) {
     stream->Add(" + %d] <-", additional_index());
   } else {
@@ skipping 1587 matching lines @@
 }
 
 
 LInstruction* LChunkBuilder::DoLoadExternalArrayPointer(
     HLoadExternalArrayPointer* instr) {
   LOperand* input = UseRegisterAtStart(instr->value());
   return DefineAsRegister(new(zone()) LLoadExternalArrayPointer(input));
 }
 
 
+static bool ShouldPrefetch(HValue* distance, ElementsKind elements_kind) {
+  bool should_prefetch = true;
+
+  if (distance->IsConstant()) {
+    HConstant* prefetch_distance = HConstant::cast(distance);
+    ASSERT(prefetch_distance->HasInteger32Value());
+    int32_t distance_value = prefetch_distance->Integer32Value();
+    if (distance_value < 0) distance_value = -distance_value;
+    // Omit the nearby accesses which are supposed to hit the cache.
+    should_prefetch =
+        (distance_value >= (64 >> ElementsKindToShiftSize(elements_kind)));
+  }
+
+  return should_prefetch;
+}
+
+
 LInstruction* LChunkBuilder::DoLoadKeyed(HLoadKeyed* instr) {
   ASSERT(instr->key()->representation().IsInteger32() ||
          instr->key()->representation().IsTagged());
   ElementsKind elements_kind = instr->elements_kind();
   bool clobbers_key = ExternalArrayOpRequiresTemp(
       instr->key()->representation(), elements_kind);
   LOperand* key = clobbers_key
       ? UseTempRegister(instr->key())
       : UseRegisterOrConstantAtStart(instr->key());
   LLoadKeyed* result = NULL;
 
+  LOperand* prefetch = NULL;
+  LOperand* temp = NULL;
+  if (instr->prefetch_distance() != graph()->GetConstantUndefined() &&
+      ShouldPrefetch(instr->prefetch_distance(), elements_kind)) {
+    prefetch = UseRegisterOrConstant(instr->prefetch_distance());
+    temp = TempRegister();
+  }
+
   if (!instr->is_external()) {
     LOperand* obj = UseRegisterAtStart(instr->elements());
-    result = new(zone()) LLoadKeyed(obj, key);
+    result = new(zone()) LLoadKeyed(obj, key, prefetch, temp);
   } else {
     ASSERT(
         (instr->representation().IsInteger32() &&
          (elements_kind != EXTERNAL_FLOAT_ELEMENTS) &&
          (elements_kind != EXTERNAL_DOUBLE_ELEMENTS)) ||
         (instr->representation().IsDouble() &&
          ((elements_kind == EXTERNAL_FLOAT_ELEMENTS) ||
           (elements_kind == EXTERNAL_DOUBLE_ELEMENTS))));
     LOperand* external_pointer = UseRegister(instr->elements());
-    result = new(zone()) LLoadKeyed(external_pointer, key);
+    result = new(zone()) LLoadKeyed(external_pointer, key, prefetch, temp);
   }
 
   DefineAsRegister(result);
   bool can_deoptimize = instr->RequiresHoleCheck() ||
       (elements_kind == EXTERNAL_UNSIGNED_INT_ELEMENTS);
   // An unsigned int array load might overflow and cause a deopt, make sure it
   // has an environment.
   return can_deoptimize ? AssignEnvironment(result) : result;
 }
 
@@ skipping 440 matching lines @@
 LInstruction* LChunkBuilder::DoLoadFieldByIndex(HLoadFieldByIndex* instr) {
   LOperand* object = UseRegister(instr->object());
   LOperand* index = UseTempRegister(instr->index());
   return DefineSameAsFirst(new(zone()) LLoadFieldByIndex(object, index));
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32