[wasm] Use MachineOperatorBuilder::word() instead of kPointerSize to determine the word size.

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/platform.h"
 
@@ skipping 844 matching lines @@
     // kExprI32ConvertI64:
     // kExprI64SConvertI32:
     // kExprI64UConvertI32:
     // kExprF64ReinterpretI64:
     // kExprI64ReinterpretF64:
     // kExprI64Clz:
     // kExprI64Ctz:
     // kExprI64Popcnt:
     // kExprF32SConvertI64:
     case wasm::kExprF32SConvertI64:
-      if (kPointerSize == 4) {
+      if (m->Is32()) {
         return BuildF32SConvertI64(input);
       }
       op = m->RoundInt64ToFloat32();
       break;
     // kExprF32UConvertI64:
     case wasm::kExprF32UConvertI64:
-      if (kPointerSize == 4) {
+      if (m->Is32()) {
         return BuildF32UConvertI64(input);
       }
       op = m->RoundUint64ToFloat32();
       break;
     // kExprF64SConvertI64:
     case wasm::kExprF64SConvertI64:
-      if (kPointerSize == 4) {
+      if (m->Is32()) {
         return BuildF64SConvertI64(input);
       }
       op = m->RoundInt64ToFloat64();
       break;
     // kExprF64UConvertI64:
     case wasm::kExprF64UConvertI64:
-      if (kPointerSize == 4) {
+      if (m->Is32()) {
         return BuildF64UConvertI64(input);
       }
       op = m->RoundUint64ToFloat64();
       break;
 // kExprI64SConvertF32:
 // kExprI64SConvertF64:
 // kExprI64UConvertF32:
 // kExprI64UConvertF64:
 #if WASM_64
     // Opcodes only supported on 64-bit platforms.
@@ skipping 1292 matching lines @@
 
 Node* WasmGraphBuilder::String(const char* string) {
   return jsgraph()->Constant(
       jsgraph()->isolate()->factory()->NewStringFromAsciiChecked(string));
 }
 
 
 Graph* WasmGraphBuilder::graph() { return jsgraph()->graph(); }
 
 void WasmGraphBuilder::Int64LoweringForTesting() {
-  if (kPointerSize == 4) {
+  if (jsgraph()->machine()->Is32()) {
     Int64Lowering r(jsgraph()->graph(), jsgraph()->machine(),
                     jsgraph()->common(), jsgraph()->zone(),
                     function_signature_);
     r.LowerGraph();
   }
 }
 
 static void RecordFunctionCompilation(Logger::LogEventsAndTags tag,
                                       CompilationInfo* info,
                                       const char* message, uint32_t index,
@@ skipping 225 matching lines @@
     SNPrintF(buffer, "Compiling WASM function #%d:%s failed:",
              function.func_index,
              module_env->module->GetName(function.name_offset));
     thrower.Failed(buffer.start(), result);
     return Handle<Code>::null();
   }
 
   // Run the compiler pipeline to generate machine code.
   CallDescriptor* descriptor =
       wasm::ModuleEnv::GetWasmCallDescriptor(&zone, function.sig);
-  if (kPointerSize == 4) {
+  if (machine.Is32()) {
     descriptor = module_env->GetI32WasmCallDescriptor(&zone, descriptor);
   }
   Code::Flags flags = Code::ComputeFlags(Code::WASM_FUNCTION);
   // add flags here if a meaningful name is helpful for debugging.
   bool debugging =
 #if DEBUG
       true;
 #else
       FLAG_print_opt_code || FLAG_trace_turbo || FLAG_trace_turbo_graph;
 #endif
@@ skipping 18 matching lines @@
         module_env->module->GetName(function.name_offset));
   }
 
   return code;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8