Implement UnaligedLoad and UnaligedStore turbofan 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 2877 matching lines @@
   BoundsCheckMem(memtype, index, offset, position);
   bool aligned = static_cast<int>(alignment) >=
                  ElementSizeLog2Of(memtype.representation());
 
   if (aligned ||
       jsgraph()->machine()->UnalignedLoadSupported(memtype, alignment)) {
     load = graph()->NewNode(jsgraph()->machine()->Load(memtype),
                             MemBuffer(offset), index, *effect_, *control_);
     *effect_ = load;
   } else {
-    load = BuildUnalignedLoad(type, memtype, index, offset, alignment);
+    if (jsgraph()->machine()->UnalignedLoad(memtype).IsSupported()) {
+      load = graph()->NewNode(jsgraph()->machine()->UnalignedLoad(memtype).op(),
+                              MemBuffer(offset), index, *effect_, *control_);
+      *effect_ = load;
+    } else {
+      load = BuildUnalignedLoad(type, memtype, index, offset, alignment);

[titzer, 2016/07/11 08:40:00]

I thought this routine would go away. Is it the case that the only other
platform that doesn't support unaligned accesses is arm, and the instruction
selector/code generator must implement this?

Otherwise, we end up with the complexity of both solutions :(

[ivica.bogosavljevic, 2016/07/11 09:34:43]

Agreed. In that case we'll make UnalignedLoad/UnalignedStore mandatory operator,
but it will never be called for those architectures that support unaligned
access. And the BuildUnalignedLoad goes away.

+    }
   }
 #if defined(V8_TARGET_BIG_ENDIAN)
   // TODO(john.yan) Implement byte swap turbofan operator
   // and use it if available for better performance
   load = BuildChangeEndianness(load, memtype, type);
 #endif
 
   if (type == wasm::kAstI64 &&
       ElementSizeLog2Of(memtype.representation()) < 3) {
     // TODO(titzer): TF zeroes the upper bits of 64-bit loads for subword sizes.
@@ skipping 120 matching lines @@
 #endif
 
   if (aligned ||
       jsgraph()->machine()->UnalignedStoreSupported(memtype, alignment)) {
     StoreRepresentation rep(memtype.representation(), kNoWriteBarrier);
     store =
         graph()->NewNode(jsgraph()->machine()->Store(rep), MemBuffer(offset),
                          index, val, *effect_, *control_);
     *effect_ = store;
   } else {
-    store = BuildUnalignedStore(memtype, index, offset, alignment, val);
+    UnalignedStoreRepresentation rep(memtype.representation());
+
+    if (jsgraph()->machine()->UnalignedStore(rep).IsSupported()) {
+      store =
+          graph()->NewNode(jsgraph()->machine()->UnalignedStore(rep).op(),
+                           MemBuffer(offset), index, val, *effect_, *control_);
+      *effect_ = store;
+    } else {
+      store = BuildUnalignedStore(memtype, index, offset, alignment, val);
+    }
   }
 
   return store;
 }
 
 Node* WasmGraphBuilder::BuildAsmjsLoadMem(MachineType type, Node* index) {
   // TODO(turbofan): fold bounds checks for constant asm.js loads.
   // asm.js semantics use CheckedLoad (i.e. OOB reads return 0ish).
   const Operator* op = jsgraph()->machine()->CheckedLoad(type);
   Node* load = graph()->NewNode(op, MemBuffer(0), index, MemSize(0), *effect_,
@@ skipping 414 matching lines @@
                             function_->code_start_offset),
            compile_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8