diff --git a/DEPS b/DEPS
index cfd0904e0613..adbb482a9502 100644
--- a/DEPS
+++ b/DEPS
@@ -88,15 +88,15 @@ vars = {
 
 deps = {
   'build':
-    Var('chromium_url') + '/chromium/src/build.git' + '@' + '710b42c08be2d80bf25542805e0d3b4d40a35d3e',
+    Var('chromium_url') + '/chromium/src/build.git' + '@' + '32fd3b2e52a86bcbaceedbd39dd8bdde93aaf4bf',
   'third_party/depot_tools':
-    Var('chromium_url') + '/chromium/tools/depot_tools.git' + '@' + '07bd252238b7ba84f7039dc55ce03b37e475489c',
+    Var('chromium_url') + '/chromium/tools/depot_tools.git' + '@' + '1076f38947e6e13964741cd6547da31a2ccc7a1d',
   'third_party/icu':
     Var('chromium_url') + '/chromium/deps/icu.git' + '@' + '899e18383fd732b47e6978db2b960a1b2a80179b',
   'third_party/instrumented_libraries':
     Var('chromium_url') + '/chromium/src/third_party/instrumented_libraries.git' + '@' + '4d3867052d35b2171f2edbb3466fa8f7e2d11319',
   'buildtools':
-    Var('chromium_url') + '/chromium/src/buildtools.git' + '@' + '13547b97dad2cdf1b3726b07b2563b921068a018',
+    Var('chromium_url') + '/chromium/src/buildtools.git' + '@' + '450b6b6103ec59640e957959356dae00c2f418b0',
   'buildtools/clang_format/script':
     Var('chromium_url') + '/chromium/llvm-project/cfe/tools/clang-format.git' + '@' + '96636aa0e9f047f17447f2d45a094d0b59ed7917',
   'buildtools/linux64': {
@@ -206,7 +206,7 @@ deps = {
   'third_party/markupsafe':
     Var('chromium_url') + '/chromium/src/third_party/markupsafe.git' + '@' + '0944e71f4b2cb9a871bcbe353f95e889b64a611a',
   'tools/swarming_client':
-    Var('chromium_url') + '/infra/luci/client-py.git' + '@' + '1a072711d4388c62e02480fabc26c68c24494be9',
+    Var('chromium_url') + '/infra/luci/client-py.git' + '@' + 'a32a1607f6093d338f756c7e7c7b4333b0c50c9c',
   'test/benchmarks/data':
     Var('chromium_url') + '/v8/deps/third_party/benchmarks.git' + '@' + '05d7188267b4560491ff9155c5ee13e207ecd65f',
   'test/mozilla/data':
diff --git a/include/v8.h b/include/v8.h
index 20d03920f585..f292758e8f93 100644
--- a/include/v8.h
+++ b/include/v8.h
@@ -6136,9 +6136,10 @@ class V8_EXPORT RegExp : public Object {
     kUnicode = 1 << 4,
     kDotAll = 1 << 5,
     kLinear = 1 << 6,
+    kHasIndices = 1 << 7,
   };
 
-  static constexpr int kFlagCount = 7;
+  static constexpr int kFlagCount = 8;
 
   /**
    * Creates a regular expression from the given pattern string and
@@ -7435,7 +7436,7 @@ using CallCompletedCallback = void (*)(Isolate*);
  * The specifier is the name of the module that should be imported.
  *
  * The embedder must compile, instantiate, evaluate the Module, and
- * obtain it's namespace object.
+ * obtain its namespace object.
  *
  * The Promise returned from this function is forwarded to userland
  * JavaScript. The embedder must resolve this promise with the module
@@ -7444,9 +7445,43 @@ using CallCompletedCallback = void (*)(Isolate*);
  * fails (e.g. due to stack overflow), the embedder must propagate
  * that exception by returning an empty MaybeLocal.
  */
-using HostImportModuleDynamicallyCallback = MaybeLocal<Promise> (*)(
-    Local<Context> context, Local<ScriptOrModule> referrer,
-    Local<String> specifier);
+using HostImportModuleDynamicallyCallback V8_DEPRECATE_SOON(
+    "Use HostImportModuleDynamicallyWithImportAssertionsCallback instead") =
+    MaybeLocal<Promise> (*)(Local<Context> context,
+                            Local<ScriptOrModule> referrer,
+                            Local<String> specifier);
+
+/**
+ * HostImportModuleDynamicallyWithImportAssertionsCallback is called when we
+ * require the embedder to load a module. This is used as part of the dynamic
+ * import syntax.
+ *
+ * The referrer contains metadata about the script/module that calls
+ * import.
+ *
+ * The specifier is the name of the module that should be imported.
+ *
+ * The import_assertions are import assertions for this request in the form:
+ * [key1, value1, key2, value2, ...] where the keys and values are of type
+ * v8::String. Note, unlike the FixedArray passed to ResolveModuleCallback and
+ * returned from ModuleRequest::GetImportAssertions(), this array does not
+ * contain the source Locations of the assertions.
+ *
+ * The embedder must compile, instantiate, evaluate the Module, and
+ * obtain its namespace object.
+ *
+ * The Promise returned from this function is forwarded to userland
+ * JavaScript. The embedder must resolve this promise with the module
+ * namespace object. In case of an exception, the embedder must reject
+ * this promise with the exception. If the promise creation itself
+ * fails (e.g. due to stack overflow), the embedder must propagate
+ * that exception by returning an empty MaybeLocal.
+ */
+using HostImportModuleDynamicallyWithImportAssertionsCallback =
+    MaybeLocal<Promise> (*)(Local<Context> context,
+                            Local<ScriptOrModule> referrer,
+                            Local<String> specifier,
+                            Local<FixedArray> import_assertions);
 
 /**
  * HostInitializeImportMetaObjectCallback is called the first time import.meta
@@ -8776,9 +8811,19 @@ class V8_EXPORT Isolate {
    * This specifies the callback called by the upcoming dynamic
    * import() language feature to load modules.
    */
+  V8_DEPRECATE_SOON(
+      "Use the version of SetHostImportModuleDynamicallyCallback that takes a "
+      "HostImportModuleDynamicallyWithImportAssertionsCallback instead")
   void SetHostImportModuleDynamicallyCallback(
       HostImportModuleDynamicallyCallback callback);
 
+  /**
+   * This specifies the callback called by the upcoming dynamic
+   * import() language feature to load modules.
+   */
+  void SetHostImportModuleDynamicallyCallback(
+      HostImportModuleDynamicallyWithImportAssertionsCallback callback);
+
   /**
    * This specifies the callback called by the upcoming import.meta
    * language feature to retrieve host-defined meta data for a module.
diff --git a/src/api/api.cc b/src/api/api.cc
index a964fec27602..3656bc689df8 100644
--- a/src/api/api.cc
+++ b/src/api/api.cc
@@ -7032,6 +7032,7 @@ REGEXP_FLAG_ASSERT_EQ(kIgnoreCase);
 REGEXP_FLAG_ASSERT_EQ(kMultiline);
 REGEXP_FLAG_ASSERT_EQ(kSticky);
 REGEXP_FLAG_ASSERT_EQ(kUnicode);
+REGEXP_FLAG_ASSERT_EQ(kHasIndices);
 REGEXP_FLAG_ASSERT_EQ(kLinear);
 #undef REGEXP_FLAG_ASSERT_EQ
 
@@ -8652,7 +8653,13 @@ void Isolate::SetAbortOnUncaughtExceptionCallback(
 }
 
 void Isolate::SetHostImportModuleDynamicallyCallback(
-    HostImportModuleDynamicallyCallback callback) {
+    i::Isolate::DeprecatedHostImportModuleDynamicallyCallback callback) {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+  isolate->SetHostImportModuleDynamicallyCallback(callback);
+}
+
+void Isolate::SetHostImportModuleDynamicallyCallback(
+    HostImportModuleDynamicallyWithImportAssertionsCallback callback) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
   isolate->SetHostImportModuleDynamicallyCallback(callback);
 }
diff --git a/src/ast/prettyprinter.cc b/src/ast/prettyprinter.cc
index 9cd64700c6ce..c3dae452c581 100644
--- a/src/ast/prettyprinter.cc
+++ b/src/ast/prettyprinter.cc
@@ -256,6 +256,7 @@ void CallPrinter::VisitRegExpLiteral(RegExpLiteral* node) {
   Print("/");
   PrintLiteral(node->pattern(), false);
   Print("/");
+  if (node->flags() & RegExp::kHasIndices) Print("d");
   if (node->flags() & RegExp::kGlobal) Print("g");
   if (node->flags() & RegExp::kIgnoreCase) Print("i");
   if (node->flags() & RegExp::kLinear) Print("l");
@@ -1156,6 +1157,7 @@ void AstPrinter::VisitRegExpLiteral(RegExpLiteral* node) {
   PrintLiteralIndented("PATTERN", node->raw_pattern(), false);
   int i = 0;
   EmbeddedVector<char, 128> buf;
+  if (node->flags() & RegExp::kHasIndices) buf[i++] = 'd';
   if (node->flags() & RegExp::kGlobal) buf[i++] = 'g';
   if (node->flags() & RegExp::kIgnoreCase) buf[i++] = 'i';
   if (node->flags() & RegExp::kLinear) buf[i++] = 'l';
diff --git a/src/builtins/accessors.cc b/src/builtins/accessors.cc
index b4c4b3f83c2a..53256725a04a 100644
--- a/src/builtins/accessors.cc
+++ b/src/builtins/accessors.cc
@@ -842,32 +842,5 @@ Handle<AccessorInfo> Accessors::MakeErrorStackInfo(Isolate* isolate) {
                       &ErrorStackGetter, &ErrorStackSetter);
 }
 
-//
-// Accessors::RegExpResultIndices
-//
-
-void Accessors::RegExpResultIndicesGetter(
-    v8::Local<v8::Name> key, const v8::PropertyCallbackInfo<v8::Value>& info) {
-  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(info.GetIsolate());
-  HandleScope scope(isolate);
-  Handle<JSRegExpResult> regexp_result(
-      Handle<JSRegExpResult>::cast(Utils::OpenHandle(*info.Holder())));
-  MaybeHandle<JSArray> maybe_indices(
-      JSRegExpResult::GetAndCacheIndices(isolate, regexp_result));
-  Handle<JSArray> indices;
-  if (!maybe_indices.ToHandle(&indices)) {
-    isolate->OptionalRescheduleException(false);
-    Handle<Object> result = isolate->factory()->undefined_value();
-    info.GetReturnValue().Set(Utils::ToLocal(result));
-  } else {
-    info.GetReturnValue().Set(Utils::ToLocal(indices));
-  }
-}
-
-Handle<AccessorInfo> Accessors::MakeRegExpResultIndicesInfo(Isolate* isolate) {
-  return MakeAccessor(isolate, isolate->factory()->indices_string(),
-                      &RegExpResultIndicesGetter, nullptr);
-}
-
 }  // namespace internal
 }  // namespace v8
diff --git a/src/builtins/accessors.h b/src/builtins/accessors.h
index 7bc8075e55ab..0148b8e3d18f 100644
--- a/src/builtins/accessors.h
+++ b/src/builtins/accessors.h
@@ -44,8 +44,6 @@ class JavaScriptFrame;
     kHasSideEffectToReceiver)                                                 \
   V(_, function_prototype, FunctionPrototype, kHasNoSideEffect,               \
     kHasSideEffectToReceiver)                                                 \
-  V(_, regexp_result_indices, RegExpResultIndices, kHasSideEffectToReceiver,  \
-    kHasSideEffectToReceiver)                                                 \
   V(_, string_length, StringLength, kHasNoSideEffect, kHasSideEffectToReceiver)
 
 #define ACCESSOR_SETTER_LIST(V) \
diff --git a/src/builtins/builtins-regexp-gen.cc b/src/builtins/builtins-regexp-gen.cc
index 0deb7528f0a4..de088ad2ace1 100644
--- a/src/builtins/builtins-regexp-gen.cc
+++ b/src/builtins/builtins-regexp-gen.cc
@@ -88,31 +88,52 @@ TNode<RawPtrT> RegExpBuiltinsAssembler::LoadCodeObjectEntry(TNode<Code> code) {
 TNode<JSRegExpResult> RegExpBuiltinsAssembler::AllocateRegExpResult(
     TNode<Context> context, TNode<Smi> length, TNode<Smi> index,
     TNode<String> input, TNode<JSRegExp> regexp, TNode<Number> last_index,
-    TNode<FixedArray>* elements_out) {
+    TNode<BoolT> has_indices, TNode<FixedArray>* elements_out) {
   CSA_ASSERT(this, SmiLessThanOrEqual(
                        length, SmiConstant(JSArray::kMaxFastArrayLength)));
   CSA_ASSERT(this, SmiGreaterThan(length, SmiConstant(0)));
 
   // Allocate.
 
+  Label result_has_indices(this), allocated(this);
   const ElementsKind elements_kind = PACKED_ELEMENTS;
-  TNode<Map> map = CAST(LoadContextElement(LoadNativeContext(context),
-                                           Context::REGEXP_RESULT_MAP_INDEX));
   base::Optional<TNode<AllocationSite>> no_gc_site = base::nullopt;
   TNode<IntPtrT> length_intptr = SmiUntag(length);
+  // Note: The returned `var_elements` may be in young large object space, but
+  // `var_array` is guaranteed to be in new space so we could skip write
+  // barriers below.
+  TVARIABLE(JSArray, var_array);
+  TVARIABLE(FixedArrayBase, var_elements);
 
-  // Note: The returned `elements` may be in young large object space, but
-  // `array` is guaranteed to be in new space so we could skip write barriers
-  // below.
-  TNode<JSArray> array;
-  TNode<FixedArrayBase> elements;
-  std::tie(array, elements) = AllocateUninitializedJSArrayWithElements(
-      elements_kind, map, length, no_gc_site, length_intptr,
-      kAllowLargeObjectAllocation, JSRegExpResult::kSize);
+  GotoIf(has_indices, &result_has_indices);
+  {
+    TNode<Map> map = CAST(LoadContextElement(LoadNativeContext(context),
+                                             Context::REGEXP_RESULT_MAP_INDEX));
+    std::tie(var_array, var_elements) =
+        AllocateUninitializedJSArrayWithElements(
+            elements_kind, map, length, no_gc_site, length_intptr,
+            kAllowLargeObjectAllocation, JSRegExpResult::kSize);
+    Goto(&allocated);
+  }
+
+  BIND(&result_has_indices);
+  {
+    TNode<Map> map =
+        CAST(LoadContextElement(LoadNativeContext(context),
+                                Context::REGEXP_RESULT_WITH_INDICES_MAP_INDEX));
+    std::tie(var_array, var_elements) =
+        AllocateUninitializedJSArrayWithElements(
+            elements_kind, map, length, no_gc_site, length_intptr,
+            kAllowLargeObjectAllocation, JSRegExpResultWithIndices::kSize);
+    Goto(&allocated);
+  }
+
+  BIND(&allocated);
 
   // Finish result initialization.
 
-  TNode<JSRegExpResult> result = UncheckedCast<JSRegExpResult>(array);
+  TNode<JSRegExpResult> result =
+      UncheckedCast<JSRegExpResult>(var_array.value());
 
   // Load undefined value once here to avoid multiple LoadRoots.
   TNode<Oddball> undefined_value = UncheckedCast<Oddball>(
@@ -127,10 +148,6 @@ TNode<JSRegExpResult> RegExpBuiltinsAssembler::AllocateRegExpResult(
   StoreObjectFieldNoWriteBarrier(result, JSRegExpResult::kNamesOffset,
                                  undefined_value);
 
-  // Stash regexp in order to re-execute and build JSRegExpResultIndices lazily
-  // when the 'indices' property is accessed.
-  StoreObjectField(result, JSRegExpResult::kCachedIndicesOrRegexpOffset,
-                   regexp);
   StoreObjectField(result, JSRegExpResult::kRegexpInputOffset, input);
 
   // If non-smi last_index then store an SmiZero instead.
@@ -142,12 +159,25 @@ TNode<JSRegExpResult> RegExpBuiltinsAssembler::AllocateRegExpResult(
                      last_index_smi);
   }
 
+  Label finish_initialization(this);
+  GotoIfNot(has_indices, &finish_initialization);
+  {
+    static_assert(
+        std::is_base_of<JSRegExpResult, JSRegExpResultWithIndices>::value,
+        "JSRegExpResultWithIndices is a subclass of JSRegExpResult");
+    StoreObjectFieldNoWriteBarrier(
+        result, JSRegExpResultWithIndices::kIndicesOffset, undefined_value);
+    Goto(&finish_initialization);
+  }
+
+  BIND(&finish_initialization);
+
   // Finish elements initialization.
 
-  FillFixedArrayWithValue(elements_kind, elements, IntPtrZero(), length_intptr,
-                          RootIndex::kUndefinedValue);
+  FillFixedArrayWithValue(elements_kind, var_elements.value(), IntPtrZero(),
+                          length_intptr, RootIndex::kUndefinedValue);
 
-  if (elements_out) *elements_out = CAST(elements);
+  if (elements_out) *elements_out = CAST(var_elements.value());
   return result;
 }
 
@@ -185,7 +215,7 @@ TNode<JSRegExpResult> RegExpBuiltinsAssembler::ConstructNewResultFromMatchInfo(
     TNode<Context> context, TNode<JSRegExp> regexp,
     TNode<RegExpMatchInfo> match_info, TNode<String> string,
     TNode<Number> last_index) {
-  Label named_captures(this), out(this);
+  Label named_captures(this), maybe_build_indices(this), out(this);
 
   TNode<IntPtrT> num_indices = SmiUntag(CAST(UnsafeLoadFixedArrayElement(
       match_info, RegExpMatchInfo::kNumberOfCapturesIndex)));
@@ -201,15 +231,19 @@ TNode<JSRegExpResult> RegExpBuiltinsAssembler::ConstructNewResultFromMatchInfo(
   TNode<String> first =
       CAST(CallBuiltin(Builtins::kSubString, context, string, start, end));
 
+  // Load flags and check if the result object needs to have indices.
+  const TNode<Smi> flags =
+      CAST(LoadObjectField(regexp, JSRegExp::kFlagsOffset));
+  const TNode<BoolT> has_indices = IsSetSmi(flags, JSRegExp::kHasIndices);
   TNode<FixedArray> result_elements;
   TNode<JSRegExpResult> result =
       AllocateRegExpResult(context, num_results, start, string, regexp,
-                           last_index, &result_elements);
+                           last_index, has_indices, &result_elements);
 
   UnsafeStoreFixedArrayElement(result_elements, 0, first);
 
   // If no captures exist we can skip named capture handling as well.
-  GotoIf(SmiEqual(num_results, SmiConstant(1)), &out);
+  GotoIf(SmiEqual(num_results, SmiConstant(1)), &maybe_build_indices);
 
   // Store all remaining captures.
   TNode<IntPtrT> limit = IntPtrAdd(
@@ -273,7 +307,7 @@ TNode<JSRegExpResult> RegExpBuiltinsAssembler::ConstructNewResultFromMatchInfo(
     // index at odd indices.
     TNode<Object> maybe_names =
         LoadFixedArrayElement(data, JSRegExp::kIrregexpCaptureNameMapIndex);
-    GotoIf(TaggedEqual(maybe_names, SmiZero()), &out);
+    GotoIf(TaggedEqual(maybe_names, SmiZero()), &maybe_build_indices);
 
     // One or more named captures exist, add a property for each one.
 
@@ -343,8 +377,8 @@ TNode<JSRegExpResult> RegExpBuiltinsAssembler::ConstructNewResultFromMatchInfo(
       }
 
       var_i = i_plus_2;
-      Branch(IntPtrGreaterThanOrEqual(var_i.value(), names_length), &out,
-             &loop);
+      Branch(IntPtrGreaterThanOrEqual(var_i.value(), names_length),
+             &maybe_build_indices, &loop);
 
       if (!V8_DICT_MODE_PROTOTYPES_BOOL) {
         // TODO(v8:11167) make unconditional  once OrderedNameDictionary
@@ -358,6 +392,22 @@ TNode<JSRegExpResult> RegExpBuiltinsAssembler::ConstructNewResultFromMatchInfo(
     }
   }
 
+  // Build indices if needed (i.e. if the /d flag is present) after named
+  // capture groups are processed.
+  BIND(&maybe_build_indices);
+  GotoIfNot(has_indices, &out);
+  {
+    const TNode<Object> maybe_names =
+        LoadObjectField(result, JSRegExpResultWithIndices::kNamesOffset);
+    const TNode<JSRegExpResultIndices> indices =
+        UncheckedCast<JSRegExpResultIndices>(
+            CallRuntime(Runtime::kRegExpBuildIndices, context, regexp,
+                        match_info, maybe_names));
+    StoreObjectField(result, JSRegExpResultWithIndices::kIndicesOffset,
+                     indices);
+    Goto(&out);
+  }
+
   BIND(&out);
   return result;
 }
@@ -836,8 +886,20 @@ void RegExpBuiltinsAssembler::BranchIfRegExpResult(const TNode<Context> context,
   const TNode<Object> initial_regexp_result_map =
       LoadContextElement(native_context, Context::REGEXP_RESULT_MAP_INDEX);
 
+  Label maybe_result_with_indices(this);
   Branch(TaggedEqual(map, initial_regexp_result_map), if_isunmodified,
-         if_ismodified);
+         &maybe_result_with_indices);
+  BIND(&maybe_result_with_indices);
+  {
+    static_assert(
+        std::is_base_of<JSRegExpResult, JSRegExpResultWithIndices>::value,
+        "JSRegExpResultWithIndices is a subclass of JSRegExpResult");
+    const TNode<Object> initial_regexp_result_with_indices_map =
+        LoadContextElement(native_context,
+                           Context::REGEXP_RESULT_WITH_INDICES_MAP_INDEX);
+    Branch(TaggedEqual(map, initial_regexp_result_with_indices_map),
+           if_isunmodified, if_ismodified);
+  }
 }
 
 // Fast path stub for ATOM regexps. String matching is done by StringIndexOf,
@@ -945,6 +1007,7 @@ TNode<String> RegExpBuiltinsAssembler::FlagsGetter(TNode<Context> context,
     BIND(&next);                                                   \
   } while (false)
 
+    CASE_FOR_FLAG(JSRegExp::kHasIndices);
     CASE_FOR_FLAG(JSRegExp::kGlobal);
     CASE_FOR_FLAG(JSRegExp::kIgnoreCase);
     CASE_FOR_FLAG(JSRegExp::kLinear);
@@ -981,35 +1044,38 @@ TNode<String> RegExpBuiltinsAssembler::FlagsGetter(TNode<Context> context,
     CASE_FOR_FLAG("sticky", JSRegExp::kSticky);
 #undef CASE_FOR_FLAG
 
-    {
-      Label next(this);
-
-      // Check the runtime value of FLAG_enable_experimental_regexp_engine
-      // first.
-      TNode<Word32T> flag_value = UncheckedCast<Word32T>(
-          Load(MachineType::Uint8(),
-               ExternalConstant(
-                   ExternalReference::
-                       address_of_enable_experimental_regexp_engine())));
-      GotoIf(Word32Equal(Word32And(flag_value, Int32Constant(0xFF)),
-                         Int32Constant(0)),
-             &next);
+#define CASE_FOR_FLAG(NAME, V8_FLAG_EXTERN_REF, FLAG)                      \
+  do {                                                                     \
+    Label next(this);                                                      \
+    TNode<Word32T> flag_value = UncheckedCast<Word32T>(                    \
+        Load(MachineType::Uint8(), ExternalConstant(V8_FLAG_EXTERN_REF))); \
+    GotoIf(Word32Equal(Word32And(flag_value, Int32Constant(0xFF)),         \
+                       Int32Constant(0)),                                  \
+           &next);                                                         \
+    const TNode<Object> flag = GetProperty(                                \
+        context, regexp, isolate->factory()->InternalizeUtf8String(NAME)); \
+    Label if_isflagset(this);                                              \
+    BranchIfToBooleanIsTrue(flag, &if_isflagset, &next);                   \
+    BIND(&if_isflagset);                                                   \
+    var_length = Uint32Add(var_length.value(), Uint32Constant(1));         \
+    var_flags = Signed(WordOr(var_flags.value(), IntPtrConstant(FLAG)));   \
+    Goto(&next);                                                           \
+    BIND(&next);                                                           \
+  } while (false)
 
-      const TNode<Object> flag = GetProperty(
-          context, regexp, isolate->factory()->InternalizeUtf8String("linear"));
-      Label if_isflagset(this);
-      BranchIfToBooleanIsTrue(flag, &if_isflagset, &next);
-      BIND(&if_isflagset);
-      var_length = Uint32Add(var_length.value(), Uint32Constant(1));
-      var_flags =
-          Signed(WordOr(var_flags.value(), IntPtrConstant(JSRegExp::kLinear)));
-      Goto(&next);
-      BIND(&next);
-    }
+    CASE_FOR_FLAG(
+        "hasIndices",
+        ExternalReference::address_of_harmony_regexp_match_indices_flag(),
+        JSRegExp::kHasIndices);
+    CASE_FOR_FLAG(
+        "linear",
+        ExternalReference::address_of_enable_experimental_regexp_engine(),
+        JSRegExp::kLinear);
+#undef CASE_FOR_FLAG
   }
 
-  // Allocate a string of the required length and fill it with the corresponding
-  // char for each set flag.
+  // Allocate a string of the required length and fill it with the
+  // corresponding char for each set flag.
 
   {
     const TNode<String> result = AllocateSeqOneByteString(var_length.value());
@@ -1029,6 +1095,7 @@ TNode<String> RegExpBuiltinsAssembler::FlagsGetter(TNode<Context> context,
     BIND(&next);                                               \
   } while (false)
 
+    CASE_FOR_FLAG(JSRegExp::kHasIndices, 'd');
     CASE_FOR_FLAG(JSRegExp::kGlobal, 'g');
     CASE_FOR_FLAG(JSRegExp::kIgnoreCase, 'i');
     CASE_FOR_FLAG(JSRegExp::kLinear, 'l');
@@ -1283,6 +1350,9 @@ TNode<BoolT> RegExpBuiltinsAssembler::SlowFlagGetter(TNode<Context> context,
     case JSRegExp::kUnicode:
       name = isolate()->factory()->unicode_string();
       break;
+    case JSRegExp::kHasIndices:
+      name = isolate()->factory()->has_indices_string();
+      break;
     case JSRegExp::kLinear:
       name = isolate()->factory()->linear_string();
       break;
diff --git a/src/builtins/builtins-regexp-gen.h b/src/builtins/builtins-regexp-gen.h
index 273e31559915..2f3d9a2051a2 100644
--- a/src/builtins/builtins-regexp-gen.h
+++ b/src/builtins/builtins-regexp-gen.h
@@ -22,13 +22,14 @@ class RegExpBuiltinsAssembler : public CodeStubAssembler {
 
   TNode<RawPtrT> LoadCodeObjectEntry(TNode<Code> code);
 
-  // Allocate a RegExpResult with the given length (the number of captures,
-  // including the match itself), index (the index where the match starts),
-  // and input string.
+  // Allocate either a JSRegExpResult or a JSRegExpResultWithIndices (depending
+  // on has_indices) with the given length (the number of captures, including
+  // the match itself), index (the index where the match starts), and input
+  // string.
   TNode<JSRegExpResult> AllocateRegExpResult(
       TNode<Context> context, TNode<Smi> length, TNode<Smi> index,
       TNode<String> input, TNode<JSRegExp> regexp, TNode<Number> last_index,
-      TNode<FixedArray>* elements_out = nullptr);
+      TNode<BoolT> has_indices, TNode<FixedArray>* elements_out = nullptr);
 
   TNode<Object> FastLoadLastIndexBeforeSmiCheck(TNode<JSRegExp> regexp);
   TNode<Smi> FastLoadLastIndex(TNode<JSRegExp> regexp) {
diff --git a/src/builtins/regexp.tq b/src/builtins/regexp.tq
index fc07f471df59..9fb1215e2ec3 100644
--- a/src/builtins/regexp.tq
+++ b/src/builtins/regexp.tq
@@ -51,8 +51,8 @@ transitioning macro RegExpExec(implicit context: Context)(
 }
 
 extern macro RegExpBuiltinsAssembler::ConstructNewResultFromMatchInfo(
-    implicit context: Context)(
-    JSRegExp, RegExpMatchInfo, String, Number): JSRegExpResult;
+    implicit context: Context)(JSRegExp, RegExpMatchInfo, String, Number):
+    JSRegExpResult|JSRegExpResultWithIndices;
 
 const kGlobalOrSticky: constexpr int31
     generates 'JSRegExp::kGlobal | JSRegExp::kSticky';
@@ -185,6 +185,7 @@ extern enum Flag constexpr 'JSRegExp::Flag' {
   kSticky,
   kUnicode,
   kDotAll,
+  kHasIndices,
   kLinear
 }
 
@@ -243,6 +244,13 @@ transitioning javascript builtin RegExpPrototypeMultilineGetter(
       'RegExp.prototype.multiline');
 }
 
+transitioning javascript builtin RegExpPrototypeHasIndicesGetter(
+    js-implicit context: NativeContext, receiver: JSAny)(): JSAny {
+  return FlagGetter(
+      receiver, Flag::kHasIndices, kNoCounterFlagGetter,
+      'RegExp.prototype.hasIndices');
+}
+
 transitioning javascript builtin RegExpPrototypeLinearGetter(
     js-implicit context: NativeContext, receiver: JSAny)(): JSAny {
   return FlagGetter(
diff --git a/src/codegen/external-reference.cc b/src/codegen/external-reference.cc
index 3a1f1af7403f..08eaadd4243f 100644
--- a/src/codegen/external-reference.cc
+++ b/src/codegen/external-reference.cc
@@ -462,6 +462,11 @@ ExternalReference ExternalReference::address_of_builtin_subclassing_flag() {
   return ExternalReference(&FLAG_builtin_subclassing);
 }
 
+ExternalReference
+ExternalReference::address_of_harmony_regexp_match_indices_flag() {
+  return ExternalReference(&FLAG_harmony_regexp_match_indices);
+}
+
 ExternalReference ExternalReference::address_of_runtime_stats_flag() {
   return ExternalReference(&TracingFlags::runtime_stats);
 }
diff --git a/src/codegen/external-reference.h b/src/codegen/external-reference.h
index c1c10419e606..79f6ce5e1be8 100644
--- a/src/codegen/external-reference.h
+++ b/src/codegen/external-reference.h
@@ -99,16 +99,18 @@ class StatsCounter;
 
 #define EXTERNAL_REFERENCE_LIST(V)                                             \
   V(abort_with_reason, "abort_with_reason")                                    \
+  V(address_of_builtin_subclassing_flag, "FLAG_builtin_subclassing")           \
   V(address_of_double_abs_constant, "double_absolute_constant")                \
   V(address_of_double_neg_constant, "double_negate_constant")                  \
   V(address_of_enable_experimental_regexp_engine,                              \
     "address_of_enable_experimental_regexp_engine")                            \
   V(address_of_float_abs_constant, "float_absolute_constant")                  \
   V(address_of_float_neg_constant, "float_negate_constant")                    \
+  V(address_of_harmony_regexp_match_indices_flag,                              \
+    "FLAG_harmony_regexp_match_indices")                                       \
   V(address_of_min_int, "LDoubleConstant::min_int")                            \
   V(address_of_mock_arraybuffer_allocator_flag,                                \
     "FLAG_mock_arraybuffer_allocator")                                         \
-  V(address_of_builtin_subclassing_flag, "FLAG_builtin_subclassing")           \
   V(address_of_one_half, "LDoubleConstant::one_half")                          \
   V(address_of_runtime_stats_flag, "TracingFlags::runtime_stats")              \
   V(address_of_the_hole_nan, "the_hole_nan")                                   \
diff --git a/src/common/message-template.h b/src/common/message-template.h
index 8394c6c5364c..11a9baca32f1 100644
--- a/src/common/message-template.h
+++ b/src/common/message-template.h
@@ -125,10 +125,14 @@ namespace internal {
   T(NonCoercibleWithProperty,                                                  \
     "Cannot destructure property '%' of '%' as it is %.")                      \
   T(NonExtensibleProto, "% is not extensible")                                 \
+  T(NonObjectAssertOption, "The 'assert' option must be an object")            \
   T(NonObjectInInstanceOfCheck,                                                \
     "Right-hand side of 'instanceof' is not an object")                        \
   T(NonObjectPropertyLoad, "Cannot read property '%' of %")                    \
   T(NonObjectPropertyStore, "Cannot set property '%' of %")                    \
+  T(NonObjectImportArgument,                                                   \
+    "The second argument to import() must be an object")                       \
+  T(NonStringImportAssertionValue, "Import assertion value must be a string")  \
   T(NoSetterInCallback, "Cannot set property % of % which has only a getter")  \
   T(NotAnIterator, "% is not an iterator")                                     \
   T(NotAPromise, "% is not a promise")                                         \
diff --git a/src/compiler/backend/arm/code-generator-arm.cc b/src/compiler/backend/arm/code-generator-arm.cc
index d54343027757..d894a65d433b 100644
--- a/src/compiler/backend/arm/code-generator-arm.cc
+++ b/src/compiler/backend/arm/code-generator-arm.cc
@@ -3220,7 +3220,9 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
       __ vrev16(Neon8, i.OutputSimd128Register(), i.InputSimd128Register(0));
       break;
     }
-    case kArmV128AnyTrue: {
+    case kArmV32x4AnyTrue:
+    case kArmV16x8AnyTrue:
+    case kArmV8x16AnyTrue: {
       const QwNeonRegister& src = i.InputSimd128Register(0);
       UseScratchRegisterScope temps(tasm());
       DwVfpRegister scratch = temps.AcquireD();
diff --git a/src/compiler/backend/arm/instruction-codes-arm.h b/src/compiler/backend/arm/instruction-codes-arm.h
index 591a5e0a1722..b5a77a1a10cb 100644
--- a/src/compiler/backend/arm/instruction-codes-arm.h
+++ b/src/compiler/backend/arm/instruction-codes-arm.h
@@ -327,9 +327,11 @@ namespace compiler {
   V(ArmS8x8Reverse)                \
   V(ArmS8x4Reverse)                \
   V(ArmS8x2Reverse)                \
+  V(ArmV32x4AnyTrue)               \
   V(ArmV32x4AllTrue)               \
+  V(ArmV16x8AnyTrue)               \
   V(ArmV16x8AllTrue)               \
-  V(ArmV128AnyTrue)                \
+  V(ArmV8x16AnyTrue)               \
   V(ArmV8x16AllTrue)               \
   V(ArmS128Load8Splat)             \
   V(ArmS128Load16Splat)            \
diff --git a/src/compiler/backend/arm/instruction-scheduler-arm.cc b/src/compiler/backend/arm/instruction-scheduler-arm.cc
index 9168e16bde8f..8b52a18482b4 100644
--- a/src/compiler/backend/arm/instruction-scheduler-arm.cc
+++ b/src/compiler/backend/arm/instruction-scheduler-arm.cc
@@ -307,9 +307,11 @@ int InstructionScheduler::GetTargetInstructionFlags(
     case kArmS8x8Reverse:
     case kArmS8x4Reverse:
     case kArmS8x2Reverse:
+    case kArmV32x4AnyTrue:
     case kArmV32x4AllTrue:
+    case kArmV16x8AnyTrue:
     case kArmV16x8AllTrue:
-    case kArmV128AnyTrue:
+    case kArmV8x16AnyTrue:
     case kArmV8x16AllTrue:
       return kNoOpcodeFlags;
 
diff --git a/src/compiler/backend/arm/instruction-selector-arm.cc b/src/compiler/backend/arm/instruction-selector-arm.cc
index b3c06887e39a..78a458083dd4 100644
--- a/src/compiler/backend/arm/instruction-selector-arm.cc
+++ b/src/compiler/backend/arm/instruction-selector-arm.cc
@@ -2596,9 +2596,11 @@ void InstructionSelector::VisitWord32AtomicPairCompareExchange(Node* node) {
   V(I8x16Abs, kArmI8x16Abs)                             \
   V(I8x16Popcnt, kArmVcnt)                              \
   V(S128Not, kArmS128Not)                               \
+  V(V32x4AnyTrue, kArmV32x4AnyTrue)                     \
   V(V32x4AllTrue, kArmV32x4AllTrue)                     \
+  V(V16x8AnyTrue, kArmV16x8AnyTrue)                     \
   V(V16x8AllTrue, kArmV16x8AllTrue)                     \
-  V(V128AnyTrue, kArmV128AnyTrue)                       \
+  V(V8x16AnyTrue, kArmV8x16AnyTrue)                     \
   V(V8x16AllTrue, kArmV8x16AllTrue)
 
 #define SIMD_SHIFT_OP_LIST(V) \
diff --git a/src/compiler/backend/arm64/instruction-selector-arm64.cc b/src/compiler/backend/arm64/instruction-selector-arm64.cc
index bc8a29354876..7979ee697eed 100644
--- a/src/compiler/backend/arm64/instruction-selector-arm64.cc
+++ b/src/compiler/backend/arm64/instruction-selector-arm64.cc
@@ -3423,9 +3423,11 @@ void InstructionSelector::VisitInt64AbsWithOverflow(Node* node) {
   V(I8x16Abs, kArm64I8x16Abs)                         \
   V(I8x16BitMask, kArm64I8x16BitMask)                 \
   V(S128Not, kArm64S128Not)                           \
+  V(V32x4AnyTrue, kArm64V128AnyTrue)                  \
   V(V32x4AllTrue, kArm64V32x4AllTrue)                 \
+  V(V16x8AnyTrue, kArm64V128AnyTrue)                  \
   V(V16x8AllTrue, kArm64V16x8AllTrue)                 \
-  V(V128AnyTrue, kArm64V128AnyTrue)                   \
+  V(V8x16AnyTrue, kArm64V128AnyTrue)                  \
   V(V8x16AllTrue, kArm64V8x16AllTrue)
 
 #define SIMD_SHIFT_OP_LIST(V) \
diff --git a/src/compiler/backend/ia32/instruction-selector-ia32.cc b/src/compiler/backend/ia32/instruction-selector-ia32.cc
index e1ad1e7d0303..8e1fcc6c5776 100644
--- a/src/compiler/backend/ia32/instruction-selector-ia32.cc
+++ b/src/compiler/backend/ia32/instruction-selector-ia32.cc
@@ -2336,6 +2336,11 @@ void InstructionSelector::VisitWord32AtomicPairCompareExchange(Node* node) {
   V(I8x16BitMask)           \
   V(S128Not)
 
+#define SIMD_ANYTRUE_LIST(V) \
+  V(V32x4AnyTrue)            \
+  V(V16x8AnyTrue)            \
+  V(V8x16AnyTrue)
+
 #define SIMD_ALLTRUE_LIST(V) \
   V(V32x4AllTrue)            \
   V(V16x8AllTrue)            \
@@ -2633,12 +2638,17 @@ SIMD_UNOP_LIST(VISIT_SIMD_UNOP)
 #undef VISIT_SIMD_UNOP
 #undef SIMD_UNOP_LIST
 
-void InstructionSelector::VisitV128AnyTrue(Node* node) {
-  IA32OperandGenerator g(this);
-  InstructionOperand temps[] = {g.TempRegister()};
-  Emit(kIA32S128AnyTrue, g.DefineAsRegister(node),
-       g.UseRegister(node->InputAt(0)), arraysize(temps), temps);
-}
+// The implementation of AnyTrue is the same for all shapes.
+#define VISIT_SIMD_ANYTRUE(Opcode)                                  \
+  void InstructionSelector::Visit##Opcode(Node* node) {             \
+    IA32OperandGenerator g(this);                                   \
+    InstructionOperand temps[] = {g.TempRegister()};                \
+    Emit(kIA32S128AnyTrue, g.DefineAsRegister(node),                \
+         g.UseRegister(node->InputAt(0)), arraysize(temps), temps); \
+  }
+SIMD_ANYTRUE_LIST(VISIT_SIMD_ANYTRUE)
+#undef VISIT_SIMD_ANYTRUE
+#undef SIMD_ANYTRUE_LIST
 
 #define VISIT_SIMD_ALLTRUE(Opcode)                                            \
   void InstructionSelector::Visit##Opcode(Node* node) {                       \
diff --git a/src/compiler/backend/instruction-selector.cc b/src/compiler/backend/instruction-selector.cc
index 3b35b0072985..6aa7326e3aa7 100644
--- a/src/compiler/backend/instruction-selector.cc
+++ b/src/compiler/backend/instruction-selector.cc
@@ -2306,12 +2306,16 @@ void InstructionSelector::VisitNode(Node* node) {
       return MarkAsSimd128(node), VisitI8x16Swizzle(node);
     case IrOpcode::kI8x16Shuffle:
       return MarkAsSimd128(node), VisitI8x16Shuffle(node);
+    case IrOpcode::kV32x4AnyTrue:
+      return MarkAsWord32(node), VisitV32x4AnyTrue(node);
     case IrOpcode::kV32x4AllTrue:
       return MarkAsWord32(node), VisitV32x4AllTrue(node);
+    case IrOpcode::kV16x8AnyTrue:
+      return MarkAsWord32(node), VisitV16x8AnyTrue(node);
     case IrOpcode::kV16x8AllTrue:
       return MarkAsWord32(node), VisitV16x8AllTrue(node);
-    case IrOpcode::kV128AnyTrue:
-      return MarkAsWord32(node), VisitV128AnyTrue(node);
+    case IrOpcode::kV8x16AnyTrue:
+      return MarkAsWord32(node), VisitV8x16AnyTrue(node);
     case IrOpcode::kV8x16AllTrue:
       return MarkAsWord32(node), VisitV8x16AllTrue(node);
     default:
diff --git a/src/compiler/backend/x64/code-generator-x64.cc b/src/compiler/backend/x64/code-generator-x64.cc
index bba7fe2e11d8..aefeb783ef0d 100644
--- a/src/compiler/backend/x64/code-generator-x64.cc
+++ b/src/compiler/backend/x64/code-generator-x64.cc
@@ -4227,7 +4227,9 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
       __ Por(dst, kScratchDoubleReg);
       break;
     }
-    case kX64V128AnyTrue: {
+    case kX64V32x4AnyTrue:
+    case kX64V16x8AnyTrue:
+    case kX64V8x16AnyTrue: {
       Register dst = i.OutputRegister();
       XMMRegister src = i.InputSimd128Register(0);
 
diff --git a/src/compiler/backend/x64/instruction-codes-x64.h b/src/compiler/backend/x64/instruction-codes-x64.h
index 805f6f883541..b2d168b86055 100644
--- a/src/compiler/backend/x64/instruction-codes-x64.h
+++ b/src/compiler/backend/x64/instruction-codes-x64.h
@@ -389,9 +389,11 @@ namespace compiler {
   V(X64S8x8Reverse)                       \
   V(X64S8x4Reverse)                       \
   V(X64S8x2Reverse)                       \
+  V(X64V32x4AnyTrue)                      \
   V(X64V32x4AllTrue)                      \
+  V(X64V16x8AnyTrue)                      \
   V(X64V16x8AllTrue)                      \
-  V(X64V128AnyTrue)                       \
+  V(X64V8x16AnyTrue)                      \
   V(X64V8x16AllTrue)                      \
   V(X64Prefetch)                          \
   V(X64PrefetchNta)                       \
diff --git a/src/compiler/backend/x64/instruction-scheduler-x64.cc b/src/compiler/backend/x64/instruction-scheduler-x64.cc
index d73080cc4f05..89c7681b0e38 100644
--- a/src/compiler/backend/x64/instruction-scheduler-x64.cc
+++ b/src/compiler/backend/x64/instruction-scheduler-x64.cc
@@ -317,7 +317,9 @@ int InstructionScheduler::GetTargetInstructionFlags(
     case kX64S128Zero:
     case kX64S128AllOnes:
     case kX64S128AndNot:
+    case kX64V32x4AnyTrue:
     case kX64V32x4AllTrue:
+    case kX64V16x8AnyTrue:
     case kX64V16x8AllTrue:
     case kX64I8x16Swizzle:
     case kX64I8x16Shuffle:
@@ -349,7 +351,7 @@ int InstructionScheduler::GetTargetInstructionFlags(
     case kX64S8x8Reverse:
     case kX64S8x4Reverse:
     case kX64S8x2Reverse:
-    case kX64V128AnyTrue:
+    case kX64V8x16AnyTrue:
     case kX64V8x16AllTrue:
       return (instr->addressing_mode() == kMode_None)
                  ? kNoOpcodeFlags
diff --git a/src/compiler/backend/x64/instruction-selector-x64.cc b/src/compiler/backend/x64/instruction-selector-x64.cc
index 57d06f01e2f1..57c6afa1cc85 100644
--- a/src/compiler/backend/x64/instruction-selector-x64.cc
+++ b/src/compiler/backend/x64/instruction-selector-x64.cc
@@ -2977,6 +2977,11 @@ VISIT_ATOMIC_BINOP(Xor)
   V(I8x16Shl)                        \
   V(I8x16ShrU)
 
+#define SIMD_ANYTRUE_LIST(V) \
+  V(V32x4AnyTrue)            \
+  V(V16x8AnyTrue)            \
+  V(V8x16AnyTrue)
+
 #define SIMD_ALLTRUE_LIST(V) \
   V(V32x4AllTrue)            \
   V(V16x8AllTrue)            \
@@ -3167,11 +3172,15 @@ SIMD_BINOP_ONE_TEMP_LIST(VISIT_SIMD_BINOP_ONE_TEMP)
 #undef VISIT_SIMD_BINOP_ONE_TEMP
 #undef SIMD_BINOP_ONE_TEMP_LIST
 
-void InstructionSelector::VisitV128AnyTrue(Node* node) {
-  X64OperandGenerator g(this);
-  Emit(kX64V128AnyTrue, g.DefineAsRegister(node),
-       g.UseUniqueRegister(node->InputAt(0)));
-}
+#define VISIT_SIMD_ANYTRUE(Opcode)                      \
+  void InstructionSelector::Visit##Opcode(Node* node) { \
+    X64OperandGenerator g(this);                        \
+    Emit(kX64##Opcode, g.DefineAsRegister(node),        \
+         g.UseUniqueRegister(node->InputAt(0)));        \
+  }
+SIMD_ANYTRUE_LIST(VISIT_SIMD_ANYTRUE)
+#undef VISIT_SIMD_ANYTRUE
+#undef SIMD_ANYTRUE_LIST
 
 #define VISIT_SIMD_ALLTRUE(Opcode)                                        \
   void InstructionSelector::Visit##Opcode(Node* node) {                   \
diff --git a/src/compiler/machine-operator.cc b/src/compiler/machine-operator.cc
index 5b24af57f941..d94cf350c3a8 100644
--- a/src/compiler/machine-operator.cc
+++ b/src/compiler/machine-operator.cc
@@ -548,9 +548,11 @@ ShiftKind ShiftKindOf(Operator const* op) {
   V(S128Not, Operator::kNoProperties, 1, 0, 1)                             \
   V(S128Select, Operator::kNoProperties, 3, 0, 1)                          \
   V(S128AndNot, Operator::kNoProperties, 2, 0, 1)                          \
+  V(V32x4AnyTrue, Operator::kNoProperties, 1, 0, 1)                        \
   V(V32x4AllTrue, Operator::kNoProperties, 1, 0, 1)                        \
+  V(V16x8AnyTrue, Operator::kNoProperties, 1, 0, 1)                        \
   V(V16x8AllTrue, Operator::kNoProperties, 1, 0, 1)                        \
-  V(V128AnyTrue, Operator::kNoProperties, 1, 0, 1)                         \
+  V(V8x16AnyTrue, Operator::kNoProperties, 1, 0, 1)                        \
   V(V8x16AllTrue, Operator::kNoProperties, 1, 0, 1)                        \
   V(I8x16Swizzle, Operator::kNoProperties, 2, 0, 1)
 
diff --git a/src/compiler/machine-operator.h b/src/compiler/machine-operator.h
index 946a412d74a6..8b0597a55b9e 100644
--- a/src/compiler/machine-operator.h
+++ b/src/compiler/machine-operator.h
@@ -819,9 +819,11 @@ class V8_EXPORT_PRIVATE MachineOperatorBuilder final
   const Operator* I8x16Swizzle();
   const Operator* I8x16Shuffle(const uint8_t shuffle[16]);
 
+  const Operator* V32x4AnyTrue();
   const Operator* V32x4AllTrue();
+  const Operator* V16x8AnyTrue();
   const Operator* V16x8AllTrue();
-  const Operator* V128AnyTrue();
+  const Operator* V8x16AnyTrue();
   const Operator* V8x16AllTrue();
 
   // load [base + index]
diff --git a/src/compiler/opcodes.h b/src/compiler/opcodes.h
index e90ee3ae6483..9a511106fd22 100644
--- a/src/compiler/opcodes.h
+++ b/src/compiler/opcodes.h
@@ -978,9 +978,11 @@
   V(S128AndNot)                 \
   V(I8x16Swizzle)               \
   V(I8x16Shuffle)               \
+  V(V32x4AnyTrue)               \
   V(V32x4AllTrue)               \
+  V(V16x8AnyTrue)               \
   V(V16x8AllTrue)               \
-  V(V128AnyTrue)                \
+  V(V8x16AnyTrue)               \
   V(V8x16AllTrue)               \
   V(LoadTransform)              \
   V(PrefetchTemporal)           \
diff --git a/src/compiler/simd-scalar-lowering.cc b/src/compiler/simd-scalar-lowering.cc
index f8408af063eb..f9bf22f8be56 100644
--- a/src/compiler/simd-scalar-lowering.cc
+++ b/src/compiler/simd-scalar-lowering.cc
@@ -166,9 +166,11 @@ void SimdScalarLowering::LowerGraph() {
   V(S128Not)                      \
   V(S128AndNot)                   \
   V(S128Select)                   \
+  V(V32x4AnyTrue)                 \
   V(V32x4AllTrue)                 \
+  V(V16x8AnyTrue)                 \
   V(V16x8AllTrue)                 \
-  V(V128AnyTrue)                  \
+  V(V8x16AnyTrue)                 \
   V(V8x16AllTrue)                 \
   V(I32x4BitMask)                 \
   V(I32x4ExtMulLowI16x8S)         \
@@ -2218,7 +2220,9 @@ void SimdScalarLowering::LowerNode(Node* node) {
       ReplaceNode(node, rep_node, 16);
       break;
     }
-    case IrOpcode::kV128AnyTrue: {
+    case IrOpcode::kV32x4AnyTrue:
+    case IrOpcode::kV16x8AnyTrue:
+    case IrOpcode::kV8x16AnyTrue: {
       DCHECK_EQ(1, node->InputCount());
       // AnyTrue always returns a I32x4, and can work with inputs of any shape,
       // but we still need GetReplacementsWithType if input is float.
diff --git a/src/compiler/wasm-compiler.cc b/src/compiler/wasm-compiler.cc
index cb2475a0f1f1..e7162303eff2 100644
--- a/src/compiler/wasm-compiler.cc
+++ b/src/compiler/wasm-compiler.cc
@@ -5211,12 +5211,16 @@ Node* WasmGraphBuilder::SimdOp(wasm::WasmOpcode opcode, Node* const* inputs) {
     case wasm::kExprS128AndNot:
       return graph()->NewNode(mcgraph()->machine()->S128AndNot(), inputs[0],
                               inputs[1]);
+    case wasm::kExprV32x4AnyTrue:
+      return graph()->NewNode(mcgraph()->machine()->V32x4AnyTrue(), inputs[0]);
     case wasm::kExprV32x4AllTrue:
       return graph()->NewNode(mcgraph()->machine()->V32x4AllTrue(), inputs[0]);
+    case wasm::kExprV16x8AnyTrue:
+      return graph()->NewNode(mcgraph()->machine()->V16x8AnyTrue(), inputs[0]);
     case wasm::kExprV16x8AllTrue:
       return graph()->NewNode(mcgraph()->machine()->V16x8AllTrue(), inputs[0]);
-    case wasm::kExprV128AnyTrue:
-      return graph()->NewNode(mcgraph()->machine()->V128AnyTrue(), inputs[0]);
+    case wasm::kExprV8x16AnyTrue:
+      return graph()->NewNode(mcgraph()->machine()->V8x16AnyTrue(), inputs[0]);
     case wasm::kExprV8x16AllTrue:
       return graph()->NewNode(mcgraph()->machine()->V8x16AllTrue(), inputs[0]);
     case wasm::kExprI8x16Swizzle:
diff --git a/src/d8/d8.cc b/src/d8/d8.cc
index 84f1628cd7fd..b9932415c343 100644
--- a/src/d8/d8.cc
+++ b/src/d8/d8.cc
@@ -839,13 +839,46 @@ class ModuleEmbedderData {
 
  public:
   explicit ModuleEmbedderData(Isolate* isolate)
-      : module_to_specifier_map(10, ModuleGlobalHash(isolate)) {}
+      : module_to_specifier_map(10, ModuleGlobalHash(isolate)),
+        json_module_to_parsed_json_map(10, ModuleGlobalHash(isolate)) {}
+
+  static ModuleType ModuleTypeFromImportAssertions(
+      Local<Context> context, Local<FixedArray> import_assertions,
+      bool hasPositions) {
+    Isolate* isolate = context->GetIsolate();
+    const int kV8AssertionEntrySize = hasPositions ? 3 : 2;
+    for (int i = 0; i < import_assertions->Length();
+         i += kV8AssertionEntrySize) {
+      Local<String> v8_assertion_key =
+          import_assertions->Get(context, i).As<v8::String>();
+      std::string assertion_key = ToSTLString(isolate, v8_assertion_key);
+
+      if (assertion_key == "type") {
+        Local<String> v8_assertion_value =
+            import_assertions->Get(context, i + 1).As<String>();
+        std::string assertion_value = ToSTLString(isolate, v8_assertion_value);
+        if (assertion_value == "json") {
+          return ModuleType::kJSON;
+        } else {
+          // JSON is currently the only supported non-JS type
+          return ModuleType::kInvalid;
+        }
+      }
+    }
+
+    // If no type is asserted, default to JS.
+    return ModuleType::kJavaScript;
+  }
 
-  // Map from normalized module specifier to Module.
-  std::unordered_map<std::string, Global<Module>> specifier_to_module_map;
+  // Map from (normalized module specifier, module type) pair to Module.
+  std::map<std::pair<std::string, ModuleType>, Global<Module>> module_map;
   // Map from Module to its URL as defined in the ScriptOrigin
   std::unordered_map<Global<Module>, std::string, ModuleGlobalHash>
       module_to_specifier_map;
+  // Map from JSON Module to its parsed content, for use in module
+  // JSONModuleEvaluationSteps
+  std::unordered_map<Global<Module>, Global<Value>, ModuleGlobalHash>
+      json_module_to_parsed_json_map;
 };
 
 enum { kModuleEmbedderDataIndex, kInspectorClientIndex };
@@ -869,7 +902,6 @@ MaybeLocal<Module> ResolveModuleCallback(Local<Context> context,
                                          Local<String> specifier,
                                          Local<FixedArray> import_assertions,
                                          Local<Module> referrer) {
-  // TODO(v8:11189) Consider JSON modules support in d8.
   Isolate* isolate = context->GetIsolate();
   ModuleEmbedderData* d = GetModuleDataFromContext(context);
   auto specifier_it =
@@ -877,8 +909,11 @@ MaybeLocal<Module> ResolveModuleCallback(Local<Context> context,
   CHECK(specifier_it != d->module_to_specifier_map.end());
   std::string absolute_path = NormalizePath(ToSTLString(isolate, specifier),
                                             DirName(specifier_it->second));
-  auto module_it = d->specifier_to_module_map.find(absolute_path);
-  CHECK(module_it != d->specifier_to_module_map.end());
+  ModuleType module_type = ModuleEmbedderData::ModuleTypeFromImportAssertions(
+      context, import_assertions, true);
+  auto module_it =
+      d->module_map.find(std::make_pair(absolute_path, module_type));
+  CHECK(module_it != d->module_map.end());
   return module_it->second.Get(isolate);
 }
 
@@ -886,7 +921,8 @@ MaybeLocal<Module> ResolveModuleCallback(Local<Context> context,
 
 MaybeLocal<Module> Shell::FetchModuleTree(Local<Module> referrer,
                                           Local<Context> context,
-                                          const std::string& file_name) {
+                                          const std::string& file_name,
+                                          ModuleType module_type) {
   DCHECK(IsAbsolutePath(file_name));
   Isolate* isolate = context->GetIsolate();
   Local<String> source_text = ReadFile(isolate, file_name.c_str());
@@ -914,16 +950,39 @@ MaybeLocal<Module> Shell::FetchModuleTree(Local<Module> referrer,
   ScriptOrigin origin(
       isolate, String::NewFromUtf8(isolate, file_name.c_str()).ToLocalChecked(),
       0, 0, false, -1, Local<Value>(), false, false, true);
-  ScriptCompiler::Source source(source_text, origin);
 
   Local<Module> module;
-  if (!CompileString<Module>(isolate, context, source_text, origin)
-           .ToLocal(&module)) {
-    return MaybeLocal<Module>();
+  if (module_type == ModuleType::kJavaScript) {
+    ScriptCompiler::Source source(source_text, origin);
+    if (!CompileString<Module>(isolate, context, source_text, origin)
+             .ToLocal(&module)) {
+      return MaybeLocal<Module>();
+    }
+  } else if (module_type == ModuleType::kJSON) {
+    Local<Value> parsed_json;
+    if (!v8::JSON::Parse(context, source_text).ToLocal(&parsed_json)) {
+      return MaybeLocal<Module>();
+    }
+
+    std::vector<Local<String>> export_names{
+        String::NewFromUtf8(isolate, "default").ToLocalChecked()};
+
+    module = v8::Module::CreateSyntheticModule(
+        isolate,
+        String::NewFromUtf8(isolate, file_name.c_str()).ToLocalChecked(),
+        export_names, Shell::JSONModuleEvaluationSteps);
+
+    CHECK(d->json_module_to_parsed_json_map
+              .insert(std::make_pair(Global<Module>(isolate, module),
+                                     Global<Value>(isolate, parsed_json)))
+              .second);
+  } else {
+    UNREACHABLE();
   }
 
-  CHECK(d->specifier_to_module_map
-            .insert(std::make_pair(file_name, Global<Module>(isolate, module)))
+  CHECK(d->module_map
+            .insert(std::make_pair(std::make_pair(file_name, module_type),
+                                   Global<Module>(isolate, module)))
             .second);
   CHECK(d->module_to_specifier_map
             .insert(std::make_pair(Global<Module>(isolate, module), file_name))
@@ -938,8 +997,23 @@ MaybeLocal<Module> Shell::FetchModuleTree(Local<Module> referrer,
     Local<String> name = module_request->GetSpecifier();
     std::string absolute_path =
         NormalizePath(ToSTLString(isolate, name), dir_name);
-    if (d->specifier_to_module_map.count(absolute_path)) continue;
-    if (FetchModuleTree(module, context, absolute_path).IsEmpty()) {
+    Local<FixedArray> import_assertions = module_request->GetImportAssertions();
+    ModuleType request_module_type =
+        ModuleEmbedderData::ModuleTypeFromImportAssertions(
+            context, import_assertions, true);
+
+    if (request_module_type == ModuleType::kInvalid) {
+      Throw(isolate, "Invalid module type was asserted");
+      return MaybeLocal<Module>();
+    }
+
+    if (d->module_map.count(
+            std::make_pair(absolute_path, request_module_type))) {
+      continue;
+    }
+
+    if (FetchModuleTree(module, context, absolute_path, request_module_type)
+            .IsEmpty()) {
       return MaybeLocal<Module>();
     }
   }
@@ -947,19 +1021,53 @@ MaybeLocal<Module> Shell::FetchModuleTree(Local<Module> referrer,
   return module;
 }
 
+MaybeLocal<Value> Shell::JSONModuleEvaluationSteps(Local<Context> context,
+                                                   Local<Module> module) {
+  Isolate* isolate = context->GetIsolate();
+
+  ModuleEmbedderData* d = GetModuleDataFromContext(context);
+  auto json_value_it =
+      d->json_module_to_parsed_json_map.find(Global<Module>(isolate, module));
+  CHECK(json_value_it != d->json_module_to_parsed_json_map.end());
+  Local<Value> json_value = json_value_it->second.Get(isolate);
+
+  TryCatch try_catch(isolate);
+  Maybe<bool> result = module->SetSyntheticModuleExport(
+      isolate,
+      String::NewFromUtf8Literal(isolate, "default",
+                                 NewStringType::kInternalized),
+      json_value);
+
+  // Setting the default export should never fail.
+  CHECK(!try_catch.HasCaught());
+  CHECK(!result.IsNothing() && result.FromJust());
+
+  if (i::FLAG_harmony_top_level_await) {
+    Local<Promise::Resolver> resolver =
+        Promise::Resolver::New(context).ToLocalChecked();
+    resolver->Resolve(context, Undefined(isolate)).ToChecked();
+    return resolver->GetPromise();
+  }
+
+  return Undefined(isolate);
+}
+
 struct DynamicImportData {
   DynamicImportData(Isolate* isolate_, Local<String> referrer_,
                     Local<String> specifier_,
+                    Local<FixedArray> import_assertions_,
                     Local<Promise::Resolver> resolver_)
       : isolate(isolate_) {
     referrer.Reset(isolate, referrer_);
     specifier.Reset(isolate, specifier_);
+    import_assertions.Reset(isolate, import_assertions_);
     resolver.Reset(isolate, resolver_);
   }
 
   Isolate* isolate;
   Global<String> referrer;
   Global<String> specifier;
+  Global<FixedArray> import_assertions;
   Global<Promise::Resolver> resolver;
 };
 
@@ -1020,15 +1128,16 @@ void Shell::ModuleResolutionFailureCallback(
 
 MaybeLocal<Promise> Shell::HostImportModuleDynamically(
     Local<Context> context, Local<ScriptOrModule> referrer,
-    Local<String> specifier) {
+    Local<String> specifier, Local<FixedArray> import_assertions) {
   Isolate* isolate = context->GetIsolate();
 
   MaybeLocal<Promise::Resolver> maybe_resolver =
       Promise::Resolver::New(context);
   Local<Promise::Resolver> resolver;
   if (maybe_resolver.ToLocal(&resolver)) {
-    DynamicImportData* data = new DynamicImportData(
-        isolate, referrer->GetResourceName().As<String>(), specifier, resolver);
+    DynamicImportData* data =
+        new DynamicImportData(isolate, referrer->GetResourceName().As<String>(),
+                              specifier, import_assertions, resolver);
     PerIsolateData::Get(isolate)->AddDynamicImportData(data);
     isolate->EnqueueMicrotask(Shell::DoHostImportModuleDynamically, data);
     return resolver->GetPromise();
@@ -1064,6 +1173,8 @@ void Shell::DoHostImportModuleDynamically(void* import_data) {
 
   Local<String> referrer(import_data_->referrer.Get(isolate));
   Local<String> specifier(import_data_->specifier.Get(isolate));
+  Local<FixedArray> import_assertions(
+      import_data_->import_assertions.Get(isolate));
   Local<Promise::Resolver> resolver(import_data_->resolver.Get(isolate));
 
   PerIsolateData* data = PerIsolateData::Get(isolate);
@@ -1072,21 +1183,33 @@ void Shell::DoHostImportModuleDynamically(void* import_data) {
   Local<Context> realm = data->realms_[data->realm_current_].Get(isolate);
   Context::Scope context_scope(realm);
 
+  ModuleType module_type = ModuleEmbedderData::ModuleTypeFromImportAssertions(
+      realm, import_assertions, false);
+
+  TryCatch try_catch(isolate);
+  try_catch.SetVerbose(true);
+
+  if (module_type == ModuleType::kInvalid) {
+    Throw(isolate, "Invalid module type was asserted");
+    CHECK(try_catch.HasCaught());
+    resolver->Reject(realm, try_catch.Exception()).ToChecked();
+    return;
+  }
+
   std::string source_url = ToSTLString(isolate, referrer);
   std::string dir_name =
       DirName(NormalizePath(source_url, GetWorkingDirectory()));
   std::string file_name = ToSTLString(isolate, specifier);
   std::string absolute_path = NormalizePath(file_name, dir_name);
 
-  TryCatch try_catch(isolate);
-  try_catch.SetVerbose(true);
-
   ModuleEmbedderData* d = GetModuleDataFromContext(realm);
   Local<Module> root_module;
-  auto module_it = d->specifier_to_module_map.find(absolute_path);
-  if (module_it != d->specifier_to_module_map.end()) {
+  auto module_it =
+      d->module_map.find(std::make_pair(absolute_path, module_type));
+  if (module_it != d->module_map.end()) {
     root_module = module_it->second.Get(isolate);
-  } else if (!FetchModuleTree(Local<Module>(), realm, absolute_path)
+  } else if (!FetchModuleTree(Local<Module>(), realm, absolute_path,
+                              module_type)
                   .ToLocal(&root_module)) {
     CHECK(try_catch.HasCaught());
     resolver->Reject(realm, try_catch.Exception()).ToChecked();
@@ -1154,7 +1277,8 @@ bool Shell::ExecuteModule(Isolate* isolate, const char* file_name) {
 
   Local<Module> root_module;
 
-  if (!FetchModuleTree(Local<Module>(), realm, absolute_path)
+  if (!FetchModuleTree(Local<Module>(), realm, absolute_path,
+                       ModuleType::kJavaScript)
            .ToLocal(&root_module)) {
     CHECK(try_catch.HasCaught());
     ReportException(isolate, &try_catch);
diff --git a/src/d8/d8.h b/src/d8/d8.h
index a6a1037cff1c..a9f6f3bc8b86 100644
--- a/src/d8/d8.h
+++ b/src/d8/d8.h
@@ -26,6 +26,8 @@ namespace v8 {
 
 class D8Console;
 
+enum class ModuleType { kJavaScript, kJSON, kInvalid };
+
 namespace internal {
 class CancelableTaskManager;
 }  // namespace internal
@@ -534,7 +536,7 @@ class Shell : public i::AllStatic {
   static void RemoveDirectory(const v8::FunctionCallbackInfo<v8::Value>& args);
   static MaybeLocal<Promise> HostImportModuleDynamically(
       Local<Context> context, Local<ScriptOrModule> referrer,
-      Local<String> specifier);
+      Local<String> specifier, Local<FixedArray> import_assertions);
   static void ModuleResolutionSuccessCallback(
       const v8::FunctionCallbackInfo<v8::Value>& info);
   static void ModuleResolutionFailureCallback(
@@ -630,7 +632,11 @@ class Shell : public i::AllStatic {
                            int index);
   static MaybeLocal<Module> FetchModuleTree(v8::Local<v8::Module> origin_module,
                                             v8::Local<v8::Context> context,
-                                            const std::string& file_name);
+                                            const std::string& file_name,
+                                            ModuleType module_type);
+
+  static MaybeLocal<Value> JSONModuleEvaluationSteps(Local<Context> context,
+                                                     Local<Module> module);
 
   template <class T>
   static MaybeLocal<T> CompileString(Isolate* isolate, Local<Context> context,
diff --git a/src/debug/debug-evaluate.cc b/src/debug/debug-evaluate.cc
index 77683fde1ef0..b8d377ce84f5 100644
--- a/src/debug/debug-evaluate.cc
+++ b/src/debug/debug-evaluate.cc
@@ -843,6 +843,7 @@ DebugInfo::SideEffectState BuiltinGetSideEffectState(Builtins::Name id) {
     case Builtins::kRegExpPrototypeSplit:
     case Builtins::kRegExpPrototypeFlagsGetter:
     case Builtins::kRegExpPrototypeGlobalGetter:
+    case Builtins::kRegExpPrototypeHasIndicesGetter:
     case Builtins::kRegExpPrototypeIgnoreCaseGetter:
     case Builtins::kRegExpPrototypeMatchAll:
     case Builtins::kRegExpPrototypeMultilineGetter:
diff --git a/src/execution/isolate.cc b/src/execution/isolate.cc
index 3869231aeb9a..fc6d252e110e 100644
--- a/src/execution/isolate.cc
+++ b/src/execution/isolate.cc
@@ -4153,11 +4153,17 @@ MaybeHandle<JSPromise> NewRejectedPromise(Isolate* isolate,
 }  // namespace
 
 MaybeHandle<JSPromise> Isolate::RunHostImportModuleDynamicallyCallback(
-    Handle<Script> referrer, Handle<Object> specifier) {
+    Handle<Script> referrer, Handle<Object> specifier,
+    MaybeHandle<Object> maybe_import_assertions_argument) {
   v8::Local<v8::Context> api_context =
       v8::Utils::ToLocal(Handle<Context>(native_context()));
+  DCHECK_EQ(host_import_module_dynamically_callback_ != nullptr,
+            host_import_module_dynamically_with_import_assertions_callback_ ==
+                nullptr);
 
-  if (host_import_module_dynamically_callback_ == nullptr) {
+  if (host_import_module_dynamically_callback_ == nullptr &&
+      host_import_module_dynamically_with_import_assertions_callback_ ==
+          nullptr) {
     Handle<Object> exception =
         factory()->NewError(error_function(), MessageTemplate::kUnsupported);
     return NewRejectedPromise(this, api_context, exception);
@@ -4174,22 +4180,150 @@ MaybeHandle<JSPromise> Isolate::RunHostImportModuleDynamicallyCallback(
   DCHECK(!has_pending_exception());
 
   v8::Local<v8::Promise> promise;
-  ASSIGN_RETURN_ON_SCHEDULED_EXCEPTION_VALUE(
-      this, promise,
-      host_import_module_dynamically_callback_(
-          api_context, v8::Utils::ScriptOrModuleToLocal(referrer),
-          v8::Utils::ToLocal(specifier_str)),
-      MaybeHandle<JSPromise>());
-  return v8::Utils::OpenHandle(*promise);
+
+  if (host_import_module_dynamically_with_import_assertions_callback_) {
+    Handle<FixedArray> import_assertions_array;
+    if (GetImportAssertionsFromArgument(maybe_import_assertions_argument)
+            .ToHandle(&import_assertions_array)) {
+      ASSIGN_RETURN_ON_SCHEDULED_EXCEPTION_VALUE(
+          this, promise,
+          host_import_module_dynamically_with_import_assertions_callback_(
+              api_context, v8::Utils::ScriptOrModuleToLocal(referrer),
+              v8::Utils::ToLocal(specifier_str),
+              ToApiHandle<v8::FixedArray>(import_assertions_array)),
+          MaybeHandle<JSPromise>());
+      return v8::Utils::OpenHandle(*promise);
+    } else {
+      Handle<Object> exception(pending_exception(), this);
+      clear_pending_exception();
+
+      return NewRejectedPromise(this, api_context, exception);
+    }
+
+  } else {
+    DCHECK_NOT_NULL(host_import_module_dynamically_callback_);
+    ASSIGN_RETURN_ON_SCHEDULED_EXCEPTION_VALUE(
+        this, promise,
+        host_import_module_dynamically_callback_(
+            api_context, v8::Utils::ScriptOrModuleToLocal(referrer),
+            v8::Utils::ToLocal(specifier_str)),
+        MaybeHandle<JSPromise>());
+    return v8::Utils::OpenHandle(*promise);
+  }
+}
+
+MaybeHandle<FixedArray> Isolate::GetImportAssertionsFromArgument(
+    MaybeHandle<Object> maybe_import_assertions_argument) {
+  Handle<FixedArray> import_assertions_array = factory()->empty_fixed_array();
+  Handle<Object> import_assertions_argument;
+  if (!maybe_import_assertions_argument.ToHandle(&import_assertions_argument) ||
+      import_assertions_argument->IsUndefined()) {
+    return import_assertions_array;
+  }
+
+  // The parser shouldn't have allowed the second argument to import() if
+  // the flag wasn't enabled.
+  DCHECK(FLAG_harmony_import_assertions);
+
+  if (!import_assertions_argument->IsJSReceiver()) {
+    this->Throw(
+        *factory()->NewTypeError(MessageTemplate::kNonObjectImportArgument));
+    return MaybeHandle<FixedArray>();
+  }
+
+  Handle<JSReceiver> import_assertions_argument_receiver =
+      Handle<JSReceiver>::cast(import_assertions_argument);
+  Handle<Name> key = factory()->assert_string();
+
+  Handle<Object> import_assertions_object;
+  if (!JSReceiver::GetProperty(this, import_assertions_argument_receiver, key)
+           .ToHandle(&import_assertions_object)) {
+    // This can happen if the property has a getter function that throws
+    // an error.
+    return MaybeHandle<FixedArray>();
+  }
+
+  // If there is no 'assert' option in the options bag, it's not an error. Just
+  // do the import() as if no assertions were provided.
+  if (import_assertions_object->IsUndefined()) return import_assertions_array;
+
+  if (!import_assertions_object->IsJSReceiver()) {
+    this->Throw(
+        *factory()->NewTypeError(MessageTemplate::kNonObjectAssertOption));
+    return MaybeHandle<FixedArray>();
+  }
+
+  Handle<JSReceiver> import_assertions_object_receiver =
+      Handle<JSReceiver>::cast(import_assertions_object);
+
+  Handle<FixedArray> assertion_keys =
+      KeyAccumulator::GetKeys(import_assertions_object_receiver,
+                              KeyCollectionMode::kOwnOnly, ENUMERABLE_STRINGS,
+                              GetKeysConversion::kConvertToString)
+          .ToHandleChecked();
+
+  // Assertions passed to the host must be sorted by the code point order of the
+  // key of each entry.
+  auto stringCompare = [this](Handle<String> lhs, Handle<String> rhs) {
+    return String::Compare(this, lhs, rhs) == ComparisonResult::kLessThan;
+  };
+  std::map<Handle<String>, Handle<String>, decltype(stringCompare)>
+      sorted_assertions(stringCompare);
+
+  // Collect the assertions in the sorted map.
+  for (int i = 0; i < assertion_keys->length(); i++) {
+    Handle<String> assertion_key(String::cast(assertion_keys->get(i)), this);
+    Handle<Object> assertion_value;
+    if (!JSReceiver::GetProperty(this, import_assertions_object_receiver,
+                                 assertion_key)
+             .ToHandle(&assertion_value)) {
+      // This can happen if the property has a getter function that throws
+      // an error.
+      return MaybeHandle<FixedArray>();
+    }
+
+    if (!assertion_value->IsString()) {
+      this->Throw(*factory()->NewTypeError(
+          MessageTemplate::kNonStringImportAssertionValue));
+      return MaybeHandle<FixedArray>();
+    }
+
+    auto insertion_result = sorted_assertions.insert(
+        std::make_pair(assertion_key, Handle<String>::cast(assertion_value)));
+
+    // Duplicate keys are not expected here.
+    CHECK(insertion_result.second);
+  }
+
+  // Move the assertions from the sorted map to the FixedArray that will be
+  // passed to the host. They will be stored in the array in the form: [key1,
+  // value1, key2, value2, ...].
+  constexpr size_t kAssertionEntrySizeForDynamicImport = 2;
+  import_assertions_array = factory()->NewFixedArray(static_cast<int>(
+      sorted_assertions.size() * kAssertionEntrySizeForDynamicImport));
+  int import_assertions_array_index = 0;
+  for (const auto& pair : sorted_assertions) {
+    import_assertions_array->set(import_assertions_array_index, *(pair.first));
+    import_assertions_array->set(import_assertions_array_index + 1,
+                                 *(pair.second));
+    import_assertions_array_index += kAssertionEntrySizeForDynamicImport;
+  }
+
+  return import_assertions_array;
 }
 
 void Isolate::ClearKeptObjects() { heap()->ClearKeptObjects(); }
 
 void Isolate::SetHostImportModuleDynamicallyCallback(
-    HostImportModuleDynamicallyCallback callback) {
+    DeprecatedHostImportModuleDynamicallyCallback callback) {
   host_import_module_dynamically_callback_ = callback;
 }
 
+void Isolate::SetHostImportModuleDynamicallyCallback(
+    HostImportModuleDynamicallyWithImportAssertionsCallback callback) {
+  host_import_module_dynamically_with_import_assertions_callback_ = callback;
+}
+
 MaybeHandle<JSObject> Isolate::RunHostInitializeImportMetaObjectCallback(
     Handle<SourceTextModule> module) {
   CHECK(module->import_meta().IsTheHole(this));
diff --git a/src/execution/isolate.h b/src/execution/isolate.h
index c8b8799f2839..0305770478c2 100644
--- a/src/execution/isolate.h
+++ b/src/execution/isolate.h
@@ -1523,10 +1523,23 @@ class V8_EXPORT_PRIVATE Isolate final : private HiddenFactory {
 
   void ClearKeptObjects();
 
+  // While deprecating v8::HostImportModuleDynamicallyCallback in v8.h we still
+  // need to support the version of the API that uses it, but we can't directly
+  // reference the deprecated version because of the enusing build warnings. So,
+  // we declare this matching type for temporary internal use.
+  // TODO(v8:10958) Delete this declaration and all references to it once
+  // v8::HostImportModuleDynamicallyCallback is removed.
+  typedef MaybeLocal<Promise> (*DeprecatedHostImportModuleDynamicallyCallback)(
+      v8::Local<v8::Context> context, v8::Local<v8::ScriptOrModule> referrer,
+      v8::Local<v8::String> specifier);
+
+  void SetHostImportModuleDynamicallyCallback(
+      DeprecatedHostImportModuleDynamicallyCallback callback);
   void SetHostImportModuleDynamicallyCallback(
-      HostImportModuleDynamicallyCallback callback);
+      HostImportModuleDynamicallyWithImportAssertionsCallback callback);
   MaybeHandle<JSPromise> RunHostImportModuleDynamicallyCallback(
-      Handle<Script> referrer, Handle<Object> specifier);
+      Handle<Script> referrer, Handle<Object> specifier,
+      MaybeHandle<Object> maybe_import_assertions_argument);
 
   void SetHostInitializeImportMetaObjectCallback(
       HostInitializeImportMetaObjectCallback callback);
@@ -1823,8 +1836,21 @@ class V8_EXPORT_PRIVATE Isolate final : private HiddenFactory {
   v8::Isolate::AtomicsWaitCallback atomics_wait_callback_ = nullptr;
   void* atomics_wait_callback_data_ = nullptr;
   PromiseHook promise_hook_ = nullptr;
-  HostImportModuleDynamicallyCallback host_import_module_dynamically_callback_ =
-      nullptr;
+  DeprecatedHostImportModuleDynamicallyCallback
+      host_import_module_dynamically_callback_ = nullptr;
+  HostImportModuleDynamicallyWithImportAssertionsCallback
+      host_import_module_dynamically_with_import_assertions_callback_ = nullptr;
+
+  // Helper function for RunHostImportModuleDynamicallyCallback.
+  // Unpacks import assertions, if present, from the second argument to dynamic
+  // import() and returns them in a FixedArray, sorted by code point order of
+  // the keys, in the form [key1, value1, key2, value2, ...]. Returns an empty
+  // MaybeHandle if an error was thrown.  In this case, the host callback should
+  // not be called and instead the caller should use the pending exception to
+  // reject the import() call's Promise.
+  MaybeHandle<FixedArray> GetImportAssertionsFromArgument(
+      MaybeHandle<Object> maybe_import_assertions_argument);
+
   HostInitializeImportMetaObjectCallback
       host_initialize_import_meta_object_callback_ = nullptr;
   base::Mutex rail_mutex_;
diff --git a/src/init/bootstrapper.cc b/src/init/bootstrapper.cc
index 565884f170ec..4159a3634a30 100644
--- a/src/init/bootstrapper.cc
+++ b/src/init/bootstrapper.cc
@@ -4436,13 +4436,31 @@ void Genesis::InitializeGlobal_harmony_weak_refs_with_cleanup_some() {
 void Genesis::InitializeGlobal_harmony_regexp_match_indices() {
   if (!FLAG_harmony_regexp_match_indices) return;
 
-  // Add indices accessor to JSRegExpResult's initial map.
-  Handle<Map> initial_map(native_context()->regexp_result_map(), isolate());
-  Descriptor d = Descriptor::AccessorConstant(
-      factory()->indices_string(), factory()->regexp_result_indices_accessor(),
-      NONE);
-  Map::EnsureDescriptorSlack(isolate(), initial_map, 1);
-  initial_map->AppendDescriptor(isolate(), &d);
+  Handle<Map> source_map(native_context()->regexp_result_map(), isolate());
+  Handle<Map> initial_map =
+      Map::Copy(isolate(), source_map, "JSRegExpResult with indices");
+  initial_map->set_instance_size(JSRegExpResultWithIndices::kSize);
+  DCHECK_EQ(initial_map->GetInObjectProperties(),
+            JSRegExpResultWithIndices::kInObjectPropertyCount);
+
+  // indices descriptor
+  {
+    Descriptor d =
+        Descriptor::DataField(isolate(), factory()->indices_string(),
+                              JSRegExpResultWithIndices::kIndicesIndex, NONE,
+                              Representation::Tagged());
+    Map::EnsureDescriptorSlack(isolate(), initial_map, 1);
+    initial_map->AppendDescriptor(isolate(), &d);
+  }
+
+  native_context()->set_regexp_result_with_indices_map(*initial_map);
+
+  Handle<JSObject> prototype(native_context()->regexp_prototype(), isolate());
+  SimpleInstallGetter(isolate(), prototype, factory()->has_indices_string(),
+                      Builtins::kRegExpPrototypeHasIndicesGetter, true);
+
+  // Store regexp prototype map again after change.
+  native_context()->set_regexp_prototype_map(prototype->map());
 }
 
 void Genesis::InitializeGlobal_harmony_string_replaceall() {
@@ -4788,16 +4806,6 @@ bool Genesis::InstallABunchOfRandomThings() {
     {
       PropertyAttributes attribs = DONT_ENUM;
 
-      // cached_indices_or_regexp descriptor.
-      {
-        Descriptor d = Descriptor::DataField(
-            isolate(),
-            factory()->regexp_result_cached_indices_or_regexp_symbol(),
-            JSRegExpResult::kCachedIndicesOrRegExpIndex, attribs,
-            Representation::Tagged());
-        initial_map->AppendDescriptor(isolate(), &d);
-      }
-
       // names descriptor.
       {
         Descriptor d = Descriptor::DataField(
diff --git a/src/init/heap-symbols.h b/src/init/heap-symbols.h
index b61e783bda9f..b2c2371548a7 100644
--- a/src/init/heap-symbols.h
+++ b/src/init/heap-symbols.h
@@ -209,6 +209,7 @@
   V(_, globalThis_string, "globalThis")                              \
   V(_, groups_string, "groups")                                      \
   V(_, has_string, "has")                                            \
+  V(_, has_indices_string, "hasIndices")                             \
   V(_, ignoreCase_string, "ignoreCase")                              \
   V(_, illegal_access_string, "illegal access")                      \
   V(_, illegal_argument_string, "illegal argument")                  \
@@ -357,7 +358,6 @@
   V(_, promise_debug_message_symbol)                  \
   V(_, promise_forwarding_handler_symbol)             \
   V(_, promise_handled_by_symbol)                     \
-  V(_, regexp_result_cached_indices_or_regexp_symbol) \
   V(_, regexp_result_names_symbol)                    \
   V(_, regexp_result_regexp_input_symbol)             \
   V(_, regexp_result_regexp_last_index_symbol)        \
diff --git a/src/interpreter/bytecode-generator.cc b/src/interpreter/bytecode-generator.cc
index ab3010d6db9c..71eecec668df 100644
--- a/src/interpreter/bytecode-generator.cc
+++ b/src/interpreter/bytecode-generator.cc
@@ -5705,8 +5705,12 @@ void BytecodeGenerator::VisitEmptyParentheses(EmptyParentheses* expr) {
 }
 
 void BytecodeGenerator::VisitImportCallExpression(ImportCallExpression* expr) {
-  RegisterList args = register_allocator()->NewRegisterList(2);
+  const int register_count = expr->import_assertions() ? 3 : 2;
+  RegisterList args = register_allocator()->NewRegisterList(register_count);
   VisitForRegisterValue(expr->specifier(), args[1]);
+  if (expr->import_assertions()) {
+    VisitForRegisterValue(expr->import_assertions(), args[2]);
+  }
   builder()
       ->MoveRegister(Register::function_closure(), args[0])
       .CallRuntime(Runtime::kDynamicImportCall, args);
diff --git a/src/objects/contexts.h b/src/objects/contexts.h
index a8f903376a94..a151ece56460 100644
--- a/src/objects/contexts.h
+++ b/src/objects/contexts.h
@@ -214,6 +214,7 @@ enum ContextLookupFlags {
   V(REGEXP_PROTOTYPE_MAP_INDEX, Map, regexp_prototype_map)                     \
   V(REGEXP_REPLACE_FUNCTION_INDEX, JSFunction, regexp_replace_function)        \
   V(REGEXP_RESULT_MAP_INDEX, Map, regexp_result_map)                           \
+  V(REGEXP_RESULT_WITH_INDICES_MAP_INDEX, Map, regexp_result_with_indices_map) \
   V(REGEXP_RESULT_INDICES_MAP_INDEX, Map, regexp_result_indices_map)           \
   V(REGEXP_SEARCH_FUNCTION_INDEX, JSFunction, regexp_search_function)          \
   V(REGEXP_SPLIT_FUNCTION_INDEX, JSFunction, regexp_split_function)            \
diff --git a/src/objects/js-regexp-inl.h b/src/objects/js-regexp-inl.h
index 8b99aa7c4c0a..9a75fff80770 100644
--- a/src/objects/js-regexp-inl.h
+++ b/src/objects/js-regexp-inl.h
@@ -24,7 +24,13 @@ TQ_OBJECT_CONSTRUCTORS_IMPL(JSRegExp)
 OBJECT_CONSTRUCTORS_IMPL_CHECK_SUPER(JSRegExpResult, JSArray)
 OBJECT_CONSTRUCTORS_IMPL_CHECK_SUPER(JSRegExpResultIndices, JSArray)
 
+inline JSRegExpResultWithIndices::JSRegExpResultWithIndices(Address ptr)
+    : JSRegExpResult(ptr) {
+  SLOW_DCHECK(IsJSArray());
+}
+
 CAST_ACCESSOR(JSRegExpResult)
+CAST_ACCESSOR(JSRegExpResultWithIndices)
 CAST_ACCESSOR(JSRegExpResultIndices)
 
 ACCESSORS(JSRegExp, last_index, Object, kLastIndexOffset)
diff --git a/src/objects/js-regexp.cc b/src/objects/js-regexp.cc
index 4149e990242d..d5ea92533f69 100644
--- a/src/objects/js-regexp.cc
+++ b/src/objects/js-regexp.cc
@@ -12,78 +12,6 @@
 namespace v8 {
 namespace internal {
 
-MaybeHandle<JSArray> JSRegExpResult::GetAndCacheIndices(
-    Isolate* isolate, Handle<JSRegExpResult> regexp_result) {
-  // Check for cached indices. We do a slow lookup and set of
-  // the cached_indices_or_match_info and names fields just in
-  // case they have been migrated to dictionaries.
-  Handle<Object> indices_or_regexp(
-      GetProperty(
-          isolate, regexp_result,
-          isolate->factory()->regexp_result_cached_indices_or_regexp_symbol())
-          .ToHandleChecked());
-  if (indices_or_regexp->IsJSRegExp()) {
-    // Build and cache indices for next lookup.
-    // TODO(joshualitt): Instead of caching the indices, we could call
-    // ReconfigureToDataProperty on 'indices' setting its value to this
-    // newly created array. However, care would have to be taken to ensure
-    // a new map is not created each time.
-
-    // Grab regexp, its last_index, and the original subject string from the
-    // result and the re-execute the regexp to generate a new MatchInfo.
-    Handle<JSRegExp> regexp(JSRegExp::cast(*indices_or_regexp), isolate);
-    Handle<Object> input_object(
-        GetProperty(isolate, regexp_result,
-                    isolate->factory()->regexp_result_regexp_input_symbol())
-            .ToHandleChecked());
-    Handle<String> subject(String::cast(*input_object), isolate);
-    Handle<Object> last_index_object(
-        GetProperty(
-            isolate, regexp_result,
-            isolate->factory()->regexp_result_regexp_last_index_symbol())
-            .ToHandleChecked());
-
-    int capture_count = regexp->CaptureCount();
-    Handle<RegExpMatchInfo> match_info =
-        RegExpMatchInfo::New(isolate, capture_count);
-
-    int last_index = Smi::ToInt(*last_index_object);
-    Handle<Object> result;
-    ASSIGN_RETURN_ON_EXCEPTION(
-        isolate, result,
-        RegExp::Exec(isolate, regexp, subject, last_index, match_info),
-        JSArray);
-    DCHECK_EQ(*result, *match_info);
-
-    Handle<Object> maybe_names(
-        GetProperty(isolate, regexp_result,
-                    isolate->factory()->regexp_result_names_symbol())
-            .ToHandleChecked());
-    indices_or_regexp =
-        JSRegExpResultIndices::BuildIndices(isolate, match_info, maybe_names);
-
-    // Cache the result and clear the names array, last_index and subject.
-    SetProperty(
-        isolate, regexp_result,
-        isolate->factory()->regexp_result_cached_indices_or_regexp_symbol(),
-        indices_or_regexp)
-        .ToHandleChecked();
-    SetProperty(isolate, regexp_result,
-                isolate->factory()->regexp_result_names_symbol(),
-                isolate->factory()->undefined_value())
-        .ToHandleChecked();
-    SetProperty(isolate, regexp_result,
-                isolate->factory()->regexp_result_regexp_last_index_symbol(),
-                isolate->factory()->undefined_value())
-        .ToHandleChecked();
-    SetProperty(isolate, regexp_result,
-                isolate->factory()->regexp_result_regexp_input_symbol(),
-                isolate->factory()->undefined_value())
-        .ToHandleChecked();
-  }
-  return Handle<JSArray>::cast(indices_or_regexp);
-}
-
 Handle<JSRegExpResultIndices> JSRegExpResultIndices::BuildIndices(
     Isolate* isolate, Handle<RegExpMatchInfo> match_info,
     Handle<Object> maybe_names) {
diff --git a/src/objects/js-regexp.h b/src/objects/js-regexp.h
index b1d1399eab13..c0ef276b9913 100644
--- a/src/objects/js-regexp.h
+++ b/src/objects/js-regexp.h
@@ -5,6 +5,7 @@
 #ifndef V8_OBJECTS_JS_REGEXP_H_
 #define V8_OBJECTS_JS_REGEXP_H_
 
+#include "src/objects/contexts.h"
 #include "src/objects/js-array.h"
 #include "torque-generated/bit-fields.h"
 
@@ -43,7 +44,7 @@ class JSRegExp : public TorqueGeneratedJSRegExp<JSRegExp, JSObject> {
   DEFINE_TORQUE_GENERATED_JS_REG_EXP_FLAGS()
 
   static base::Optional<Flag> FlagFromChar(char c) {
-    STATIC_ASSERT(kFlagCount == 7);
+    STATIC_ASSERT(kFlagCount == 8);
     // clang-format off
     return c == 'g' ? base::Optional<Flag>(kGlobal)
          : c == 'i' ? base::Optional<Flag>(kIgnoreCase)
@@ -53,6 +54,8 @@ class JSRegExp : public TorqueGeneratedJSRegExp<JSRegExp, JSObject> {
          : c == 's' ? base::Optional<Flag>(kDotAll)
          : (FLAG_enable_experimental_regexp_engine && c == 'l')
            ? base::Optional<Flag>(kLinear)
+         : (FLAG_harmony_regexp_match_indices &&  c == 'd')
+           ? base::Optional<Flag>(kHasIndices)
          : base::Optional<Flag>();
     // clang-format on
   }
@@ -65,6 +68,7 @@ class JSRegExp : public TorqueGeneratedJSRegExp<JSRegExp, JSObject> {
   STATIC_ASSERT(static_cast<int>(kUnicode) == v8::RegExp::kUnicode);
   STATIC_ASSERT(static_cast<int>(kDotAll) == v8::RegExp::kDotAll);
   STATIC_ASSERT(static_cast<int>(kLinear) == v8::RegExp::kLinear);
+  STATIC_ASSERT(static_cast<int>(kHasIndices) == v8::RegExp::kHasIndices);
   STATIC_ASSERT(kFlagCount == v8::RegExp::kFlagCount);
 
   DECL_ACCESSORS(last_index, Object)
@@ -249,24 +253,40 @@ class JSRegExpResult : public JSArray {
   DEFINE_FIELD_OFFSET_CONSTANTS(JSArray::kHeaderSize,
                                 TORQUE_GENERATED_JS_REG_EXP_RESULT_FIELDS)
 
-  static MaybeHandle<JSArray> GetAndCacheIndices(
-      Isolate* isolate, Handle<JSRegExpResult> regexp_result);
-
   // Indices of in-object properties.
   static const int kIndexIndex = 0;
   static const int kInputIndex = 1;
   static const int kGroupsIndex = 2;
 
   // Private internal only fields.
-  static const int kCachedIndicesOrRegExpIndex = 3;
-  static const int kNamesIndex = 4;
-  static const int kRegExpInputIndex = 5;
-  static const int kRegExpLastIndex = 6;
-  static const int kInObjectPropertyCount = 7;
+  static const int kNamesIndex = 3;
+  static const int kRegExpInputIndex = 4;
+  static const int kRegExpLastIndex = 5;
+  static const int kInObjectPropertyCount = 6;
+
+  static const int kMapIndexInContext = Context::REGEXP_RESULT_MAP_INDEX;
 
   OBJECT_CONSTRUCTORS(JSRegExpResult, JSArray);
 };
 
+class JSRegExpResultWithIndices : public JSRegExpResult {
+ public:
+  DECL_CAST(JSRegExpResultWithIndices)
+
+  // Layout description.
+  DEFINE_FIELD_OFFSET_CONSTANTS(
+      JSRegExpResult::kSize,
+      TORQUE_GENERATED_JS_REG_EXP_RESULT_WITH_INDICES_FIELDS)
+
+  static_assert(
+      JSRegExpResult::kInObjectPropertyCount == 6,
+      "JSRegExpResultWithIndices must be a subclass of JSRegExpResult");
+  static const int kIndicesIndex = 6;
+  static const int kInObjectPropertyCount = 7;
+
+  OBJECT_CONSTRUCTORS(JSRegExpResultWithIndices, JSRegExpResult);
+};
+
 // JSRegExpResultIndices is just a JSArray with a specific initial map.
 // This initial map adds in-object properties for "group"
 // properties, as assigned by RegExp.prototype.exec, which allows
diff --git a/src/objects/js-regexp.tq b/src/objects/js-regexp.tq
index 38c6e005800b..d8cff3fced99 100644
--- a/src/objects/js-regexp.tq
+++ b/src/objects/js-regexp.tq
@@ -10,6 +10,7 @@ bitfield struct JSRegExpFlags extends uint31 {
   unicode: bool: 1 bit;
   dot_all: bool: 1 bit;
   linear: bool: 1 bit;
+  has_indices: bool: 1 bit;
 }
 
 @generateCppClass
@@ -34,6 +35,10 @@ RegExpBuiltinsAssembler::FastLoadLastIndex(FastJSRegExp): Smi;
 extern operator '.lastIndex=' macro
 RegExpBuiltinsAssembler::FastStoreLastIndex(FastJSRegExp, Smi): void;
 
+@doNotGenerateCast
+extern class JSRegExpConstructor extends JSFunction
+    generates 'TNode<JSFunction>';
+
 extern shape JSRegExpResult extends JSArray {
   // In-object properties:
   // The below fields are externally exposed.
@@ -42,15 +47,14 @@ extern shape JSRegExpResult extends JSArray {
   groups: JSAny;
 
   // The below fields are for internal use only.
-  cached_indices_or_regexp: JSRegExpResultIndices|JSRegExp;
   names: FixedArray|Undefined;
   regexp_input: String;
   regexp_last_index: Smi;
 }
 
-@doNotGenerateCast
-extern class JSRegExpConstructor extends JSFunction
-    generates 'TNode<JSFunction>';
+extern shape JSRegExpResultWithIndices extends JSRegExpResult {
+  indices: JSAny;
+}
 
 extern shape JSRegExpResultIndices extends JSArray {
   // In-object properties:
diff --git a/src/objects/value-serializer.cc b/src/objects/value-serializer.cc
index f9560fc64748..d94fe99d3875 100644
--- a/src/objects/value-serializer.cc
+++ b/src/objects/value-serializer.cc
@@ -1662,6 +1662,9 @@ MaybeHandle<JSRegExp> ValueDeserializer::ReadJSRegExp() {
   if (!FLAG_enable_experimental_regexp_engine) {
     bad_flags_mask |= JSRegExp::kLinear;
   }
+  if (!FLAG_harmony_regexp_match_indices) {
+    bad_flags_mask |= JSRegExp::kHasIndices;
+  }
   if ((raw_flags & bad_flags_mask) ||
       !JSRegExp::New(isolate_, pattern, static_cast<JSRegExp::Flags>(raw_flags))
            .ToHandle(&regexp)) {
diff --git a/src/runtime/runtime-module.cc b/src/runtime/runtime-module.cc
index dd15f64be55d..1862b504feff 100644
--- a/src/runtime/runtime-module.cc
+++ b/src/runtime/runtime-module.cc
@@ -14,19 +14,26 @@ namespace internal {
 
 RUNTIME_FUNCTION(Runtime_DynamicImportCall) {
   HandleScope scope(isolate);
-  DCHECK_EQ(2, args.length());
+  DCHECK_LE(2, args.length());
+  DCHECK_GE(3, args.length());
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
   CONVERT_ARG_HANDLE_CHECKED(Object, specifier, 1);
 
+  MaybeHandle<Object> import_assertions;
+  if (args.length() == 3) {
+    CHECK(args[2].IsObject());
+    import_assertions = args.at<Object>(2);
+  }
+
   Handle<Script> script(Script::cast(function->shared().script()), isolate);
 
   while (script->has_eval_from_shared()) {
     script = handle(Script::cast(script->eval_from_shared().script()), isolate);
   }
 
-  RETURN_RESULT_OR_FAILURE(
-      isolate,
-      isolate->RunHostImportModuleDynamicallyCallback(script, specifier));
+  RETURN_RESULT_OR_FAILURE(isolate,
+                           isolate->RunHostImportModuleDynamicallyCallback(
+                               script, specifier, import_assertions));
 }
 
 RUNTIME_FUNCTION(Runtime_GetModuleNamespace) {
diff --git a/src/runtime/runtime-regexp.cc b/src/runtime/runtime-regexp.cc
index ec3a60dcfc51..b5f262081db0 100644
--- a/src/runtime/runtime-regexp.cc
+++ b/src/runtime/runtime-regexp.cc
@@ -894,6 +894,21 @@ RUNTIME_FUNCTION(Runtime_RegExpExperimentalOneshotExec) {
                                                last_match_info));
 }
 
+RUNTIME_FUNCTION(Runtime_RegExpBuildIndices) {
+  DCHECK(FLAG_harmony_regexp_match_indices);
+
+  HandleScope scope(isolate);
+  DCHECK_EQ(3, args.length());
+  CONVERT_ARG_HANDLE_CHECKED(RegExpMatchInfo, match_info, 1);
+  CONVERT_ARG_HANDLE_CHECKED(Object, maybe_names, 2);
+#ifdef DEBUG
+  CONVERT_ARG_HANDLE_CHECKED(JSRegExp, regexp, 0);
+  DCHECK(regexp->GetFlags() & JSRegExp::kHasIndices);
+#endif
+
+  return *JSRegExpResultIndices::BuildIndices(isolate, match_info, maybe_names);
+}
+
 namespace {
 
 class MatchInfoBackedMatch : public String::Match {
diff --git a/src/runtime/runtime.h b/src/runtime/runtime.h
index 3845603fa37f..5d95490e8f99 100644
--- a/src/runtime/runtime.h
+++ b/src/runtime/runtime.h
@@ -265,9 +265,9 @@ namespace internal {
   F(CreateObjectLiteralWithoutAllocationSite, 2, 1) \
   F(CreateRegExpLiteral, 4, 1)
 
-#define FOR_EACH_INTRINSIC_MODULE(F, I) \
-  F(DynamicImportCall, 2, 1)            \
-  I(GetImportMetaObject, 0, 1)          \
+#define FOR_EACH_INTRINSIC_MODULE(F, I)    \
+  F(DynamicImportCall, -1 /* [2, 3] */, 1) \
+  I(GetImportMetaObject, 0, 1)             \
   F(GetModuleNamespace, 1, 1)
 
 #define FOR_EACH_INTRINSIC_NUMBERS(F, I) \
@@ -385,6 +385,7 @@ namespace internal {
 
 #define FOR_EACH_INTRINSIC_REGEXP(F, I)             \
   I(IsRegExp, 1, 1)                                 \
+  F(RegExpBuildIndices, 3, 1)                       \
   F(RegExpExec, 4, 1)                               \
   F(RegExpExperimentalOneshotExec, 4, 1)            \
   F(RegExpExecMultiple, 4, 1)                       \
diff --git a/src/wasm/baseline/arm/liftoff-assembler-arm.h b/src/wasm/baseline/arm/liftoff-assembler-arm.h
index a7785ee72199..8a7a849e975b 100644
--- a/src/wasm/baseline/arm/liftoff-assembler-arm.h
+++ b/src/wasm/baseline/arm/liftoff-assembler-arm.h
@@ -2964,6 +2964,11 @@ void LiftoffAssembler::emit_i32x4_neg(LiftoffRegister dst,
        liftoff::GetSimd128Register(src));
 }
 
+void LiftoffAssembler::emit_v32x4_anytrue(LiftoffRegister dst,
+                                          LiftoffRegister src) {
+  liftoff::EmitAnyTrue(this, dst, src);
+}
+
 void LiftoffAssembler::emit_v32x4_alltrue(LiftoffRegister dst,
                                           LiftoffRegister src) {
   UseScratchRegisterScope temps(this);
@@ -3136,6 +3141,11 @@ void LiftoffAssembler::emit_i16x8_neg(LiftoffRegister dst,
        liftoff::GetSimd128Register(src));
 }
 
+void LiftoffAssembler::emit_v16x8_anytrue(LiftoffRegister dst,
+                                          LiftoffRegister src) {
+  liftoff::EmitAnyTrue(this, dst, src);
+}
+
 void LiftoffAssembler::emit_v16x8_alltrue(LiftoffRegister dst,
                                           LiftoffRegister src) {
   UseScratchRegisterScope temps(this);
@@ -3423,8 +3433,8 @@ void LiftoffAssembler::emit_i8x16_neg(LiftoffRegister dst,
        liftoff::GetSimd128Register(src));
 }
 
-void LiftoffAssembler::emit_v128_anytrue(LiftoffRegister dst,
-                                         LiftoffRegister src) {
+void LiftoffAssembler::emit_v8x16_anytrue(LiftoffRegister dst,
+                                          LiftoffRegister src) {
   liftoff::EmitAnyTrue(this, dst, src);
 }
 
diff --git a/src/wasm/baseline/arm64/liftoff-assembler-arm64.h b/src/wasm/baseline/arm64/liftoff-assembler-arm64.h
index ce95a332b91d..2a5931cd14c1 100644
--- a/src/wasm/baseline/arm64/liftoff-assembler-arm64.h
+++ b/src/wasm/baseline/arm64/liftoff-assembler-arm64.h
@@ -2106,6 +2106,11 @@ void LiftoffAssembler::emit_i32x4_neg(LiftoffRegister dst,
   Neg(dst.fp().V4S(), src.fp().V4S());
 }
 
+void LiftoffAssembler::emit_v32x4_anytrue(LiftoffRegister dst,
+                                          LiftoffRegister src) {
+  liftoff::EmitAnyTrue(this, dst, src);
+}
+
 void LiftoffAssembler::emit_v32x4_alltrue(LiftoffRegister dst,
                                           LiftoffRegister src) {
   liftoff::EmitAllTrue(this, dst, src, kFormat4S);
@@ -2272,6 +2277,11 @@ void LiftoffAssembler::emit_i16x8_neg(LiftoffRegister dst,
   Neg(dst.fp().V8H(), src.fp().V8H());
 }
 
+void LiftoffAssembler::emit_v16x8_anytrue(LiftoffRegister dst,
+                                          LiftoffRegister src) {
+  liftoff::EmitAnyTrue(this, dst, src);
+}
+
 void LiftoffAssembler::emit_v16x8_alltrue(LiftoffRegister dst,
                                           LiftoffRegister src) {
   liftoff::EmitAllTrue(this, dst, src, kFormat8H);
@@ -2468,8 +2478,8 @@ void LiftoffAssembler::emit_i8x16_neg(LiftoffRegister dst,
   Neg(dst.fp().V16B(), src.fp().V16B());
 }
 
-void LiftoffAssembler::emit_v128_anytrue(LiftoffRegister dst,
-                                         LiftoffRegister src) {
+void LiftoffAssembler::emit_v8x16_anytrue(LiftoffRegister dst,
+                                          LiftoffRegister src) {
   liftoff::EmitAnyTrue(this, dst, src);
 }
 
diff --git a/src/wasm/baseline/ia32/liftoff-assembler-ia32.h b/src/wasm/baseline/ia32/liftoff-assembler-ia32.h
index 158f1030f2d1..6e5f03484691 100644
--- a/src/wasm/baseline/ia32/liftoff-assembler-ia32.h
+++ b/src/wasm/baseline/ia32/liftoff-assembler-ia32.h
@@ -3197,8 +3197,8 @@ void LiftoffAssembler::emit_i8x16_neg(LiftoffRegister dst,
   }
 }
 
-void LiftoffAssembler::emit_v128_anytrue(LiftoffRegister dst,
-                                         LiftoffRegister src) {
+void LiftoffAssembler::emit_v8x16_anytrue(LiftoffRegister dst,
+                                          LiftoffRegister src) {
   liftoff::EmitAnyTrue(this, dst, src);
 }
 
@@ -3441,6 +3441,11 @@ void LiftoffAssembler::emit_i16x8_neg(LiftoffRegister dst,
   }
 }
 
+void LiftoffAssembler::emit_v16x8_anytrue(LiftoffRegister dst,
+                                          LiftoffRegister src) {
+  liftoff::EmitAnyTrue(this, dst, src);
+}
+
 void LiftoffAssembler::emit_v16x8_alltrue(LiftoffRegister dst,
                                           LiftoffRegister src) {
   liftoff::EmitAllTrue<&TurboAssembler::Pcmpeqw>(this, dst, src);
@@ -3612,6 +3617,11 @@ void LiftoffAssembler::emit_i32x4_neg(LiftoffRegister dst,
   }
 }
 
+void LiftoffAssembler::emit_v32x4_anytrue(LiftoffRegister dst,
+                                          LiftoffRegister src) {
+  liftoff::EmitAnyTrue(this, dst, src);
+}
+
 void LiftoffAssembler::emit_v32x4_alltrue(LiftoffRegister dst,
                                           LiftoffRegister src) {
   liftoff::EmitAllTrue<&TurboAssembler::Pcmpeqd>(this, dst, src);
diff --git a/src/wasm/baseline/liftoff-assembler.h b/src/wasm/baseline/liftoff-assembler.h
index ea5fe264232e..45b6feb89f9c 100644
--- a/src/wasm/baseline/liftoff-assembler.h
+++ b/src/wasm/baseline/liftoff-assembler.h
@@ -956,7 +956,7 @@ class LiftoffAssembler : public TurboAssembler {
   inline void emit_s128_select(LiftoffRegister dst, LiftoffRegister src1,
                                LiftoffRegister src2, LiftoffRegister mask);
   inline void emit_i8x16_neg(LiftoffRegister dst, LiftoffRegister src);
-  inline void emit_v128_anytrue(LiftoffRegister dst, LiftoffRegister src);
+  inline void emit_v8x16_anytrue(LiftoffRegister dst, LiftoffRegister src);
   inline void emit_v8x16_alltrue(LiftoffRegister dst, LiftoffRegister src);
   inline void emit_i8x16_bitmask(LiftoffRegister dst, LiftoffRegister src);
   inline void emit_i8x16_shl(LiftoffRegister dst, LiftoffRegister lhs,
@@ -994,6 +994,7 @@ class LiftoffAssembler : public TurboAssembler {
   inline void emit_i8x16_max_u(LiftoffRegister dst, LiftoffRegister lhs,
                                LiftoffRegister rhs);
   inline void emit_i16x8_neg(LiftoffRegister dst, LiftoffRegister src);
+  inline void emit_v16x8_anytrue(LiftoffRegister dst, LiftoffRegister src);
   inline void emit_v16x8_alltrue(LiftoffRegister dst, LiftoffRegister src);
   inline void emit_i16x8_bitmask(LiftoffRegister dst, LiftoffRegister src);
   inline void emit_i16x8_shl(LiftoffRegister dst, LiftoffRegister lhs,
@@ -1046,6 +1047,7 @@ class LiftoffAssembler : public TurboAssembler {
                                        LiftoffRegister src1,
                                        LiftoffRegister src2);
   inline void emit_i32x4_neg(LiftoffRegister dst, LiftoffRegister src);
+  inline void emit_v32x4_anytrue(LiftoffRegister dst, LiftoffRegister src);
   inline void emit_v32x4_alltrue(LiftoffRegister dst, LiftoffRegister src);
   inline void emit_i32x4_bitmask(LiftoffRegister dst, LiftoffRegister src);
   inline void emit_i32x4_shl(LiftoffRegister dst, LiftoffRegister lhs,
diff --git a/src/wasm/baseline/liftoff-compiler.cc b/src/wasm/baseline/liftoff-compiler.cc
index d12719a7da31..0b9c28229e48 100644
--- a/src/wasm/baseline/liftoff-compiler.cc
+++ b/src/wasm/baseline/liftoff-compiler.cc
@@ -2998,8 +2998,8 @@ class LiftoffCompiler {
         return EmitTerOp<kS128, kS128>(&LiftoffAssembler::emit_s128_select);
       case wasm::kExprI8x16Neg:
         return EmitUnOp<kS128, kS128>(&LiftoffAssembler::emit_i8x16_neg);
-      case wasm::kExprV128AnyTrue:
-        return EmitUnOp<kS128, kI32>(&LiftoffAssembler::emit_v128_anytrue);
+      case wasm::kExprV8x16AnyTrue:
+        return EmitUnOp<kS128, kI32>(&LiftoffAssembler::emit_v8x16_anytrue);
       case wasm::kExprV8x16AllTrue:
         return EmitUnOp<kS128, kI32>(&LiftoffAssembler::emit_v8x16_alltrue);
       case wasm::kExprI8x16BitMask:
@@ -3037,6 +3037,8 @@ class LiftoffCompiler {
         return EmitBinOp<kS128, kS128>(&LiftoffAssembler::emit_i8x16_max_u);
       case wasm::kExprI16x8Neg:
         return EmitUnOp<kS128, kS128>(&LiftoffAssembler::emit_i16x8_neg);
+      case wasm::kExprV16x8AnyTrue:
+        return EmitUnOp<kS128, kI32>(&LiftoffAssembler::emit_v16x8_anytrue);
       case wasm::kExprV16x8AllTrue:
         return EmitUnOp<kS128, kI32>(&LiftoffAssembler::emit_v16x8_alltrue);
       case wasm::kExprI16x8BitMask:
@@ -3089,6 +3091,8 @@ class LiftoffCompiler {
             &LiftoffAssembler::emit_i16x8_q15mulr_sat_s);
       case wasm::kExprI32x4Neg:
         return EmitUnOp<kS128, kS128>(&LiftoffAssembler::emit_i32x4_neg);
+      case wasm::kExprV32x4AnyTrue:
+        return EmitUnOp<kS128, kI32>(&LiftoffAssembler::emit_v32x4_anytrue);
       case wasm::kExprV32x4AllTrue:
         return EmitUnOp<kS128, kI32>(&LiftoffAssembler::emit_v32x4_alltrue);
       case wasm::kExprI32x4BitMask:
diff --git a/src/wasm/baseline/ppc/liftoff-assembler-ppc.h b/src/wasm/baseline/ppc/liftoff-assembler-ppc.h
index 1d0a4d52cf1c..080274fbf6d0 100644
--- a/src/wasm/baseline/ppc/liftoff-assembler-ppc.h
+++ b/src/wasm/baseline/ppc/liftoff-assembler-ppc.h
@@ -590,6 +590,13 @@ void LiftoffAssembler::LoadLane(LiftoffRegister dst, LiftoffRegister src,
   bailout(kSimd, "loadlane");
 }
 
+void LiftoffAssembler::StoreLane(Register dst, Register offset,
+                                 uintptr_t offset_imm, LiftoffRegister src,
+                                 StoreType type, uint8_t lane,
+                                 uint32_t* protected_store_pc) {
+  bailout(kSimd, "store lane");
+}
+
 void LiftoffAssembler::emit_i8x16_swizzle(LiftoffRegister dst,
                                           LiftoffRegister lhs,
                                           LiftoffRegister rhs) {
diff --git a/src/wasm/baseline/s390/liftoff-assembler-s390.h b/src/wasm/baseline/s390/liftoff-assembler-s390.h
index 84648f4d90ff..790e1361a2f3 100644
--- a/src/wasm/baseline/s390/liftoff-assembler-s390.h
+++ b/src/wasm/baseline/s390/liftoff-assembler-s390.h
@@ -837,6 +837,13 @@ void LiftoffAssembler::LoadLane(LiftoffRegister dst, LiftoffRegister src,
   bailout(kSimd, "loadlane");
 }
 
+void LiftoffAssembler::StoreLane(Register dst, Register offset,
+                                 uintptr_t offset_imm, LiftoffRegister src,
+                                 StoreType type, uint8_t lane,
+                                 uint32_t* protected_store_pc) {
+  bailout(kSimd, "store lane");
+}
+
 void LiftoffAssembler::emit_i8x16_swizzle(LiftoffRegister dst,
                                           LiftoffRegister lhs,
                                           LiftoffRegister rhs) {
diff --git a/src/wasm/baseline/x64/liftoff-assembler-x64.h b/src/wasm/baseline/x64/liftoff-assembler-x64.h
index 7bde8a1b59d0..10c9fe1514cf 100644
--- a/src/wasm/baseline/x64/liftoff-assembler-x64.h
+++ b/src/wasm/baseline/x64/liftoff-assembler-x64.h
@@ -2795,8 +2795,8 @@ void LiftoffAssembler::emit_i8x16_neg(LiftoffRegister dst,
   }
 }
 
-void LiftoffAssembler::emit_v128_anytrue(LiftoffRegister dst,
-                                         LiftoffRegister src) {
+void LiftoffAssembler::emit_v8x16_anytrue(LiftoffRegister dst,
+                                          LiftoffRegister src) {
   liftoff::EmitAnyTrue(this, dst, src);
 }
 
@@ -3039,6 +3039,11 @@ void LiftoffAssembler::emit_i16x8_neg(LiftoffRegister dst,
   }
 }
 
+void LiftoffAssembler::emit_v16x8_anytrue(LiftoffRegister dst,
+                                          LiftoffRegister src) {
+  liftoff::EmitAnyTrue(this, dst, src);
+}
+
 void LiftoffAssembler::emit_v16x8_alltrue(LiftoffRegister dst,
                                           LiftoffRegister src) {
   liftoff::EmitAllTrue<&TurboAssembler::Pcmpeqw>(this, dst, src);
@@ -3209,6 +3214,11 @@ void LiftoffAssembler::emit_i32x4_neg(LiftoffRegister dst,
   }
 }
 
+void LiftoffAssembler::emit_v32x4_anytrue(LiftoffRegister dst,
+                                          LiftoffRegister src) {
+  liftoff::EmitAnyTrue(this, dst, src);
+}
+
 void LiftoffAssembler::emit_v32x4_alltrue(LiftoffRegister dst,
                                           LiftoffRegister src) {
   liftoff::EmitAllTrue<&TurboAssembler::Pcmpeqd>(this, dst, src);
diff --git a/src/wasm/wasm-opcodes-inl.h b/src/wasm/wasm-opcodes-inl.h
index 4d37c1a07287..dcc9b8f662b8 100644
--- a/src/wasm/wasm-opcodes-inl.h
+++ b/src/wasm/wasm-opcodes-inl.h
@@ -32,7 +32,6 @@ namespace wasm {
 #define CASE_I16x8_OP(name, str) CASE_OP(I16x8##name, "i16x8." str)
 #define CASE_I8x16_OP(name, str) CASE_OP(I8x16##name, "i8x16." str)
 #define CASE_S128_OP(name, str) CASE_OP(S128##name, "s128." str)
-#define CASE_V128_OP(name, str) CASE_OP(V128##name, "v128." str)
 #define CASE_S64x2_OP(name, str) CASE_OP(S64x2##name, "s64x2." str)
 #define CASE_S32x4_OP(name, str) CASE_OP(S32x4##name, "s32x4." str)
 #define CASE_S16x8_OP(name, str) CASE_OP(S16x8##name, "s16x8." str)
@@ -295,7 +294,7 @@ constexpr const char* WasmOpcodes::OpcodeName(WasmOpcode opcode) {
     CASE_S128_OP(AndNot, "andnot")
     CASE_I8x16_OP(Swizzle, "swizzle")
     CASE_I8x16_OP(Shuffle, "shuffle")
-    CASE_V128_OP(AnyTrue, "any_true")
+    CASE_SIMDV_OP(AnyTrue, "any_true")
     CASE_SIMDV_OP(AllTrue, "all_true")
     CASE_SIMDF_OP(Qfma, "qfma")
     CASE_SIMDF_OP(Qfms, "qfms")
diff --git a/src/wasm/wasm-opcodes.h b/src/wasm/wasm-opcodes.h
index b23731224470..fcf1793282c5 100644
--- a/src/wasm/wasm-opcodes.h
+++ b/src/wasm/wasm-opcodes.h
@@ -357,7 +357,7 @@ bool V8_EXPORT_PRIVATE IsJSCompatibleSignature(const FunctionSig* sig,
   V(S128Select, 0xfd52, s_sss)               \
   V(I8x16Abs, 0xfd60, s_s)                   \
   V(I8x16Neg, 0xfd61, s_s)                   \
-  V(V128AnyTrue, 0xfd62, i_s)                \
+  V(V8x16AnyTrue, 0xfd62, i_s)               \
   V(V8x16AllTrue, 0xfd63, i_s)               \
   V(I8x16BitMask, 0xfd64, i_s)               \
   V(I8x16SConvertI16x8, 0xfd65, s_ss)        \
@@ -378,6 +378,7 @@ bool V8_EXPORT_PRIVATE IsJSCompatibleSignature(const FunctionSig* sig,
   V(I8x16RoundingAverageU, 0xfd7b, s_ss)     \
   V(I16x8Abs, 0xfd80, s_s)                   \
   V(I16x8Neg, 0xfd81, s_s)                   \
+  V(V16x8AnyTrue, 0xfd82, i_s)               \
   V(V16x8AllTrue, 0xfd83, i_s)               \
   V(I16x8BitMask, 0xfd84, i_s)               \
   V(I16x8SConvertI32x4, 0xfd85, s_ss)        \
@@ -408,6 +409,7 @@ bool V8_EXPORT_PRIVATE IsJSCompatibleSignature(const FunctionSig* sig,
   V(I16x8Q15MulRSatS, 0xfd9c, s_ss)          \
   V(I32x4Abs, 0xfda0, s_s)                   \
   V(I32x4Neg, 0xfda1, s_s)                   \
+  V(V32x4AnyTrue, 0xfda2, i_s)               \
   V(V32x4AllTrue, 0xfda3, i_s)               \
   V(I32x4BitMask, 0xfda4, i_s)               \
   V(I32x4SConvertI16x8Low, 0xfda7, s_s)      \
diff --git a/test/cctest/interpreter/bytecode_expectations/PrivateAccessorAccess.golden b/test/cctest/interpreter/bytecode_expectations/PrivateAccessorAccess.golden
index 579f8cf2e867..a5d356a3dbe0 100644
--- a/test/cctest/interpreter/bytecode_expectations/PrivateAccessorAccess.golden
+++ b/test/cctest/interpreter/bytecode_expectations/PrivateAccessorAccess.golden
@@ -83,7 +83,7 @@ bytecodes: [
                 B(Mov), R(this), R(0),
                 B(Mov), R(context), R(2),
   /*   48 E> */ B(CallRuntime), U16(Runtime::kAddPrivateBrand), R(0), U8(3),
-  /*   53 S> */ B(Wide), B(LdaSmi), I16(272),
+  /*   53 S> */ B(Wide), B(LdaSmi), I16(275),
                 B(Star), R(3),
                 B(LdaConstant), U8(0),
                 B(Star), R(4),
@@ -114,7 +114,7 @@ bytecodes: [
                 B(Mov), R(this), R(0),
                 B(Mov), R(context), R(2),
   /*   41 E> */ B(CallRuntime), U16(Runtime::kAddPrivateBrand), R(0), U8(3),
-  /*   46 S> */ B(Wide), B(LdaSmi), I16(271),
+  /*   46 S> */ B(Wide), B(LdaSmi), I16(274),
                 B(Star), R(3),
                 B(LdaConstant), U8(0),
                 B(Star), R(4),
@@ -145,7 +145,7 @@ bytecodes: [
                 B(Mov), R(this), R(0),
                 B(Mov), R(context), R(2),
   /*   48 E> */ B(CallRuntime), U16(Runtime::kAddPrivateBrand), R(0), U8(3),
-  /*   53 S> */ B(Wide), B(LdaSmi), I16(272),
+  /*   53 S> */ B(Wide), B(LdaSmi), I16(275),
                 B(Star), R(3),
                 B(LdaConstant), U8(0),
                 B(Star), R(4),
@@ -176,7 +176,7 @@ bytecodes: [
                 B(Mov), R(this), R(0),
                 B(Mov), R(context), R(2),
   /*   41 E> */ B(CallRuntime), U16(Runtime::kAddPrivateBrand), R(0), U8(3),
-  /*   46 S> */ B(Wide), B(LdaSmi), I16(271),
+  /*   46 S> */ B(Wide), B(LdaSmi), I16(274),
                 B(Star), R(4),
                 B(LdaConstant), U8(0),
                 B(Star), R(5),
diff --git a/test/cctest/interpreter/bytecode_expectations/PrivateMethodAccess.golden b/test/cctest/interpreter/bytecode_expectations/PrivateMethodAccess.golden
index c768ea4dbc49..213955e8957c 100644
--- a/test/cctest/interpreter/bytecode_expectations/PrivateMethodAccess.golden
+++ b/test/cctest/interpreter/bytecode_expectations/PrivateMethodAccess.golden
@@ -56,7 +56,7 @@ bytecodes: [
                 B(Mov), R(this), R(0),
                 B(Mov), R(context), R(2),
   /*   44 E> */ B(CallRuntime), U16(Runtime::kAddPrivateBrand), R(0), U8(3),
-  /*   49 S> */ B(Wide), B(LdaSmi), I16(270),
+  /*   49 S> */ B(Wide), B(LdaSmi), I16(273),
                 B(Star), R(3),
                 B(LdaConstant), U8(0),
                 B(Star), R(4),
@@ -88,7 +88,7 @@ bytecodes: [
                 B(Mov), R(this), R(0),
                 B(Mov), R(context), R(2),
   /*   44 E> */ B(CallRuntime), U16(Runtime::kAddPrivateBrand), R(0), U8(3),
-  /*   49 S> */ B(Wide), B(LdaSmi), I16(270),
+  /*   49 S> */ B(Wide), B(LdaSmi), I16(273),
                 B(Star), R(3),
                 B(LdaConstant), U8(0),
                 B(Star), R(4),
diff --git a/test/cctest/interpreter/bytecode_expectations/StaticPrivateMethodAccess.golden b/test/cctest/interpreter/bytecode_expectations/StaticPrivateMethodAccess.golden
index 782654441420..165c22a68f71 100644
--- a/test/cctest/interpreter/bytecode_expectations/StaticPrivateMethodAccess.golden
+++ b/test/cctest/interpreter/bytecode_expectations/StaticPrivateMethodAccess.golden
@@ -24,7 +24,7 @@ bytecodes: [
                 B(TestReferenceEqual), R(this),
                 B(Mov), R(this), R(1),
                 B(JumpIfTrue), U8(18),
-                B(Wide), B(LdaSmi), I16(268),
+                B(Wide), B(LdaSmi), I16(271),
                 B(Star), R(2),
                 B(LdaConstant), U8(0),
                 B(Star), R(3),
@@ -55,7 +55,7 @@ frame size: 2
 parameter count: 1
 bytecode array length: 16
 bytecodes: [
-  /*   56 S> */ B(Wide), B(LdaSmi), I16(270),
+  /*   56 S> */ B(Wide), B(LdaSmi), I16(273),
                 B(Star), R(0),
                 B(LdaConstant), U8(0),
                 B(Star), R(1),
@@ -82,7 +82,7 @@ frame size: 2
 parameter count: 1
 bytecode array length: 16
 bytecodes: [
-  /*   56 S> */ B(Wide), B(LdaSmi), I16(270),
+  /*   56 S> */ B(Wide), B(LdaSmi), I16(273),
                 B(Star), R(0),
                 B(LdaConstant), U8(0),
                 B(Star), R(1),
@@ -121,7 +121,7 @@ bytecodes: [
   /*   94 E> */ B(TestReferenceEqual), R(this),
                 B(Mov), R(this), R(0),
                 B(JumpIfTrue), U8(18),
-                B(Wide), B(LdaSmi), I16(268),
+                B(Wide), B(LdaSmi), I16(271),
                 B(Star), R(2),
                 B(LdaConstant), U8(0),
                 B(Star), R(3),
@@ -143,7 +143,7 @@ bytecodes: [
   /*  109 E> */ B(TestReferenceEqual), R(this),
                 B(Mov), R(this), R(1),
                 B(JumpIfTrue), U8(18),
-                B(Wide), B(LdaSmi), I16(269),
+                B(Wide), B(LdaSmi), I16(272),
                 B(Star), R(3),
                 B(LdaConstant), U8(0),
                 B(Star), R(4),
@@ -158,7 +158,7 @@ bytecodes: [
   /*  133 E> */ B(TestReferenceEqual), R(this),
                 B(Mov), R(this), R(0),
                 B(JumpIfTrue), U8(18),
-                B(Wide), B(LdaSmi), I16(268),
+                B(Wide), B(LdaSmi), I16(271),
                 B(Star), R(2),
                 B(LdaConstant), U8(0),
                 B(Star), R(3),
@@ -188,7 +188,7 @@ frame size: 2
 parameter count: 1
 bytecode array length: 16
 bytecodes: [
-  /*   60 S> */ B(Wide), B(LdaSmi), I16(272),
+  /*   60 S> */ B(Wide), B(LdaSmi), I16(275),
                 B(Star), R(0),
                 B(LdaConstant), U8(0),
                 B(Star), R(1),
@@ -214,7 +214,7 @@ frame size: 2
 parameter count: 1
 bytecode array length: 16
 bytecodes: [
-  /*   53 S> */ B(Wide), B(LdaSmi), I16(271),
+  /*   53 S> */ B(Wide), B(LdaSmi), I16(274),
                 B(Star), R(0),
                 B(LdaConstant), U8(0),
                 B(Star), R(1),
@@ -240,7 +240,7 @@ frame size: 2
 parameter count: 1
 bytecode array length: 16
 bytecodes: [
-  /*   60 S> */ B(Wide), B(LdaSmi), I16(272),
+  /*   60 S> */ B(Wide), B(LdaSmi), I16(275),
                 B(Star), R(0),
                 B(LdaConstant), U8(0),
                 B(Star), R(1),
@@ -266,7 +266,7 @@ frame size: 3
 parameter count: 1
 bytecode array length: 16
 bytecodes: [
-  /*   46 S> */ B(Wide), B(LdaSmi), I16(271),
+  /*   46 S> */ B(Wide), B(LdaSmi), I16(274),
                 B(Star), R(1),
                 B(LdaConstant), U8(0),
                 B(Star), R(2),
diff --git a/test/cctest/test-api.cc b/test/cctest/test-api.cc
index 4c69ea7dc95a..613cef8123f5 100644
--- a/test/cctest/test-api.cc
+++ b/test/cctest/test-api.cc
@@ -26103,7 +26103,7 @@ TEST(CorrectEnteredContext) {
 
 v8::MaybeLocal<v8::Promise> HostImportModuleDynamicallyCallbackResolve(
     Local<Context> context, Local<v8::ScriptOrModule> referrer,
-    Local<String> specifier) {
+    Local<String> specifier, Local<FixedArray> import_assertions) {
   CHECK(!referrer.IsEmpty());
   String::Utf8Value referrer_utf8(
       context->GetIsolate(), Local<String>::Cast(referrer->GetResourceName()));
@@ -26116,6 +26116,8 @@ v8::MaybeLocal<v8::Promise> HostImportModuleDynamicallyCallbackResolve(
   String::Utf8Value specifier_utf8(context->GetIsolate(), specifier);
   CHECK_EQ(0, strcmp("index.js", *specifier_utf8));
 
+  CHECK_EQ(0, import_assertions->Length());
+
   Local<v8::Promise::Resolver> resolver =
       v8::Promise::Resolver::New(context).ToLocalChecked();
   auto result = v8_str("hello world");
@@ -26127,7 +26129,6 @@ TEST(DynamicImport) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-
   isolate->SetHostImportModuleDynamicallyCallback(
       HostImportModuleDynamicallyCallbackResolve);
 
@@ -26143,7 +26144,95 @@ TEST(DynamicImport) {
   referrer->set_name(*url);
   referrer->set_host_defined_options(*options);
   i::MaybeHandle<i::JSPromise> maybe_promise =
-      i_isolate->RunHostImportModuleDynamicallyCallback(referrer, specifier);
+      i_isolate->RunHostImportModuleDynamicallyCallback(
+          referrer, specifier, i::MaybeHandle<i::Object>());
+  i::Handle<i::JSPromise> promise = maybe_promise.ToHandleChecked();
+  isolate->PerformMicrotaskCheckpoint();
+  CHECK(result->Equals(i::String::cast(promise->result())));
+}
+
+v8::MaybeLocal<v8::Promise>
+HostImportModuleDynamicallyWithAssertionsCallbackResolve(
+    Local<Context> context, Local<v8::ScriptOrModule> referrer,
+    Local<String> specifier, Local<v8::FixedArray> import_assertions) {
+  CHECK(!referrer.IsEmpty());
+  String::Utf8Value referrer_utf8(
+      context->GetIsolate(), Local<String>::Cast(referrer->GetResourceName()));
+  CHECK_EQ(0, strcmp("www.google.com", *referrer_utf8));
+  CHECK(referrer->GetHostDefinedOptions()
+            ->Get(context->GetIsolate(), 0)
+            ->IsSymbol());
+
+  CHECK(!specifier.IsEmpty());
+  String::Utf8Value specifier_utf8(context->GetIsolate(), specifier);
+  CHECK_EQ(0, strcmp("index.js", *specifier_utf8));
+
+  // clang-format off
+  const char* expected_assertions[][2] = {
+    {"a", "z"},
+    {"aa", "x"},
+    {"b", "w"},
+    {"c", "y"}
+  };
+
+  // clang-format on
+  CHECK_EQ(8, import_assertions->Length());
+  constexpr size_t kAssertionEntrySizeForDynamicImport = 2;
+  for (int i = 0; i < static_cast<int>(arraysize(expected_assertions)); ++i) {
+    Local<String> assertion_key =
+        import_assertions
+            ->Get(context, (i * kAssertionEntrySizeForDynamicImport))
+            .As<Value>()
+            .As<String>();
+    CHECK(v8_str(expected_assertions[i][0])->StrictEquals(assertion_key));
+    Local<String> assertion_value =
+        import_assertions
+            ->Get(context, (i * kAssertionEntrySizeForDynamicImport) + 1)
+            .As<Value>()
+            .As<String>();
+    CHECK(v8_str(expected_assertions[i][1])->StrictEquals(assertion_value));
+  }
+
+  Local<v8::Promise::Resolver> resolver =
+      v8::Promise::Resolver::New(context).ToLocalChecked();
+  auto result = v8_str("hello world");
+  resolver->Resolve(context, result).ToChecked();
+  return resolver->GetPromise();
+}
+
+TEST(DynamicImportWithAssertions) {
+  FLAG_SCOPE_EXTERNAL(harmony_import_assertions);
+
+  LocalContext context;
+  v8::Isolate* isolate = context->GetIsolate();
+  v8::HandleScope scope(isolate);
+  isolate->SetHostImportModuleDynamicallyCallback(
+      HostImportModuleDynamicallyWithAssertionsCallbackResolve);
+
+  i::Handle<i::String> url(v8::Utils::OpenHandle(*v8_str("www.google.com")));
+  i::Handle<i::Object> specifier(v8::Utils::OpenHandle(*v8_str("index.js")));
+  i::Handle<i::String> result(v8::Utils::OpenHandle(*v8_str("hello world")));
+  i::Handle<i::String> source(v8::Utils::OpenHandle(*v8_str("foo")));
+  v8::Local<v8::Object> import_assertions =
+      CompileRun(
+          "var arg = { assert: { 'b': 'w', aa: 'x',  c: 'y', a: 'z'} };"
+          "arg;")
+          ->ToObject(context.local())
+          .ToLocalChecked();
+
+  i::Handle<i::Object> i_import_assertions =
+      v8::Utils::OpenHandle(*import_assertions);
+
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  i::Handle<i::FixedArray> options = i_isolate->factory()->NewFixedArray(1);
+  i::Handle<i::Symbol> symbol = i_isolate->factory()->NewSymbol();
+  options->set(0, *symbol);
+  i::Handle<i::Script> referrer = i_isolate->factory()->NewScript(source);
+  referrer->set_name(*url);
+  referrer->set_host_defined_options(*options);
+  i::MaybeHandle<i::JSPromise> maybe_promise =
+      i_isolate->RunHostImportModuleDynamicallyCallback(referrer, specifier,
+                                                        i_import_assertions);
   i::Handle<i::JSPromise> promise = maybe_promise.ToHandleChecked();
   isolate->PerformMicrotaskCheckpoint();
   CHECK(result->Equals(i::String::cast(promise->result())));
diff --git a/test/cctest/test-modules.cc b/test/cctest/test-modules.cc
index 73a37b352ecc..c4fee8ccc9e8 100644
--- a/test/cctest/test-modules.cc
+++ b/test/cctest/test-modules.cc
@@ -938,7 +938,7 @@ void DoHostImportModuleDynamically(void* import_data) {
 
 v8::MaybeLocal<v8::Promise> HostImportModuleDynamicallyCallbackResolve(
     Local<Context> context, Local<v8::ScriptOrModule> referrer,
-    Local<String> specifier) {
+    Local<String> specifier, Local<FixedArray> import_assertions) {
   Isolate* isolate = context->GetIsolate();
   Local<v8::Promise::Resolver> resolver =
       v8::Promise::Resolver::New(context).ToLocalChecked();
@@ -951,7 +951,7 @@ v8::MaybeLocal<v8::Promise> HostImportModuleDynamicallyCallbackResolve(
 
 v8::MaybeLocal<v8::Promise> HostImportModuleDynamicallyCallbackReject(
     Local<Context> context, Local<v8::ScriptOrModule> referrer,
-    Local<String> specifier) {
+    Local<String> specifier, Local<FixedArray> import_assertions) {
   Isolate* isolate = context->GetIsolate();
   Local<v8::Promise::Resolver> resolver =
       v8::Promise::Resolver::New(context).ToLocalChecked();
diff --git a/test/cctest/wasm/test-run-wasm-simd-scalar-lowering.cc b/test/cctest/wasm/test-run-wasm-simd-scalar-lowering.cc
index 4c5309aae5d1..11db27f72c43 100644
--- a/test/cctest/wasm/test-run-wasm-simd-scalar-lowering.cc
+++ b/test/cctest/wasm/test-run-wasm-simd-scalar-lowering.cc
@@ -224,7 +224,7 @@ WASM_SIMD_TEST(AnyTrue_DifferentShapes) {
     WasmRunner<int32_t, int32_t> r(execution_tier, lower_simd);
 
     BUILD(r, WASM_SIMD_I32x4_SPLAT(WASM_LOCAL_GET(0)),
-          WASM_SIMD_OP(kExprV128AnyTrue));
+          WASM_SIMD_OP(kExprV8x16AnyTrue));
 
     CHECK_EQ(0, r.Call(0x00000000));
   }
@@ -233,7 +233,7 @@ WASM_SIMD_TEST(AnyTrue_DifferentShapes) {
     WasmRunner<int32_t, int32_t> r(execution_tier, lower_simd);
 
     BUILD(r, WASM_SIMD_I32x4_SPLAT(WASM_LOCAL_GET(0)),
-          WASM_SIMD_OP(kExprV128AnyTrue));
+          WASM_SIMD_OP(kExprV16x8AnyTrue));
 
     CHECK_EQ(1, r.Call(0x000000FF));
   }
@@ -243,7 +243,7 @@ WASM_SIMD_TEST(AnyTrue_DifferentShapes) {
     WasmRunner<int32_t, float> r(execution_tier, lower_simd);
 
     BUILD(r, WASM_SIMD_F32x4_SPLAT(WASM_LOCAL_GET(0)),
-          WASM_SIMD_OP(kExprV128AnyTrue));
+          WASM_SIMD_OP(kExprV8x16AnyTrue));
 
     CHECK_EQ(0, r.Call(0x00000000));
   }
diff --git a/test/cctest/wasm/test-run-wasm-simd.cc b/test/cctest/wasm/test-run-wasm-simd.cc
index d32e624d4f17..f869bd6a7176 100644
--- a/test/cctest/wasm/test-run-wasm-simd.cc
+++ b/test/cctest/wasm/test-run-wasm-simd.cc
@@ -3470,14 +3470,14 @@ WASM_SIMD_TEST(S8x16MultiShuffleFuzz) {
     byte reduced = r.AllocateLocal(kWasmI32);                                  \
     BUILD(r, WASM_LOCAL_SET(zero, WASM_SIMD_I##format##_SPLAT(int_type(0))),   \
           WASM_LOCAL_SET(                                                      \
-              reduced, WASM_SIMD_UNOP(kExprV128AnyTrue,                        \
+              reduced, WASM_SIMD_UNOP(kExprV##format##AnyTrue,                 \
                                       WASM_SIMD_BINOP(kExprI##format##Eq,      \
                                                       WASM_LOCAL_GET(zero),    \
                                                       WASM_LOCAL_GET(zero)))), \
           WASM_IF(WASM_I32_EQ(WASM_LOCAL_GET(reduced), WASM_ZERO),             \
                   WASM_RETURN1(WASM_ZERO)),                                    \
           WASM_LOCAL_SET(                                                      \
-              reduced, WASM_SIMD_UNOP(kExprV128AnyTrue,                        \
+              reduced, WASM_SIMD_UNOP(kExprV##format##AnyTrue,                 \
                                       WASM_SIMD_BINOP(kExprI##format##Ne,      \
                                                       WASM_LOCAL_GET(zero),    \
                                                       WASM_LOCAL_GET(zero)))), \
@@ -3501,14 +3501,14 @@ WASM_SIMD_TEST(S8x16MultiShuffleFuzz) {
                          WASM_SIMD_I##format##_REPLACE_LANE(                   \
                              lanes - 1, WASM_LOCAL_GET(zero), int_type(1))),   \
           WASM_LOCAL_SET(                                                      \
-              reduced, WASM_SIMD_UNOP(kExprV128AnyTrue,                        \
+              reduced, WASM_SIMD_UNOP(kExprV##format##AnyTrue,                 \
                                       WASM_SIMD_BINOP(kExprI##format##Eq,      \
                                                       WASM_LOCAL_GET(one_one), \
                                                       WASM_LOCAL_GET(zero)))), \
           WASM_IF(WASM_I32_EQ(WASM_LOCAL_GET(reduced), WASM_ZERO),             \
                   WASM_RETURN1(WASM_ZERO)),                                    \
           WASM_LOCAL_SET(                                                      \
-              reduced, WASM_SIMD_UNOP(kExprV128AnyTrue,                        \
+              reduced, WASM_SIMD_UNOP(kExprV##format##AnyTrue,                 \
                                       WASM_SIMD_BINOP(kExprI##format##Ne,      \
                                                       WASM_LOCAL_GET(one_one), \
                                                       WASM_LOCAL_GET(zero)))), \
@@ -4403,7 +4403,7 @@ WASM_SIMD_TEST_NO_LOWERING(S128Store64Lane) {
     BUILD(                                                                    \
         r,                                                                    \
         WASM_LOCAL_SET(simd, WASM_SIMD_I##format##_SPLAT(WASM_LOCAL_GET(0))), \
-        WASM_SIMD_UNOP(kExprV128AnyTrue, WASM_LOCAL_GET(simd)));              \
+        WASM_SIMD_UNOP(kExprV##format##AnyTrue, WASM_LOCAL_GET(simd)));       \
     CHECK_EQ(1, r.Call(max));                                                 \
     CHECK_EQ(1, r.Call(5));                                                   \
     CHECK_EQ(0, r.Call(0));                                                   \
@@ -4415,11 +4415,11 @@ WASM_SIMD_ANYTRUE_TEST(8x16, 16, 0xff, int32_t)
 // Special any true test cases that splats a -0.0 double into a i64x2.
 // This is specifically to ensure that our implementation correct handles that
 // 0.0 and -0.0 will be different in an anytrue (IEEE753 says they are equals).
-WASM_SIMD_TEST(V128AnytrueWithNegativeZero) {
+WASM_SIMD_TEST(V32x4AnytrueWithNegativeZero) {
   WasmRunner<int32_t, int64_t> r(execution_tier, lower_simd);
   byte simd = r.AllocateLocal(kWasmS128);
   BUILD(r, WASM_LOCAL_SET(simd, WASM_SIMD_I64x2_SPLAT(WASM_LOCAL_GET(0))),
-        WASM_SIMD_UNOP(kExprV128AnyTrue, WASM_LOCAL_GET(simd)));
+        WASM_SIMD_UNOP(kExprV32x4AnyTrue, WASM_LOCAL_GET(simd)));
   CHECK_EQ(1, r.Call(0x8000000000000000));
   CHECK_EQ(0, r.Call(0x0000000000000000));
 }
diff --git a/test/common/wasm/wasm-interpreter.cc b/test/common/wasm/wasm-interpreter.cc
index 5ed5345fade9..2e15dfa1e965 100644
--- a/test/common/wasm/wasm-interpreter.cc
+++ b/test/common/wasm/wasm-interpreter.cc
@@ -2678,7 +2678,9 @@ class WasmInterpreterInternals {
         Push(WasmValue(Simd128(res)));
         return true;
       }
-      case kExprV128AnyTrue: {
+      case kExprV32x4AnyTrue:
+      case kExprV16x8AnyTrue:
+      case kExprV8x16AnyTrue: {
         int4 s = Pop().to_s128().to_i32x4();
         bool res = s.val[LANE(0, s)] | s.val[LANE(1, s)] | s.val[LANE(2, s)] |
                    s.val[LANE(3, s)];
diff --git a/test/fuzzer/regexp-builtins.cc b/test/fuzzer/regexp-builtins.cc
index 0cdaaaff214f..e17400c4c3a2 100644
--- a/test/fuzzer/regexp-builtins.cc
+++ b/test/fuzzer/regexp-builtins.cc
@@ -243,8 +243,9 @@ std::string GenerateRandomFlags(FuzzerArgs* args) {
   // TODO(mbid,v8:10765): Find a way to generate the kLinear flag sometimes,
   // but only for patterns that are supported by the experimental engine.
   constexpr size_t kFlagCount = JSRegExp::kFlagCount;
-  CHECK_EQ(JSRegExp::kLinear, 1 << (kFlagCount - 1));
-  CHECK_EQ(JSRegExp::kDotAll, 1 << (kFlagCount - 2));
+  CHECK_EQ(JSRegExp::kHasIndices, 1 << (kFlagCount - 1));
+  CHECK_EQ(JSRegExp::kLinear, 1 << (kFlagCount - 2));
+  CHECK_EQ(JSRegExp::kDotAll, 1 << (kFlagCount - 3));
   STATIC_ASSERT((1 << kFlagCount) - 1 <= 0xFF);
 
   const size_t flags = RandomByte(args) & ((1 << kFlagCount) - 1);
@@ -258,6 +259,7 @@ std::string GenerateRandomFlags(FuzzerArgs* args) {
   if (flags & JSRegExp::kSticky) buffer[cursor++] = 'y';
   if (flags & JSRegExp::kUnicode) buffer[cursor++] = 'u';
   if (flags & JSRegExp::kDotAll) buffer[cursor++] = 's';
+  if (flags & JSRegExp::kHasIndices) buffer[cursor++] = 'd';
 
   return std::string(buffer, cursor);
 }
diff --git a/test/fuzzer/wasm-compile.cc b/test/fuzzer/wasm-compile.cc
index 9416050e5f5c..0c5e6801d028 100644
--- a/test/fuzzer/wasm-compile.cc
+++ b/test/fuzzer/wasm-compile.cc
@@ -934,11 +934,13 @@ void WasmGenerator::Generate<ValueType::kI32>(DataRange* data) {
                                 ValueType::kI32, ValueType::kI32,
                                 ValueType::kI32>,
 
-      &WasmGenerator::op_with_prefix<kExprV128AnyTrue, ValueType::kS128>,
+      &WasmGenerator::op_with_prefix<kExprV8x16AnyTrue, ValueType::kS128>,
       &WasmGenerator::op_with_prefix<kExprV8x16AllTrue, ValueType::kS128>,
       &WasmGenerator::op_with_prefix<kExprI8x16BitMask, ValueType::kS128>,
+      &WasmGenerator::op_with_prefix<kExprV16x8AnyTrue, ValueType::kS128>,
       &WasmGenerator::op_with_prefix<kExprV16x8AllTrue, ValueType::kS128>,
       &WasmGenerator::op_with_prefix<kExprI16x8BitMask, ValueType::kS128>,
+      &WasmGenerator::op_with_prefix<kExprV32x4AnyTrue, ValueType::kS128>,
       &WasmGenerator::op_with_prefix<kExprV32x4AllTrue, ValueType::kS128>,
       &WasmGenerator::op_with_prefix<kExprI32x4BitMask, ValueType::kS128>,
       &WasmGenerator::op_with_prefix<kExprI64x2BitMask, ValueType::kS128>,
diff --git a/test/message/fail/modules-import-assertions-fail-1.mjs b/test/message/fail/modules-import-assertions-fail-1.mjs
new file mode 100644
index 000000000000..0033baab539d
--- /dev/null
+++ b/test/message/fail/modules-import-assertions-fail-1.mjs
@@ -0,0 +1,9 @@
+// Copyright 2021 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.
+//
+// MODULE
+//
+// Flags: --harmony-import-assertions
+
+import "modules-skip-1-import-assertions-fail.mjs" assert { type: "notARealType"}
diff --git a/test/message/fail/modules-import-assertions-fail-1.out b/test/message/fail/modules-import-assertions-fail-1.out
new file mode 100644
index 000000000000..1b3be22192a3
--- /dev/null
+++ b/test/message/fail/modules-import-assertions-fail-1.out
@@ -0,0 +1 @@
+undefined:0: Error: Invalid module type was asserted
\ No newline at end of file
diff --git a/test/message/fail/modules-import-assertions-fail-2.mjs b/test/message/fail/modules-import-assertions-fail-2.mjs
new file mode 100644
index 000000000000..bf7cdb3d4ee4
--- /dev/null
+++ b/test/message/fail/modules-import-assertions-fail-2.mjs
@@ -0,0 +1,9 @@
+// Copyright 2021 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.
+//
+// MODULE
+//
+// Flags: --harmony-import-assertions
+
+import "modules-skip-1-import-assertions-fail.mjs" assert { type: "json"}
diff --git a/test/message/fail/modules-import-assertions-fail-2.out b/test/message/fail/modules-import-assertions-fail-2.out
new file mode 100644
index 000000000000..f7c9b6a44238
--- /dev/null
+++ b/test/message/fail/modules-import-assertions-fail-2.out
@@ -0,0 +1,4 @@
+undefined:1: SyntaxError: Unexpected token / in JSON at position 0
+// Copyright 2021 the V8 project authors. All rights reserved.
+^
+SyntaxError: Unexpected token / in JSON at position 0
\ No newline at end of file
diff --git a/test/message/fail/modules-import-assertions-fail-3.mjs b/test/message/fail/modules-import-assertions-fail-3.mjs
new file mode 100644
index 000000000000..3a6a1b1a019f
--- /dev/null
+++ b/test/message/fail/modules-import-assertions-fail-3.mjs
@@ -0,0 +1,9 @@
+// Copyright 2021 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.
+//
+// MODULE
+//
+// Flags: --harmony-import-assertions
+
+import "modules-skip-3-import-assertions-fail.json"
diff --git a/test/message/fail/modules-import-assertions-fail-3.out b/test/message/fail/modules-import-assertions-fail-3.out
new file mode 100644
index 000000000000..2de8442c1336
--- /dev/null
+++ b/test/message/fail/modules-import-assertions-fail-3.out
@@ -0,0 +1,4 @@
+*modules-skip-3-import-assertions-fail.json:1: SyntaxError: Unexpected token ':'
+{ "life": 42 }
+        ^
+SyntaxError: Unexpected token ':'
\ No newline at end of file
diff --git a/test/message/fail/modules-skip-1-import-assertions-fail.mjs b/test/message/fail/modules-skip-1-import-assertions-fail.mjs
new file mode 100644
index 000000000000..75b4c3fbf192
--- /dev/null
+++ b/test/message/fail/modules-skip-1-import-assertions-fail.mjs
@@ -0,0 +1,7 @@
+// Copyright 2021 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.
+//
+// MODULE
+
+export function life() { return 42; }
diff --git a/test/message/fail/modules-skip-3-import-assertions-fail.json b/test/message/fail/modules-skip-3-import-assertions-fail.json
new file mode 100644
index 000000000000..15385d56a0cc
--- /dev/null
+++ b/test/message/fail/modules-skip-3-import-assertions-fail.json
@@ -0,0 +1 @@
+{ "life": 42 }
diff --git a/test/mjsunit/harmony/modules-import-assertions-1.mjs b/test/mjsunit/harmony/modules-import-assertions-1.mjs
new file mode 100644
index 000000000000..eaeffa49677b
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-1.mjs
@@ -0,0 +1,9 @@
+// Copyright 2021 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.
+
+// Flags: --harmony-import-assertions
+
+import { life } from 'modules-skip-1.mjs' assert { };
+
+assertEquals(42, life());
diff --git a/test/mjsunit/harmony/modules-import-assertions-2.mjs b/test/mjsunit/harmony/modules-import-assertions-2.mjs
new file mode 100644
index 000000000000..ac0295870db3
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-2.mjs
@@ -0,0 +1,9 @@
+// Copyright 2021 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.
+
+// Flags: --harmony-import-assertions
+
+import json from 'modules-skip-1.json' assert { type: 'json' };
+
+assertEquals(42, json.life);
diff --git a/test/mjsunit/harmony/modules-import-assertions-3.mjs b/test/mjsunit/harmony/modules-import-assertions-3.mjs
new file mode 100644
index 000000000000..9a648fcc6e62
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-3.mjs
@@ -0,0 +1,9 @@
+// Copyright 2021 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.
+
+// Flags: --harmony-import-assertions
+
+import {life} from 'modules-skip-imports-json-1.mjs';
+
+assertEquals(42, life());
diff --git a/test/mjsunit/harmony/modules-import-assertions-4.mjs b/test/mjsunit/harmony/modules-import-assertions-4.mjs
new file mode 100644
index 000000000000..99d486abf712
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-4.mjs
@@ -0,0 +1,9 @@
+// Copyright 2021 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.
+
+// Flags: --harmony-import-assertions
+
+import json from 'modules-skip-1.json' assert { type: 'json', notARealAssertion: 'value'};
+
+assertEquals(42, json.life);
diff --git a/test/mjsunit/harmony/modules-import-assertions-dynamic-1.mjs b/test/mjsunit/harmony/modules-import-assertions-dynamic-1.mjs
new file mode 100644
index 000000000000..c1daa47eaa25
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-dynamic-1.mjs
@@ -0,0 +1,12 @@
+// Copyright 2021 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.
+
+// Flags: --allow-natives-syntax --harmony-import-assertions
+
+var life;
+import('modules-skip-1.mjs', { }).then(namespace => life = namespace.life());
+
+%PerformMicrotaskCheckpoint();
+
+assertEquals(42, life);
diff --git a/test/mjsunit/harmony/modules-import-assertions-dynamic-10.mjs b/test/mjsunit/harmony/modules-import-assertions-dynamic-10.mjs
new file mode 100644
index 000000000000..beef27d68cbb
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-dynamic-10.mjs
@@ -0,0 +1,19 @@
+// Copyright 2021 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.
+
+// Flags: --allow-natives-syntax --harmony-import-assertions
+
+var result1;
+var result2;
+import('modules-skip-1.json', { get assert() { throw 'bad \'assert\' getter!'; } }).then(
+    () => assertUnreachable('Should have failed due to throwing getter'),
+    error => result1 = error);
+import('modules-skip-1.json', { assert: { get assertionKey() { throw 'bad \'assertionKey\' getter!'; } } }).then(
+    () => assertUnreachable('Should have failed due to throwing getter'),
+    error => result2 = error);
+
+%PerformMicrotaskCheckpoint();
+
+assertEquals('bad \'assert\' getter!', result1);
+assertEquals('bad \'assertionKey\' getter!', result2);
\ No newline at end of file
diff --git a/test/mjsunit/harmony/modules-import-assertions-dynamic-2.mjs b/test/mjsunit/harmony/modules-import-assertions-dynamic-2.mjs
new file mode 100644
index 000000000000..041e330448a9
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-dynamic-2.mjs
@@ -0,0 +1,13 @@
+// Copyright 2021 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.
+
+// Flags: --allow-natives-syntax --harmony-import-assertions
+
+var life;
+import('modules-skip-1.mjs', { assert: { } }).then(
+    namespace => life = namespace.life());
+
+%PerformMicrotaskCheckpoint();
+
+assertEquals(42, life);
diff --git a/test/mjsunit/harmony/modules-import-assertions-dynamic-3.mjs b/test/mjsunit/harmony/modules-import-assertions-dynamic-3.mjs
new file mode 100644
index 000000000000..56a9062b1165
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-dynamic-3.mjs
@@ -0,0 +1,13 @@
+// Copyright 2021 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.
+
+// Flags: --allow-natives-syntax --harmony-import-assertions
+
+var life;
+import('modules-skip-1.json', { assert: { type: 'json' } }).then(
+    namespace => life = namespace.default.life);
+
+%PerformMicrotaskCheckpoint();
+
+assertEquals(42, life);
diff --git a/test/mjsunit/harmony/modules-import-assertions-dynamic-4.mjs b/test/mjsunit/harmony/modules-import-assertions-dynamic-4.mjs
new file mode 100644
index 000000000000..05a1929ff330
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-dynamic-4.mjs
@@ -0,0 +1,14 @@
+// Copyright 2021 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.
+
+// Flags: --allow-natives-syntax --harmony-import-assertions
+
+var result;
+import('modules-skip-1.json', { assert: { type: 'notARealType' } }).then(
+    () => assertUnreachable('Should have failed due to bad module type'),
+    error => result = error.message);
+
+%PerformMicrotaskCheckpoint();
+
+assertEquals('Invalid module type was asserted', result);
diff --git a/test/mjsunit/harmony/modules-import-assertions-dynamic-5.mjs b/test/mjsunit/harmony/modules-import-assertions-dynamic-5.mjs
new file mode 100644
index 000000000000..2019cfd12ab1
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-dynamic-5.mjs
@@ -0,0 +1,12 @@
+// Copyright 2021 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.
+
+// Flags: --allow-natives-syntax --harmony-import-assertions
+
+var life;
+import('modules-skip-imports-json-1.mjs',).then(namespace => life = namespace.life());
+
+%PerformMicrotaskCheckpoint();
+
+assertEquals(42, life);
diff --git a/test/mjsunit/harmony/modules-import-assertions-dynamic-6.mjs b/test/mjsunit/harmony/modules-import-assertions-dynamic-6.mjs
new file mode 100644
index 000000000000..3388aefb5c5b
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-dynamic-6.mjs
@@ -0,0 +1,13 @@
+// Copyright 2021 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.
+
+// Flags: --allow-natives-syntax --harmony-import-assertions
+
+var life;
+import('modules-skip-1.json', { assert: { type: 'json', notARealAssertion: 'value' } }).then(
+    namespace => life = namespace.default.life);
+
+%PerformMicrotaskCheckpoint();
+
+assertEquals(42, life);
diff --git a/test/mjsunit/harmony/modules-import-assertions-dynamic-7.mjs b/test/mjsunit/harmony/modules-import-assertions-dynamic-7.mjs
new file mode 100644
index 000000000000..b45e5b692c2a
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-dynamic-7.mjs
@@ -0,0 +1,63 @@
+// Copyright 2021 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.
+
+// Flags: --allow-natives-syntax --harmony-import-assertions
+
+var result1;
+var result2;
+var result3;
+var result4;
+var result5;
+var result6;
+var result7;
+var result8;
+var result9;
+var result10;
+import('modules-skip-1.json', null).then(
+    () => assertUnreachable('Should have failed due to non-object parameter'),
+    error => result1 = error.message);
+import('modules-skip-1.json', 7).then(
+    () => assertUnreachable('Should have failed due to non-object parameter'),
+    error => result2 = error.message);
+import('modules-skip-1.json', 'string').then(
+        () => assertUnreachable('Should have failed due to non-object parameter'),
+        error => result3 = error.message);
+import('modules-skip-1.json', { assert: null}).then(
+    () => assertUnreachable('Should have failed due to bad assert object'),
+    error => result4 = error.message);
+import('modules-skip-1.json', { assert: 7}).then(
+    () => assertUnreachable('Should have failed due to bad assert object'),
+    error => result5 = error.message);
+import('modules-skip-1.json', { assert: 'string'}).then(
+    () => assertUnreachable('Should have failed due to bad assert object'),
+    error => result6 = error.message);
+import('modules-skip-1.json', { assert: { a: null }}).then(
+    () => assertUnreachable('Should have failed due to bad assert object'),
+    error => result7 = error.message);
+import('modules-skip-1.json', { assert: { a: undefined }}).then(
+    () => assertUnreachable('Should have failed due to bad assertion value'),
+    error => result8 = error.message);
+import('modules-skip-1.json', { assert: { a: 7 }}).then(
+    () => assertUnreachable('Should have failed due to bad assertion value'),
+    error => result9 = error.message);
+    import('modules-skip-1.json', { assert: { a: { } }}).then(
+        () => assertUnreachable('Should have failed due to bad assertion value'),
+        error => result10 = error.message);
+
+%PerformMicrotaskCheckpoint();
+
+const argumentNotObjectError = 'The second argument to import() must be an object';
+const assertOptionNotObjectError = 'The \'assert\' option must be an object';
+const assertionValueNotStringError = 'Import assertion value must be a string';
+
+assertEquals(argumentNotObjectError, result1);
+assertEquals(argumentNotObjectError, result2);
+assertEquals(argumentNotObjectError, result3);
+assertEquals(assertOptionNotObjectError, result4);
+assertEquals(assertOptionNotObjectError, result5);
+assertEquals(assertOptionNotObjectError, result6);
+assertEquals(assertionValueNotStringError, result7);
+assertEquals(assertionValueNotStringError, result8);
+assertEquals(assertionValueNotStringError, result9);
+assertEquals(assertionValueNotStringError, result10);
diff --git a/test/mjsunit/harmony/modules-import-assertions-dynamic-8.mjs b/test/mjsunit/harmony/modules-import-assertions-dynamic-8.mjs
new file mode 100644
index 000000000000..95e1a1e70706
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-dynamic-8.mjs
@@ -0,0 +1,13 @@
+// Copyright 2021 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.
+
+// Flags: --allow-natives-syntax --harmony-import-assertions
+
+var life;
+import('modules-skip-1.mjs', undefined).then(
+    namespace => life = namespace.life());
+
+%PerformMicrotaskCheckpoint();
+
+assertEquals(42, life);
diff --git a/test/mjsunit/harmony/modules-import-assertions-dynamic-9.mjs b/test/mjsunit/harmony/modules-import-assertions-dynamic-9.mjs
new file mode 100644
index 000000000000..2a03c31cf5ea
--- /dev/null
+++ b/test/mjsunit/harmony/modules-import-assertions-dynamic-9.mjs
@@ -0,0 +1,13 @@
+// Copyright 2021 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.
+
+// Flags: --allow-natives-syntax --harmony-import-assertions
+
+var life;
+import('modules-skip-1.mjs', { assert: undefined }).then(
+    namespace => life = namespace.life());
+
+%PerformMicrotaskCheckpoint();
+
+assertEquals(42, life);
diff --git a/test/mjsunit/harmony/modules-skip-1.json b/test/mjsunit/harmony/modules-skip-1.json
new file mode 100644
index 000000000000..c26c11d682ba
--- /dev/null
+++ b/test/mjsunit/harmony/modules-skip-1.json
@@ -0,0 +1 @@
+{ "life": 42}
diff --git a/test/mjsunit/harmony/modules-skip-imports-json-1.mjs b/test/mjsunit/harmony/modules-skip-imports-json-1.mjs
new file mode 100644
index 000000000000..3930313dab80
--- /dev/null
+++ b/test/mjsunit/harmony/modules-skip-imports-json-1.mjs
@@ -0,0 +1,6 @@
+// Copyright 2021 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.
+
+import json from "modules-skip-1.json" assert { type: "json" };
+export function life() { return json.life; }
diff --git a/test/mjsunit/harmony/regexp-match-indices-no-flag.js b/test/mjsunit/harmony/regexp-match-indices-no-flag.js
new file mode 100644
index 000000000000..06cf89ad06bf
--- /dev/null
+++ b/test/mjsunit/harmony/regexp-match-indices-no-flag.js
@@ -0,0 +1,13 @@
+// Copyright 2021 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.
+
+// Flags: --no-harmony-regexp-match-indices
+
+// Redefined hasIndices should not reflect in flags without
+// --harmony-regexp-match-indices
+{
+  let re = /./;
+  Object.defineProperty(re, "hasIndices", { get: function() { return true; } });
+  assertEquals("", re.flags);
+}
diff --git a/test/mjsunit/harmony/regexp-match-indices.js b/test/mjsunit/harmony/regexp-match-indices.js
index 61d3c9d0d016..adbfa4eff23d 100644
--- a/test/mjsunit/harmony/regexp-match-indices.js
+++ b/test/mjsunit/harmony/regexp-match-indices.js
@@ -2,11 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
-// Flags: --harmony-regexp-match-indices --expose-gc --stack-size=100
+// Flags: --harmony-regexp-match-indices --allow-natives-syntax
+// Flags: --expose-gc --stack-size=100
+// Flags: --no-force-slow-path
 
 // Sanity test.
 {
-  const re = /a+(?<Z>z)?/;
+  const re = /a+(?<Z>z)?/d;
   const m = re.exec("xaaaz");
 
   assertEquals(m.indices, [[1, 5], [4, 5]]);
@@ -15,7 +17,7 @@
 
 // Capture groups that are not matched return `undefined`.
 {
-  const re = /a+(?<Z>z)?/;
+  const re = /a+(?<Z>z)?/d;
   const m = re.exec("xaaay");
 
   assertEquals(m.indices, [[1, 4], undefined]);
@@ -24,7 +26,7 @@
 
 // Two capture groups.
 {
-  const re = /a+(?<A>zz)?(?<B>ii)?/;
+  const re = /a+(?<A>zz)?(?<B>ii)?/d;
   const m = re.exec("xaaazzii");
 
   assertEquals(m.indices, [[1, 8], [4, 6], [6, 8]]);
@@ -33,16 +35,16 @@
 
 // No capture groups.
 {
-  const re = /a+/;
+  const re = /a+/d;
   const m = re.exec("xaaazzii");
 
-  assertEquals(m.indices [[1, 4]]);
+  assertEquals(m.indices, [[1, 4]]);
   assertEquals(m.indices.groups, undefined);
 }
 
 // No match.
 {
-  const re = /a+/;
+  const re = /a+/d;
   const m = re.exec("xzzii");
 
   assertEquals(null, m);
@@ -50,8 +52,8 @@
 
 // Unnamed capture groups.
 {
-  const re = /a+(z)?/;
-  const m = re.exec("xaaaz")
+  const re = /a+(z)?/d;
+  const m = re.exec("xaaaz");
 
   assertEquals(m.indices, [[1, 5], [4, 5]]);
   assertEquals(m.indices.groups, undefined)
@@ -59,7 +61,7 @@
 
 // Named and unnamed capture groups.
 {
-  const re = /a+(z)?(?<Y>y)?/;
+  const re = /a+(z)?(?<Y>y)?/d;
   const m = re.exec("xaaazyy")
 
   assertEquals(m.indices, [[1, 6], [4, 5], [5, 6]]);
@@ -69,7 +71,7 @@
 
 // Verify property overwrite.
 {
-  const re = /a+(?<Z>z)?/;
+  const re = /a+(?<Z>z)?/d;
   const m = re.exec("xaaaz");
 
   m.indices = null;
@@ -98,7 +100,7 @@
     }
   });
 
-  const re = /a+(?<Z>z)?/;
+  const re = /a+(?<Z>z)?/d;
   const m = re.exec("xaaaz");
 
   assertEquals(m.indices.groups, {'Z': [4, 5]})
@@ -106,14 +108,14 @@
 
 // Test atomic regexp.
 {
-  const m = /undefined/.exec();
+  const m = (/undefined/d).exec();
 
   assertEquals(m.indices, [[0, 9]]);
 }
 
 // Test deleting unrelated fields does not break.
 {
-  const m = /undefined/.exec();
+  const m = (/undefined/d).exec();
   delete m['index'];
   gc();
   assertEquals(m.indices, [[0, 9]]);
@@ -121,7 +123,7 @@
 
 // Stack overflow.
 {
-  const re = /a+(?<Z>z)?/;
+  const re = /a+(?<Z>z)?/d;
   const m = re.exec("xaaaz");
 
   function rec() {
@@ -138,9 +140,30 @@
 
 // Match between matches.
 {
-  const re = /a+(?<A>zz)?(?<B>ii)?/;
+  const re = /a+(?<A>zz)?(?<B>ii)?/d;
   const m = re.exec("xaaazzii");
   assertTrue(/b+(?<C>cccc)?/.test("llllllbbbbbbcccc"));
   assertEquals(m.indices, [[1, 8], [4, 6], [6, 8]]);
   assertEquals(m.indices.groups, {'A': [4, 6], 'B': [6, 8]});
 }
+
+// Redefined hasIndices should reflect in flags.
+{
+  let re = /./;
+  Object.defineProperty(re, "hasIndices", { get: function() { return true; } });
+  assertEquals("d", re.flags);
+}
+
+{
+  // The flags field of a regexp should be sorted.
+  assertEquals("dgmsy", (/asdf/dymsg).flags);
+
+  // The 'hasIndices' member should be set according to the hasIndices flag.
+  assertTrue((/asdf/dymsg).hasIndices);
+  assertFalse((/asdf/ymsg).hasIndices);
+
+  // The new fields installed on the regexp prototype map shouldn't make
+  // unmodified regexps slow.
+  assertTrue(%RegexpIsUnmodified(/asdf/));
+  assertTrue(%RegexpIsUnmodified(/asdf/d));
+}
diff --git a/test/mjsunit/regexp-linear-flag.js b/test/mjsunit/regexp-linear-flag.js
index 029db097ceab..d388f4d497f7 100644
--- a/test/mjsunit/regexp-linear-flag.js
+++ b/test/mjsunit/regexp-linear-flag.js
@@ -33,3 +33,10 @@ assertFalse((/asdf/ymsg).linear);
 // unmodified regexps slow.
 assertTrue(%RegexpIsUnmodified(/asdf/));
 assertTrue(%RegexpIsUnmodified(/asdf/l));
+
+// Redefined .linear should reflect in flags.
+{
+  let re = /./;
+  Object.defineProperty(re, "linear", { get: function() { return true; } });
+  assertEquals("l", re.flags);
+}
diff --git a/test/mjsunit/regexp-no-linear-flag.js b/test/mjsunit/regexp-no-linear-flag.js
index 7df34aa830dc..eb5ea1607319 100644
--- a/test/mjsunit/regexp-no-linear-flag.js
+++ b/test/mjsunit/regexp-no-linear-flag.js
@@ -15,8 +15,10 @@ assertThrows(() => new RegExp("((a*)*)*\1", "l"), SyntaxError)
 assertFalse(RegExp.prototype.hasOwnProperty('linear'));
 assertFalse(/123/.hasOwnProperty('linear'));
 
+// Redefined .linear shouldn't reflect in flags without
+// --enable-experimental-regexp-engine.
 {
   let re = /./;
-  re.linear = true;
+  Object.defineProperty(re, "linear", { get: function() { return true; } });
   assertEquals("", re.flags);
 }
diff --git a/test/mjsunit/regress/wasm/regress-1054466.js b/test/mjsunit/regress/wasm/regress-1054466.js
index 2fbb82ff71b9..2c35add9add8 100644
--- a/test/mjsunit/regress/wasm/regress-1054466.js
+++ b/test/mjsunit/regress/wasm/regress-1054466.js
@@ -44,7 +44,7 @@ kExprI32Const, 0x83, 0x01,  // i32.const
 kSimdPrefix, kExprI32x4Splat,  // i32x4.splat
 kSimdPrefix, kExprI32x4Eq,  // i32x4.eq
 kSimdPrefix, kExprI32x4Eq,  // i32x4.eq
-kSimdPrefix, kExprV128AnyTrue,  // v128.any_true
+kSimdPrefix, kExprV8x16AnyTrue,  // v8x16.any_true
 kExprEnd,  // end @64
 ]);
 builder.addExport('main', 0);
diff --git a/test/mjsunit/regress/wasm/regress-1065599.js b/test/mjsunit/regress/wasm/regress-1065599.js
index 7deceb5dead3..55833a76b64d 100644
--- a/test/mjsunit/regress/wasm/regress-1065599.js
+++ b/test/mjsunit/regress/wasm/regress-1065599.js
@@ -17,7 +17,7 @@ builder.addFunction(undefined, 0 /* sig */).addBodyWithEnd([
   kSimdPrefix, kExprI16x8Splat,       // i16x8.splat
   kExprMemorySize, 0x00,              // memory.size
   kSimdPrefix, kExprI16x8ShrS, 0x01,  // i16x8.shr_s
-  kSimdPrefix, kExprV128AnyTrue,     // v128.any_true
+  kSimdPrefix, kExprV8x16AnyTrue,     // v8x16.any_true
   kExprMemorySize, 0x00,              // memory.size
   kExprI32RemS,                       // i32.rem_s
   kExprEnd,                           // end @15
diff --git a/test/mjsunit/regress/wasm/regress-1070078.js b/test/mjsunit/regress/wasm/regress-1070078.js
index 51293755e432..5301c5747d56 100644
--- a/test/mjsunit/regress/wasm/regress-1070078.js
+++ b/test/mjsunit/regress/wasm/regress-1070078.js
@@ -30,7 +30,7 @@ builder.addFunction(undefined, 0 /* sig */).addBodyWithEnd([
   0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // i8x16.shuffle
   kSimdPrefix, kExprI8x16LeU,  // i8x16.le_u
-  kSimdPrefix, kExprV128AnyTrue,  // v128.any_true
+  kSimdPrefix, kExprV8x16AnyTrue,  // v8x16.any_true
   kExprMemoryGrow, 0x00,  // memory.grow
   kExprDrop,
   kExprEnd,  // end @233
diff --git a/test/mjsunit/regress/wasm/regress-1081030.js b/test/mjsunit/regress/wasm/regress-1081030.js
index afebaa7ca1d9..7430c62128ff 100644
--- a/test/mjsunit/regress/wasm/regress-1081030.js
+++ b/test/mjsunit/regress/wasm/regress-1081030.js
@@ -17,7 +17,7 @@ builder.addFunction(undefined, 0 /* sig */).addBodyWithEnd([
   kExprF32Const, 0xf8, 0xf8, 0xf8, 0xf8,
   kSimdPrefix, kExprF32x4Splat,         // f32x4.splat
   kSimdPrefix, kExprF32x4Min, 0x01,     // f32x4.min
-  kSimdPrefix, kExprV128AnyTrue, 0x01,  // v128.any_true
+  kSimdPrefix, kExprV32x4AnyTrue, 0x01,  // i32x4.any_true
   kExprEnd,                             // end @16
 ]);
 builder.addExport('main', 0);
diff --git a/test/mjsunit/wasm/wasm-module-builder.js b/test/mjsunit/wasm/wasm-module-builder.js
index 871b7edbd99e..69c61f58c87f 100644
--- a/test/mjsunit/wasm/wasm-module-builder.js
+++ b/test/mjsunit/wasm/wasm-module-builder.js
@@ -623,7 +623,7 @@ let kExprS128Xor = 0x51;
 let kExprS128Select = 0x52;
 let kExprI8x16Abs = 0x60;
 let kExprI8x16Neg = 0x61;
-let kExprV128AnyTrue = 0x62;
+let kExprV8x16AnyTrue = 0x62;
 let kExprV8x16AllTrue = 0x63;
 let kExprI8x16SConvertI16x8 = 0x65;
 let kExprI8x16UConvertI16x8 = 0x66;
@@ -643,6 +643,7 @@ let kExprI8x16MaxU = 0x79;
 let kExprI8x16RoundingAverageU = 0x7b;
 let kExprI16x8Abs = 0x80;
 let kExprI16x8Neg = 0x81;
+let kExprV16x8AnyTrue = 0x82;
 let kExprV16x8AllTrue = 0x83;
 let kExprI16x8SConvertI32x4 = 0x85;
 let kExprI16x8UConvertI32x4 = 0x86;
@@ -667,6 +668,7 @@ let kExprI16x8MaxU = 0x99;
 let kExprI16x8RoundingAverageU = 0x9b;
 let kExprI32x4Abs = 0xa0;
 let kExprI32x4Neg = 0xa1;
+let kExprV32x4AnyTrue = 0xa2;
 let kExprV32x4AllTrue = 0xa3;
 let kExprI32x4SConvertI16x8Low = 0xa7;
 let kExprI32x4SConvertI16x8High = 0xa8;
diff --git a/test/test262/test262.status b/test/test262/test262.status
index d5a49570ecef..bf5c0357a28d 100644
--- a/test/test262/test262.status
+++ b/test/test262/test262.status
@@ -581,6 +581,9 @@
   'built-ins/String/prototype/at/*': [FAIL],
   'built-ins/TypedArray/prototype/at/*': [FAIL],
 
+  # Temporarily disabled until upstream tests are changed to use /d
+  'built-ins/RegExp/match-indices/*': [FAIL],
+
   ######################## NEEDS INVESTIGATION ###########################
 
   # https://bugs.chromium.org/p/v8/issues/detail?id=7833
diff --git a/test/unittests/objects/value-serializer-unittest.cc b/test/unittests/objects/value-serializer-unittest.cc
index 82afd6fd1f2a..0e5575bdab2b 100644
--- a/test/unittests/objects/value-serializer-unittest.cc
+++ b/test/unittests/objects/value-serializer-unittest.cc
@@ -1511,6 +1511,25 @@ TEST_F(ValueSerializerTest, DecodeLinearRegExp) {
   i::FLAG_enable_experimental_regexp_engine = flag_was_enabled;
 }
 
+TEST_F(ValueSerializerTest, DecodeHasIndicesRegExp) {
+  bool flag_was_enabled = i::FLAG_harmony_regexp_match_indices;
+
+  // The last byte encodes the regexp flags.
+  std::vector<uint8_t> regexp_encoding = {0xFF, 0x09, 0x3F, 0x00, 0x52, 0x03,
+                                          0x66, 0x6F, 0x6F, 0xAD, 0x01};
+
+  i::FLAG_harmony_regexp_match_indices = true;
+  Local<Value> value = DecodeTest(regexp_encoding);
+  ASSERT_TRUE(value->IsRegExp());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === RegExp.prototype");
+  ExpectScriptTrue("result.toString() === '/foo/dgmsy'");
+
+  i::FLAG_harmony_regexp_match_indices = false;
+  InvalidDecodeTest(regexp_encoding);
+
+  i::FLAG_harmony_regexp_match_indices = flag_was_enabled;
+}
+
 TEST_F(ValueSerializerTest, RoundTripMap) {
   Local<Value> value = RoundTripTest("var m = new Map(); m.set(42, 'foo'); m;");
   ASSERT_TRUE(value->IsMap());
diff --git a/test/wasm-spec-tests/wasm-spec-tests.status b/test/wasm-spec-tests/wasm-spec-tests.status
index 4524b8c972a5..470578f25092 100644
--- a/test/wasm-spec-tests/wasm-spec-tests.status
+++ b/test/wasm-spec-tests/wasm-spec-tests.status
@@ -35,10 +35,6 @@
 
   # This test requires the reftypes flag to be disabled.
   'proposals/bulk-memory-operations/imports': [FAIL],
-
-  # TODO(v8:11331): Remove once spec tests are updated with v128.any_true.
-  'proposals/simd/simd_boolean': [FAIL],
-  'proposals/simd/simd_lane': [FAIL],
 }],  # ALWAYS
 
 ['arch == arm and not simulator_run', {
diff --git a/tools/v8heapconst.py b/tools/v8heapconst.py
index 29031227889e..620de253b7ea 100644
--- a/tools/v8heapconst.py
+++ b/tools/v8heapconst.py
@@ -319,68 +319,68 @@
   ("read_only_space", 0x03151): (67, "BasicBlockCountersMarkerMap"),
   ("read_only_space", 0x03195): (87, "ArrayBoilerplateDescriptionMap"),
   ("read_only_space", 0x0327d): (99, "InterceptorInfoMap"),
-  ("read_only_space", 0x053d1): (72, "PromiseFulfillReactionJobTaskMap"),
-  ("read_only_space", 0x053f9): (73, "PromiseRejectReactionJobTaskMap"),
-  ("read_only_space", 0x05421): (74, "CallableTaskMap"),
-  ("read_only_space", 0x05449): (75, "CallbackTaskMap"),
-  ("read_only_space", 0x05471): (76, "PromiseResolveThenableJobTaskMap"),
-  ("read_only_space", 0x05499): (79, "FunctionTemplateInfoMap"),
-  ("read_only_space", 0x054c1): (80, "ObjectTemplateInfoMap"),
-  ("read_only_space", 0x054e9): (81, "AccessCheckInfoMap"),
-  ("read_only_space", 0x05511): (82, "AccessorInfoMap"),
-  ("read_only_space", 0x05539): (83, "AccessorPairMap"),
-  ("read_only_space", 0x05561): (84, "AliasedArgumentsEntryMap"),
-  ("read_only_space", 0x05589): (85, "AllocationMementoMap"),
-  ("read_only_space", 0x055b1): (88, "AsmWasmDataMap"),
-  ("read_only_space", 0x055d9): (89, "AsyncGeneratorRequestMap"),
-  ("read_only_space", 0x05601): (90, "BreakPointMap"),
-  ("read_only_space", 0x05629): (91, "BreakPointInfoMap"),
-  ("read_only_space", 0x05651): (92, "CachedTemplateObjectMap"),
-  ("read_only_space", 0x05679): (94, "ClassPositionsMap"),
-  ("read_only_space", 0x056a1): (95, "DebugInfoMap"),
-  ("read_only_space", 0x056c9): (98, "FunctionTemplateRareDataMap"),
-  ("read_only_space", 0x056f1): (100, "InterpreterDataMap"),
-  ("read_only_space", 0x05719): (101, "ModuleRequestMap"),
-  ("read_only_space", 0x05741): (102, "PromiseCapabilityMap"),
-  ("read_only_space", 0x05769): (103, "PromiseReactionMap"),
-  ("read_only_space", 0x05791): (104, "PropertyDescriptorObjectMap"),
-  ("read_only_space", 0x057b9): (105, "PrototypeInfoMap"),
-  ("read_only_space", 0x057e1): (106, "ScriptMap"),
-  ("read_only_space", 0x05809): (107, "SourceTextModuleInfoEntryMap"),
-  ("read_only_space", 0x05831): (108, "StackFrameInfoMap"),
-  ("read_only_space", 0x05859): (109, "StackTraceFrameMap"),
-  ("read_only_space", 0x05881): (110, "TemplateObjectDescriptionMap"),
-  ("read_only_space", 0x058a9): (111, "Tuple2Map"),
-  ("read_only_space", 0x058d1): (112, "WasmExceptionTagMap"),
-  ("read_only_space", 0x058f9): (113, "WasmExportedFunctionDataMap"),
-  ("read_only_space", 0x05921): (114, "WasmIndirectFunctionTableMap"),
-  ("read_only_space", 0x05949): (115, "WasmJSFunctionDataMap"),
-  ("read_only_space", 0x05971): (134, "SloppyArgumentsElementsMap"),
-  ("read_only_space", 0x05999): (151, "DescriptorArrayMap"),
-  ("read_only_space", 0x059c1): (156, "UncompiledDataWithoutPreparseDataMap"),
-  ("read_only_space", 0x059e9): (155, "UncompiledDataWithPreparseDataMap"),
-  ("read_only_space", 0x05a11): (171, "OnHeapBasicBlockProfilerDataMap"),
-  ("read_only_space", 0x05a39): (180, "WasmCapiFunctionDataMap"),
-  ("read_only_space", 0x05a61): (168, "InternalClassMap"),
-  ("read_only_space", 0x05a89): (177, "SmiPairMap"),
-  ("read_only_space", 0x05ab1): (176, "SmiBoxMap"),
-  ("read_only_space", 0x05ad9): (145, "ExportedSubClassBaseMap"),
-  ("read_only_space", 0x05b01): (146, "ExportedSubClassMap"),
-  ("read_only_space", 0x05b29): (68, "AbstractInternalClassSubclass1Map"),
-  ("read_only_space", 0x05b51): (69, "AbstractInternalClassSubclass2Map"),
-  ("read_only_space", 0x05b79): (132, "InternalClassWithSmiElementsMap"),
-  ("read_only_space", 0x05ba1): (169, "InternalClassWithStructElementsMap"),
-  ("read_only_space", 0x05bc9): (147, "ExportedSubClass2Map"),
-  ("read_only_space", 0x05bf1): (178, "SortStateMap"),
-  ("read_only_space", 0x05c19): (86, "AllocationSiteWithWeakNextMap"),
-  ("read_only_space", 0x05c41): (86, "AllocationSiteWithoutWeakNextMap"),
-  ("read_only_space", 0x05c69): (77, "LoadHandler1Map"),
-  ("read_only_space", 0x05c91): (77, "LoadHandler2Map"),
-  ("read_only_space", 0x05cb9): (77, "LoadHandler3Map"),
-  ("read_only_space", 0x05ce1): (78, "StoreHandler0Map"),
-  ("read_only_space", 0x05d09): (78, "StoreHandler1Map"),
-  ("read_only_space", 0x05d31): (78, "StoreHandler2Map"),
-  ("read_only_space", 0x05d59): (78, "StoreHandler3Map"),
+  ("read_only_space", 0x053d9): (72, "PromiseFulfillReactionJobTaskMap"),
+  ("read_only_space", 0x05401): (73, "PromiseRejectReactionJobTaskMap"),
+  ("read_only_space", 0x05429): (74, "CallableTaskMap"),
+  ("read_only_space", 0x05451): (75, "CallbackTaskMap"),
+  ("read_only_space", 0x05479): (76, "PromiseResolveThenableJobTaskMap"),
+  ("read_only_space", 0x054a1): (79, "FunctionTemplateInfoMap"),
+  ("read_only_space", 0x054c9): (80, "ObjectTemplateInfoMap"),
+  ("read_only_space", 0x054f1): (81, "AccessCheckInfoMap"),
+  ("read_only_space", 0x05519): (82, "AccessorInfoMap"),
+  ("read_only_space", 0x05541): (83, "AccessorPairMap"),
+  ("read_only_space", 0x05569): (84, "AliasedArgumentsEntryMap"),
+  ("read_only_space", 0x05591): (85, "AllocationMementoMap"),
+  ("read_only_space", 0x055b9): (88, "AsmWasmDataMap"),
+  ("read_only_space", 0x055e1): (89, "AsyncGeneratorRequestMap"),
+  ("read_only_space", 0x05609): (90, "BreakPointMap"),
+  ("read_only_space", 0x05631): (91, "BreakPointInfoMap"),
+  ("read_only_space", 0x05659): (92, "CachedTemplateObjectMap"),
+  ("read_only_space", 0x05681): (94, "ClassPositionsMap"),
+  ("read_only_space", 0x056a9): (95, "DebugInfoMap"),
+  ("read_only_space", 0x056d1): (98, "FunctionTemplateRareDataMap"),
+  ("read_only_space", 0x056f9): (100, "InterpreterDataMap"),
+  ("read_only_space", 0x05721): (101, "ModuleRequestMap"),
+  ("read_only_space", 0x05749): (102, "PromiseCapabilityMap"),
+  ("read_only_space", 0x05771): (103, "PromiseReactionMap"),
+  ("read_only_space", 0x05799): (104, "PropertyDescriptorObjectMap"),
+  ("read_only_space", 0x057c1): (105, "PrototypeInfoMap"),
+  ("read_only_space", 0x057e9): (106, "ScriptMap"),
+  ("read_only_space", 0x05811): (107, "SourceTextModuleInfoEntryMap"),
+  ("read_only_space", 0x05839): (108, "StackFrameInfoMap"),
+  ("read_only_space", 0x05861): (109, "StackTraceFrameMap"),
+  ("read_only_space", 0x05889): (110, "TemplateObjectDescriptionMap"),
+  ("read_only_space", 0x058b1): (111, "Tuple2Map"),
+  ("read_only_space", 0x058d9): (112, "WasmExceptionTagMap"),
+  ("read_only_space", 0x05901): (113, "WasmExportedFunctionDataMap"),
+  ("read_only_space", 0x05929): (114, "WasmIndirectFunctionTableMap"),
+  ("read_only_space", 0x05951): (115, "WasmJSFunctionDataMap"),
+  ("read_only_space", 0x05979): (134, "SloppyArgumentsElementsMap"),
+  ("read_only_space", 0x059a1): (151, "DescriptorArrayMap"),
+  ("read_only_space", 0x059c9): (156, "UncompiledDataWithoutPreparseDataMap"),
+  ("read_only_space", 0x059f1): (155, "UncompiledDataWithPreparseDataMap"),
+  ("read_only_space", 0x05a19): (171, "OnHeapBasicBlockProfilerDataMap"),
+  ("read_only_space", 0x05a41): (180, "WasmCapiFunctionDataMap"),
+  ("read_only_space", 0x05a69): (168, "InternalClassMap"),
+  ("read_only_space", 0x05a91): (177, "SmiPairMap"),
+  ("read_only_space", 0x05ab9): (176, "SmiBoxMap"),
+  ("read_only_space", 0x05ae1): (145, "ExportedSubClassBaseMap"),
+  ("read_only_space", 0x05b09): (146, "ExportedSubClassMap"),
+  ("read_only_space", 0x05b31): (68, "AbstractInternalClassSubclass1Map"),
+  ("read_only_space", 0x05b59): (69, "AbstractInternalClassSubclass2Map"),
+  ("read_only_space", 0x05b81): (132, "InternalClassWithSmiElementsMap"),
+  ("read_only_space", 0x05ba9): (169, "InternalClassWithStructElementsMap"),
+  ("read_only_space", 0x05bd1): (147, "ExportedSubClass2Map"),
+  ("read_only_space", 0x05bf9): (178, "SortStateMap"),
+  ("read_only_space", 0x05c21): (86, "AllocationSiteWithWeakNextMap"),
+  ("read_only_space", 0x05c49): (86, "AllocationSiteWithoutWeakNextMap"),
+  ("read_only_space", 0x05c71): (77, "LoadHandler1Map"),
+  ("read_only_space", 0x05c99): (77, "LoadHandler2Map"),
+  ("read_only_space", 0x05cc1): (77, "LoadHandler3Map"),
+  ("read_only_space", 0x05ce9): (78, "StoreHandler0Map"),
+  ("read_only_space", 0x05d11): (78, "StoreHandler1Map"),
+  ("read_only_space", 0x05d39): (78, "StoreHandler2Map"),
+  ("read_only_space", 0x05d61): (78, "StoreHandler3Map"),
   ("map_space", 0x02119): (1057, "ExternalMap"),
   ("map_space", 0x02141): (1098, "JSMessageObjectMap"),
   ("map_space", 0x02169): (181, "WasmRttEqrefMap"),
@@ -447,52 +447,51 @@
   ("old_space", 0x022f5): "FunctionNameAccessor",
   ("old_space", 0x02339): "FunctionLengthAccessor",
   ("old_space", 0x0237d): "FunctionPrototypeAccessor",
-  ("old_space", 0x023c1): "RegExpResultIndicesAccessor",
-  ("old_space", 0x02405): "StringLengthAccessor",
-  ("old_space", 0x02449): "InvalidPrototypeValidityCell",
-  ("old_space", 0x02535): "EmptyScript",
-  ("old_space", 0x02575): "ManyClosuresCell",
-  ("old_space", 0x02581): "ArrayConstructorProtector",
-  ("old_space", 0x02595): "NoElementsProtector",
-  ("old_space", 0x025a9): "IsConcatSpreadableProtector",
-  ("old_space", 0x025bd): "ArraySpeciesProtector",
-  ("old_space", 0x025d1): "TypedArraySpeciesProtector",
-  ("old_space", 0x025e5): "PromiseSpeciesProtector",
-  ("old_space", 0x025f9): "RegExpSpeciesProtector",
-  ("old_space", 0x0260d): "StringLengthProtector",
-  ("old_space", 0x02621): "ArrayIteratorProtector",
-  ("old_space", 0x02635): "ArrayBufferDetachingProtector",
-  ("old_space", 0x02649): "PromiseHookProtector",
-  ("old_space", 0x0265d): "PromiseResolveProtector",
-  ("old_space", 0x02671): "MapIteratorProtector",
-  ("old_space", 0x02685): "PromiseThenProtector",
-  ("old_space", 0x02699): "SetIteratorProtector",
-  ("old_space", 0x026ad): "StringIteratorProtector",
-  ("old_space", 0x026c1): "SingleCharacterStringCache",
-  ("old_space", 0x02ac9): "StringSplitCache",
-  ("old_space", 0x02ed1): "RegExpMultipleCache",
-  ("old_space", 0x032d9): "BuiltinsConstantsTable",
-  ("old_space", 0x036cd): "AsyncFunctionAwaitRejectSharedFun",
-  ("old_space", 0x036f1): "AsyncFunctionAwaitResolveSharedFun",
-  ("old_space", 0x03715): "AsyncGeneratorAwaitRejectSharedFun",
-  ("old_space", 0x03739): "AsyncGeneratorAwaitResolveSharedFun",
-  ("old_space", 0x0375d): "AsyncGeneratorYieldResolveSharedFun",
-  ("old_space", 0x03781): "AsyncGeneratorReturnResolveSharedFun",
-  ("old_space", 0x037a5): "AsyncGeneratorReturnClosedRejectSharedFun",
-  ("old_space", 0x037c9): "AsyncGeneratorReturnClosedResolveSharedFun",
-  ("old_space", 0x037ed): "AsyncIteratorValueUnwrapSharedFun",
-  ("old_space", 0x03811): "PromiseAllResolveElementSharedFun",
-  ("old_space", 0x03835): "PromiseAllSettledResolveElementSharedFun",
-  ("old_space", 0x03859): "PromiseAllSettledRejectElementSharedFun",
-  ("old_space", 0x0387d): "PromiseAnyRejectElementSharedFun",
-  ("old_space", 0x038a1): "PromiseCapabilityDefaultRejectSharedFun",
-  ("old_space", 0x038c5): "PromiseCapabilityDefaultResolveSharedFun",
-  ("old_space", 0x038e9): "PromiseCatchFinallySharedFun",
-  ("old_space", 0x0390d): "PromiseGetCapabilitiesExecutorSharedFun",
-  ("old_space", 0x03931): "PromiseThenFinallySharedFun",
-  ("old_space", 0x03955): "PromiseThrowerFinallySharedFun",
-  ("old_space", 0x03979): "PromiseValueThunkFinallySharedFun",
-  ("old_space", 0x0399d): "ProxyRevokeSharedFun",
+  ("old_space", 0x023c1): "StringLengthAccessor",
+  ("old_space", 0x02405): "InvalidPrototypeValidityCell",
+  ("old_space", 0x024f1): "EmptyScript",
+  ("old_space", 0x02531): "ManyClosuresCell",
+  ("old_space", 0x0253d): "ArrayConstructorProtector",
+  ("old_space", 0x02551): "NoElementsProtector",
+  ("old_space", 0x02565): "IsConcatSpreadableProtector",
+  ("old_space", 0x02579): "ArraySpeciesProtector",
+  ("old_space", 0x0258d): "TypedArraySpeciesProtector",
+  ("old_space", 0x025a1): "PromiseSpeciesProtector",
+  ("old_space", 0x025b5): "RegExpSpeciesProtector",
+  ("old_space", 0x025c9): "StringLengthProtector",
+  ("old_space", 0x025dd): "ArrayIteratorProtector",
+  ("old_space", 0x025f1): "ArrayBufferDetachingProtector",
+  ("old_space", 0x02605): "PromiseHookProtector",
+  ("old_space", 0x02619): "PromiseResolveProtector",
+  ("old_space", 0x0262d): "MapIteratorProtector",
+  ("old_space", 0x02641): "PromiseThenProtector",
+  ("old_space", 0x02655): "SetIteratorProtector",
+  ("old_space", 0x02669): "StringIteratorProtector",
+  ("old_space", 0x0267d): "SingleCharacterStringCache",
+  ("old_space", 0x02a85): "StringSplitCache",
+  ("old_space", 0x02e8d): "RegExpMultipleCache",
+  ("old_space", 0x03295): "BuiltinsConstantsTable",
+  ("old_space", 0x0368d): "AsyncFunctionAwaitRejectSharedFun",
+  ("old_space", 0x036b1): "AsyncFunctionAwaitResolveSharedFun",
+  ("old_space", 0x036d5): "AsyncGeneratorAwaitRejectSharedFun",
+  ("old_space", 0x036f9): "AsyncGeneratorAwaitResolveSharedFun",
+  ("old_space", 0x0371d): "AsyncGeneratorYieldResolveSharedFun",
+  ("old_space", 0x03741): "AsyncGeneratorReturnResolveSharedFun",
+  ("old_space", 0x03765): "AsyncGeneratorReturnClosedRejectSharedFun",
+  ("old_space", 0x03789): "AsyncGeneratorReturnClosedResolveSharedFun",
+  ("old_space", 0x037ad): "AsyncIteratorValueUnwrapSharedFun",
+  ("old_space", 0x037d1): "PromiseAllResolveElementSharedFun",
+  ("old_space", 0x037f5): "PromiseAllSettledResolveElementSharedFun",
+  ("old_space", 0x03819): "PromiseAllSettledRejectElementSharedFun",
+  ("old_space", 0x0383d): "PromiseAnyRejectElementSharedFun",
+  ("old_space", 0x03861): "PromiseCapabilityDefaultRejectSharedFun",
+  ("old_space", 0x03885): "PromiseCapabilityDefaultResolveSharedFun",
+  ("old_space", 0x038a9): "PromiseCatchFinallySharedFun",
+  ("old_space", 0x038cd): "PromiseGetCapabilitiesExecutorSharedFun",
+  ("old_space", 0x038f1): "PromiseThenFinallySharedFun",
+  ("old_space", 0x03915): "PromiseThrowerFinallySharedFun",
+  ("old_space", 0x03939): "PromiseValueThunkFinallySharedFun",
+  ("old_space", 0x0395d): "ProxyRevokeSharedFun",
 }
 
 # Lower 32 bits of first page addresses for various heap spaces.