X64: Omitted creating native builtins and using them in test-heap.

test/cctest/test-heap.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "execution.h"
 #include "factory.h"
 #include "macro-assembler.h"
 #include "global-handles.h"
@@ skipping 18 matching lines @@
   CHECK_EQ(Heap::meta_map(), map->map());
   CHECK_EQ(type, map->instance_type());
   CHECK_EQ(instance_size, map->instance_size());
 }
 
 
 TEST(HeapMaps) {
   InitializeVM();
   CheckMap(Heap::meta_map(), MAP_TYPE, Map::kSize);
   CheckMap(Heap::heap_number_map(), HEAP_NUMBER_TYPE, HeapNumber::kSize);
-  CheckMap(Heap::fixed_array_map(), FIXED_ARRAY_TYPE, Array::kHeaderSize);
+  CheckMap(Heap::fixed_array_map(), FIXED_ARRAY_TYPE, Array::kAlignedSize);
   CheckMap(Heap::long_string_map(), LONG_STRING_TYPE,
-           SeqTwoByteString::kHeaderSize);
+           SeqTwoByteString::kAlignedSize);
 }
 
 
 static void CheckOddball(Object* obj, const char* string) {
   CHECK(obj->IsOddball());
+#ifndef V8_HOST_ARCH_64_BIT
+// TODO(X64): Reenable when native builtins work.
   bool exc;
   Object* print_string = *Execution::ToString(Handle<Object>(obj), &exc);
   CHECK(String::cast(print_string)->IsEqualTo(CStrVector(string)));
+#endif  // V8_HOST_ARCH_64_BIT
 }
 
 
 static void CheckSmi(int value, const char* string) {
+#ifndef V8_HOST_ARCH_64_BIT
+// TODO(X64): Reenable when native builtins work.
   bool exc;
   Object* print_string =
       *Execution::ToString(Handle<Object>(Smi::FromInt(value)), &exc);
   CHECK(String::cast(print_string)->IsEqualTo(CStrVector(string)));
+#endif  // V8_HOST_ARCH_64_BIT
 }
 
 
 static void CheckNumber(double value, const char* string) {
   Object* obj = Heap::NumberFromDouble(value);
   CHECK(obj->IsNumber());
+#ifndef V8_HOST_ARCH_64_BIT
+// TODO(X64): Reenable when native builtins work.
   bool exc;
   Object* print_string = *Execution::ToString(Handle<Object>(obj), &exc);
   CHECK(String::cast(print_string)->IsEqualTo(CStrVector(string)));
+#endif  // V8_HOST_ARCH_64_BIT
 }
 
 
 static void CheckFindCodeObject() {
   // Test FindCodeObject
 #define __ assm.
 
   Assembler assm(NULL, 0);
 
   __ nop();  // supported on all architectures
@@ skipping 94 matching lines @@
 
   // Check ToString for Numbers
   CheckNumber(1.1, "1.1");
 
   CheckFindCodeObject();
 }
 
 
 TEST(Tagging) {
   InitializeVM();
+  int request = 24;
+  ASSERT_EQ(request, OBJECT_SIZE_ALIGN(request));

[William Hesse, 2009/05/22 12:21:13]

Shouldn't this be CHECK_EQ?  Otherwise, you could have check failures later in
release mode, because of a misaligned request.

[Lasse Reichstein, 2009/05/22 13:10:10]

I couldn't decide. It's not a check in the same sense as the following ones.
They check that something works as intended.  This is more like a sanity check
for the test itself. I.e., if this fails, it's not a bug in the code being
tested, but in the test itself - equivalent to ASSERTs in the main code.

   CHECK(Smi::FromInt(42)->IsSmi());
-  CHECK(Failure::RetryAfterGC(12, NEW_SPACE)->IsFailure());
-  CHECK_EQ(12, Failure::RetryAfterGC(12, NEW_SPACE)->requested());
-  CHECK_EQ(NEW_SPACE, Failure::RetryAfterGC(12, NEW_SPACE)->allocation_space());
+  CHECK(Failure::RetryAfterGC(request, NEW_SPACE)->IsFailure());
+  CHECK_EQ(request, Failure::RetryAfterGC(request, NEW_SPACE)->requested());
+  CHECK_EQ(NEW_SPACE,
+           Failure::RetryAfterGC(request, NEW_SPACE)->allocation_space());
   CHECK_EQ(OLD_POINTER_SPACE,
-           Failure::RetryAfterGC(12, OLD_POINTER_SPACE)->allocation_space());
+           Failure::RetryAfterGC(request,
+                                 OLD_POINTER_SPACE)->allocation_space());
   CHECK(Failure::Exception()->IsFailure());
   CHECK(Smi::FromInt(Smi::kMinValue)->IsSmi());
   CHECK(Smi::FromInt(Smi::kMaxValue)->IsSmi());
 }
 
 
 TEST(GarbageCollection) {
   InitializeVM();
 
   v8::HandleScope sc;
@@ skipping 579 matching lines @@
   objs[next_objs_index++] =
       Factory::NewStringFromAscii(CStrVector(str), TENURED);
   delete[] str;
 
   // Add a Map object to look for.
   objs[next_objs_index++] = Handle<Map>(HeapObject::cast(*objs[0])->map());
 
   CHECK_EQ(objs_count, next_objs_index);
   CHECK_EQ(objs_count, ObjectsFoundInHeap(objs, objs_count));
 }