Merged: [wasm] Fix code specialization for empty memory buffer

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 49 matching lines @@
 
 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,
                                                   uint32_t new_size) {
-  DCHECK(old_mem_start == 0 && new_mem_start == 0);
-  DCHECK(old_start != 0 || new_start != 0);
+  DCHECK(old_mem_start == nullptr && old_mem_size == 0 &&
+         new_mem_start == nullptr && new_mem_size == 0);
+  DCHECK(old_start != new_start || old_size != new_size);
   old_mem_start = old_start;
   old_mem_size = old_size;
   new_mem_start = new_start;
   new_mem_size = new_size;
 }
 
 void CodeSpecialization::RelocateGlobals(Address old_start, Address new_start) {
   DCHECK(old_globals_start == 0 && new_globals_start == 0);
   DCHECK(old_start != 0 || new_start != 0);
   old_globals_start = old_start;
@@ skipping 73 matching lines @@
   }
   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());
 
-  bool reloc_mem = old_mem_start || new_mem_start;
+  bool reloc_mem_addr = old_mem_start != new_mem_start;
+  bool reloc_mem_size = old_mem_size != new_mem_size;
   bool reloc_globals = old_globals_start || new_globals_start;
   bool patch_table_size = old_function_table_size || new_function_table_size;
   bool reloc_direct_calls = !relocate_direct_calls_instance.is_null();
   bool reloc_objects = has_objects_to_relocate;
 
   int reloc_mode = 0;
   auto add_mode = [&reloc_mode](bool cond, RelocInfo::Mode mode) {
     if (cond) reloc_mode |= RelocInfo::ModeMask(mode);
   };
-  add_mode(reloc_mem, RelocInfo::WASM_MEMORY_REFERENCE);
-  add_mode(reloc_mem, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
+  add_mode(reloc_mem_addr, RelocInfo::WASM_MEMORY_REFERENCE);
+  add_mode(reloc_mem_size, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
   add_mode(reloc_globals, RelocInfo::WASM_GLOBAL_REFERENCE);
   add_mode(patch_table_size, RelocInfo::WASM_FUNCTION_TABLE_SIZE_REFERENCE);
   add_mode(reloc_direct_calls, RelocInfo::CODE_TARGET);
   add_mode(reloc_objects, RelocInfo::EMBEDDED_OBJECT);
 
   std::unique_ptr<PatchDirectCallsHelper> patch_direct_calls_helper;
   bool changed = false;
 
   for (RelocIterator it(code, reloc_mode); !it.done(); it.next()) {
     RelocInfo::Mode mode = it.rinfo()->rmode();
     switch (mode) {
       case RelocInfo::WASM_MEMORY_REFERENCE:
+        DCHECK(reloc_mem_addr);
+        it.rinfo()->update_wasm_memory_reference(old_mem_start, new_mem_start,
+                                                 icache_flush_mode);
+        changed = true;
+        break;
       case RelocInfo::WASM_MEMORY_SIZE_REFERENCE:
-        DCHECK(reloc_mem);
-        it.rinfo()->update_wasm_memory_reference(old_mem_start, new_mem_start,
-                                                 old_mem_size, new_mem_size,
-                                                 icache_flush_mode);
+        DCHECK(reloc_mem_size);
+        it.rinfo()->update_wasm_memory_size(old_mem_size, new_mem_size,
+                                            icache_flush_mode);
         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);
@@ skipping 44 matching lines @@
             icache_flush_mode);
         changed = true;
         break;
       default:
         UNREACHABLE();
     }
   }
 
   return changed;
 }