Polymorphic inlining for []= operators.

runtime/vm/flow_graph_optimizer.h

 // Copyright (c) 2012, 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_FLOW_GRAPH_OPTIMIZER_H_
 #define VM_FLOW_GRAPH_OPTIMIZER_H_
 
 #include "vm/intermediate_language.h"
 #include "vm/flow_graph.h"
 
@@ skipping 28 matching lines @@
   void EliminateDeadPhis();
 
   void SelectRepresentations();
 
   void InferSmiRanges();
 
   void AnalyzeTryCatch();
 
   bool TryInlineRecognizedMethod(const Function& target,
                                  Instruction* call,
+                                 intptr_t token_pos,
                                  const ICData& ic_data,
                                  TargetEntryInstr** entry,
                                  Definition** last);
 
   // Remove environments from the instructions which do not deoptimize.
   void EliminateEnvironments();
 
   virtual void VisitStaticCall(StaticCallInstr* instr);
   virtual void VisitInstanceCall(InstanceCallInstr* instr);
   virtual void VisitEqualityCompare(EqualityCompareInstr* instr);
   virtual void VisitBranch(BranchInstr* instr);
   virtual void VisitStrictCompare(StrictCompareInstr* instr);
 
   void InsertBefore(Instruction* next,
                     Instruction* instr,
                     Environment* env,
                     Definition::UseKind use_kind) {
     flow_graph_->InsertBefore(next, instr, env, use_kind);
   }
 
  private:
   // Attempt to build ICData for call using propagated class-ids.
   bool TryCreateICData(InstanceCallInstr* call);
 
   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);
 
   bool TryReplaceWithRelationalOp(InstanceCallInstr* call, Token::Kind op_kind);
 
   bool TryInlineInstanceGetter(InstanceCallInstr* call);
   bool TryInlineInstanceSetter(InstanceCallInstr* call,
                                const ICData& unary_ic_data);
 
@@ skipping 24 matching lines @@
 
   // Insert a check of 'to_check' determined by 'unary_checks'.  If the
   // check fails it will deoptimize to 'deopt_id' using the deoptimization
   // environment 'deopt_environment'.  The check is inserted immediately
   // before 'insert_before'.
   void AddCheckClass(Definition* to_check,
                      const ICData& unary_checks,
                      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,
                    intptr_t deopt_id,
                    Environment* deopt_environment,
                    Instruction* insert_before);
 
   // Add a class check for a call's first argument immediately before the
   // call, using the call's IC data to determine the check, and the call's
   // deopt ID and deoptimization environment if the check fails.
@@ skipping 228 matching lines @@
 // Optimize spill stores inside try-blocks by identifying values that always
 // contain a single known constant at catch block entry.
 class TryCatchAnalyzer : public AllStatic {
  public:
   static void Optimize(FlowGraph* flow_graph);
 };
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_OPTIMIZER_H_