Revert of [compiler] Add relocatable pointer constants for wasm memory references.

test/cctest/compiler/test-run-wasm-machops.cc

-// Copyright 2016 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 <cmath>
-#include <functional>
-#include <limits>
-
-#include "src/base/bits.h"
-#include "src/base/utils/random-number-generator.h"
-#include "src/codegen.h"
-#include "test/cctest/cctest.h"
-#include "test/cctest/compiler/codegen-tester.h"
-#include "test/cctest/compiler/graph-builder-tester.h"
-#include "test/cctest/compiler/value-helper.h"
-
-using namespace v8::internal;
-using namespace v8::internal::compiler;
-
-static void UpdateMemoryReferences(Handle<Code> code, Address old_base,
-                                   Address new_base, size_t old_size,
-                                   size_t new_size) {
-  Isolate* isolate = CcTest::i_isolate();
-  bool modified = false;
-  int mode_mask = (1 << RelocInfo::WASM_MEMORY_REFERENCE);
-  for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
-    RelocInfo::Mode mode = it.rinfo()->rmode();
-    if (RelocInfo::IsWasmMemoryReference(mode)) {
-      // Patch addresses with change in memory start address
-      it.rinfo()->update_wasm_memory_reference(old_base, new_base, old_size,
-                                               new_size);
-      modified = true;
-    }
-  }
-  if (modified) {
-    Assembler::FlushICache(isolate, code->instruction_start(),
-                           code->instruction_size());
-  }
-}
-
-template <typename CType>
-static void RunLoadStoreRelocation(MachineType rep) {
-  const int kNumElems = 2;
-  CType buffer[kNumElems];
-  CType new_buffer[kNumElems];
-  byte* raw = reinterpret_cast<byte*>(buffer);
-  byte* new_raw = reinterpret_cast<byte*>(new_buffer);
-  for (size_t i = 0; i < sizeof(buffer); i++) {
-    raw[i] = static_cast<byte>((i + sizeof(CType)) ^ 0xAA);
-    new_raw[i] = static_cast<byte>((i + sizeof(CType)) ^ 0xAA);
-  }
-  int32_t OK = 0x29000;
-  RawMachineAssemblerTester<uint32_t> m;
-  Node* base = m.RelocatableIntPtrConstant(reinterpret_cast<intptr_t>(raw),
-                                           RelocInfo::WASM_MEMORY_REFERENCE);
-  Node* base1 = m.RelocatableIntPtrConstant(
-      reinterpret_cast<intptr_t>(raw + sizeof(CType)),
-      RelocInfo::WASM_MEMORY_REFERENCE);
-  Node* index = m.Int32Constant(0);
-  Node* load = m.Load(rep, base, index);
-  m.Store(rep.representation(), base1, index, load, kNoWriteBarrier);
-  m.Return(m.Int32Constant(OK));
-  CHECK(buffer[0] != buffer[1]);
-  CHECK_EQ(OK, m.Call());
-  CHECK(buffer[0] == buffer[1]);
-  m.GenerateCode();
-  Handle<Code> code = m.GetCode();
-  UpdateMemoryReferences(code, raw, new_raw, sizeof(buffer),
-                         sizeof(new_buffer));
-  CHECK(new_buffer[0] != new_buffer[1]);
-  CHECK_EQ(OK, m.Call());
-  CHECK(new_buffer[0] == new_buffer[1]);
-}
-
-TEST(RunLoadStoreRelocation) {
-  RunLoadStoreRelocation<int8_t>(MachineType::Int8());
-  RunLoadStoreRelocation<uint8_t>(MachineType::Uint8());
-  RunLoadStoreRelocation<int16_t>(MachineType::Int16());
-  RunLoadStoreRelocation<uint16_t>(MachineType::Uint16());
-  RunLoadStoreRelocation<int32_t>(MachineType::Int32());
-  RunLoadStoreRelocation<uint32_t>(MachineType::Uint32());
-  RunLoadStoreRelocation<void*>(MachineType::AnyTagged());
-  RunLoadStoreRelocation<float>(MachineType::Float32());
-  RunLoadStoreRelocation<double>(MachineType::Float64());
-}
-
-template <typename CType>
-static void RunLoadStoreRelocationOffset(MachineType rep) {
-  RawMachineAssemblerTester<int32_t> r(MachineType::Int32());
-  const int kNumElems = 4;
-  CType buffer[kNumElems];
-  CType new_buffer[kNumElems + 1];
-
-  for (int32_t x = 0; x < kNumElems; x++) {
-    int32_t y = kNumElems - x - 1;
-    // initialize the buffer with raw data.
-    byte* raw = reinterpret_cast<byte*>(buffer);
-    for (size_t i = 0; i < sizeof(buffer); i++) {
-      raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
-    }
-
-    RawMachineAssemblerTester<int32_t> m;
-    int32_t OK = 0x29000 + x;
-    Node* base = m.RelocatableIntPtrConstant(reinterpret_cast<intptr_t>(buffer),
-                                             RelocInfo::WASM_MEMORY_REFERENCE);
-    Node* index0 = m.IntPtrConstant(x * sizeof(buffer[0]));
-    Node* load = m.Load(rep, base, index0);
-    Node* index1 = m.IntPtrConstant(y * sizeof(buffer[0]));
-    m.Store(rep.representation(), base, index1, load, kNoWriteBarrier);
-    m.Return(m.Int32Constant(OK));
-
-    CHECK(buffer[x] != buffer[y]);
-    CHECK_EQ(OK, m.Call());
-    CHECK(buffer[x] == buffer[y]);
-    m.GenerateCode();
-
-    // Initialize new buffer and set old_buffer to 0
-    byte* new_raw = reinterpret_cast<byte*>(new_buffer);
-    for (size_t i = 0; i < sizeof(buffer); i++) {
-      raw[i] = 0;
-      new_raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
-    }
-
-    // Perform relocation on generated code
-    Handle<Code> code = m.GetCode();
-    UpdateMemoryReferences(code, raw, new_raw, sizeof(buffer),
-                           sizeof(new_buffer));
-
-    CHECK(new_buffer[x] != new_buffer[y]);
-    CHECK_EQ(OK, m.Call());
-    CHECK(new_buffer[x] == new_buffer[y]);
-  }
-}
-
-TEST(RunLoadStoreRelocationOffset) {
-  RunLoadStoreRelocationOffset<int8_t>(MachineType::Int8());
-  RunLoadStoreRelocationOffset<uint8_t>(MachineType::Uint8());
-  RunLoadStoreRelocationOffset<int16_t>(MachineType::Int16());
-  RunLoadStoreRelocationOffset<uint16_t>(MachineType::Uint16());
-  RunLoadStoreRelocationOffset<int32_t>(MachineType::Int32());
-  RunLoadStoreRelocationOffset<uint32_t>(MachineType::Uint32());
-  RunLoadStoreRelocationOffset<void*>(MachineType::AnyTagged());
-  RunLoadStoreRelocationOffset<float>(MachineType::Float32());
-  RunLoadStoreRelocationOffset<double>(MachineType::Float64());
-}