Polymorphic inlining of [] operations.

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 114 matching lines @@
   V(_Uint32x4, get:flagY, Uint32x4GetFlagY, 2013140570)                        \
   V(_Uint32x4, get:flagZ, Uint32x4GetFlagZ, 944674353)                         \
   V(_Uint32x4, get:flagW, Uint32x4GetFlagW, 22686587)                          \
   V(_Uint32x4, get:signMask, Uint32x4GetSignMask, 1858084501)                  \
   V(_Uint32x4, select, Uint32x4Select, 881590808)                              \
   V(_Uint32x4, withFlagX, Uint32x4WithFlagX, 1475542073)                       \
   V(_Uint32x4, withFlagY, Uint32x4WithFlagY, 830610988)                        \
   V(_Uint32x4, withFlagZ, Uint32x4WithFlagZ, 1714792414)                       \
   V(_Uint32x4, withFlagW, Uint32x4WithFlagW, 1516924162)                       \
   V(_Uint32x4, _toFloat32x4, Uint32x4ToUint32x4, 2054503505)                   \
+  V(_ObjectArray, [], ObjectArrayGetIndexed, 93386978)                         \
+  V(_ImmutableArray, [], ImmutableArrayGetIndexed, 894753724)                  \
+  V(_GrowableObjectArray, [], GrowableArrayGetIndexed, 500679426)              \
+  V(_Float32Array, [], Float32ArrayGetIndexed, 1103519924)                     \
+  V(_Float64Array, [], Float64ArrayGetIndexed, 749351746)                      \
+  V(_Int8Array, [], Int8ArrayGetIndexed, 78158949)                             \
+  V(_Uint8Array, [], Uint8ArrayGetIndexed, 380681966)                          \
+  V(_Uint8ClampedArray, [], Uint8ClampedArrayGetIndexed, 1171127014)           \
+  V(_ExternalUint8Array, [], ExternalUint8ArrayGetIndexed, 1709616627)         \
+  V(_ExternalUint8ClampedArray, [], ExternalUint8ClampedArrayGetIndexed,       \
+    1710139506)                                                                \
+  V(_Int16Array, [], Int16ArrayGetIndexed, 1070032854)                         \
+  V(_Uint16Array, [], Uint16ArrayGetIndexed, 692410555)                        \
+  V(_Int32Array, [], Int32ArrayGetIndexed, 665555051)                          \
+  V(_Uint32Array, [], Uint32ArrayGetIndexed, 1300156137)                       \
+  V(_Float32x4Array, [], Float32x4ArrayGetIndexed, 1779360236)                 \
 
 
 // A list of core function that should always be inlined.
 #define INLINE_WHITE_LIST(V)                                                   \
   V(_ObjectArray, get:length, ObjectArrayLength, 259323113)                    \
   V(_ImmutableArray, get:length, ImmutableArrayLength, 1341942416)             \
   V(_TypedList, get:length, TypedDataLength, 26556746)                         \
   V(_GrowableObjectArray, get:length, GrowableArrayLength, 1160357614)         \
   V(_StringBase, get:length, StringBaseLength, 1483460481)                     \
   V(ListIterator, moveNext, ListIteratorMoveNext, 657540761)                   \
@@ skipping 1174 matching lines @@
   Instruction* Current() const { return current_; }
 
  private:
   BlockEntryInstr* block_entry_;
   Instruction* current_;
 };
 
 
 class GraphEntryInstr : public BlockEntryInstr {
  public:
-  GraphEntryInstr(const ParsedFunction& parsed_function,
+  GraphEntryInstr(const ParsedFunction* parsed_function,
                   TargetEntryInstr* normal_entry,
                   intptr_t osr_id);
 
   DECLARE_INSTRUCTION(GraphEntry)
 
   virtual intptr_t PredecessorCount() const { return 0; }
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const {
     UNREACHABLE();
     return NULL;
   }
@@ skipping 24 matching lines @@
   // without try-catch, this is 0. Otherwise, it is the number of local
   // variables.
   intptr_t fixed_slot_count() const { return fixed_slot_count_; }
   void set_fixed_slot_count(intptr_t count) {
     ASSERT(count >= 0);
     fixed_slot_count_ = count;
   }
   TargetEntryInstr* normal_entry() const { return normal_entry_; }
 
   const ParsedFunction& parsed_function() const {
-    return parsed_function_;
+    return *parsed_function_;
   }
 
   const GrowableArray<CatchBlockEntryInstr*>& catch_entries() const {
     return catch_entries_;
   }
 
   virtual void PrintTo(BufferFormatter* f) const;
 
  private:
   virtual void ClearPredecessors() {}
   virtual void AddPredecessor(BlockEntryInstr* predecessor) { UNREACHABLE(); }
 
-  const ParsedFunction& parsed_function_;
+  const ParsedFunction* parsed_function_;
   TargetEntryInstr* normal_entry_;
   GrowableArray<CatchBlockEntryInstr*> catch_entries_;
   GrowableArray<Definition*> initial_definitions_;
   const intptr_t osr_id_;
   intptr_t entry_count_;
   intptr_t spill_slot_count_;
   intptr_t fixed_slot_count_;  // For try-catch in optimized code.
 
   DISALLOW_COPY_AND_ASSIGN(GraphEntryInstr);
 };
@@ skipping 5386 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_