Polymorphic inlining for []= operators.

runtime/vm/flow_graph_optimizer.h

Index: runtime/vm/flow_graph_optimizer.h
===================================================================
--- runtime/vm/flow_graph_optimizer.h	(revision 28165)
+++ runtime/vm/flow_graph_optimizer.h	(working copy)
@@ -46,6 +46,7 @@
 
   bool TryInlineRecognizedMethod(const Function& target,
                                  Instruction* call,
+                                 intptr_t token_pos,
                                  const ICData& ic_data,
                                  TargetEntryInstr** entry,
                                  Definition** last);
@@ -72,21 +73,28 @@
 
   void SpecializePolymorphicInstanceCall(PolymorphicInstanceCallInstr* call);
 
-  intptr_t PrepareIndexedOp(InstanceCallInstr* call,
-                            intptr_t class_id,
-                            Definition** array,
-                            Definition** index);
   bool TryReplaceWithStoreIndexed(InstanceCallInstr* call);
-  void BuildStoreIndexed(InstanceCallInstr* call,
-                         const ICData& value_check,
-                         intptr_t class_id);
+  bool BuildInlineSetIndexed(MethodRecognizer::Kind kind,
+                             const Function& target,
+                             Instruction* call,
+                             intptr_t token_pos,
+                             const ICData* ic_data,
+                             const ICData& value_check,
+                             TargetEntryInstr** entry,
+                             Definition** last);

[srdjan, 2013/10/02 16:19:19]

It would be nice if we could simplify the code by reducing the number of
argument. Sorry, I do not have a suggestion how.

[Florian Schneider, 2013/10/03 09:20:52]

I agree. The problem is that the call can be a InstanceCall or a
PolymorphicInstanceCall (in case it is called from FlowGraphInliner). That's why
I'm passing all the individual components separately.

   bool TryReplaceWithLoadIndexed(InstanceCallInstr* call);
-  bool TryInlineGetIndexed(MethodRecognizer::Kind kind,
-                           Instruction* call,
-                           const ICData& ic_data,
-                           TargetEntryInstr** entry,
-                           Definition** last);
+  bool BuildInlineGetIndexed(MethodRecognizer::Kind kind,

[srdjan, 2013/10/02 16:19:19]

s/BuildInlineXXXIndexed/InlineXXXIndexed/  ?

[Florian Schneider, 2013/10/03 09:20:52]

Done.

+                             Instruction* call,
+                             const ICData& ic_data,
+                             TargetEntryInstr** entry,
+                             Definition** last);
+  intptr_t PrepareInlineIndexedOp(Instruction* call,
+                                  intptr_t array_cid,
+                                  Definition** array,
+                                  Definition* index,
+                                  Instruction** cursor);
 
+
   bool TryReplaceWithBinaryOp(InstanceCallInstr* call, Token::Kind op_kind);
   bool TryReplaceWithUnaryOp(InstanceCallInstr* call, Token::Kind op_kind);
 
@@ -130,6 +138,9 @@
                      intptr_t deopt_id,
                      Environment* deopt_environment,
                      Instruction* insert_before);
+  Instruction* GetCheckClass(Definition* to_check,
+                             const ICData& unary_checks,
+                             intptr_t deopt_id);
 
   // Insert a Smi check if needed.
   void AddCheckSmi(Definition* to_check,