From: rodolph.perfetta@gmail.com Date: Tue, 16 Apr 2013 14:39:48 +0000 (+0000) Subject: ARM: Makefile/gyp update allowing better control of ARM specific options. X-Git-Tag: upstream/4.7.83~14564 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=caa37597ad491a18cadda39da75dc341be8ab1bb;p=platform%2Fupstream%2Fv8.git 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 --- diff --git a/Makefile b/Makefile index 88e338a..bedf087 100644 --- a/Makefile +++ b/Makefile @@ -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: -------------------- diff --git a/build/common.gypi b/build/common.gypi index a3c9ed0..37cfe16 100644 --- a/build/common.gypi +++ b/build/common.gypi @@ -136,55 +136,105 @@ 'defines': [ 'V8_TARGET_ARCH_ARM', ], + 'variables': { + 'armsimulator': '&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" diff --git a/src/arm/assembler-arm.cc b/src/arm/assembler-arm.cc index b0dbe06..8c5eb03 100644 --- a/src/arm/assembler-arm.cc +++ b/src/arm/assembler-arm.cc @@ -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(1) << VFP32DREGS; } + if (FLAG_enable_unaligned_accesses) { + supported_ |= static_cast(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(1) << ARMv7; } - if (!IsSupported(ARMv7) && OS::ArmCpuHasFeature(ARMv7)) { + if (!IsSupported(ARMv7) && FLAG_enable_armv7 && OS::ArmCpuHasFeature(ARMv7)) { found_by_runtime_probing_only_ |= static_cast(1) << ARMv7; } - if (!IsSupported(SUDIV) && OS::ArmCpuHasFeature(SUDIV)) { + if (!IsSupported(SUDIV) && FLAG_enable_sudiv && OS::ArmCpuHasFeature(SUDIV)) { found_by_runtime_probing_only_ |= static_cast(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(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(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(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 diff --git a/src/arm/assembler-arm.h b/src/arm/assembler-arm.h index 57582b6..0aecbcd 100644 --- a/src/arm/assembler-arm.h +++ b/src/arm/assembler-arm.h @@ -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; } diff --git a/src/arm/constants-arm.h b/src/arm/constants-arm.h index c3a5beb..ffedfd1 100644 --- a/src/arm/constants-arm.h +++ b/src/arm/constants-arm.h @@ -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 diff --git a/src/arm/macro-assembler-arm.h b/src/arm/macro-assembler-arm.h index fc6d797..86ae8f2 100644 --- a/src/arm/macro-assembler-arm.h +++ b/src/arm/macro-assembler-arm.h @@ -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; diff --git a/src/flag-definitions.h b/src/flag-definitions.h index e6f8ab4..9c9362b 100644 --- a/src/flag-definitions.h +++ b/src/flag-definitions.h @@ -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)") diff --git a/src/flags.cc b/src/flags.cc index a7fae68..282bf20 100644 --- a/src/flags.cc +++ b/src/flags.cc @@ -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"); diff --git a/src/platform-linux.cc b/src/platform-linux.cc index 4ac69ec..38f7c67 100644 --- a/src/platform-linux.cc +++ b/src/platform-linux.cc @@ -996,25 +996,6 @@ void OS::SetUp() { uint64_t seed = Ticks() ^ (getpid() << 16); srandom(static_cast(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 } diff --git a/tools/gyp/v8.gyp b/tools/gyp/v8.gyp index 80ab63c..d285205 100644 --- a/tools/gyp/v8.gyp +++ b/tools/gyp/v8.gyp @@ -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)',