make a64 compile on mavericks

src/a64/simulator-a64.cc

 // Copyright 2013 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 94 matching lines @@
   Simulator* sim = isolate_data->simulator();
   if (sim == NULL) {
     // TODO(146): delete the simulator object when a thread/isolate goes away.
     sim = new Simulator(new Decoder(), isolate);
     isolate_data->set_simulator(sim);
   }
   return sim;
 }
 
 
-void Simulator::CallVoid(byte* entry, va_list args) {
+void Simulator::CallVoid(byte* entry, CallArgument* args) {
   int index_x = 0;
   int index_d = 0;
 
-  // At this point, we don't know how much stack space we need (for arguments
-  // that don't fit into registers). We can only do one pass through the
-  // va_list, so we store the extra arguments in a vector, then copy them to
-  // their proper locations later.
   std::vector<int64_t> stack_args(0);
-
-  // Process register arguments.
-  CallArgument arg = va_arg(args, CallArgument);
-  while (!arg.IsEnd()) {
+  for (int i = 0; !args[i].IsEnd(); i++) {
+    CallArgument arg = args[i];
     if (arg.IsX() && (index_x < 8)) {
       set_xreg(index_x++, arg.bits());
     } else if (arg.IsD() && (index_d < 8)) {
       set_dreg_bits(index_d++, arg.bits());
     } else {
       ASSERT(arg.IsD() || arg.IsX());
       stack_args.push_back(arg.bits());
     }
-    arg = va_arg(args, CallArgument);
   }
 
   // Process stack arguments, and make sure the stack is suitably aligned.
   uintptr_t original_stack = sp();
   uintptr_t entry_stack = original_stack -
                           stack_args.size() * sizeof(stack_args[0]);
   if (OS::ActivationFrameAlignment() != 0) {
     entry_stack &= -OS::ActivationFrameAlignment();
   }
   char * stack = reinterpret_cast<char*>(entry_stack);
   std::vector<int64_t>::const_iterator it;
   for (it = stack_args.begin(); it != stack_args.end(); it++) {
     memcpy(stack, &(*it), sizeof(*it));
     stack += sizeof(*it);
   }
 
   ASSERT(reinterpret_cast<uintptr_t>(stack) <= original_stack);
   set_sp(entry_stack);
 
   // Call the generated code.
   set_pc(entry);
   set_lr(kEndOfSimAddress);
   CheckPCSComplianceAndRun();
 
   set_sp(original_stack);
 }
 
 
-
-void Simulator::CallVoid(byte* entry, ...) {
-  va_list args;
-  va_start(args, entry);
+int64_t Simulator::CallInt64(byte* entry, CallArgument* args) {
   CallVoid(entry, args);
-  va_end(args);
-}
-
-
-int64_t Simulator::CallInt64(byte* entry, ...) {
-  va_list args;
-  va_start(args, entry);
-  CallVoid(entry, args);
-  va_end(args);
-
   return xreg(0);
 }
 
 
-double Simulator::CallDouble(byte* entry, ...) {
-  va_list args;
-  va_start(args, entry);
+double Simulator::CallDouble(byte* entry, CallArgument* args) {
   CallVoid(entry, args);
-  va_end(args);
-
   return dreg(0);
 }
 
 
 int64_t Simulator::CallJS(byte* entry,
                           byte* function_entry,
                           JSFunction* func,
                           Object* revc,
                           int64_t argc,
                           Object*** argv) {
-  return CallInt64(entry,
-                   CallArgument(function_entry),
-                   CallArgument(func),
-                   CallArgument(revc),
-                   CallArgument(argc),
-                   CallArgument(argv),
-                   CallArgument::End());
+  CallArgument args[] = {
+    CallArgument(function_entry),
+    CallArgument(func),
+    CallArgument(revc),
+    CallArgument(argc),
+    CallArgument(argv),
+    CallArgument::End()
+  };
+  return CallInt64(entry, args);
 }
 
 int64_t Simulator::CallRegExp(byte* entry,
                               String* input,
                               int64_t start_offset,
                               const byte* input_start,
                               const byte* input_end,
                               int* output,
                               int64_t output_size,
                               Address stack_base,
                               int64_t direct_call,
                               void* return_address,
                               Isolate* isolate) {
-  return CallInt64(entry,
-                   CallArgument(input),
-                   CallArgument(start_offset),
-                   CallArgument(input_start),
-                   CallArgument(input_end),
-                   CallArgument(output),
-                   CallArgument(output_size),
-                   CallArgument(stack_base),
-                   CallArgument(direct_call),
-                   CallArgument(return_address),
-                   CallArgument(isolate),
-                   CallArgument::End());
+  CallArgument args[] = {
+    CallArgument(input),
+    CallArgument(start_offset),
+    CallArgument(input_start),
+    CallArgument(input_end),
+    CallArgument(output),
+    CallArgument(output_size),
+    CallArgument(stack_base),
+    CallArgument(direct_call),
+    CallArgument(return_address),
+    CallArgument(isolate),
+    CallArgument::End()
+  };
+  return CallInt64(entry, args);
 }
 
 
 void Simulator::CheckPCSComplianceAndRun() {
 #ifdef DEBUG
   CHECK_EQ(kNumberOfCalleeSavedRegisters, kCalleeSaved.Count());
   CHECK_EQ(kNumberOfCalleeSavedFPRegisters, kCalleeSavedFP.Count());
 
   int64_t saved_registers[kNumberOfCalleeSavedRegisters];
   uint64_t saved_fpregisters[kNumberOfCalleeSavedFPRegisters];
@@ skipping 2698 matching lines @@
         } else {  // "mem"
           int64_t value;
           if (!GetValue(arg1, &value)) {
             PrintF("%s unrecognized\n", arg1);
             continue;
           }
           cur = reinterpret_cast<int64_t*>(value);
           next_arg++;
         }
 
-        int64_t words;
+        int64_t words = 0;
         if (argc == next_arg) {
           words = 10;
         } else if (argc == next_arg + 1) {
           if (!GetValue(argv[next_arg], &words)) {
             PrintF("%s unrecognized\n", argv[next_arg]);
             PrintF("Printing 10 double words by default");
             words = 10;
           }
+        } else {
+          UNREACHABLE();
         }
         end = cur + words;
 
         while (cur < end) {
           PrintF("  0x%016" PRIx64 ":  0x%016" PRIx64 " %10" PRId64,
                  reinterpret_cast<uint64_t>(cur), *cur, *cur);
           HeapObject* obj = reinterpret_cast<HeapObject*>(*cur);
           int64_t value = *cur;
           Heap* current_heap = v8::internal::Isolate::Current()->heap();
           if (((value & 1) == 0) || current_heap->Contains(obj)) {
@@ skipping 451 matching lines @@
     default:
       UNIMPLEMENTED();
   }
 }
 
 #endif  // USE_SIMULATOR
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64