Port and integrate the irregexp engine from V8

runtime/vm/intermediate_language_arm.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_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/cpu.h"
@@ skipping 1343 matching lines @@
       }
       break;
     default:
       ASSERT((class_id() == kArrayCid) || (class_id() == kImmutableArrayCid));
       __ ldr(result, element_address);
       break;
   }
 }
 
 
+CompileType LoadCodeUnitsInstr::ComputeType() const {
+  switch (class_id()) {
+    case kOneByteStringCid:
+    case kExternalOneByteStringCid:
+      return CompileType::FromCid(element_count() < 4 ? kSmiCid : kMintCid);
+    case kTwoByteStringCid:
+    case kExternalTwoByteStringCid:
+      return CompileType::FromCid(element_count() < 2 ? kSmiCid : kMintCid);
+    default:
+      UNIMPLEMENTED();
+      return CompileType::Dynamic();
+  }
+}
+
+
+Representation LoadCodeUnitsInstr::representation() const {
+  switch (class_id()) {
+    case kOneByteStringCid:
+    case kExternalOneByteStringCid:
+      return element_count() < 4 ? kTagged : kUnboxedMint;
+    case kTwoByteStringCid:
+    case kExternalTwoByteStringCid:
+      return element_count() < 2 ? kTagged : kUnboxedMint;
+    default:
+      UNIMPLEMENTED();
+      return kTagged;
+  }
+}
+
+
+LocationSummary* LoadCodeUnitsInstr::MakeLocationSummary(Isolate* isolate,
+                                                         bool opt) const {
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* locs = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  locs->set_in(0, Location::RequiresRegister());
+  bool needs_base = false;
+  if (CanBeImmediateIndex(index(), class_id(), IsExternal(),
+                          true,  // Load.
+                          &needs_base)) {
+    // CanBeImmediateIndex must return false for unsafe smis.
+    locs->set_in(1, Location::Constant(index()->definition()->AsConstant()));
+  } else {
+    locs->set_in(1, Location::RequiresRegister());
+  }
+
+  if (representation() == kUnboxedMint) {
+    locs->set_out(0, Location::Pair(Location::RequiresRegister(),
+                                    Location::RequiresRegister()));
+  } else {
+    ASSERT(representation() == kTagged);
+    locs->set_out(0, Location::RequiresRegister());
+  }
+
+  return locs;
+}
+
+
+void LoadCodeUnitsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  const Register array = locs()->in(0).reg();
+  const Location index = locs()->in(1);
+
+  Address element_address = index.IsRegister()
+      ? __ ElementAddressForRegIndex(true,  // Load.
+                                     IsExternal(), class_id(), index_scale(),
+                                     array,
+                                     index.reg())
+      : __ ElementAddressForIntIndex(true,  // Load.
+                                     IsExternal(), class_id(), index_scale(),
+                                     array, Smi::Cast(index.constant()).Value(),
+                                     IP);  // Temp register.
+  // Warning: element_address may use register IP as base.
+
+  if (representation() == kUnboxedMint) {
+    ASSERT(locs()->out(0).IsPairLocation());
+    PairLocation* result_pair = locs()->out(0).AsPairLocation();
+    Register result1 = result_pair->At(0).reg();
+    Register result2 = result_pair->At(1).reg();
+    switch (class_id()) {
+      case kOneByteStringCid:
+      case kExternalOneByteStringCid:
+        ASSERT(element_count() == 4);
+        __ ldr(result1, element_address);
+        __ eor(result2, result2, Operand(result2));
+        break;
+      case kTwoByteStringCid:
+      case kExternalTwoByteStringCid:
+        ASSERT(element_count() == 2);
+        __ ldr(result1, element_address);
+        __ eor(result2, result2, Operand(result2));
+        break;
+      default:
+        UNREACHABLE();
+    }
+  } else {
+    ASSERT(representation() == kTagged);
+    Register result = locs()->out(0).reg();
+    switch (class_id()) {
+      case kOneByteStringCid:
+      case kExternalOneByteStringCid:
+        switch (element_count()) {
+          case 1: __ ldrb(result, element_address); break;
+          case 2: __ ldrsh(result, element_address); break;
+          default: UNREACHABLE();
+        }
+        __ SmiTag(result);
+        break;
+      case kTwoByteStringCid:
+      case kExternalTwoByteStringCid:
+        ASSERT(element_count() == 1);
+        __ ldrsh(result, element_address);
+        __ SmiTag(result);
+        break;
+      default:
+        UNREACHABLE();
+        break;
+    }
+  }
+}
+
+
 Representation StoreIndexedInstr::RequiredInputRepresentation(
     intptr_t idx) const {
   // Array can be a Dart object or a pointer to external data.
   if (idx == 0)  return kNoRepresentation;  // Flexible input representation.
   if (idx == 1) return kTagged;  // Index is a smi.
   ASSERT(idx == 2);
   switch (class_id_) {
     case kArrayCid:
     case kOneByteStringCid:
     case kTypedDataInt8ArrayCid:
@@ skipping 3726 matching lines @@
       __ vmovrrd(R0, R1, D0);
       __ vmovrrd(R2, R3, D1);
       __ CallRuntime(TargetFunction(), InputCount());
       __ vmovdrr(D0, R0, R1);
       __ vmovdrr(D1, R2, R3);
     }
   }
 }
 
 
+LocationSummary* CaseInsensitiveCompareUC16Instr::MakeLocationSummary(
+    Isolate* isolate, bool opt) const {
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, InputCount(), kNumTemps, LocationSummary::kCall);
+  summary->set_in(0, Location::RegisterLocation(R0));
+  summary->set_in(1, Location::RegisterLocation(R1));
+  summary->set_in(2, Location::RegisterLocation(R2));
+  summary->set_in(3, Location::RegisterLocation(R3));
+  summary->set_out(0, Location::RegisterLocation(R0));
+  return summary;
+}
+
+
+void CaseInsensitiveCompareUC16Instr::EmitNativeCode(
+    FlowGraphCompiler* compiler) {
+
+  // Call the function.
+  __ CallRuntime(TargetFunction(), TargetFunction().argument_count());
+}
+
+
 LocationSummary* MathMinMaxInstr::MakeLocationSummary(Isolate* isolate,
                                                       bool opt) const {
   if (result_cid() == kDoubleCid) {
     const intptr_t kNumInputs = 2;
     const intptr_t kNumTemps = 1;
     LocationSummary* summary = new(isolate) LocationSummary(
         isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresFpuRegister());
     summary->set_in(1, Location::RequiresFpuRegister());
     // Reuse the left register so that code can be made shorter.
@@ skipping 1724 matching lines @@
 }
 
 
 void GraphEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (!compiler->CanFallThroughTo(normal_entry())) {
     __ b(compiler->GetJumpLabel(normal_entry()));
   }
 }
 
 
+void IndirectEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  __ Bind(compiler->GetJumpLabel(this));
+  if (!compiler->is_optimizing()) {
+    compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
+                                   deopt_id_,
+                                   Scanner::kNoSourcePos);
+  }
+  if (HasParallelMove()) {
+    compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
+  }
+}
+
+
 LocationSummary* GotoInstr::MakeLocationSummary(Isolate* isolate,
                                                 bool opt) const {
   return new(isolate) LocationSummary(isolate, 0, 0, LocationSummary::kNoCall);
 }
 
 
 void GotoInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (!compiler->is_optimizing()) {
     if (FLAG_emit_edge_counters) {
       compiler->EmitEdgeCounter();
@@ skipping 12 matching lines @@
   }
 
   // We can fall through if the successor is the next block in the list.
   // Otherwise, we need a jump.
   if (!compiler->CanFallThroughTo(successor())) {
     __ b(compiler->GetJumpLabel(successor()));
   }
 }
 
 
+LocationSummary* IndirectGotoInstr::MakeLocationSummary(Isolate* isolate,
+                                                        bool opt) const {
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 1;
+
+  LocationSummary* locs = new(isolate) LocationSummary(
+        isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+
+  locs->set_in(0, Location::RequiresRegister());
+  locs->set_temp(0, Location::RequiresRegister());
+
+  return locs;
+}
+
+
+void IndirectGotoInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register sum_reg = locs()->temp_slot(0)->reg();
+
+  // Load from [current frame pointer] + kPcMarkerSlotFromFp.
+  __ ldr(sum_reg, Address(FP, kPcMarkerSlotFromFp * kWordSize));
+
+  // Subtract the entrypoint offset.
+  __ AddImmediate(sum_reg, -Assembler::EntryPointToPcMarkerOffset());
+
+  // Add the offset.
+  Register offset_reg = locs()->in(0).reg();
+  __ SmiUntag(offset_reg);
+  __ add(sum_reg, sum_reg, Operand(offset_reg));
+
+  // Jump to the absolute address.
+  __ bx(sum_reg);
+}
+
+
 LocationSummary* CurrentContextInstr::MakeLocationSummary(Isolate* isolate,
                                                           bool opt) const {
   return LocationSummary::Make(isolate,
                                0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void CurrentContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 135 matching lines @@
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 #if defined(DEBUG)
   __ LoadImmediate(R4, kInvalidObjectPointer);
   __ LoadImmediate(R5, kInvalidObjectPointer);
 #endif
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM