Skip to content

V
V8
Commit caa37597 authored by rodolph.perfetta@gmail.com's avatar rodolph.perfetta@gmail.com
Browse files
Options

ARM: Makefile/gyp update allowing better control of ARM specific options. 

This patch defines new makefile command line paramaters to better control the
ARM specific options. The new paramters are
 * armfpu      = vfp, vfpv3-d16, vfpv3, neon.
 * armfloatabi = softfp, hard
 * armneon     = on
 * armthumb    = on, off
 * armtest     = on
One existing paratemer has been modified:
 * armv7       = true, false
A number of parameters have been deprecated (but are still working):
 * hardfp      = on, off
 * vfp2        = off
 * vfp3        = off

the armtest paratmer when set to "on" will lock the options used during compile
time at runtime. This allows for example to easily test the ARMv6 build on an
ARMv7 platform without having to worry about features detected at runtime. When
not specified the compiler default will be used meaning it is not necessary
anymore to specify hardfp=on when natively building on an hardfp platform.

The shell help now prints the target options and features detected.

BUG=none
TEST=none

Review URL: https://chromiumcodereview.appspot.com/14263018

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@14288 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
parent 3fad5206
Hide whitespace changes
Inline Side-by-side
Showing with 293 additions and 140 deletions
Makefile
View file @ caa37597
......@@ -87,22 +87,14 @@ endif
ifeq ($(vtunejit), on)
GYPFLAGS += -Dv8_enable_vtunejit=1
endif
# vfp2=off
ifeq ($(vfp2), off)
GYPFLAGS += -Dv8_can_use_vfp2_instructions=false
else
GYPFLAGS += -Dv8_can_use_vfp2_instructions=true -Darm_fpu=vfpv2
endif
# vfp3=off
ifeq ($(vfp3), off)
GYPFLAGS += -Dv8_can_use_vfp3_instructions=false
else
GYPFLAGS += -Dv8_can_use_vfp3_instructions=true -Darm_fpu=vfpv3
endif
# debuggersupport=off
ifeq ($(debuggersupport), off)
GYPFLAGS += -Dv8_enable_debugger_support=0
endif
# unalignedaccess=on
ifeq ($(unalignedaccess), on)
GYPFLAGS += -Dv8_can_use_unaligned_accesses=true
endif
# soname_version=1.2.3
ifdef soname_version
GYPFLAGS += -Dsoname_version=$(soname_version)
......@@ -123,13 +115,72 @@ endif
ifeq ($(regexp), interpreted)
GYPFLAGS += -Dv8_interpreted_regexp=1
endif
# hardfp=on
ifeq ($(hardfp), on)
GYPFLAGS += -Dv8_use_arm_eabi_hardfloat=true
endif
# armv7=false
# arm specific flags.
# armv7=false/true
ifeq ($(armv7), false)
GYPFLAGS += -Darmv7=0
else
ifeq ($(armv7), true)
GYPFLAGS += -Darmv7=1
else
GYPFLAGS += -Darmv7=default
endif
endif
# vfp2=off. Deprecated, use armfpu=
# vfp3=off. Deprecated, use armfpu=
ifeq ($(vfp3), off)
GYPFLAGS += -Darm_fpu=vfp
endif
# hardfp=on/off. Deprecated, use armfloatabi
ifeq ($(hardfp),on)
GYPFLAGS += -Darm_float_abi=hard
else
ifeq ($(hardfp),off)
GYPFLAGS += -Darm_float_abi=softfp
endif
endif
# armneon=on/off
ifeq ($(armneon), on)
GYPFLAGS += -Darm_neon=1
endif
# fpu: armfpu=xxx
# xxx: vfp, vfpv3-d16, vfpv3, neon.
ifeq ($(armfpu),)
ifneq ($(vfp3), off)
GYPFLAGS += -Darm_fpu=default
endif
else
GYPFLAGS += -Darm_fpu=$(armfpu)
endif
# float abi: armfloatabi=softfp/hard
ifeq ($(armfloatabi),)
ifeq ($(hardfp),)
GYPFLAGS += -Darm_float_abi=default
endif
else
GYPFLAGS += -Darm_float_abi=$(armfloatabi)
endif
# armthumb=on/off
ifeq ($(armthumb), off)
GYPFLAGS += -Darm_thumb=0
else
ifeq ($(armthumb), on)
GYPFLAGS += -Darm_thumb=1
else
GYPFLAGS += -Darm_thumb=default
endif
endif
# armtest=on
# With this flag set, by default v8 will only use features implied
# by the compiler (no probe). This is done by modifying the default
# values of enable_armv7, enable_vfp2, enable_vfp3 and enable_32dregs.
# Modifying these flags when launching v8 will enable the probing for
# the specified values.
# When using the simulator, this flag is implied.
ifeq ($(armtest), on)
GYPFLAGS += -Darm_test=on
else
GYPFLAGS += -Darm_test=off
endif
# ----------------- available targets: --------------------
......
build/common.gypi
View file @ caa37597
......@@ -136,55 +136,105 @@
'defines': [
'V8_TARGET_ARCH_ARM',
],
'variables': {
'armsimulator': '<!($(echo <(CXX)) -v 2>&1 | grep -q "^Target: arm" && echo "no" || echo "yes")',
},
'conditions': [
['armv7==1', {
'defines': [
'CAN_USE_ARMV7_INSTRUCTIONS=1',
],
}],
[ 'v8_can_use_unaligned_accesses=="true"', {
'defines': [
'CAN_USE_UNALIGNED_ACCESSES=1',
],
}],
[ 'v8_can_use_unaligned_accesses=="false"', {
}, {
'defines': [
'CAN_USE_UNALIGNED_ACCESSES=0',
],
}],
# NEON implies VFP3 and VFP3 implies VFP2.
[ 'v8_can_use_vfp2_instructions=="true" or arm_neon==1 or \
arm_fpu=="vfpv3" or arm_fpu=="vfpv3-d16"', {
'defines': [
'CAN_USE_VFP2_INSTRUCTIONS',
],
}],
# NEON implies VFP3.
[ 'v8_can_use_vfp3_instructions=="true" or arm_neon==1 or \
arm_fpu=="vfpv3" or arm_fpu=="vfpv3-d16"', {
'defines': [
'CAN_USE_VFP3_INSTRUCTIONS',
],
}],
[ 'v8_use_arm_eabi_hardfloat=="true"', {
'defines': [
'USE_EABI_HARDFLOAT=1',
'CAN_USE_VFP2_INSTRUCTIONS',
],
['armsimulator=="no"', {
'target_conditions': [
['_toolset=="target"', {
'cflags': ['-mfloat-abi=hard',],
'conditions': [
[ 'armv7==1', {
'cflags': ['-march=armv7-a',],
}],
[ 'armv7==1 or armv7=="default"', {
'conditions': [
[ 'arm_neon==1', {
'cflags': ['-mfpu=neon',],
},
{
'conditions': [
[ 'arm_fpu!="default"', {
'cflags': ['-mfpu=<(arm_fpu)',],
}],
]
}],
]
}],
[ 'arm_float_abi!="default"', {
'cflags': ['-mfloat-abi=<(arm_float_abi)',],
}],
[ 'arm_thumb==1', {
'cflags': ['-mthumb',],
}],
[ 'arm_thumb==0', {
'cflags': ['-marm',],
}],
],
}],
],
}, {
'defines': [
'USE_EABI_HARDFLOAT=0',
'conditions': [
[ 'arm_test=="on"', {
'defines': [
'ARM_TEST',
],
}],
],
}],
[ 'v8_can_use_vfp32dregs=="true"', {
['armsimulator=="yes"', {
'defines': [
'CAN_USE_VFP32DREGS',
'ARM_TEST',
],
'conditions': [
[ 'armv7==1 or armv7=="default"', {
'defines': [
'CAN_USE_ARMV7_INSTRUCTIONS=1',
],
'conditions': [
[ 'arm_fpu=="default"', {
'defines': [
'CAN_USE_VFP3_INSTRUCTIONS',
],
}],
[ 'arm_fpu=="vfpv3-d16"', {
'defines': [
'CAN_USE_VFP3_INSTRUCTIONS',
],
}],
[ 'arm_fpu=="vfpv3"', {
'defines': [
'CAN_USE_VFP3_INSTRUCTIONS',
'CAN_USE_VFP32DREGS',
],
}],
[ 'arm_fpu=="neon" or arm_neon==1', {
'defines': [
'CAN_USE_VFP3_INSTRUCTIONS',
'CAN_USE_VFP32DREGS',
],
}],
],
}],
[ 'arm_float_abi=="hard"', {
'defines': [
'USE_EABI_HARDFLOAT=1',
],
}],
[ 'arm_float_abi=="softfp" or arm_float_abi=="default"', {
'defines': [
'USE_EABI_HARDFLOAT=0',
],
}],
]
}],
],
}], # v8_target_arch=="arm"
......
src/arm/assembler-arm.cc
View file @ caa37597
......@@ -63,26 +63,21 @@ ExternalReference ExternalReference::cpu_features() {
static unsigned CpuFeaturesImpliedByCompiler() {
unsigned answer = 0;
#ifdef CAN_USE_ARMV7_INSTRUCTIONS
answer |= 1u << ARMv7;
if (FLAG_enable_armv7) {
answer |= 1u << ARMv7;
}
#endif // CAN_USE_ARMV7_INSTRUCTIONS
#ifdef CAN_USE_VFP3_INSTRUCTIONS
answer |= 1u << VFP3 | 1u << ARMv7;
if (FLAG_enable_vfp3) {
answer |= 1u << VFP3 | 1u << ARMv7;
}
#endif // CAN_USE_VFP3_INSTRUCTIONS
#ifdef CAN_USE_VFP32DREGS
answer |= 1u << VFP32DREGS;
if (FLAG_enable_32dregs) {
answer |= 1u << VFP32DREGS;
}
#endif // CAN_USE_VFP32DREGS
#ifdef __arm__
// If the compiler is allowed to use VFP then we can use VFP too in our code
// generation even when generating snapshots. ARMv7 and hardware floating
// point support implies VFPv3, see ARM DDI 0406B, page A1-6.
#if defined(CAN_USE_ARMV7_INSTRUCTIONS) && defined(__VFP_FP__) \
&& !defined(__SOFTFP__)
answer |= 1u << VFP3 | 1u << ARMv7;
#endif // defined(CAN_USE_ARMV7_INSTRUCTIONS) && defined(__VFP_FP__)
// && !defined(__SOFTFP__)
#endif // _arm__
if (answer & (1u << ARMv7)) {
if ((answer & (1u << ARMv7)) && FLAG_enable_unaligned_accesses) {
answer |= 1u << UNALIGNED_ACCESSES;
}
......@@ -116,6 +111,8 @@ void CpuFeatures::Probe() {
if (Serializer::enabled()) {
// No probing for features if we might serialize (generate snapshot).
printf(" ");
PrintFeatures();
return;
}
......@@ -144,9 +141,13 @@ void CpuFeatures::Probe() {
supported_ |= static_cast<uint64_t>(1) << VFP32DREGS;
}
if (FLAG_enable_unaligned_accesses) {
supported_ |= static_cast<uint64_t>(1) << UNALIGNED_ACCESSES;
}
#else // __arm__
// Probe for additional features not already known to be available.
if (!IsSupported(VFP3) && OS::ArmCpuHasFeature(VFP3)) {
if (!IsSupported(VFP3) && FLAG_enable_vfp3 && OS::ArmCpuHasFeature(VFP3)) {
// This implementation also sets the VFP flags if runtime
// detection of VFP returns true. VFPv3 implies ARMv7, see ARM DDI
// 0406B, page A1-6.
......@@ -155,26 +156,28 @@ void CpuFeatures::Probe() {
static_cast<uint64_t>(1) << ARMv7;
}
if (!IsSupported(ARMv7) && OS::ArmCpuHasFeature(ARMv7)) {
if (!IsSupported(ARMv7) && FLAG_enable_armv7 && OS::ArmCpuHasFeature(ARMv7)) {
found_by_runtime_probing_only_ |= static_cast<uint64_t>(1) << ARMv7;
}
if (!IsSupported(SUDIV) && OS::ArmCpuHasFeature(SUDIV)) {
if (!IsSupported(SUDIV) && FLAG_enable_sudiv && OS::ArmCpuHasFeature(SUDIV)) {
found_by_runtime_probing_only_ |= static_cast<uint64_t>(1) << SUDIV;
}
if (!IsSupported(UNALIGNED_ACCESSES) && OS::ArmCpuHasFeature(ARMv7)) {
if (!IsSupported(UNALIGNED_ACCESSES) && FLAG_enable_unaligned_accesses
&& OS::ArmCpuHasFeature(ARMv7)) {
found_by_runtime_probing_only_ |=
static_cast<uint64_t>(1) << UNALIGNED_ACCESSES;
}
if (OS::GetCpuImplementer() == QUALCOMM_IMPLEMENTER &&
OS::ArmCpuHasFeature(ARMv7)) {
FLAG_enable_movw_movt && OS::ArmCpuHasFeature(ARMv7)) {
found_by_runtime_probing_only_ |=
static_cast<uint64_t>(1) << MOVW_MOVT_IMMEDIATE_LOADS;
}
if (!IsSupported(VFP32DREGS) && OS::ArmCpuHasFeature(VFP32DREGS)) {
if (!IsSupported(VFP32DREGS) && FLAG_enable_32dregs
&& OS::ArmCpuHasFeature(VFP32DREGS)) {
found_by_runtime_probing_only_ |= static_cast<uint64_t>(1) << VFP32DREGS;
}
......@@ -186,6 +189,79 @@ void CpuFeatures::Probe() {
}
void CpuFeatures::PrintTarget() {
const char* arm_arch = NULL;
const char* arm_test = "";
const char* arm_fpu = "";
const char* arm_thumb = "";
const char* arm_float_abi = NULL;
#if defined CAN_USE_ARMV7_INSTRUCTIONS
arm_arch = "arm v7";
#else
arm_arch = "arm v6";
#endif
#ifdef __arm__
# ifdef ARM_TEST
arm_test = " test";
# endif
# if defined __ARM_NEON__
arm_fpu = " neon";
# elif defined CAN_USE_VFP3_INSTRUCTIONS
arm_fpu = " vfp3";
# else
arm_fpu = " vfp2";
# endif
# if (defined __thumb__) || (defined __thumb2__)
arm_thumb = " thumb";
# endif
arm_float_abi = OS::ArmUsingHardFloat() ? "hard" : "softfp";
#else // __arm__
arm_test = " simulator";
# if defined CAN_USE_VFP3_INSTRUCTIONS
# if defined CAN_USE_VFP32DREGS
arm_fpu = " vfp3";
# else
arm_fpu = " vfp3-d16";
# endif
# else
arm_fpu = " vfp2";
# endif
# if USE_EABI_HARDFLOAT == 1
arm_float_abi = "hard";
# else
arm_float_abi = "softfp";
# endif
#endif // __arm__
printf("target%s %s%s%s %s\n",
arm_test, arm_arch, arm_fpu, arm_thumb, arm_float_abi);
}
void CpuFeatures::PrintFeatures() {
printf(
"ARMv7=%d VFP3=%d VFP32DREGS=%d SUDIV=%d UNALIGNED_ACCESSES=%d "
"MOVW_MOVT_IMMEDIATE_LOADS=%d",
CpuFeatures::IsSupported(ARMv7),
CpuFeatures::IsSupported(VFP3),
CpuFeatures::IsSupported(VFP32DREGS),
CpuFeatures::IsSupported(SUDIV),
CpuFeatures::IsSupported(UNALIGNED_ACCESSES),
CpuFeatures::IsSupported(MOVW_MOVT_IMMEDIATE_LOADS));
#ifdef __arm__
printf(" USE_EABI_HARDFLOAT=%d\n", OS::ArmUsingHardFloat());
#else
printf(" USE_EABI_HARDFLOAT=%d\n", USE_EABI_HARDFLOAT);
#endif
}
// -----------------------------------------------------------------------------
// Implementation of RelocInfo
......
src/arm/assembler-arm.h
View file @ caa37597
......@@ -55,15 +55,15 @@ class CpuFeatures : public AllStatic {
// is enabled (snapshots must be portable).
static void Probe();
// Display target use when compiling.
static void PrintTarget();
// Display features.
static void PrintFeatures();
// Check whether a feature is supported by the target CPU.
static bool IsSupported(CpuFeature f) {
ASSERT(initialized_);
if (f == VFP3 && !FLAG_enable_vfp3) return false;
if (f == SUDIV && !FLAG_enable_sudiv) return false;
if (f == UNALIGNED_ACCESSES && !FLAG_enable_unaligned_accesses) {
return false;
}
if (f == VFP32DREGS && !FLAG_enable_32dregs) return false;
return (supported_ & (1u << f)) != 0;
}
......
src/arm/constants-arm.h
View file @ caa37597
......@@ -44,21 +44,23 @@
defined(__ARM_ARCH_7R__) || \
defined(__ARM_ARCH_7__)
# define CAN_USE_ARMV7_INSTRUCTIONS 1
# define CAN_USE_VFP3_INSTRUCTIONS
#endif
#if defined(__ARM_ARCH_6__) || \
defined(__ARM_ARCH_6J__) || \
defined(__ARM_ARCH_6K__) || \
defined(__ARM_ARCH_6Z__) || \
#if defined(__ARM_ARCH_6__) || \
defined(__ARM_ARCH_6J__) || \
defined(__ARM_ARCH_6K__) || \
defined(__ARM_ARCH_6Z__) || \
defined(__ARM_ARCH_6ZK__) || \
defined(__ARM_ARCH_6T2__) || \
defined(CAN_USE_ARMV7_INSTRUCTIONS)
# define CAN_USE_ARMV6_INSTRUCTIONS 1
#endif
#if defined(__ARM_ARCH_5T__) || \
defined(__ARM_ARCH_5TE__) || \
defined(__ARM_ARCH_5TEJ__) || \
#if defined(__ARM_ARCH_5__) || \
defined(__ARM_ARCH_5T__) || \
defined(__ARM_ARCH_5TE__) || \
defined(__ARM_ARCH_5TEJ__) || \
defined(CAN_USE_ARMV6_INSTRUCTIONS)
# define CAN_USE_ARMV5_INSTRUCTIONS 1
# define CAN_USE_THUMB_INSTRUCTIONS 1
......
src/arm/macro-assembler-arm.h
View file @ caa37597
......@@ -1149,7 +1149,9 @@ class MacroAssembler: public Assembler {
// EABI variant for double arguments in use.
bool use_eabi_hardfloat() {
#if USE_EABI_HARDFLOAT
#ifdef __arm__
return OS::ArmUsingHardFloat();
#elif USE_EABI_HARDFLOAT
return true;
#else
return false;
......
src/flag-definitions.h
View file @ caa37597
......@@ -119,6 +119,22 @@ public:
};
#endif
#if (defined CAN_USE_VFP3_INSTRUCTIONS) || !(defined ARM_TEST)
# define ENABLE_VFP3_DEFAULT true
#else
# define ENABLE_VFP3_DEFAULT false
#endif
#if (defined CAN_USE_ARMV7_INSTRUCTIONS) || !(defined ARM_TEST)
# define ENABLE_ARMV7_DEFAULT true
#else
# define ENABLE_ARMV7_DEFAULT false
#endif
#if (defined CAN_USE_VFP32DREGS) || !(defined ARM_TEST)
# define ENABLE_32DREGS_DEFAULT true
#else
# define ENABLE_32DREGS_DEFAULT false
#endif
#define DEFINE_bool(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)
#define DEFINE_int(nam, def, cmt) FLAG(INT, int, nam, def, cmt)
#define DEFINE_float(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt)
......@@ -308,9 +324,9 @@ DEFINE_bool(enable_rdtsc, true,
"enable use of RDTSC instruction if available")
DEFINE_bool(enable_sahf, true,
"enable use of SAHF instruction if available (X64 only)")
DEFINE_bool(enable_vfp3, true,
DEFINE_bool(enable_vfp3, ENABLE_VFP3_DEFAULT,
"enable use of VFP3 instructions if available")
DEFINE_bool(enable_armv7, true,
DEFINE_bool(enable_armv7, ENABLE_ARMV7_DEFAULT,
"enable use of ARMv7 instructions if available (ARM only)")
DEFINE_bool(enable_sudiv, true,
"enable use of SDIV and UDIV instructions if available (ARM only)")
......@@ -319,7 +335,7 @@ DEFINE_bool(enable_movw_movt, false,
"instruction pairs (ARM only)")
DEFINE_bool(enable_unaligned_accesses, true,
"enable unaligned accesses for ARMv7 (ARM only)")
DEFINE_bool(enable_32dregs, true,
DEFINE_bool(enable_32dregs, ENABLE_32DREGS_DEFAULT,
"enable use of d16-d31 registers on ARM - this requires VFP3")
DEFINE_bool(enable_vldr_imm, false,
"enable use of constant pools for double immediate (ARM only)")
......
src/flags.cc
View file @ caa37597
......@@ -34,6 +34,9 @@
#include "smart-pointers.h"
#include "string-stream.h"
#ifdef V8_TARGET_ARCH_ARM
#include "arm/assembler-arm-inl.h"
#endif
namespace v8 {
namespace internal {
......@@ -517,6 +520,12 @@ void FlagList::ResetAllFlags() {
// static
void FlagList::PrintHelp() {
#ifdef V8_TARGET_ARCH_ARM
CpuFeatures::PrintTarget();
CpuFeatures::Probe();
CpuFeatures::PrintFeatures();
#endif // V8_TARGET_ARCH_ARM
printf("Usage:\n");
printf(" shell [options] -e string\n");
printf(" execute string in V8\n");
......
src/platform-linux.cc
View file @ caa37597
......@@ -996,25 +996,6 @@ void OS::SetUp() {
uint64_t seed = Ticks() ^ (getpid() << 16);
srandom(static_cast<unsigned int>(seed));
limit_mutex = CreateMutex();
#ifdef __arm__
// When running on ARM hardware check that the EABI used by V8 and
// by the C code is the same.
bool hard_float = OS::ArmUsingHardFloat();
if (hard_float) {
#if !USE_EABI_HARDFLOAT
PrintF("ERROR: Binary compiled with -mfloat-abi=hard but without "
"-DUSE_EABI_HARDFLOAT\n");
exit(1);
#endif
} else {
#if USE_EABI_HARDFLOAT
PrintF("ERROR: Binary not compiled with -mfloat-abi=hard but with "
"-DUSE_EABI_HARDFLOAT\n");
exit(1);
#endif
}
#endif
}
......
tools/gyp/v8.gyp
View file @ caa37597
......@@ -155,40 +155,6 @@
'--logfile', '<(INTERMEDIATE_DIR)/snapshot.log',
],
},
'conditions': [
['v8_target_arch=="arm"', {
# The following rules should be consistent with chromium's
# common.gypi and V8's runtime rule to ensure they all generate
# the same correct machine code. The following issue is about
# V8's runtime rule about vfpv3 and neon:
# http://code.google.com/p/v8/issues/detail?id=914
'conditions': [
['armv7==1', {
# The ARM Architecture Manual mandates VFPv3 if NEON is
# available.
# V8 does not use d16-d31 unless explicitly enabled
# (--enable_32dregs) or detected at run-time, so for vfpv3-d16,
# we can also enable vfp3 for the better performance.
'conditions': [
['arm_neon!=1 and arm_fpu!="vfpv3" and arm_fpu!="vfpv3-d16"', {
'variables': {
'mksnapshot_flags': [
'--noenable_vfp3',
],
},
}],
],
},{ # else: armv7!=1
'variables': {
'mksnapshot_flags': [
'--noenable_armv7',
'--noenable_vfp3',
],
},
}],
],
}],
],
'action': [
'<@(_inputs)',
'<@(mksnapshot_flags)',
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment