[wasm] Fix bounds check for zero initial memory.

src/assembler.cc

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // All Rights Reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 // - Redistributions of source code must retain the above copyright notice,
 // this list of conditions and the following disclaimer.
 //
@@ skipping 337 matching lines @@
     // The reference is not checked here but at runtime. Validity of references
     // may change over time.
     unchecked_update_wasm_memory_reference(updated_reference,
                                            icache_flush_mode);
   } else if (IsWasmMemorySizeReference(rmode_)) {
     uint32_t current_size_reference = wasm_memory_size_reference();
     DCHECK(old_size == 0 || current_size_reference <= old_size);
     uint32_t offset = old_size - current_size_reference;
     DCHECK_GE(new_size, offset);
     uint32_t updated_size_reference = new_size - offset;
+
+    if (old_size == 0) {
+      switch (rmode_) {
+        case RelocInfo::WASM_MEMORY_WORD_SIZE_REFERENCE:
+          updated_size_reference = updated_size_reference - 1;
+          break;
+        case RelocInfo::WASM_MEMORY_DWORD_SIZE_REFERENCE:
+          updated_size_reference = updated_size_reference - 3;
+          break;
+        case RelocInfo::WASM_MEMORY_QWORD_SIZE_REFERENCE:
+          updated_size_reference = updated_size_reference - 7;
+          break;
+        default:
+          DCHECK(rmode_ == RelocInfo::WASM_MEMORY_BYTE_SIZE_REFERENCE);

[bradn, 2016/10/12 18:50:45]

Handle explicit and make default unreachable?

[gdeepti, 2016/10/13 08:42:59]

Got rid of additional RelocInfo modes, code removed in latest patch. 

+      }
+    }
     unchecked_update_wasm_memory_size(updated_size_reference,
                                       icache_flush_mode);
   } else {
     UNREACHABLE();
   }
   if (icache_flush_mode != SKIP_ICACHE_FLUSH) {
     Assembler::FlushICache(isolate_, pc_, sizeof(int64_t));
   }
 }
 
@@ skipping 411 matching lines @@
     case DEBUG_BREAK_SLOT_AT_CALL:
       return "debug break slot at call";
     case DEBUG_BREAK_SLOT_AT_TAIL_CALL:
       return "debug break slot at tail call";
     case CODE_AGE_SEQUENCE:
       return "code age sequence";
     case GENERATOR_CONTINUATION:
       return "generator continuation";
     case WASM_MEMORY_REFERENCE:
       return "wasm memory reference";
-    case WASM_MEMORY_SIZE_REFERENCE:
-      return "wasm memory size reference";
+    case WASM_MEMORY_BYTE_SIZE_REFERENCE:
+      return "wasm memory size byte reference";
+    case WASM_MEMORY_WORD_SIZE_REFERENCE:
+      return "wasm memory size word reference";
+    case WASM_MEMORY_DWORD_SIZE_REFERENCE:
+      return "wasm memory size dword reference";
+    case WASM_MEMORY_QWORD_SIZE_REFERENCE:
+      return "wasm memory size qword reference";
     case WASM_GLOBAL_REFERENCE:
       return "wasm global value reference";
     case NUMBER_OF_MODES:
     case PC_JUMP:
       UNREACHABLE();
       return "number_of_modes";
   }
   return "unknown relocation type";
 }
 
@@ skipping 77 matching lines @@
     case DEOPT_REASON:
     case DEOPT_ID:
     case CONST_POOL:
     case VENEER_POOL:
     case DEBUG_BREAK_SLOT_AT_POSITION:
     case DEBUG_BREAK_SLOT_AT_RETURN:
     case DEBUG_BREAK_SLOT_AT_CALL:
     case DEBUG_BREAK_SLOT_AT_TAIL_CALL:
     case GENERATOR_CONTINUATION:
     case WASM_MEMORY_REFERENCE:
-    case WASM_MEMORY_SIZE_REFERENCE:
+    case WASM_MEMORY_BYTE_SIZE_REFERENCE:
+    case WASM_MEMORY_WORD_SIZE_REFERENCE:
+    case WASM_MEMORY_DWORD_SIZE_REFERENCE:
+    case WASM_MEMORY_QWORD_SIZE_REFERENCE:
     case WASM_GLOBAL_REFERENCE:
     case NONE32:
     case NONE64:
       break;
     case NUMBER_OF_MODES:
     case PC_JUMP:
       UNREACHABLE();
       break;
     case CODE_AGE_SEQUENCE:
       DCHECK(Code::IsYoungSequence(isolate, pc_) || code_age_stub()->IsCode());
@@ skipping 1040 matching lines @@
 
 
 void Assembler::DataAlign(int m) {
   DCHECK(m >= 2 && base::bits::IsPowerOfTwo32(m));
   while ((pc_offset() & (m - 1)) != 0) {
     db(0);
   }
 }
 }  // namespace internal
 }  // namespace v8