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

runtime/vm/flow_graph_compiler_shared.h

Index: runtime/vm/flow_graph_compiler_shared.h
===================================================================
--- runtime/vm/flow_graph_compiler_shared.h	(revision 8338)
+++ runtime/vm/flow_graph_compiler_shared.h	(working copy)
@@ -16,6 +16,7 @@
 class BlockEntryInstr;
 class ExceptionHandlerList;
 class FlowGraphCompilerShared;
+class Instruction;
 class ParsedFunction;
 class TargetEntryInstr;
 
@@ -63,6 +64,8 @@
   // 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 {
@@ -151,7 +154,27 @@
                              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: