[wasm] Cleanup the wasm-call fuzzer

test/fuzzer/wasm-call.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 <stddef.h>
 #include <stdint.h>
 
 #include "include/v8.h"
 #include "src/isolate.h"
 #include "src/objects.h"
+#include "src/utils.h"
 #include "src/wasm/wasm-interpreter.h"
 #include "src/wasm/wasm-module-builder.h"
 #include "src/wasm/wasm-module.h"
 #include "test/common/wasm/test-signatures.h"
 #include "test/common/wasm/wasm-module-runner.h"
 #include "test/fuzzer/fuzzer-support.h"
 
 #define WASM_CODE_FUZZER_HASH_SEED 83
 #define MAX_NUM_FUNCTIONS 3
 #define MAX_NUM_PARAMS 3
 
-#define FUZZER_TYPE_FLOAT32 0
-#define FUZZER_TYPE_FLOAT64 1
-#define FUZZER_TYPE_INT32 2
-#define FUZZER_TYPE_INT64 3
-
 using namespace v8::internal::wasm;
 
 template <typename V>
 static inline V read_value(const uint8_t** data, size_t* size, bool* ok) {
   // The status flag {ok} checks that the decoding up until now was okay, and
   // that a value of type V can be read without problems.
   *ok &= (*size > sizeof(V));
   if (!(*ok)) return 0;
-  V result = *reinterpret_cast<const V*>(*data);
+  V result = v8::internal::ReadLittleEndianValue<V>(*data);
   *data += sizeof(V);
   *size -= sizeof(V);
   return result;
 }
 
 static void add_argument(
-    v8::internal::Isolate* isolate, uint8_t type, WasmVal* interpreter_args,
+    v8::internal::Isolate* isolate, LocalType type, WasmVal* interpreter_args,
     v8::internal::Handle<v8::internal::Object>* compiled_args, int* argc,
     const uint8_t** data, size_t* size, bool* ok) {
   if (!(*ok)) return;
   switch (type) {
-    case FUZZER_TYPE_FLOAT32: {
+    case kAstF32: {
       float value = read_value<float>(data, size, ok);
       interpreter_args[*argc] = WasmVal(value);
       compiled_args[*argc] =
           isolate->factory()->NewNumber(static_cast<double>(value));
       break;
     }
-    case FUZZER_TYPE_FLOAT64: {
+    case kAstF64: {
       double value = read_value<double>(data, size, ok);
       interpreter_args[*argc] = WasmVal(value);
       compiled_args[*argc] = isolate->factory()->NewNumber(value);
       break;
     }
-    case FUZZER_TYPE_INT32: {
+    case kAstI32: {
       int32_t value = read_value<int32_t>(data, size, ok);
       interpreter_args[*argc] = WasmVal(value);
       compiled_args[*argc] =
           isolate->factory()->NewNumber(static_cast<double>(value));
       break;
     }
     default:
       UNREACHABLE();
   }
   (*argc)++;
@@ skipping 28 matching lines @@
   int argc = 0;
 
   WasmModuleBuilder builder(&zone);
   for (int fun = 0; fun < num_functions; fun++) {
     size_t num_params = static_cast<size_t>(
         (read_value<uint8_t>(&data, &size, &ok) % MAX_NUM_PARAMS) + 1);
     FunctionSig::Builder sig_builder(&zone, 1, num_params);
     sig_builder.AddReturn(kAstI32);
     for (size_t param = 0; param < num_params; param++) {
       // The main function cannot handle int64 parameters.
-      uint8_t param_type = (read_value<uint8_t>(&data, &size, &ok) %
-                            (arraysize(types) - (fun == 0 ? 1 : 0)));
-      sig_builder.AddParam(types[param_type]);
+      LocalType param_type = types[(read_value<uint8_t>(&data, &size, &ok) %
+                                    (arraysize(types) - (fun == 0 ? 1 : 0)))];
+      sig_builder.AddParam(param_type);
       if (fun == 0) {
         add_argument(i_isolate, param_type, interpreter_args, compiled_args,
                      &argc, &data, &size, &ok);
       }
     }
     v8::internal::wasm::WasmFunctionBuilder* f =
         builder.AddFunction(sig_builder.Build());
     uint32_t code_size = static_cast<uint32_t>(size / num_functions);
     f->EmitCode(data, code_size);
     data += code_size;
@@ skipping 56 matching lines @@
     // result_compiled. Therefore we do not check the equality of the results
     // if the execution may have produced a NaN at some point.
     if (!possible_nondeterminism && (result_interpreted != result_compiled)) {
       V8_Fatal(__FILE__, __LINE__, "WasmCodeFuzzerHash=%x",
                v8::internal::StringHasher::HashSequentialString(
                    data, static_cast<int>(size), WASM_CODE_FUZZER_HASH_SEED));
     }
   }
   return 0;
 }