ARM: Support hardfloat in SCons build and make it a build time setting

src/arm/simulator-arm.cc

 // Copyright 2011 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 994 matching lines @@
   char buffer[2 * sizeof(vfp_register[0])];
   memcpy(buffer, &vfp_register[2 * dreg], 2 * sizeof(vfp_register[0]));
   memcpy(&dm_val, buffer, 2 * sizeof(vfp_register[0]));
   return(dm_val);
 }
 
 
 // For use in calls that take two double values, constructed either
 // from r0-r3 or d0 and d1.
 void Simulator::GetFpArgs(double* x, double* y) {
-  if (FLAG_hardfloat) {
+  if (use_eabi_hardfloat()) {
     *x = vfp_register[0];
     *y = vfp_register[1];
   } else {
     // We use a char buffer to get around the strict-aliasing rules which
     // otherwise allow the compiler to optimize away the copy.
     char buffer[2 * sizeof(registers_[0])];
     // Registers 0 and 1 -> x.
     memcpy(buffer, registers_, sizeof(buffer));
     memcpy(x, buffer, sizeof(buffer));
     // Registers 2 and 3 -> y.
     memcpy(buffer, registers_ + 2, sizeof(buffer));
     memcpy(y, buffer, sizeof(buffer));
   }
 }
 
 // For use in calls that take one double value, constructed either
 // from r0 and r1 or d0.
 void Simulator::GetFpArgs(double* x) {
-  if (FLAG_hardfloat) {
+  if (use_eabi_hardfloat()) {
     *x = vfp_register[0];
   } else {
     // We use a char buffer to get around the strict-aliasing rules which
     // otherwise allow the compiler to optimize away the copy.
     char buffer[2 * sizeof(registers_[0])];
     // Registers 0 and 1 -> x.
     memcpy(buffer, registers_, sizeof(buffer));
     memcpy(x, buffer, sizeof(buffer));
   }
 }
 
 
 // For use in calls that take two double values, constructed either
 // from r0-r3 or d0 and d1.
 void Simulator::GetFpArgs(double* x, int32_t* y) {
-  if (FLAG_hardfloat) {
+  if (use_eabi_hardfloat()) {
     *x = vfp_register[0];
     *y = registers_[1];
   } else {
     // We use a char buffer to get around the strict-aliasing rules which
     // otherwise allow the compiler to optimize away the copy.
     char buffer[2 * sizeof(registers_[0])];
     // Registers 0 and 1 -> x.
     memcpy(buffer, registers_, sizeof(buffer));
     memcpy(x, buffer, sizeof(buffer));
     // Registers 2 and 3 -> y.
     memcpy(buffer, registers_ + 2, sizeof(buffer));
     memcpy(y, buffer, sizeof(buffer));
   }
 }
 
 
 // The return value is either in r0/r1 or d0.
 void Simulator::SetFpResult(const double& result) {
-  if (FLAG_hardfloat) {
+  if (use_eabi_hardfloat()) {
     char buffer[2 * sizeof(vfp_register[0])];
     memcpy(buffer, &result, sizeof(buffer));
     // Copy result to d0.
     memcpy(vfp_register, buffer, sizeof(buffer));
   } else {
     char buffer[2 * sizeof(registers_[0])];
     memcpy(buffer, &result, sizeof(buffer));
     // Copy result to r0 and r1.
     memcpy(registers_, buffer, sizeof(buffer));
   }
@@ skipping 651 matching lines @@
       int32_t arg2 = get_register(r2);
       int32_t arg3 = get_register(r3);
       int32_t* stack_pointer = reinterpret_cast<int32_t*>(get_register(sp));
       int32_t arg4 = stack_pointer[0];
       int32_t arg5 = stack_pointer[1];
       bool fp_call =
          (redirection->type() == ExternalReference::BUILTIN_FP_FP_CALL) ||
          (redirection->type() == ExternalReference::BUILTIN_COMPARE_CALL) ||
          (redirection->type() == ExternalReference::BUILTIN_FP_CALL) ||
          (redirection->type() == ExternalReference::BUILTIN_FP_INT_CALL);
-      if (FLAG_hardfloat) {
+      if (use_eabi_hardfloat()) {
         // With the hard floating point calling convention, double
         // arguments are passed in VFP registers. Fetch the arguments
         // from there and call the builtin using soft floating point
         // convention.
         switch (redirection->type()) {
         case ExternalReference::BUILTIN_FP_FP_CALL:
         case ExternalReference::BUILTIN_COMPARE_CALL:
           arg0 = vfp_register[0];
           arg1 = vfp_register[1];
           arg2 = vfp_register[2];
@@ skipping 1653 matching lines @@
   uintptr_t address = *stack_slot;
   set_register(sp, current_sp + sizeof(uintptr_t));
   return address;
 }
 
 } }  // namespace v8::internal
 
 #endif  // USE_SIMULATOR
 
 #endif  // V8_TARGET_ARCH_ARM