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

runtime/vm/intermediate_language.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_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
 #include "vm/handles_impl.h"
 #include "vm/object.h"
 
 namespace dart {
 
 class BitVector;
-class FlowGraphCompiler;
+class FlowGraphCompilerShared;
 class FlowGraphVisitor;
 class LocalVariable;
 class LocationSummary;
 
 // M is a two argument macro.  It is applied to each concrete value's
 // typename and classname.
 #define FOR_EACH_VALUE(M)                                                      \
   M(Use, UseVal)                                                               \
   M(Constant, ConstantVal)                                                     \
 
@@ skipping 100 matching lines @@
   // it acts as a DoInstr, otherwise a BindInstr.
   void set_instr(Instruction* value) { instr_ = value; }
   Instruction* instr() const { return instr_; }
 
   // Create a location summary for this computation.
   // TODO(fschneider): Temporarily returns NULL for instructions
   // that are not yet converted to the location based code generation.
   virtual LocationSummary* MakeLocationSummary() const = 0;
 
   // TODO(fschneider): Make EmitNativeCode and locs const.
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler) = 0;
+  virtual void EmitNativeCode(FlowGraphCompilerShared* compiler) = 0;
 
   static LocationSummary* MakeCallSummary();
 
  private:
   friend class Instruction;
   static intptr_t GetNextCid(Isolate* isolate) {
     intptr_t tmp = isolate->computation_id();
     isolate->set_computation_id(tmp + 1);
     return tmp;
   }
@@ skipping 98 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Value);
 };
 
 
 // Functions defined in all concrete computation classes.
 #define DECLARE_COMPUTATION(ShortName)                                         \
   virtual void Accept(FlowGraphVisitor* visitor);                              \
   virtual const char* DebugName() const { return #ShortName; }                 \
   virtual RawAbstractType* StaticType() const;                                 \
   virtual LocationSummary* MakeLocationSummary() const;                        \
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+  virtual void EmitNativeCode(FlowGraphCompilerShared* compiler);
 
 // Functions defined in all concrete value classes.
 #define DECLARE_VALUE(ShortName)                                               \
   DECLARE_COMPUTATION(ShortName)                                               \
   virtual ShortName##Val* As##ShortName() { return this; }                     \
   virtual void PrintTo(BufferFormatter* f) const;
 
 
 class BindInstr;
 
@@ skipping 1225 matching lines @@
 
   // Returns structure describing location constraints required
   // to emit native code for this instruction.
   virtual LocationSummary* locs() {
     // TODO(vegorov): This should be pure virtual method.
     // However we are temporary using NULL for instructions that
     // were not converted to the location based code generation yet.
     return NULL;
   }
 
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
+  virtual void EmitNativeCode(FlowGraphCompilerShared* compiler) {
     UNIMPLEMENTED();
   }
 
  private:
   intptr_t cid_;
   ICData* ic_data_;
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
@@ skipping 22 matching lines @@
 // predecessors.  Targets are all other basic block entries.  The types
 // enforce edge-split form---joins are forbidden as the successors of
 // branches.
 class BlockEntryInstr : public Instruction {
  public:
   virtual bool IsBlockEntry() const { return true; }
 
   virtual intptr_t PredecessorCount() const = 0;
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const = 0;
   virtual void AddPredecessor(BlockEntryInstr* predecessor) = 0;
-  virtual void PrepareEntry(FlowGraphCompiler* compiler) = 0;
+  virtual void PrepareEntry(FlowGraphCompilerShared* compiler) = 0;
 
   intptr_t preorder_number() const { return preorder_number_; }
   void set_preorder_number(intptr_t number) { preorder_number_ = number; }
 
   intptr_t postorder_number() const { return postorder_number_; }
   void set_postorder_number(intptr_t number) { postorder_number_ = number; }
 
   intptr_t block_id() const { return block_id_; }
   void set_block_id(intptr_t value) { block_id_ = value; }
 
@@ skipping 53 matching lines @@
   virtual void DiscoverBlocks(
       BlockEntryInstr* current_block,
       GrowableArray<BlockEntryInstr*>* preorder,
       GrowableArray<BlockEntryInstr*>* postorder,
       GrowableArray<intptr_t>* parent,
       GrowableArray<BitVector*>* assigned_vars,
       intptr_t variable_count);
 
   void AddCatchEntry(TargetEntryInstr* entry) { catch_entries_.Add(entry); }
 
-  virtual void PrepareEntry(FlowGraphCompiler* compiler);
+  virtual void PrepareEntry(FlowGraphCompilerShared* compiler);
 
  private:
   TargetEntryInstr* normal_entry_;
   GrowableArray<TargetEntryInstr*> catch_entries_;
 
   DISALLOW_COPY_AND_ASSIGN(GraphEntryInstr);
 };
 
 
 class JoinEntryInstr : public BlockEntryInstr {
@@ skipping 14 matching lines @@
   }
 
   virtual Instruction* StraightLineSuccessor() const {
     return successor_;
   }
   virtual void SetSuccessor(Instruction* instr) {
     ASSERT(successor_ == NULL);
     successor_ = instr;
   }
 
-  virtual void PrepareEntry(FlowGraphCompiler* compiler);
+  virtual void PrepareEntry(FlowGraphCompilerShared* compiler);
 
  private:
   ZoneGrowableArray<BlockEntryInstr*> predecessors_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(JoinEntryInstr);
 };
 
 
 class TargetEntryInstr : public BlockEntryInstr {
@@ skipping 35 matching lines @@
 
   bool HasTryIndex() const {
     return try_index_ != CatchClauseNode::kInvalidTryIndex;
   }
 
   intptr_t try_index() const {
     ASSERT(HasTryIndex());
     return try_index_;
   }
 
-  virtual void PrepareEntry(FlowGraphCompiler* compiler);
+  virtual void PrepareEntry(FlowGraphCompilerShared* compiler);
 
  private:
   BlockEntryInstr* predecessor_;
   Instruction* successor_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(TargetEntryInstr);
 };
 
 
@@ skipping 18 matching lines @@
     ASSERT(successor_ == NULL);
     successor_ = instr;
   }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars);
 
   virtual LocationSummary* locs() {
     return computation()->locs();
   }
 
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
+  virtual void EmitNativeCode(FlowGraphCompilerShared* compiler) {
     computation()->EmitNativeCode(compiler);
   }
 
  private:
   Computation* computation_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(DoInstr);
 };
 
@@ skipping 30 matching lines @@
   virtual RawAbstractType* StaticType() const {
     return computation()->StaticType();
   }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars);
 
   virtual LocationSummary* locs() {
     return computation()->locs();
   }
 
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+  virtual void EmitNativeCode(FlowGraphCompilerShared* compiler);
 
  private:
   intptr_t temp_index_;
   Computation* computation_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(BindInstr);
 };
 
 
 class ReturnInstr : public InstructionWithInputs {
  public:
   ReturnInstr(intptr_t token_index, Value* value)
       : InstructionWithInputs(), token_index_(token_index), value_(value) {
     ASSERT(value_ != NULL);
   }
 
   DECLARE_INSTRUCTION(Return)
 
   Value* value() const { return value_; }
   intptr_t token_index() const { return token_index_; }
 
   virtual Instruction* StraightLineSuccessor() const { return NULL; }
   virtual void SetSuccessor(Instruction* instr) { UNREACHABLE(); }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+  virtual void EmitNativeCode(FlowGraphCompilerShared* compiler);
 
  private:
   const intptr_t token_index_;
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public InstructionWithInputs {
@@ skipping 17 matching lines @@
 
   // Parser can generate a throw within an expression tree.  We never
   // add successor instructions to the graph.
   virtual Instruction* StraightLineSuccessor() const { return NULL; }
   virtual void SetSuccessor(Instruction* instr) {
     ASSERT(successor_ == NULL);
   }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+  virtual void EmitNativeCode(FlowGraphCompilerShared* compiler);
 
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   Value* exception_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
@@ skipping 25 matching lines @@
   // never add successor instructions to the graph.
   virtual Instruction* StraightLineSuccessor() const {
     return NULL;
   }
   virtual void SetSuccessor(Instruction* instr) {
     ASSERT(successor_ == NULL);
   }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+  virtual void EmitNativeCode(FlowGraphCompilerShared* compiler);
 
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   Value* exception_;
   Value* stack_trace_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
@@ skipping 25 matching lines @@
   virtual void DiscoverBlocks(
       BlockEntryInstr* current_block,
       GrowableArray<BlockEntryInstr*>* preorder,
       GrowableArray<BlockEntryInstr*>* postorder,
       GrowableArray<intptr_t>* parent,
       GrowableArray<BitVector*>* assigned_vars,
       intptr_t variable_count);
 
   virtual LocationSummary* MakeLocationSummary() const;
 
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+  virtual void EmitNativeCode(FlowGraphCompilerShared* compiler);
 
  private:
   Value* value_;
   TargetEntryInstr* true_successor_;
   TargetEntryInstr* false_successor_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 #undef DECLARE_INSTRUCTION
@@ skipping 29 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_