Port and integrate the irregexp engine from V8

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_optimizer.h"
 #include "vm/flow_graph_range_analysis.h"
 #include "vm/locations.h"
 #include "vm/method_recognizer.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
+#include "vm/regexp_assembler.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 #include "vm/il_printer.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, propagate_ic_data, true,
@@ skipping 333 matching lines @@
 }
 
 
 bool LoadIndexedInstr::AttributesEqual(Instruction* other) const {
   LoadIndexedInstr* other_load = other->AsLoadIndexed();
   ASSERT(other_load != NULL);
   return class_id() == other_load->class_id();
 }
 
 
+bool LoadCodeUnitsInstr::AttributesEqual(Instruction* other) const {
+  LoadCodeUnitsInstr* other_load = other->AsLoadCodeUnits();
+  ASSERT(other_load != NULL);
+  return (class_id() == other_load->class_id() &&
+      element_count() == other_load->element_count());
+}
+
+
 ConstantInstr::ConstantInstr(const Object& value) : value_(value) {
   // Check that the value is not an incorrect Integer representation.
   ASSERT(!value.IsBigint() || !Bigint::Cast(value).FitsIntoSmi());
   ASSERT(!value.IsBigint() || !Bigint::Cast(value).FitsIntoInt64());
   ASSERT(!value.IsMint() || !Smi::IsValid(Mint::Cast(value).AsInt64Value()));
 }
 
 
 bool ConstantInstr::AttributesEqual(Instruction* other) const {
   ConstantInstr* other_constant = other->AsConstant();
@@ skipping 70 matching lines @@
 }
 
 
 GraphEntryInstr::GraphEntryInstr(const ParsedFunction* parsed_function,
                                  TargetEntryInstr* normal_entry,
                                  intptr_t osr_id)
     : BlockEntryInstr(0, CatchClauseNode::kInvalidTryIndex),
       parsed_function_(parsed_function),
       normal_entry_(normal_entry),
       catch_entries_(),
+      indirect_entries_(),
       initial_definitions_(),
       osr_id_(osr_id),
       entry_count_(0),
       spill_slot_count_(0),
       fixed_slot_count_(0) {
 }
 
 
 ConstantInstr* GraphEntryInstr::constant_null() {
   ASSERT(initial_definitions_.length() > 0);
@@ skipping 643 matching lines @@
   return NULL;
 }
 
 
 intptr_t GraphEntryInstr::SuccessorCount() const {
   return 1 + catch_entries_.length();
 }
 
 
 BlockEntryInstr* GraphEntryInstr::SuccessorAt(intptr_t index) const {
-  if (index == 0) return normal_entry_;
-  return catch_entries_[index - 1];
+  if (index == 0) {
+    return normal_entry_;
+  } else {
+    ASSERT(index < catch_entries_.length() + 1);

[srdjan, 2014/09/22 22:34:07]

Add parentheses.

[jgruber1, 2014/09/23 10:58:46]

Reverted this change since it was functionally identical to its its previous
state.

+    return catch_entries_[index - 1];
+  }
 }
 
 
 intptr_t BranchInstr::SuccessorCount() const {
   return 2;
 }
 
 
 BlockEntryInstr* BranchInstr::SuccessorAt(intptr_t index) const {
   if (index == 0) return true_successor_;
@@ skipping 631 matching lines @@
 
 
 // A math unary instruction has a side effect (exception
 // thrown) if the argument is not a number.
 // TODO(srdjan): eliminate if has no uses and input is guaranteed to be number.
 Definition* MathUnaryInstr::Canonicalize(FlowGraph* flow_graph) {
   return this;
 }
 
 
+Definition* CaseInsensitiveCompareUC16Instr::Canonicalize(
+    FlowGraph* flow_graph) {
+  return this;
+}
+
+
 Definition* LoadFieldInstr::Canonicalize(FlowGraph* flow_graph) {
   if (!HasUses()) return NULL;
   if (!IsImmutableLengthLoad()) return this;
 
   // For fixed length arrays if the array is the result of a known constructor
   // call we can replace the length load with the length argument passed to
   // the constructor.
   StaticCallInstr* call = instance()->definition()->AsStaticCall();
   if (call != NULL) {
     if (call->is_known_list_constructor() &&
@@ skipping 712 matching lines @@
     compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
                                    deopt_id_,
                                    Scanner::kNoSourcePos);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
+LocationSummary* IndirectEntryInstr::MakeLocationSummary(
+    Isolate* isolate, bool optimizing) const {
+  UNREACHABLE();
+  return NULL;
+}
+
+
 LocationSummary* PhiInstr::MakeLocationSummary(Isolate* isolate,
                                                bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void PhiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
@@ skipping 760 matching lines @@
     case kIllegal:       return "illegal";
     case kSin:           return "sin";
     case kCos:           return "cos";
     case kSqrt:          return "sqrt";
     case kDoubleSquare:  return "double-square";
   }
   UNREACHABLE();
   return "";
 }
 
+typedef RawBool* (*CaseInsensitiveCompareUC16Function) (
+    RawString* string_raw,
+    RawSmi* lhs_index_raw,
+    RawSmi* rhs_index_raw,
+    RawSmi* length_raw);
+
+
+extern const RuntimeEntry kCaseInsensitiveCompareUC16RuntimeEntry(
+    "CaseInsensitiveCompareUC16", reinterpret_cast<RuntimeFunction>(
+        static_cast<CaseInsensitiveCompareUC16Function>(
+        &IRRegExpMacroAssembler::CaseInsensitiveCompareUC16)), 4, true, false);
+
+
+const RuntimeEntry& CaseInsensitiveCompareUC16Instr::TargetFunction() const {
+  return kCaseInsensitiveCompareUC16RuntimeEntry;
+}
+
 
 MergedMathInstr::MergedMathInstr(ZoneGrowableArray<Value*>* inputs,
                                  intptr_t original_deopt_id,
                                  MergedMathInstr::Kind kind)
     : inputs_(inputs),
       kind_(kind) {
   ASSERT(inputs_->length() == InputCountFor(kind_));
   for (intptr_t i = 0; i < inputs_->length(); ++i) {
     ASSERT((*inputs)[i] != NULL);
     (*inputs)[i]->set_instruction(this);
@@ skipping 17 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart