[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/module-decoder.h"
 #include "src/wasm/wasm-module.h"
 
 #define TRACE(...)                                      \
@@ skipping 33 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(), static_cast<double>(kMaxUInt32));
+  CHECK_LE(num->value(), 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(), static_cast<double>(Smi::kMinValue));
-  CHECK_LE(num->value(), static_cast<double>(Smi::kMaxValue));
+  CHECK_GE(num->value(), Smi::kMinValue);
+  CHECK_LE(num->value(), 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 311 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(static_cast<size_t>(bytes->length()), function.name_offset);
-  DCHECK_GE(static_cast<size_t>(bytes->length() - function.name_offset),
-            function.name_length);
+  DCHECK_GE(bytes->length(), function.name_offset);
+  DCHECK_GE(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(static_cast<uint32_t>(kMaxInt),
-            functions[func_index].code_start_offset);
+  DCHECK_GE(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 44 matching lines @@
 
   AsmJsOffsetsResult asm_offsets;
   {
     DisallowHeapAllocation no_gc;
     const byte* bytes_start = offset_table->GetDataStartAddress();
     const byte* bytes_end = bytes_start + offset_table->length() - 1;
     asm_offsets = wasm::DecodeAsmJsOffsets(bytes_start, bytes_end);
   }
   // Wasm bytes must be valid and must contain asm.js offset table.
   DCHECK(asm_offsets.ok());
-  DCHECK_GE(static_cast<size_t>(kMaxInt), asm_offsets.val.size());
+  DCHECK_GE(kMaxInt, asm_offsets.val.size());
   int num_functions = static_cast<int>(asm_offsets.val.size());
   int num_imported_functions =
       static_cast<int>(compiled_module->module()->num_imported_functions);
   DCHECK_EQ(compiled_module->module()->functions.size(),
             static_cast<size_t>(num_functions) + num_imported_functions);
   // One byte to encode that this is a decoded table.
   int total_size = 1;
   for (int func = 0; func < num_functions; ++func) {
     size_t new_size = asm_offsets.val[func].size() * 2 * kIntSize;
     DCHECK_LE(new_size, static_cast<size_t>(kMaxInt) - total_size);
@@ skipping 80 matching lines @@
       !array->get(kPreviousInstanceWrapper)->IsFixedArray())
     return false;
   return true;
 }
 
 void WasmInstanceWrapper::set_instance_object(Handle<JSObject> instance,
                                               Isolate* isolate) {
   Handle<WeakCell> cell = isolate->factory()->NewWeakCell(instance);
   set(kWrapperInstanceObject, *cell);
 }