Re-landing of "replace TrySync with Metadata".

runtime/vm/flow_graph_compiler.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 RUNTIME_VM_FLOW_GRAPH_COMPILER_H_
 #define RUNTIME_VM_FLOW_GRAPH_COMPILER_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/code_descriptors.h"
 #include "vm/code_generator.h"
 #include "vm/intermediate_language.h"
 
 namespace dart {
 
 // Forward declarations.
 class Code;
 class DeoptInfoBuilder;
 class FlowGraph;
 class FlowGraphCompiler;
 class Function;
 template <typename T>
 class GrowableArray;
 class ParsedFunction;
 
+
 class ParallelMoveResolver : public ValueObject {
  public:
   explicit ParallelMoveResolver(FlowGraphCompiler* compiler);
 
   // Resolve a set of parallel moves, emitting assembler instructions.
   void EmitNativeCode(ParallelMoveInstr* parallel_move);
 
  private:
   class ScratchFpuRegisterScope : public ValueObject {
    public:
@@ skipping 318 matching lines @@
                            intptr_t deopt_id,
                            const RuntimeEntry& entry,
                            intptr_t argument_count,
                            LocationSummary* locs);
 
   void GenerateCall(TokenPosition token_pos,
                     const StubEntry& stub_entry,
                     RawPcDescriptors::Kind kind,
                     LocationSummary* locs);
 
+  void GenerateCallWithDeopt(TokenPosition token_pos,
+                             intptr_t deopt_id,
+                             const StubEntry& stub_entry,
+                             RawPcDescriptors::Kind kind,
+                             LocationSummary* locs);
+
   void GeneratePatchableCall(TokenPosition token_pos,
                              const StubEntry& stub_entry,
                              RawPcDescriptors::Kind kind,
                              LocationSummary* locs);
 
   void GenerateDartCall(intptr_t deopt_id,
                         TokenPosition token_pos,
                         const StubEntry& stub_entry,
                         RawPcDescriptors::Kind kind,
                         LocationSummary* locs);
@@ skipping 86 matching lines @@
                                         TokenPosition token_pos);
   Condition EmitEqualityRegRegCompare(Register left,
                                       Register right,
                                       bool needs_number_check,
                                       TokenPosition token_pos);
 
   bool NeedsEdgeCounter(TargetEntryInstr* block);
 
   void EmitEdgeCounter(intptr_t edge_id);
 #endif  // !defined(TARGET_ARCH_DBC)
+  void EmitCatchEntryState(
+      Environment* env = NULL,
+      intptr_t try_index = CatchClauseNode::kInvalidTryIndex);
 
-  void EmitTrySync(Instruction* instr, intptr_t try_index);
+  void EmitCallsiteMetaData(TokenPosition token_pos,
+                            intptr_t deopt_id,
+                            RawPcDescriptors::Kind kind,
+                            LocationSummary* locs);
 
   void EmitComment(Instruction* instr);
 
   intptr_t StackSize() const;
 
   // Returns assembler label associated with the given block entry.
   Label* GetJumpLabel(BlockEntryInstr* block_entry) const;
   bool WasCompacted(BlockEntryInstr* block_entry) const;
 
   // Returns the label of the fall-through of the current block.
@@ skipping 41 matching lines @@
 
   CompilerDeoptInfo* AddDeoptIndexAtCall(intptr_t deopt_id);
 
   void AddSlowPathCode(SlowPathCode* slow_path);
 
   void FinalizeExceptionHandlers(const Code& code);
   void FinalizePcDescriptors(const Code& code);
   RawArray* CreateDeoptInfo(Assembler* assembler);
   void FinalizeStackMaps(const Code& code);
   void FinalizeVarDescriptors(const Code& code);
+  void FinalizeCatchEntryStateMap(const Code& code);
   void FinalizeStaticCallTargetsTable(const Code& code);
   void FinalizeCodeSourceMap(const Code& code);
 
   const Class& double_class() const { return double_class_; }
   const Class& mint_class() const { return mint_class_; }
   const Class& float32x4_class() const { return float32x4_class_; }
   const Class& float64x2_class() const { return float64x2_class_; }
   const Class& int32x4_class() const { return int32x4_class_; }
 
   const Class& BoxClassFor(Representation rep);
@@ skipping 59 matching lines @@
   void RecordAfterCallHelper(TokenPosition token_pos,
                              intptr_t deopt_id,
                              intptr_t argument_count,
                              CallResult result,
                              LocationSummary* locs);
   void RecordAfterCall(Instruction* instr, CallResult result);
 #endif
 
  private:
   friend class CheckStackOverflowSlowPath;  // For pending_deoptimization_env_.
+  friend class CheckedSmiSlowPath;          // Same.
+  friend class CheckedSmiComparisonSlowPath;  // Same.
 
   static bool ShouldInlineSmiStringHashCode(const ICData& ic_data);
 
   void EmitFrameEntry();
 
   void AddStaticCallTarget(const Function& function);
 
   void GenerateDeferredCode();
 
   void EmitInstructionPrologue(Instruction* instr);
@@ skipping 142 matching lines @@
 #endif
 
   // Compiler specific per-block state.  Indexed by postorder block number
   // for convenience.  This is not the block's index in the block order,
   // which is reverse postorder.
   BlockEntryInstr* current_block_;
   ExceptionHandlerList* exception_handlers_list_;
   DescriptorList* pc_descriptors_list_;
   StackMapTableBuilder* stackmap_table_builder_;
   CodeSourceMapBuilder* code_source_map_builder_;
+  CatchEntryStateMapBuilder* catch_entry_state_maps_builder_;
   GrowableArray<BlockInfo*> block_info_;
   GrowableArray<CompilerDeoptInfo*> deopt_infos_;
   GrowableArray<SlowPathCode*> slow_path_code_;
   // Stores static call targets as well as stub targets.
   // TODO(srdjan): Evaluate if we should store allocation stub targets into a
   // separate table?
   GrowableArray<StaticCallsStruct*> static_calls_target_table_;
   const bool is_optimizing_;
   // Set to true if optimized code has IC calls.
   bool may_reoptimize_;
@@ skipping 19 matching lines @@
   ZoneGrowableArray<const ICData*>* deopt_id_to_ic_data_;
 
   Array& edge_counters_array_;
 
   DISALLOW_COPY_AND_ASSIGN(FlowGraphCompiler);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_FLOW_GRAPH_COMPILER_H_