Revert "Make GCC happy again." and "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.".

test/cctest/test-assembler-x64.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 33 matching lines @@
 // The AMD64 calling convention is used, with the first six arguments
 // in RDI, RSI, RDX, RCX, R8, and R9, and floating point arguments in
 // the XMM registers.  The return value is in RAX.
 // This calling convention is used on Linux, with GCC, and on Mac OS,
 // with GCC.  A different convention is used on 64-bit windows,
 // where the first four integer arguments are passed in RCX, RDX, R8 and R9.
 
 typedef int (*F0)();
 typedef int (*F1)(int64_t x);
 typedef int (*F2)(int64_t x, int64_t y);
-typedef unsigned (*F3)(double x);
-typedef uint64_t (*F4)(uint64_t* x, uint64_t* y);
-typedef uint64_t (*F5)(uint64_t x);
+typedef int (*F3)(double x);
+typedef int64_t (*F4)(int64_t* x, int64_t* y);
+typedef int64_t (*F5)(int64_t x);
 
 #ifdef _WIN64
 static const Register arg1 = rcx;
 static const Register arg2 = rdx;
 #else
 static const Register arg1 = rdi;
 static const Register arg2 = rsi;
 #endif
 
 #define __ assm.
@@ skipping 146 matching lines @@
   __ movq(rax, Operand(arg1, 0));
   __ movq(r11, Operand(arg2, 0));
   __ xchgl(rax, r11);
   __ movq(Operand(arg1, 0), rax);
   __ movq(Operand(arg2, 0), r11);
   __ ret(0);
 
   CodeDesc desc;
   assm.GetCode(&desc);
   // Call the function from C++.
-  uint64_t left = V8_2PART_UINT64_C(0x10000000, 20000000);
-  uint64_t right = V8_2PART_UINT64_C(0x30000000, 40000000);
-  uint64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
+  int64_t left   = V8_2PART_UINT64_C(0x10000000, 20000000);
+  int64_t right  = V8_2PART_UINT64_C(0x30000000, 40000000);
+  int64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
   CHECK_EQ(V8_2PART_UINT64_C(0x00000000, 40000000), left);
   CHECK_EQ(V8_2PART_UINT64_C(0x00000000, 20000000), right);
   USE(result);
 }
 
 
 TEST(AssemblerX64OrlOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   __ movq(rax, Operand(arg2, 0));
   __ orl(Operand(arg1, 0), rax);
   __ ret(0);
 
   CodeDesc desc;
   assm.GetCode(&desc);
   // Call the function from C++.
-  uint64_t left = V8_2PART_UINT64_C(0x10000000, 20000000);
-  uint64_t right = V8_2PART_UINT64_C(0x30000000, 40000000);
-  uint64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
+  int64_t left   = V8_2PART_UINT64_C(0x10000000, 20000000);
+  int64_t right  = V8_2PART_UINT64_C(0x30000000, 40000000);
+  int64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
   CHECK_EQ(V8_2PART_UINT64_C(0x10000000, 60000000), left);
   USE(result);
 }
 
 
 TEST(AssemblerX64RollOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   __ movq(rax, arg1);
   __ roll(rax, Immediate(1));
   __ ret(0);
 
   CodeDesc desc;
   assm.GetCode(&desc);
   // Call the function from C++.
-  uint64_t src = V8_2PART_UINT64_C(0x10000000, C0000000);
-  uint64_t result = FUNCTION_CAST<F5>(buffer)(src);
+  int64_t src    = V8_2PART_UINT64_C(0x10000000, C0000000);
+  int64_t result = FUNCTION_CAST<F5>(buffer)(src);
   CHECK_EQ(V8_2PART_UINT64_C(0x00000000, 80000001), result);
 }
 
 
 TEST(AssemblerX64SublOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   __ movq(rax, Operand(arg2, 0));
   __ subl(Operand(arg1, 0), rax);
   __ ret(0);
 
   CodeDesc desc;
   assm.GetCode(&desc);
   // Call the function from C++.
-  uint64_t left = V8_2PART_UINT64_C(0x10000000, 20000000);
-  uint64_t right = V8_2PART_UINT64_C(0x30000000, 40000000);
-  uint64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
+  int64_t left   = V8_2PART_UINT64_C(0x10000000, 20000000);
+  int64_t right  = V8_2PART_UINT64_C(0x30000000, 40000000);
+  int64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
   CHECK_EQ(V8_2PART_UINT64_C(0x10000000, e0000000), left);
   USE(result);
 }
 
 
 TEST(AssemblerX64TestlOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   // Set rax with the ZF flag of the testl instruction.
   Label done;
   __ movq(rax, Immediate(1));
   __ movq(r11, Operand(arg2, 0));
   __ testl(Operand(arg1, 0), r11);
   __ j(zero, &done, Label::kNear);
   __ movq(rax, Immediate(0));
   __ bind(&done);
   __ ret(0);
 
   CodeDesc desc;
   assm.GetCode(&desc);
   // Call the function from C++.
-  uint64_t left = V8_2PART_UINT64_C(0x10000000, 20000000);
-  uint64_t right = V8_2PART_UINT64_C(0x30000000, 00000000);
-  uint64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
-  CHECK_EQ(1u, result);
+  int64_t left   = V8_2PART_UINT64_C(0x10000000, 20000000);
+  int64_t right  = V8_2PART_UINT64_C(0x30000000, 00000000);
+  int64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
+  CHECK_EQ(static_cast<int64_t>(1), result);
 }
 
 
 TEST(AssemblerX64XorlOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   __ movq(rax, Operand(arg2, 0));
   __ xorl(Operand(arg1, 0), rax);
   __ ret(0);
 
   CodeDesc desc;
   assm.GetCode(&desc);
   // Call the function from C++.
-  uint64_t left = V8_2PART_UINT64_C(0x10000000, 20000000);
-  uint64_t right = V8_2PART_UINT64_C(0x30000000, 60000000);
-  uint64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
+  int64_t left   = V8_2PART_UINT64_C(0x10000000, 20000000);
+  int64_t right  = V8_2PART_UINT64_C(0x30000000, 60000000);
+  int64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
   CHECK_EQ(V8_2PART_UINT64_C(0x10000000, 40000000), left);
   USE(result);
 }
 
 
 TEST(AssemblerX64MemoryOperands) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
@@ skipping 219 matching lines @@
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F0 f = FUNCTION_CAST<F0>(code->entry());
   int res = f();
   CHECK_EQ(42, res);
 }
 
 
 #ifdef __GNUC__
-#define ELEMENT_COUNT 4u
+#define ELEMENT_COUNT 4
 
 void DoSSE2(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(CcTest::isolate());
   byte buffer[1024];
 
   CHECK(args[0]->IsArray());
   v8::Local<v8::Array> vec = v8::Local<v8::Array>::Cast(args[0]);
   CHECK_EQ(ELEMENT_COUNT, vec->Length());
 
   Isolate* isolate = CcTest::i_isolate();
   Assembler assm(isolate, buffer, sizeof(buffer));
 
   // Remove return address from the stack for fix stack frame alignment.
   __ popq(rcx);
 
   // Store input vector on the stack.
-  for (unsigned i = 0; i < ELEMENT_COUNT; i++) {
+  for (int i = 0; i < ELEMENT_COUNT; i++) {
     __ movl(rax, Immediate(vec->Get(i)->Int32Value()));
     __ shlq(rax, Immediate(0x20));
     __ orq(rax, Immediate(vec->Get(++i)->Int32Value()));
     __ pushq(rax);
   }
 
   // Read vector into a xmm register.
   __ xorps(xmm0, xmm0);
   __ movdqa(xmm0, Operand(rsp, 0));
   // Create mask and store it in the return register.
@@ skipping 33 matching lines @@
       "function foo(vec) {"
       "  return do_sse2(vec);"
       "}");
 
   v8::Local<v8::Object> global_object = env->Global();
   v8::Local<v8::Function> foo =
       v8::Local<v8::Function>::Cast(global_object->Get(v8_str("foo")));
 
   int32_t vec[ELEMENT_COUNT] = { -1, 1, 1, 1 };
   v8::Local<v8::Array> v8_vec = v8::Array::New(isolate, ELEMENT_COUNT);
-  for (unsigned i = 0; i < ELEMENT_COUNT; i++) {
+  for (int i = 0; i < ELEMENT_COUNT; i++) {
     v8_vec->Set(i, v8_num(vec[i]));
   }
 
   v8::Local<v8::Value> args[] = { v8_vec };
   v8::Local<v8::Value> result = foo->Call(global_object, 1, args);
 
   // The mask should be 0b1000.
   CHECK_EQ(8, result->Int32Value());
 }
 
@@ skipping 18 matching lines @@
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F3 f = FUNCTION_CAST<F3>(code->entry());
   uint64_t value1 = V8_2PART_UINT64_C(0x12345678, 87654321);
-  CHECK_EQ(0x12345678u, f(uint64_to_double(value1)));
+  CHECK_EQ(0x12345678, f(uint64_to_double(value1)));
   uint64_t value2 = V8_2PART_UINT64_C(0x87654321, 12345678);
-  CHECK_EQ(0x87654321u, f(uint64_to_double(value2)));
+  CHECK_EQ(0x87654321, f(uint64_to_double(value2)));
 }
 
 
 typedef int (*F6)(float x, float y);
 TEST(AssemblerX64SSE) {
   CcTest::InitializeVM();
 
   Isolate* isolate = reinterpret_cast<Isolate*>(CcTest::isolate());
   HandleScope scope(isolate);
   v8::internal::byte buffer[256];
@@ skipping 468 matching lines @@
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F8 f = FUNCTION_CAST<F8>(code->entry());
   CHECK_EQ(0, f(9.26621069e-05f, -2.4607749f, -1.09587872f));
 }
 #undef __