MIPS: Fix unaligned read/write operations in wasm.

src/wasm/ast-decoder.cc

 // Copyright 2015 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/base/platform/elapsed-timer.h"
 #include "src/signature.h"
 
 #include "src/flags.h"
 #include "src/handles.h"
 #include "src/zone-containers.h"
@@ skipping 376 matching lines @@
             error("improperly nested conditional branch");
           }
           len = 2;
           break;
         }
         case kExprTableSwitch: {
           if (!checkAvailable(5)) {
             error("expected #tableswitch <cases> <table>, fell off end");
             break;
           }
-          uint16_t case_count = *reinterpret_cast<const uint16_t*>(pc_ + 1);
-          uint16_t table_count = *reinterpret_cast<const uint16_t*>(pc_ + 3);
+          uint16_t case_count = ReadUnalignedUInt16(pc_ + 1);
+          uint16_t table_count = ReadUnalignedUInt16(pc_ + 3);
           len = 5 + table_count * 2;
 
           if (table_count == 0) {
             error("tableswitch with 0 entries");
             break;
           }
 
           if (!checkAvailable(len)) {
             error("expected #tableswitch <cases> <table>, fell off end");
             break;
           }
 
           Shift(kAstEnd, 1 + case_count);
 
           // Verify table.
           for (int i = 0; i < table_count; i++) {
-            uint16_t target =
-                *reinterpret_cast<const uint16_t*>(pc_ + 5 + i * 2);
+            uint16_t target = ReadUnalignedUInt16(pc_ + 5 + i * 2);
+
             if (target >= 0x8000) {
               size_t depth = target - 0x8000;
               if (depth > blocks_.size()) {
                 error(pc_ + 5 + i * 2, "improper branch in tableswitch");
               }
             } else {
               if (target >= case_count) {
                 error(pc_ + 5 + i * 2, "invalid case target in tableswitch");
               }
             }
@@ skipping 371 matching lines @@
           SsaEnv* tenv = Split(fenv);
           BUILD(Branch, p->tree->children[0]->node, &tenv->control,
                 &fenv->control);
           ssa_env_ = tenv;
           ReduceBreakToExprBlock(p, block);
           ssa_env_ = fenv;
         }
         break;
       }
       case kExprTableSwitch: {
-        uint16_t table_count = *reinterpret_cast<const uint16_t*>(p->pc() + 3);
+        uint16_t table_count = ReadUnalignedUInt16(p->pc() + 3);
         if (table_count == 1) {
           // Degenerate switch with only a default target.
           if (p->index == 1) {
             SsaEnv* break_env = ssa_env_;
             PushBlock(break_env);
             SetEnv("switch:default", Steal(break_env));
           }
           if (p->done()) {
             Block* block = &blocks_.back();
             // fall through to the end.
             ReduceBreakToExprBlock(p, block);
             SetEnv("switch:end", block->ssa_env);
             blocks_.pop_back();
           }
           break;
         }
 
         if (p->index == 1) {
           // Switch key finished.
           TypeCheckLast(p, kAstI32);
 
           TFNode* sw = BUILD(Switch, table_count, p->last()->node);
 
           // Allocate environments for each case.
-          uint16_t case_count = *reinterpret_cast<const uint16_t*>(p->pc() + 1);
+          uint16_t case_count = ReadUnalignedUInt16(p->pc() + 1);
           SsaEnv** case_envs = zone_->NewArray<SsaEnv*>(case_count);
           for (int i = 0; i < case_count; i++) {
             case_envs[i] = UnreachableEnv();
           }
 
           ifs_.push_back({nullptr, nullptr, case_envs});
           SsaEnv* break_env = ssa_env_;
           PushBlock(break_env);
           SsaEnv* copy = Steal(break_env);
           ssa_env_ = copy;
 
           // Build the environments for each case based on the table.
           const uint16_t* table =
               reinterpret_cast<const uint16_t*>(p->pc() + 5);
           for (int i = 0; i < table_count; i++) {
-            uint16_t target = table[i];
+            uint16_t target = ReadUnalignedUInt16(table + i);
             SsaEnv* env = Split(copy);
             env->control = (i == table_count - 1) ? BUILD(IfDefault, sw)
                                                   : BUILD(IfValue, i, sw);
             if (target >= 0x8000) {
               // Targets an outer block.
               int depth = target - 0x8000;
               SsaEnv* tenv = blocks_[blocks_.size() - depth - 1].ssa_env;
               Goto(env, tenv);
             } else {
               // Targets a case.
@@ skipping 440 matching lines @@
           break;
         case 4:
           msg = "Expected 4-byte operand following opcode";
           break;
         default:
           break;
       }
       error(pc, msg);
       return -1;
     }
-    return *reinterpret_cast<const V*>(pc + 1);
+    return ReadUnalignedValue<V>(pc + 1);
   }
 
   int EnvironmentCount() {
     if (builder_) return static_cast<int>(function_env_->GetLocalCount());
     return 0;  // if we aren't building a graph, don't bother with SSA renaming.
   }
 
   LocalType LocalOperand(const byte* pc, uint32_t* index, int* length) {
     *index = UnsignedLEB128Operand(pc, length);
     if (function_env_->IsValidLocal(*index)) {
@@ skipping 174 matching lines @@
     case kExprLoadGlobal:
     case kExprCallFunction:
     case kExprCallIndirect:
     case kExprGetLocal: {
       int length;
       uint32_t result = 0;
       ReadUnsignedLEB128Operand(pc + 1, pc + 6, &length, &result);
       return 1 + length;
     }
     case kExprTableSwitch: {
-      uint16_t table_count = *reinterpret_cast<const uint16_t*>(pc + 3);
+      uint16_t table_count = ReadUnalignedUInt16(pc + 3);
       return 5 + table_count * 2;
     }
 
     default:
       return 1;
   }
 }
 
 
 int OpcodeArity(FunctionEnv* env, const byte* pc) {
@@ skipping 58 matching lines @@
       FOREACH_MISC_MEM_OPCODE(DECLARE_OPCODE_CASE)
       FOREACH_SIMPLE_OPCODE(DECLARE_OPCODE_CASE)
 #undef DECLARE_OPCODE_CASE
   }
   UNREACHABLE();
   return 0;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8