Implemented missing instructions in ia32, more sharing, removed bailouts, enable optimiziations on …

runtime/vm/flow_graph_compiler_shared.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_COMPILER_SHARED_H_
 #define VM_FLOW_GRAPH_COMPILER_SHARED_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/code_descriptors.h"
 #include "vm/code_generator.h"
 #include "vm/growable_array.h"
 
 namespace dart {
 
 class BlockEntryInstr;
 class ExceptionHandlerList;
 class FlowGraphCompilerShared;
+class Instruction;
 class ParsedFunction;
 class TargetEntryInstr;
 
 class DeoptimizationStub : public ZoneAllocated {
  public:
   DeoptimizationStub(intptr_t deopt_id,
                      intptr_t deopt_token_index,
                      intptr_t try_index,
                      DeoptReasonId reason)
       : deopt_id_(deopt_id),
@@ skipping 27 matching lines @@
                           const ParsedFunction& parsed_function,
                           const GrowableArray<BlockEntryInstr*>& block_order,
                           bool is_optimizing);
 
   virtual ~FlowGraphCompilerShared();
 
   // Constructor is lighweight, major initialization work should occur here.
   // This makes it easier to measure time spent in the compiler.
   void InitCompiler();
 
+  void VisitBlocks();
+
   Assembler* assembler() const { return assembler_; }
   const ParsedFunction& parsed_function() const { return parsed_function_; }
   const GrowableArray<BlockEntryInstr*>& block_order() const {
     return block_order_;
   }
   DescriptorList* pc_descriptors_list() const {
     return pc_descriptors_list_;
   }
   BlockEntryInstr* current_block() const { return current_block_; }
   void set_current_block(BlockEntryInstr* value) {
@@ skipping 68 matching lines @@
                                     intptr_t argument_count) = 0;
   // Returns pc-offset (in bytes) of the pc after the call, can be used to emit
   // pc-descriptor information.
   virtual intptr_t EmitStaticCall(const Function& function,
                                   const Array& arguments_descriptor,
                                   intptr_t argument_count) = 0;
   virtual void CheckClassIds(Register class_id_reg,
                              const GrowableArray<intptr_t>& class_ids,
                              Label* is_equal_lbl,
                              Label* is_not_equal_lbl) = 0;
+  virtual void EmitInstructionPrologue(Instruction* instr) = 0;

[Florian Schneider, 2012/06/07 10:41:48]

Somehow it feels wrong to make those pure virtual just to share the code. How
about the following structure to avoid having those pure virtual functions and
also removing the extra super-class FlowGraphCompilerShared):

1. Eliminate the class FlowGraphCompilerShared and the files
flow_graph_compiler_shared{.h, .cc}.
2. Have plaform-specific .h file (flow_graph_compiler_xx.h) included from
flow_graph_compiler.h (as is currently)
3. Implement the shared function in flow_graph_compiler.cc. The compiler/linker
will complain if one is missing.

[srdjan, 2012/06/07 16:34:45]

Excellent idea, will do that and then submit.

+  virtual void GenerateCallRuntime(intptr_t cid,
+                                   intptr_t token_index,
+                                   intptr_t try_index,
+                                   const RuntimeEntry& entry) = 0;
+  virtual void GenerateCall(intptr_t token_index,
+                            intptr_t try_index,
+                            const ExternalLabel* label,
+                            PcDescriptors::Kind kind) = 0;
+  virtual void GenerateAssertAssignable(intptr_t cid,
+                                        intptr_t token_index,
+                                        intptr_t try_index,
+                                        const AbstractType& dst_type,
+                                        const String& dst_name) = 0;
+  virtual void GenerateInstanceOf(intptr_t cid,
+                                  intptr_t token_index,
+                                  intptr_t try_index,
+                                  const AbstractType& type,
+                                  bool negate_result) = 0;
 
+  void EmitComment(Instruction* instr);
 
   struct BlockInfo : public ZoneAllocated {
    public:
     BlockInfo() : label() { }
 
     Label label;
   };
 
   const GrowableArray<BlockInfo*>& block_info() const { return block_info_; }
 
@@ skipping 24 matching lines @@
   const bool is_optimizing_;
 
   DISALLOW_COPY_AND_ASSIGN(FlowGraphCompilerShared);
 };
 
 
 }  // namespace dart
 
 
 #endif  // VM_FLOW_GRAPH_COMPILER_SHARED_H_