Re-landing of "replace TrySync with Metadata".

runtime/vm/code_descriptors.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_CODE_DESCRIPTORS_H_
 #define RUNTIME_VM_CODE_DESCRIPTORS_H_
 
 #include "vm/ast.h"
 #include "vm/code_generator.h"
+#include "vm/datastream.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/object.h"
 #include "vm/log.h"
 
 namespace dart {
 
 class DescriptorList : public ZoneAllocated {
  public:
   explicit DescriptorList(intptr_t initial_capacity)
@@ skipping 121 matching lines @@
   }
 
   RawExceptionHandlers* FinalizeExceptionHandlers(uword entry_point) const;
 
  private:
   GrowableArray<struct HandlerDesc> list_;
   DISALLOW_COPY_AND_ASSIGN(ExceptionHandlerList);
 };
 
 
+// An encoded move from stack/constant to stack performed
+struct CatchEntryStatePair {
+  enum { kCatchEntryStateIsMove = 1, kCatchEntryStateDestShift = 1 };
+
+  intptr_t src, dest;
+
+  static CatchEntryStatePair FromConstant(intptr_t pool_id,
+                                          intptr_t dest_slot) {
+    CatchEntryStatePair pair;
+    pair.src = pool_id;
+    pair.dest = (dest_slot << kCatchEntryStateDestShift);
+    return pair;
+  }
+
+  static CatchEntryStatePair FromMove(intptr_t src_slot, intptr_t dest_slot) {
+    CatchEntryStatePair pair;
+    pair.src = src_slot;
+    pair.dest =
+        (dest_slot << kCatchEntryStateDestShift) | kCatchEntryStateIsMove;
+    return pair;
+  }
+
+  bool operator==(const CatchEntryStatePair& rhs) {
+    return src == rhs.src && dest == rhs.dest;
+  }
+};
+
+
+// Used to construct CatchEntryState metadata for AoT mode of compilation.
+class CatchEntryStateMapBuilder : public ZoneAllocated {
+ public:
+  CatchEntryStateMapBuilder();
+
+  void NewMapping(intptr_t pc_offset);
+  void AppendMove(intptr_t src_slot, intptr_t dest_slot);
+  void AppendConstant(intptr_t pool_id, intptr_t dest_slot);
+  void EndMapping();
+  RawTypedData* FinalizeCatchEntryStateMap();
+
+ private:
+  class TrieNode;
+
+  Zone* zone_;
+  TrieNode* root_;
+  intptr_t current_pc_offset_;
+  GrowableArray<CatchEntryStatePair> moves_;
+  uint8_t* buffer_;
+  WriteStream stream_;
+
+  DISALLOW_COPY_AND_ASSIGN(CatchEntryStateMapBuilder);
+};
+
+
 // A CodeSourceMap maps from pc offsets to a stack of inlined functions and
 // their positions. This is encoded as a little bytecode that pushes and pops
 // functions and changes the top function's position as the PC advances.
 // Decoding happens by running this bytecode until we reach the desired PC.
 //
 // The implementation keeps track of two sets of state: one written to the byte
 // stream and one that is buffered. On the JIT, this buffering effectively gives
 // us a peephole optimization that merges adjacent advance PC bytecodes. On AOT,
 // this allows to skip encoding our position until we reach a PC where we might
 // throw.
@@ skipping 107 matching lines @@
   const CodeSourceMap& map_;
   const Array& functions_;
   const Function& root_;
 
   DISALLOW_COPY_AND_ASSIGN(CodeSourceMapReader);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_CODE_DESCRIPTORS_H_