Revert of [base] Define CHECK comparison for signed vs. unsigned

src/wasm/wasm-objects.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/wasm/wasm-objects.h"
 #include "src/wasm/wasm-module.h"
 
 #define TRACE(...)                                      \
   do {                                                  \
     if (FLAG_trace_wasm_instances) PrintF(__VA_ARGS__); \
@@ skipping 31 matching lines @@
 
 static uint32_t SafeUint32(Object* value) {
   if (value->IsSmi()) {
     int32_t val = Smi::cast(value)->value();
     CHECK_GE(val, 0);
     return static_cast<uint32_t>(val);
   }
   DCHECK(value->IsHeapNumber());
   HeapNumber* num = HeapNumber::cast(value);
   CHECK_GE(num->value(), 0.0);
-  CHECK_LE(num->value(), kMaxUInt32);
+  CHECK_LE(num->value(), static_cast<double>(kMaxUInt32));
   return static_cast<uint32_t>(num->value());
 }
 
 static int32_t SafeInt32(Object* value) {
   if (value->IsSmi()) {
     return Smi::cast(value)->value();
   }
   DCHECK(value->IsHeapNumber());
   HeapNumber* num = HeapNumber::cast(value);
-  CHECK_GE(num->value(), Smi::kMinValue);
-  CHECK_LE(num->value(), Smi::kMaxValue);
+  CHECK_GE(num->value(), static_cast<double>(Smi::kMinValue));
+  CHECK_LE(num->value(), static_cast<double>(Smi::kMaxValue));
   return static_cast<int32_t>(num->value());
 }
 
 Handle<WasmModuleObject> WasmModuleObject::New(
     Isolate* isolate, Handle<WasmCompiledModule> compiled_module) {
   ModuleOrigin origin = compiled_module->module()->origin;
 
   Handle<JSObject> module_object;
   if (origin == ModuleOrigin::kWasmOrigin) {
     Handle<JSFunction> module_cons(
@@ skipping 290 matching lines @@
 
 uint32_t WasmCompiledModule::default_mem_size() const {
   return min_mem_pages() * WasmModule::kPageSize;
 }
 
 Vector<const uint8_t> WasmCompiledModule::GetRawFunctionName(
     uint32_t func_index) {
   DCHECK_GT(module()->functions.size(), func_index);
   WasmFunction& function = module()->functions[func_index];
   SeqOneByteString* bytes = ptr_to_module_bytes();
-  DCHECK_GE(bytes->length(), function.name_offset);
-  DCHECK_GE(bytes->length() - function.name_offset, function.name_length);
+  DCHECK_GE(static_cast<size_t>(bytes->length()), function.name_offset);
+  DCHECK_GE(static_cast<size_t>(bytes->length() - function.name_offset),
+            function.name_length);
   return Vector<const uint8_t>(bytes->GetCharsAddress() + function.name_offset,
                                function.name_length);
 }
 
 int WasmCompiledModule::GetFunctionOffset(uint32_t func_index) const {
   std::vector<WasmFunction>& functions = module()->functions;
   if (static_cast<uint32_t>(func_index) >= functions.size()) return -1;
-  DCHECK_GE(kMaxInt, functions[func_index].code_start_offset);
+  DCHECK_GE(static_cast<uint32_t>(kMaxInt),
+            functions[func_index].code_start_offset);
   return static_cast<int>(functions[func_index].code_start_offset);
 }
 
 int WasmCompiledModule::GetContainingFunction(uint32_t byte_offset) const {
   std::vector<WasmFunction>& functions = module()->functions;
 
   // Binary search for a function containing the given position.
   int left = 0;                                    // inclusive
   int right = static_cast<int>(functions.size());  // exclusive
   if (right == 0) return false;
@@ skipping 21 matching lines @@
   if (func_index < 0) return false;
 
   WasmFunction& function = module()->functions[func_index];
 
   info->line = func_index;
   info->column = position - function.code_start_offset;
   info->line_start = function.code_start_offset;
   info->line_end = function.code_end_offset;
   return true;
 }