Integrate the Irregexp Regular Expression Engine.

runtime/vm/flow_graph_compiler.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/exceptions.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
 #include "vm/locations.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
+#include "vm/raw_object.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, code_comments);
 DECLARE_FLAG(bool, disassemble);
 DECLARE_FLAG(bool, disassemble_optimized);
 DECLARE_FLAG(bool, emit_edge_counters);
@@ skipping 189 matching lines @@
     return true;
   }
   return false;
 }
 
 
 static bool IsEmptyBlock(BlockEntryInstr* block) {
   return !block->IsCatchBlockEntry() &&
          !block->HasNonRedundantParallelMove() &&
          block->next()->IsGoto() &&
-         !block->next()->AsGoto()->HasNonRedundantParallelMove();
+         !block->next()->AsGoto()->HasNonRedundantParallelMove() &&
+         !block->IsIndirectEntry();
 }
 
 
 void FlowGraphCompiler::CompactBlock(BlockEntryInstr* block) {
   BlockInfo* block_info = block_info_[block->postorder_number()];
 
   // Break out of cycles in the control flow graph.
   if (block_info->is_marked()) {
     return;
   }
@@ skipping 106 matching lines @@
     BlockEntryInstr* entry = block_order()[i];
     assembler()->Comment("B%" Pd "", entry->block_id());
     set_current_block(entry);
 
     if (WasCompacted(entry)) {
       continue;
     }
 
     LoopInfoComment(assembler(), *entry, *loop_headers);
 
+    entry->set_offset(assembler()->CodeSize());
     entry->EmitNativeCode(this);
     // Compile all successors until an exit, branch, or a block entry.
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       Instruction* instr = it.Current();
       if (FLAG_code_comments ||
           FLAG_disassemble ||
           FLAG_disassemble_optimized) {
         if (FLAG_source_lines) {
           EmitSourceLine(instr);
         }
@@ skipping 452 matching lines @@
   } else {
     // Finalize the stack map array and add it to the code object.
     ASSERT(is_optimizing());
     code.set_stackmaps(
         Array::Handle(stackmap_table_builder_->FinalizeStackmaps(code)));
   }
 }
 
 
 void FlowGraphCompiler::FinalizeVarDescriptors(const Code& code) {
-  const LocalVarDescriptors& var_descs = LocalVarDescriptors::Handle(
-          parsed_function_.node_sequence()->scope()->GetVarDescriptors(
-              parsed_function_.function()));
+  LocalVarDescriptors& var_descs = LocalVarDescriptors::Handle();
+  if (parsed_function().node_sequence() == NULL) {
+    ASSERT(flow_graph().IsIrregexpFunction());
+    var_descs = LocalVarDescriptors::New(1);
+    RawLocalVarDescriptors::VarInfo info;
+    info.set_kind(RawLocalVarDescriptors::kSavedCurrentContext);
+    info.scope_id = 0;
+    info.begin_pos = 0;
+    info.end_pos = 0;
+    info.set_index(parsed_function().current_context_var()->index());
+    var_descs.SetVar(0, Symbols::CurrentContextVar(), &info);
+  } else {
+    var_descs =
+        parsed_function_.node_sequence()->scope()->GetVarDescriptors(
+            parsed_function_.function());
+  }
   code.set_var_descriptors(var_descs);
 }
 
 
 void FlowGraphCompiler::FinalizeStaticCallTargetsTable(const Code& code) {
   ASSERT(code.static_calls_target_table() == Array::null());
   code.set_static_calls_target_table(
       Array::Handle(Array::MakeArray(static_calls_target_table_)));
 }
 
@@ skipping 667 matching lines @@
     case kUnboxedMint:
       return mint_class();
     default:
       UNREACHABLE();
       return Class::ZoneHandle();
   }
 }
 
 
 }  // namespace dart