Implement optional turbofan UnalignedLoad and UnalignedStore operators

src/compiler/wasm-compiler.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/compiler/wasm-compiler.h"
 
 #include "src/isolate-inl.h"
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/base/platform/platform.h"
@@ skipping 2248 matching lines @@
     size_t limit = size - offset - memsize;
     CHECK(limit <= kMaxUInt32);
     cond = graph()->NewNode(
         jsgraph()->machine()->Uint32LessThanOrEqual(), index,
         jsgraph()->Int32Constant(static_cast<uint32_t>(limit)));
   }
 
   trap_->AddTrapIfFalse(kTrapMemOutOfBounds, cond);
 }
 
-
 Node* WasmGraphBuilder::LoadMem(wasm::LocalType type, MachineType memtype,
-                                Node* index, uint32_t offset) {
+                                Node* index, uint32_t offset,
+                                uint32_t alignment) {
   Node* load;
 
   if (module_ && module_->asm_js()) {
     // asm.js semantics use CheckedLoad (i.e. OOB reads return 0ish).
     DCHECK_EQ(0, offset);
     const Operator* op = jsgraph()->machine()->CheckedLoad(memtype);
     load = graph()->NewNode(op, MemBuffer(0), index, MemSize(0), *effect_,
                             *control_);
   } else {
     // WASM semantics throw on OOB. Introduce explicit bounds check.
     BoundsCheckMem(memtype, index, offset);
-    load = graph()->NewNode(jsgraph()->machine()->Load(memtype),
-                            MemBuffer(offset), index, *effect_, *control_);
+    bool aligned = alignment >= ElementSizeLog2Of(memtype.representation());
+    if (aligned ||
+        !jsgraph()->machine()->UnalignedLoad(memtype).IsSupported()) {
+      load = graph()->NewNode(jsgraph()->machine()->Load(memtype),
+                              MemBuffer(offset), index, *effect_, *control_);
+    } else {
+      load = graph()->NewNode(jsgraph()->machine()->UnalignedLoad(memtype).op(),
+                              MemBuffer(offset), index, *effect_, *control_);
+    }
   }
 
   *effect_ = load;
 
   if (type == wasm::kAstI64 &&
       ElementSizeLog2Of(memtype.representation()) < 3) {
     // TODO(titzer): TF zeroes the upper bits of 64-bit loads for subword sizes.
     if (memtype.IsSigned()) {
       // sign extend
       load = graph()->NewNode(jsgraph()->machine()->ChangeInt32ToInt64(), load);
     } else {
       // zero extend
       load =
           graph()->NewNode(jsgraph()->machine()->ChangeUint32ToUint64(), load);
     }
   }
 
   return load;
 }
 
-
 Node* WasmGraphBuilder::StoreMem(MachineType memtype, Node* index,
-                                 uint32_t offset, Node* val) {
+                                 uint32_t offset, uint32_t alignment,
+                                 Node* val) {
   Node* store;
   if (module_ && module_->asm_js()) {
     // asm.js semantics use CheckedStore (i.e. ignore OOB writes).
     DCHECK_EQ(0, offset);
     const Operator* op =
         jsgraph()->machine()->CheckedStore(memtype.representation());
     store = graph()->NewNode(op, MemBuffer(0), index, MemSize(0), val, *effect_,
                              *control_);
   } else {
     // WASM semantics throw on OOB. Introduce explicit bounds check.
     BoundsCheckMem(memtype, index, offset);
-    StoreRepresentation rep(memtype.representation(), kNoWriteBarrier);
-    store =
-        graph()->NewNode(jsgraph()->machine()->Store(rep), MemBuffer(offset),
-                         index, val, *effect_, *control_);
+    bool aligned = alignment >= ElementSizeLog2Of(memtype.representation());
+    if (aligned ||
+        !jsgraph()
+             ->machine()
+             ->UnalignedStore(memtype.representation())
+             .IsSupported()) {
+      StoreRepresentation rep(memtype.representation(), kNoWriteBarrier);
+      store =
+          graph()->NewNode(jsgraph()->machine()->Store(rep), MemBuffer(offset),
+                           index, val, *effect_, *control_);
+    } else {
+      store = graph()->NewNode(
+          jsgraph()->machine()->UnalignedStore(memtype.representation()).op(),
+          MemBuffer(offset), index, val, *effect_, *control_);
+    }
   }
   *effect_ = store;
   return store;
 }
 
 
 void WasmGraphBuilder::PrintDebugName(Node* node) {
   PrintF("#%d:%s", node->id(), node->op()->mnemonic());
 }
 
@@ skipping 320 matching lines @@
         static_cast<int>(function.code_end_offset - function.code_start_offset),
         decode_ms, static_cast<int>(graph.NodeCount()), compile_ms);
   }
   return code;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8