[regexp] Use consistent map checks for fast paths

src/regexp/regexp-utils.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/regexp/regexp-utils.h"
 
 #include "src/factory.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
 #include "src/regexp/jsregexp.h"
@@ skipping 118 matching lines @@
   Handle<Object> match;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, match,
       JSObject::GetProperty(receiver, isolate->factory()->match_symbol()),
       Nothing<bool>());
 
   if (!match->IsUndefined(isolate)) return Just(match->BooleanValue());
   return Just(object->IsJSRegExp());
 }
 
-bool RegExpUtils::IsBuiltinExec(Handle<Object> exec) {
-  if (!exec->IsJSFunction()) return false;
+bool RegExpUtils::IsUnmodifiedRegExp(Isolate* isolate, Handle<Object> obj) {
+  // TODO(ishell): Update this check once map changes for constant field
+  // tracking are landing.
 
-  Code* code = Handle<JSFunction>::cast(exec)->code();
-  if (code == nullptr) return false;
+  if (!obj->IsJSReceiver()) return false;
 
-  return (code->builtin_index() == Builtins::kRegExpPrototypeExec);
+  JSReceiver* recv = JSReceiver::cast(*obj);
+
+  // Check the receiver's map.
+  Handle<JSFunction> regexp_function = isolate->regexp_function();
+  if (recv->map() != regexp_function->initial_map()) return false;
+
+  // Check the receiver's prototype's map.
+  Object* proto = recv->map()->prototype();
+  if (!proto->IsJSReceiver()) return false;
+
+  Handle<Map> initial_proto_initial_map = isolate->regexp_prototype_map();
+  return (JSReceiver::cast(proto)->map() == *initial_proto_initial_map);
 }
 
 int RegExpUtils::AdvanceStringIndex(Isolate* isolate, Handle<String> string,
                                     int index, bool unicode) {
   if (unicode && index < string->length()) {
     const uint16_t first = string->Get(index);
     if (first >= 0xD800 && first <= 0xDBFF && string->length() > index + 1) {
       const uint16_t second = string->Get(index + 1);
       if (second >= 0xDC00 && second <= 0xDFFF) {
         return index + 2;
@@ skipping 18 matching lines @@
 
   const int last_index = Handle<Smi>::cast(last_index_obj)->value();
   const int new_last_index =
       AdvanceStringIndex(isolate, string, last_index, unicode);
 
   return SetLastIndex(isolate, regexp, new_last_index);
 }
 
 }  // namespace internal
 }  // namespace v8