Inline getters of byte array view in the optimized flow graph.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 766 matching lines @@
             call->deopt_id() : Isolate::kNoDeoptId;
       }
       break;
     default:
       return false;
   }
   Value* array = NULL;
   Value* index = NULL;
   intptr_t array_cid = PrepareIndexedOp(call, class_id, &array, &index);
   Definition* array_op =
-      new LoadIndexedInstr(array, index, array_cid, deopt_id);
+      new LoadIndexedInstr(array,
+                           index,
+                           FlowGraphCompiler::ElementSizeFor(array_cid),
+                           array_cid,
+                           deopt_id);
   call->ReplaceWith(array_op, current_iterator());
   RemovePushArguments(call);
   return true;
 }
 
 
 void FlowGraphOptimizer::InsertBefore(Instruction* next,
                                       Instruction* instr,
                                       Environment* env,
                                       Definition::UseKind use_kind) {
@@ skipping 524 matching lines @@
     length->set_recognized_kind(MethodRecognizer::kStringBaseLength);
     InsertBefore(call, length, NULL, Definition::kValue);
     InsertBefore(call,
                  new CheckArrayBoundInstr(new Value(length),
                                           index->Copy(),
                                           cid,
                                           call),
                  call->env(),
                  Definition::kEffect);
   }
-  return new LoadIndexedInstr(str, index, cid, Isolate::kNoDeoptId);
+  return new LoadIndexedInstr(str,
+                              index,
+                              FlowGraphCompiler::ElementSizeFor(cid),
+                              cid,
+                              Isolate::kNoDeoptId);  // Can't deoptimize.
 }
 
 
 void FlowGraphOptimizer::ReplaceWithMathCFunction(
   InstanceCallInstr* call,
   MethodRecognizer::Kind recognized_kind) {
   AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
   ZoneGrowableArray<Value*>* args =
       new ZoneGrowableArray<Value*>(call->ArgumentCount());
   for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
     args->Add(call->ArgumentAt(i)->value());
   }
   InvokeMathCFunctionInstr* invoke =
       new InvokeMathCFunctionInstr(args, call, recognized_kind);
   call->ReplaceWith(invoke, current_iterator());
   RemovePushArguments(call);
 }
 
 
+static bool IsSupportedByteArrayCid(intptr_t cid) {
+  switch (cid) {
+    case kInt8ArrayCid:
+    case kUint8ArrayCid:
+    case kUint8ClampedArrayCid:
+    case kInt16ArrayCid:
+    case kUint16ArrayCid:
+    case kInt32ArrayCid:
+    case kUint32ArrayCid:
+    case kFloat32ArrayCid:
+    case kFloat64ArrayCid:

[srdjan, 2013/02/06 17:11:16]

They may be ordered, i.e., you could check for ranges, maybe...

[Florian Schneider, 2013/02/14 12:20:51]

How can I make sure that they are ordered? It would be nice to have
kFirstByteArrayCid and kLastByteArrayCid for a concise cid check.

Right now, I'm hoping that gcc figures out an efficient check if they're are
indeed ordered.

[srdjan, 2013/02/14 16:36:35]

They are ordered but not as we need it, see RawObject::IsByteArrayClassId.

+      return true;
+    default:
+      return false;
+  }
+}
+
+
 // Inline only simple, frequently called core library methods.
 bool FlowGraphOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if ((ic_data.NumberOfChecks() == 0) || !ic_data.HasOneTarget()) {
     // No type feedback collected or multiple targets found.
     return false;
   }
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
@@ skipping 71 matching lines @@
           call->ReplaceWith(d2d_instr, current_iterator());
           RemovePushArguments(call);
         }
         return true;
       default:
         // Unsupported method.
         return false;
     }
   }
 
+  if (IsSupportedByteArrayCid(class_ids[0]) && ic_data.NumberOfChecks() == 1) {

[srdjan, 2013/02/06 17:11:16]

Add Parenthesis

[Florian Schneider, 2013/02/14 12:20:51]

Done.

+    Definition* array_op = NULL;
+    switch (recognized_kind) {
+      case MethodRecognizer::kByteArrayBaseGetInt8:
+        array_op = BuildByteArrayViewLoad(call, class_ids[0], kInt8ArrayCid);
+        break;
+      case MethodRecognizer::kByteArrayBaseGetUint8:
+        array_op = BuildByteArrayViewLoad(call, class_ids[0], kUint8ArrayCid);
+        break;
+      case MethodRecognizer::kByteArrayBaseGetInt16:
+        array_op = BuildByteArrayViewLoad(call, class_ids[0], kInt16ArrayCid);
+        break;
+      case MethodRecognizer::kByteArrayBaseGetUint16:
+        array_op = BuildByteArrayViewLoad(call, class_ids[0], kUint16ArrayCid);
+        break;
+      case MethodRecognizer::kByteArrayBaseGetInt32:
+        array_op = BuildByteArrayViewLoad(call, class_ids[0], kInt32ArrayCid);
+        break;
+      case MethodRecognizer::kByteArrayBaseGetUint32:
+        array_op = BuildByteArrayViewLoad(call, class_ids[0], kUint32ArrayCid);
+        break;
+      case MethodRecognizer::kByteArrayBaseGetFloat32:
+        array_op = BuildByteArrayViewLoad(call, class_ids[0], kFloat32ArrayCid);
+        break;
+      case MethodRecognizer::kByteArrayBaseGetFloat64:
+        array_op = BuildByteArrayViewLoad(call, class_ids[0], kFloat64ArrayCid);
+        break;
+      default:
+        // Unsupported method.
+        return false;
+    }
+    ASSERT(array_op != NULL);
+    call->ReplaceWith(array_op, current_iterator());
+    RemovePushArguments(call);
+    return true;
+  }
   return false;
 }
 
 
+LoadIndexedInstr* FlowGraphOptimizer::BuildByteArrayViewLoad(
+    InstanceCallInstr* call,
+    intptr_t receiver_cid,
+    intptr_t view_cid) {
+    Value* array = call->ArgumentAt(0)->value();
+    Value* byte_index = call->ArgumentAt(1)->value();
+
+    AddCheckClass(call, array->Copy());
+    const bool is_immutable = true;
+    LoadFieldInstr* length = new LoadFieldInstr(
+        array->Copy(),
+        CheckArrayBoundInstr::LengthOffsetFor(receiver_cid),
+        Type::ZoneHandle(Type::SmiType()),
+        is_immutable);
+    length->set_result_cid(kSmiCid);
+    length->set_recognized_kind(
+        LoadFieldInstr::RecognizedKindFromArrayCid(receiver_cid));
+    InsertBefore(call, length, NULL, Definition::kValue);
+
+    // len_in_bytes = length * kBytesPerElement(receiver)
+    intptr_t element_size = FlowGraphCompiler::ElementSizeFor(receiver_cid);
+    ConstantInstr* bytes_per_element =
+        new ConstantInstr(Smi::Handle(Smi::New(element_size)));
+    InsertBefore(call, bytes_per_element, NULL, Definition::kValue);
+    BinarySmiOpInstr* len_in_bytes =
+        new BinarySmiOpInstr(Token::kMUL,
+                             call,
+                             new Value(length),
+                             new Value(bytes_per_element));
+    InsertBefore(call, len_in_bytes, call->env(), Definition::kValue);
+
+    // Check byte_index < len_in_bytes.
+    InsertBefore(call,
+                 new CheckArrayBoundInstr(new Value(len_in_bytes),
+                                          byte_index->Copy(),
+                                          receiver_cid,
+                                          call),
+                 call->env(),
+                 Definition::kEffect);
+
+    // TODO(fschneider): Optimistically build smi load for Int32 and Uint32
+    // loads on ia32 like we do for normal array loads, and only revert to
+    // mint case after deoptimizing here.
+    return new LoadIndexedInstr(array,
+                                byte_index,
+                                1,  // Index scale.
+                                view_cid,
+                                Isolate::kNoDeoptId);  // Can't deoptimize.
+}
+
+
 // Returns a Boolean constant if all classes in ic_data yield the same type-test
 // result and the type tests do not depend on type arguments. Otherwise return
 // Bool::null().
 RawBool* FlowGraphOptimizer::InstanceOfAsBool(const ICData& ic_data,
                                               const AbstractType& type) const {
   ASSERT(ic_data.num_args_tested() == 1);  // Unary checks only.
   if (!type.IsInstantiated() || type.IsMalformed()) return Bool::null();
   const Class& type_class = Class::Handle(type.type_class());
   if (type_class.HasTypeArguments()) return Bool::null();
   const ClassTable& class_table = *Isolate::Current()->class_table();
@@ skipping 3104 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart