[wasm] Exit loop once wasm code in JS_TO_WASM is found

src/wasm/wasm-code-specialization.cc

 // Copyright 2017 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/wasm/wasm-code-specialization.h"
 
 #include "src/assembler-inl.h"
 #include "src/objects-inl.h"
 #include "src/source-position-table.h"
 #include "src/wasm/decoder.h"
@@ skipping 38 matching lines @@
     int func_index = Smi::cast(deopt_data->get(1))->value();
     func_bytes = comp_mod->module_bytes()->GetChars() +
                  comp_mod->module()->functions[func_index].code_start_offset;
   }
 
   SourcePositionTableIterator source_pos_it;
   Decoder decoder;
   const byte* func_bytes;
 };
 
+bool IsAtWasmDirectCallTarget(RelocIterator& it) {
+  DCHECK(RelocInfo::IsCodeTarget(it.rinfo()->rmode()));
+  Code* code = Code::GetCodeFromTargetAddress(it.rinfo()->target_address());
+  return code->kind() == Code::WASM_FUNCTION ||
+         code->kind() == Code::WASM_TO_JS_FUNCTION ||
+         code->builtin_index() == Builtins::kIllegal;
+}
+
 }  // namespace
 
 CodeSpecialization::CodeSpecialization(Isolate* isolate, Zone* zone)
     : objects_to_relocate(isolate->heap(), ZoneAllocationPolicy(zone)) {}
 
 CodeSpecialization::~CodeSpecialization() {}
 
 void CodeSpecialization::RelocateMemoryReferences(Address old_start,
                                                   uint32_t old_size,
                                                   Address new_start,
@@ skipping 55 matching lines @@
     Code* wasm_function = Code::cast(code_table->get(func_index));
     changed |= ApplyToWasmCode(wasm_function, icache_flush_mode);
   }
 
   // Patch all exported functions.
   for (auto exp : module->export_table) {
     if (exp.kind != kExternalFunction) continue;
     Code* export_wrapper = Code::cast(code_table->get(func_index));
     DCHECK_EQ(Code::JS_TO_WASM_FUNCTION, export_wrapper->kind());
     // There must be exactly one call to WASM_FUNCTION or WASM_TO_JS_FUNCTION.
-    int num_wasm_calls = 0;
     for (RelocIterator it(export_wrapper,
                           RelocInfo::ModeMask(RelocInfo::CODE_TARGET));
-         !it.done(); it.next()) {
-      DCHECK(RelocInfo::IsCodeTarget(it.rinfo()->rmode()));
-      Code* code = Code::GetCodeFromTargetAddress(it.rinfo()->target_address());
+         ; it.next()) {
+      DCHECK(!it.done());
       // Ignore calls to other builtins like ToNumber.
-      if (code->kind() != Code::WASM_FUNCTION &&
-          code->kind() != Code::WASM_TO_JS_FUNCTION &&
-          code->builtin_index() != Builtins::kIllegal)
-        continue;
-      ++num_wasm_calls;
+      if (!IsAtWasmDirectCallTarget(it)) continue;
       Code* new_code = Code::cast(code_table->get(exp.index));
       DCHECK(new_code->kind() == Code::WASM_FUNCTION ||
              new_code->kind() == Code::WASM_TO_JS_FUNCTION);
       it.rinfo()->set_target_address(new_code->instruction_start(),
                                      UPDATE_WRITE_BARRIER, SKIP_ICACHE_FLUSH);
-      changed = true;
+      break;
     }
-    DCHECK_EQ(1, num_wasm_calls);
+    changed = true;
     func_index++;
   }
   DCHECK_EQ(code_table->length(), func_index);
   return changed;
 }
 
 bool CodeSpecialization::ApplyToWasmCode(Code* code,
                                          ICacheFlushMode icache_flush_mode) {
   DisallowHeapAllocation no_gc;
   DCHECK_EQ(Code::WASM_FUNCTION, code->kind());
@@ skipping 30 matching lines @@
         changed = true;
         break;
       case RelocInfo::WASM_GLOBAL_REFERENCE:
         DCHECK(reloc_globals);
         it.rinfo()->update_wasm_global_reference(
             old_globals_start, new_globals_start, icache_flush_mode);
         changed = true;
         break;
       case RelocInfo::CODE_TARGET: {
         DCHECK(reloc_direct_calls);
-        Code* old_code =
-            Code::GetCodeFromTargetAddress(it.rinfo()->target_address());
         // Skip everything which is not a wasm call (stack checks, traps, ...).
-        if (old_code->kind() != Code::WASM_FUNCTION &&
-            old_code->kind() != Code::WASM_TO_JS_FUNCTION &&
-            old_code->builtin_index() != Builtins::kIllegal)
-          continue;
+        if (!IsAtWasmDirectCallTarget(it)) continue;
         // Iterate simultaneously over the relocation information and the source
         // position table. For each call in the reloc info, move the source
         // position iterator forward to that position to find the byte offset of
         // the respective call. Then extract the call index from the module wire
         // bytes to find the new compiled function.
         size_t offset = it.rinfo()->pc() - code->instruction_start();
         if (!patch_direct_calls_helper) {
           patch_direct_calls_helper.reset(new PatchDirectCallsHelper(
               *relocate_direct_calls_instance, code));
         }
@@ skipping 27 matching lines @@
             icache_flush_mode);
         changed = true;
         break;
       default:
         UNREACHABLE();
     }
   }
 
   return changed;
 }