mirror of
https://github.com/google/cpu_features.git
synced 2025-04-27 23:22:31 +02:00
Use enum properly to directly access kConfig struct
This commit is contained in:
Dr.-Ing. Patrick Siegl
parent
bdb36d9489
commit
22c05ed620
@ -20,6 +20,7 @@
|
||||
#include "internal/string_view.h"
|
||||
#include "internal/unix_features_aggregator.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <ctype.h>
|
||||
|
||||
DECLARE_SETTER(Aarch64Features, fp)
|
||||
@ -31,13 +32,13 @@ DECLARE_SETTER(Aarch64Features, sha2)
|
||||
DECLARE_SETTER(Aarch64Features, crc32)
|
||||
|
||||
static const CapabilityConfig kConfigs[] = {
|
||||
{{AARCH64_HWCAP_FP, 0}, "fp", &set_fp}, //
|
||||
{{AARCH64_HWCAP_ASIMD, 0}, "asimd", &set_asimd}, //
|
||||
{{AARCH64_HWCAP_AES, 0}, "aes", &set_aes}, //
|
||||
{{AARCH64_HWCAP_PMULL, 0}, "pmull", &set_pmull}, //
|
||||
{{AARCH64_HWCAP_SHA1, 0}, "sha1", &set_sha1}, //
|
||||
{{AARCH64_HWCAP_SHA2, 0}, "sha2", &set_sha2}, //
|
||||
{{AARCH64_HWCAP_CRC32, 0}, "crc32", &set_crc32}, //
|
||||
[AARCH64_FP] = {{AARCH64_HWCAP_FP, 0}, "fp", &set_fp}, //
|
||||
[AARCH64_ASIMD] = {{AARCH64_HWCAP_ASIMD, 0}, "asimd", &set_asimd}, //
|
||||
[AARCH64_AES] = {{AARCH64_HWCAP_AES, 0}, "aes", &set_aes}, //
|
||||
[AARCH64_PMULL] = {{AARCH64_HWCAP_PMULL, 0}, "pmull", &set_pmull}, //
|
||||
[AARCH64_SHA1] = {{AARCH64_HWCAP_SHA1, 0}, "sha1", &set_sha1}, //
|
||||
[AARCH64_SHA2] = {{AARCH64_HWCAP_SHA2, 0}, "sha2", &set_sha2}, //
|
||||
[AARCH64_CRC32] {{AARCH64_HWCAP_CRC32, 0}, "crc32", &set_crc32}, //
|
||||
};
|
||||
|
||||
static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig);
|
||||
@ -79,6 +80,8 @@ static void FillProcCpuInfoData(Aarch64Info* const info) {
|
||||
static const Aarch64Info kEmptyAarch64Info;
|
||||
|
||||
Aarch64Info GetAarch64Info(void) {
|
||||
assert(kConfigsSize == AARCH64_LAST_);
|
||||
|
||||
// capabilities are fetched from both getauxval and /proc/cpuinfo so we can
|
||||
// have some information if the executable is sandboxed (aka no access to
|
||||
// /proc/cpuinfo).
|
||||
@ -119,23 +122,7 @@ int GetAarch64FeaturesEnumValue(const Aarch64Features* features,
|
||||
}
|
||||
|
||||
const char* GetAarch64FeaturesEnumName(Aarch64FeaturesEnum value) {
|
||||
switch (value) {
|
||||
case AARCH64_FP:
|
||||
return "fp";
|
||||
case AARCH64_ASIMD:
|
||||
return "asimd";
|
||||
case AARCH64_AES:
|
||||
return "aes";
|
||||
case AARCH64_PMULL:
|
||||
return "pmull";
|
||||
case AARCH64_SHA1:
|
||||
return "sha1";
|
||||
case AARCH64_SHA2:
|
||||
return "sha2";
|
||||
case AARCH64_CRC32:
|
||||
return "crc32";
|
||||
case AARCH64_LAST_:
|
||||
break;
|
||||
}
|
||||
return "unknown feature";
|
||||
if(value >= kConfigsSize)
|
||||
return "unknown feature";
|
||||
return kConfigs[value].proc_cpuinfo_flag;
|
||||
}
|
||||
|
||||
@ -21,6 +21,7 @@
|
||||
#include "internal/string_view.h"
|
||||
#include "internal/unix_features_aggregator.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <ctype.h>
|
||||
|
||||
DECLARE_SETTER(ArmFeatures, swp)
|
||||
@ -52,33 +53,33 @@ DECLARE_SETTER(ArmFeatures, sha2)
|
||||
DECLARE_SETTER(ArmFeatures, crc32)
|
||||
|
||||
static const CapabilityConfig kConfigs[] = {
|
||||
{{ARM_HWCAP_SWP, 0}, "swp", &set_swp}, //
|
||||
{{ARM_HWCAP_HALF, 0}, "half", &set_half}, //
|
||||
{{ARM_HWCAP_THUMB, 0}, "thumb", &set_thumb}, //
|
||||
{{ARM_HWCAP_26BIT, 0}, "26bit", &set__26bit}, //
|
||||
{{ARM_HWCAP_FAST_MULT, 0}, "fastmult", &set_fastmult}, //
|
||||
{{ARM_HWCAP_FPA, 0}, "fpa", &set_fpa}, //
|
||||
{{ARM_HWCAP_VFP, 0}, "vfp", &set_vfp}, //
|
||||
{{ARM_HWCAP_EDSP, 0}, "edsp", &set_edsp}, //
|
||||
{{ARM_HWCAP_JAVA, 0}, "java", &set_java}, //
|
||||
{{ARM_HWCAP_IWMMXT, 0}, "iwmmxt", &set_iwmmxt}, //
|
||||
{{ARM_HWCAP_CRUNCH, 0}, "crunch", &set_crunch}, //
|
||||
{{ARM_HWCAP_THUMBEE, 0}, "thumbee", &set_thumbee}, //
|
||||
{{ARM_HWCAP_NEON, 0}, "neon", &set_neon}, //
|
||||
{{ARM_HWCAP_VFPV3, 0}, "vfpv3", &set_vfpv3}, //
|
||||
{{ARM_HWCAP_VFPV3D16, 0}, "vfpv3d16", &set_vfpv3d16}, //
|
||||
{{ARM_HWCAP_TLS, 0}, "tls", &set_tls}, //
|
||||
{{ARM_HWCAP_VFPV4, 0}, "vfpv4", &set_vfpv4}, //
|
||||
{{ARM_HWCAP_IDIVA, 0}, "idiva", &set_idiva}, //
|
||||
{{ARM_HWCAP_IDIVT, 0}, "idivt", &set_idivt}, //
|
||||
{{ARM_HWCAP_VFPD32, 0}, "vfpd32", &set_vfpd32}, //
|
||||
{{ARM_HWCAP_LPAE, 0}, "lpae", &set_lpae}, //
|
||||
{{ARM_HWCAP_EVTSTRM, 0}, "evtstrm", &set_evtstrm}, //
|
||||
{{0, ARM_HWCAP2_AES}, "aes", &set_aes}, //
|
||||
{{0, ARM_HWCAP2_PMULL}, "pmull", &set_pmull}, //
|
||||
{{0, ARM_HWCAP2_SHA1}, "sha1", &set_sha1}, //
|
||||
{{0, ARM_HWCAP2_SHA2}, "sha2", &set_sha2}, //
|
||||
{{0, ARM_HWCAP2_CRC32}, "crc32", &set_crc32}, //
|
||||
[ARM_SWP] = {{ARM_HWCAP_SWP, 0}, "swp", &set_swp}, //
|
||||
[ARM_HALF] = {{ARM_HWCAP_HALF, 0}, "half", &set_half}, //
|
||||
[ARM_THUMB] = {{ARM_HWCAP_THUMB, 0}, "thumb", &set_thumb}, //
|
||||
[ARM_26BIT] = {{ARM_HWCAP_26BIT, 0}, "26bit", &set__26bit}, //
|
||||
[ARM_FASTMULT] = {{ARM_HWCAP_FAST_MULT, 0}, "fastmult", &set_fastmult}, //
|
||||
[ARM_FPA] = {{ARM_HWCAP_FPA, 0}, "fpa", &set_fpa}, //
|
||||
[ARM_VFP] = {{ARM_HWCAP_VFP, 0}, "vfp", &set_vfp}, //
|
||||
[ARM_EDSP] = {{ARM_HWCAP_EDSP, 0}, "edsp", &set_edsp}, //
|
||||
[ARM_JAVA] = {{ARM_HWCAP_JAVA, 0}, "java", &set_java}, //
|
||||
[ARM_IWMMXT] = {{ARM_HWCAP_IWMMXT, 0}, "iwmmxt", &set_iwmmxt}, //
|
||||
[ARM_CRUNCH] = {{ARM_HWCAP_CRUNCH, 0}, "crunch", &set_crunch}, //
|
||||
[ARM_THUMBEE] = {{ARM_HWCAP_THUMBEE, 0}, "thumbee", &set_thumbee}, //
|
||||
[ARM_NEON] = {{ARM_HWCAP_NEON, 0}, "neon", &set_neon}, //
|
||||
[ARM_VFPV3] = {{ARM_HWCAP_VFPV3, 0}, "vfpv3", &set_vfpv3}, //
|
||||
[ARM_VFPV3D16] = {{ARM_HWCAP_VFPV3D16, 0}, "vfpv3d16", &set_vfpv3d16}, //
|
||||
[ARM_TLS] = {{ARM_HWCAP_TLS, 0}, "tls", &set_tls}, //
|
||||
[ARM_VFPV4] = {{ARM_HWCAP_VFPV4, 0}, "vfpv4", &set_vfpv4}, //
|
||||
[ARM_IDIVA] = {{ARM_HWCAP_IDIVA, 0}, "idiva", &set_idiva}, //
|
||||
[ARM_IDIVT] = {{ARM_HWCAP_IDIVT, 0}, "idivt", &set_idivt}, //
|
||||
[ARM_VFPD32] = {{ARM_HWCAP_VFPD32, 0}, "vfpd32", &set_vfpd32}, //
|
||||
[ARM_LPAE] = {{ARM_HWCAP_LPAE, 0}, "lpae", &set_lpae}, //
|
||||
[ARM_EVTSTRM] = {{ARM_HWCAP_EVTSTRM, 0}, "evtstrm", &set_evtstrm}, //
|
||||
[ARM_AES] = {{0, ARM_HWCAP2_AES}, "aes", &set_aes}, //
|
||||
[ARM_PMULL] = {{0, ARM_HWCAP2_PMULL}, "pmull", &set_pmull}, //
|
||||
[ARM_SHA1] = {{0, ARM_HWCAP2_SHA1}, "sha1", &set_sha1}, //
|
||||
[ARM_SHA2] = {{0, ARM_HWCAP2_SHA2}, "sha2", &set_sha2}, //
|
||||
[ARM_CRC32] = {{0, ARM_HWCAP2_CRC32}, "crc32", &set_crc32}, //
|
||||
};
|
||||
|
||||
static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig);
|
||||
@ -285,61 +286,7 @@ int GetArmFeaturesEnumValue(const ArmFeatures* features,
|
||||
}
|
||||
|
||||
const char* GetArmFeaturesEnumName(ArmFeaturesEnum value) {
|
||||
switch (value) {
|
||||
case ARM_SWP:
|
||||
return "swp";
|
||||
case ARM_HALF:
|
||||
return "half";
|
||||
case ARM_THUMB:
|
||||
return "thumb";
|
||||
case ARM_FASTMULT:
|
||||
return "fastmult";
|
||||
case ARM_FPA:
|
||||
return "fpa";
|
||||
case ARM_VFP:
|
||||
return "vfp";
|
||||
case ARM_EDSP:
|
||||
return "edsp";
|
||||
case ARM_JAVA:
|
||||
return "java";
|
||||
case ARM_IWMMXT:
|
||||
return "iwmmxt";
|
||||
case ARM_CRUNCH:
|
||||
return "crunch";
|
||||
case ARM_THUMBEE:
|
||||
return "thumbee";
|
||||
case ARM_NEON:
|
||||
return "neon";
|
||||
case ARM_VFPV3:
|
||||
return "vfpv3";
|
||||
case ARM_VFPV3D16:
|
||||
return "vfpv3d16";
|
||||
case ARM_TLS:
|
||||
return "tls";
|
||||
case ARM_VFPV4:
|
||||
return "vfpv4";
|
||||
case ARM_IDIVA:
|
||||
return "idiva";
|
||||
case ARM_IDIVT:
|
||||
return "idivt";
|
||||
case ARM_VFPD32:
|
||||
return "vfpd32";
|
||||
case ARM_LPAE:
|
||||
return "lpae";
|
||||
case ARM_EVTSTRM:
|
||||
return "evtstrm";
|
||||
case ARM_AES:
|
||||
return "aes";
|
||||
case ARM_PMULL:
|
||||
return "pmull";
|
||||
case ARM_SHA1:
|
||||
return "sha1";
|
||||
case ARM_SHA2:
|
||||
return "sha2";
|
||||
case ARM_CRC32:
|
||||
return "crc32";
|
||||
case ARM_LAST_:
|
||||
break;
|
||||
}
|
||||
return "unknown feature";
|
||||
if(value >= kConfigsSize)
|
||||
return "unknown feature";
|
||||
return kConfigs[value].proc_cpuinfo_flag;
|
||||
}
|
||||
|
||||
@ -19,14 +19,16 @@
|
||||
#include "internal/string_view.h"
|
||||
#include "internal/unix_features_aggregator.h"
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
DECLARE_SETTER(MipsFeatures, msa)
|
||||
DECLARE_SETTER(MipsFeatures, eva)
|
||||
DECLARE_SETTER(MipsFeatures, r6)
|
||||
|
||||
static const CapabilityConfig kConfigs[] = {
|
||||
{{MIPS_HWCAP_MSA, 0}, "msa", &set_msa}, //
|
||||
{{0, 0}, "eva", &set_eva}, //
|
||||
{{MIPS_HWCAP_R6, 0}, "r6", &set_r6}, //
|
||||
[MIPS_MSA] = {{MIPS_HWCAP_MSA, 0}, "msa", &set_msa}, //
|
||||
[MIPS_EVA] = {{0, 0}, "eva", &set_eva}, //
|
||||
[MIPS_R6] = {{MIPS_HWCAP_R6, 0}, "r6", &set_r6}, //
|
||||
};
|
||||
static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig);
|
||||
|
||||
@ -59,6 +61,8 @@ static void FillProcCpuInfoData(MipsFeatures* const features) {
|
||||
static const MipsInfo kEmptyMipsInfo;
|
||||
|
||||
MipsInfo GetMipsInfo(void) {
|
||||
assert(kConfigsSize == MIPS_LAST_);
|
||||
|
||||
// capabilities are fetched from both getauxval and /proc/cpuinfo so we can
|
||||
// have some information if the executable is sandboxed (aka no access to
|
||||
// /proc/cpuinfo).
|
||||
@ -90,15 +94,7 @@ int GetMipsFeaturesEnumValue(const MipsFeatures* features,
|
||||
}
|
||||
|
||||
const char* GetMipsFeaturesEnumName(MipsFeaturesEnum value) {
|
||||
switch (value) {
|
||||
case MIPS_MSA:
|
||||
return "msa";
|
||||
case MIPS_EVA:
|
||||
return "eva";
|
||||
case MIPS_R6:
|
||||
return "r6";
|
||||
case MIPS_LAST_:
|
||||
break;
|
||||
}
|
||||
return "unknown feature";
|
||||
if(value >= kConfigsSize)
|
||||
return "unknown feature";
|
||||
return kConfigs[value].proc_cpuinfo_flag;
|
||||
}
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdbool.h>
|
||||
#include <string.h>
|
||||
|
||||
@ -65,49 +66,49 @@ DECLARE_SETTER(PPCFeatures, scv)
|
||||
DECLARE_SETTER(PPCFeatures, htm_no_suspend)
|
||||
|
||||
static const CapabilityConfig kConfigs[] = {
|
||||
{{PPC_FEATURE_32, 0}, "ppc32", &set_ppc32},
|
||||
{{PPC_FEATURE_64, 0}, "ppc64", &set_ppc64},
|
||||
{{PPC_FEATURE_601_INSTR, 0}, "ppc601", &set_ppc601},
|
||||
{{PPC_FEATURE_HAS_ALTIVEC, 0}, "altivec", &set_altivec},
|
||||
{{PPC_FEATURE_HAS_FPU, 0}, "fpu", &set_fpu},
|
||||
{{PPC_FEATURE_HAS_MMU, 0}, "mmu", &set_mmu},
|
||||
{{PPC_FEATURE_HAS_4xxMAC, 0}, "4xxmac", &set_mac_4xx},
|
||||
{{PPC_FEATURE_UNIFIED_CACHE, 0}, "ucache", &set_unifiedcache},
|
||||
{{PPC_FEATURE_HAS_SPE, 0}, "spe", &set_spe},
|
||||
{{PPC_FEATURE_HAS_EFP_SINGLE, 0}, "efpsingle", &set_efpsingle},
|
||||
{{PPC_FEATURE_HAS_EFP_DOUBLE, 0}, "efpdouble", &set_efpdouble},
|
||||
{{PPC_FEATURE_NO_TB, 0}, "notb", &set_no_tb},
|
||||
{{PPC_FEATURE_POWER4, 0}, "power4", &set_power4},
|
||||
{{PPC_FEATURE_POWER5, 0}, "power5", &set_power5},
|
||||
{{PPC_FEATURE_POWER5_PLUS, 0}, "power5+", &set_power5plus},
|
||||
{{PPC_FEATURE_CELL, 0}, "cellbe", &set_cell},
|
||||
{{PPC_FEATURE_BOOKE, 0}, "booke", &set_booke},
|
||||
{{PPC_FEATURE_SMT, 0}, "smt", &set_smt},
|
||||
{{PPC_FEATURE_ICACHE_SNOOP, 0}, "ic_snoop", &set_icachesnoop},
|
||||
{{PPC_FEATURE_ARCH_2_05, 0}, "arch_2_05", &set_arch205},
|
||||
{{PPC_FEATURE_PA6T, 0}, "pa6t", &set_pa6t},
|
||||
{{PPC_FEATURE_HAS_DFP, 0}, "dfp", &set_dfp},
|
||||
{{PPC_FEATURE_POWER6_EXT, 0}, "power6x", &set_power6ext},
|
||||
{{PPC_FEATURE_ARCH_2_06, 0}, "arch_2_06", &set_arch206},
|
||||
{{PPC_FEATURE_HAS_VSX, 0}, "vsx", &set_vsx},
|
||||
{{PPC_FEATURE_PSERIES_PERFMON_COMPAT, 0},
|
||||
[PPC_32] = {{PPC_FEATURE_32, 0}, "ppc32", &set_ppc32},
|
||||
[PPC_64] = {{PPC_FEATURE_64, 0}, "ppc64", &set_ppc64},
|
||||
[PPC_601_INSTR] = {{PPC_FEATURE_601_INSTR, 0}, "ppc601", &set_ppc601},
|
||||
[PPC_HAS_ALTIVEC] = {{PPC_FEATURE_HAS_ALTIVEC, 0}, "altivec", &set_altivec},
|
||||
[PPC_HAS_FPU] = {{PPC_FEATURE_HAS_FPU, 0}, "fpu", &set_fpu},
|
||||
[PPC_HAS_MMU] = {{PPC_FEATURE_HAS_MMU, 0}, "mmu", &set_mmu},
|
||||
[PPC_HAS_4xxMAC] = {{PPC_FEATURE_HAS_4xxMAC, 0}, "4xxmac", &set_mac_4xx},
|
||||
[PPC_UNIFIED_CACHE] = {{PPC_FEATURE_UNIFIED_CACHE, 0}, "ucache", &set_unifiedcache},
|
||||
[PPC_HAS_SPE] = {{PPC_FEATURE_HAS_SPE, 0}, "spe", &set_spe},
|
||||
[PPC_HAS_EFP_SINGLE] = {{PPC_FEATURE_HAS_EFP_SINGLE, 0}, "efpsingle", &set_efpsingle},
|
||||
[PPC_HAS_EFP_DOUBLE] = {{PPC_FEATURE_HAS_EFP_DOUBLE, 0}, "efpdouble", &set_efpdouble},
|
||||
[PPC_NO_TB] = {{PPC_FEATURE_NO_TB, 0}, "notb", &set_no_tb},
|
||||
[PPC_POWER4] = {{PPC_FEATURE_POWER4, 0}, "power4", &set_power4},
|
||||
[PPC_POWER5] = {{PPC_FEATURE_POWER5, 0}, "power5", &set_power5},
|
||||
[PPC_POWER5_PLUS] = {{PPC_FEATURE_POWER5_PLUS, 0}, "power5+", &set_power5plus},
|
||||
[PPC_CELL] = {{PPC_FEATURE_CELL, 0}, "cellbe", &set_cell},
|
||||
[PPC_BOOKE] = {{PPC_FEATURE_BOOKE, 0}, "booke", &set_booke},
|
||||
[PPC_SMT] = {{PPC_FEATURE_SMT, 0}, "smt", &set_smt},
|
||||
[PPC_ICACHE_SNOOP] = {{PPC_FEATURE_ICACHE_SNOOP, 0}, "ic_snoop", &set_icachesnoop},
|
||||
[PPC_ARCH_2_05] = {{PPC_FEATURE_ARCH_2_05, 0}, "arch_2_05", &set_arch205},
|
||||
[PPC_PA6T] = {{PPC_FEATURE_PA6T, 0}, "pa6t", &set_pa6t},
|
||||
[PPC_HAS_DFP] = {{PPC_FEATURE_HAS_DFP, 0}, "dfp", &set_dfp},
|
||||
[PPC_POWER6_EXT] = {{PPC_FEATURE_POWER6_EXT, 0}, "power6x", &set_power6ext},
|
||||
[PPC_ARCH_2_06] = {{PPC_FEATURE_ARCH_2_06, 0}, "arch_2_06", &set_arch206},
|
||||
[PPC_HAS_VSX] = {{PPC_FEATURE_HAS_VSX, 0}, "vsx", &set_vsx},
|
||||
[PPC_PSERIES_PERFMON_COMPAT] = {{PPC_FEATURE_PSERIES_PERFMON_COMPAT, 0},
|
||||
"archpmu",
|
||||
&set_pseries_perfmon_compat},
|
||||
{{PPC_FEATURE_TRUE_LE, 0}, "true_le", &set_truele},
|
||||
{{PPC_FEATURE_PPC_LE, 0}, "ppcle", &set_ppcle},
|
||||
{{0, PPC_FEATURE2_ARCH_2_07}, "arch_2_07", &set_arch207},
|
||||
{{0, PPC_FEATURE2_HTM}, "htm", &set_htm},
|
||||
{{0, PPC_FEATURE2_DSCR}, "dscr", &set_dscr},
|
||||
{{0, PPC_FEATURE2_EBB}, "ebb", &set_ebb},
|
||||
{{0, PPC_FEATURE2_ISEL}, "isel", &set_isel},
|
||||
{{0, PPC_FEATURE2_TAR}, "tar", &set_tar},
|
||||
{{0, PPC_FEATURE2_VEC_CRYPTO}, "vcrypto", &set_vcrypto},
|
||||
{{0, PPC_FEATURE2_HTM_NOSC}, "htm-nosc", &set_htm_nosc},
|
||||
{{0, PPC_FEATURE2_ARCH_3_00}, "arch_3_00", &set_arch300},
|
||||
{{0, PPC_FEATURE2_HAS_IEEE128}, "ieee128", &set_ieee128},
|
||||
{{0, PPC_FEATURE2_DARN}, "darn", &set_darn},
|
||||
{{0, PPC_FEATURE2_SCV}, "scv", &set_scv},
|
||||
{{0, PPC_FEATURE2_HTM_NO_SUSPEND}, "htm-no-suspend", &set_htm_no_suspend},
|
||||
[PPC_TRUE_LE] = {{PPC_FEATURE_TRUE_LE, 0}, "true_le", &set_truele},
|
||||
[PPC_PPC_LE] = {{PPC_FEATURE_PPC_LE, 0}, "ppcle", &set_ppcle},
|
||||
[PPC_ARCH_2_07] = {{0, PPC_FEATURE2_ARCH_2_07}, "arch_2_07", &set_arch207},
|
||||
[PPC_HTM] = {{0, PPC_FEATURE2_HTM}, "htm", &set_htm},
|
||||
[PPC_DSCR] = {{0, PPC_FEATURE2_DSCR}, "dscr", &set_dscr},
|
||||
[PPC_EBB] = {{0, PPC_FEATURE2_EBB}, "ebb", &set_ebb},
|
||||
[PPC_ISEL] = {{0, PPC_FEATURE2_ISEL}, "isel", &set_isel},
|
||||
[PPC_TAR] = {{0, PPC_FEATURE2_TAR}, "tar", &set_tar},
|
||||
[PPC_VEC_CRYPTO] = {{0, PPC_FEATURE2_VEC_CRYPTO}, "vcrypto", &set_vcrypto},
|
||||
[PPC_HTM_NOSC] = {{0, PPC_FEATURE2_HTM_NOSC}, "htm-nosc", &set_htm_nosc},
|
||||
[PPC_ARCH_3_00] = {{0, PPC_FEATURE2_ARCH_3_00}, "arch_3_00", &set_arch300},
|
||||
[PPC_HAS_IEEE128] = {{0, PPC_FEATURE2_HAS_IEEE128}, "ieee128", &set_ieee128},
|
||||
[PPC_DARN] = {{0, PPC_FEATURE2_DARN}, "darn", &set_darn},
|
||||
[PPC_SCV] = {{0, PPC_FEATURE2_SCV}, "scv", &set_scv},
|
||||
[PPC_HTM_NO_SUSPEND] = {{0, PPC_FEATURE2_HTM_NO_SUSPEND}, "htm-no-suspend", &set_htm_no_suspend},
|
||||
};
|
||||
static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig);
|
||||
|
||||
@ -268,91 +269,7 @@ int GetPPCFeaturesEnumValue(const PPCFeatures* features,
|
||||
|
||||
/* Have used the same names as glibc */
|
||||
const char* GetPPCFeaturesEnumName(PPCFeaturesEnum value) {
|
||||
switch (value) {
|
||||
case PPC_32:
|
||||
return "ppc32";
|
||||
case PPC_64:
|
||||
return "ppc64";
|
||||
case PPC_601_INSTR:
|
||||
return "ppc601";
|
||||
case PPC_HAS_ALTIVEC:
|
||||
return "altivec";
|
||||
case PPC_HAS_FPU:
|
||||
return "fpu";
|
||||
case PPC_HAS_MMU:
|
||||
return "mmu";
|
||||
case PPC_HAS_4xxMAC:
|
||||
return "4xxmac";
|
||||
case PPC_UNIFIED_CACHE:
|
||||
return "ucache";
|
||||
case PPC_HAS_SPE:
|
||||
return "spe";
|
||||
case PPC_HAS_EFP_SINGLE:
|
||||
return "efpsingle";
|
||||
case PPC_HAS_EFP_DOUBLE:
|
||||
return "efpdouble";
|
||||
case PPC_NO_TB:
|
||||
return "notb";
|
||||
case PPC_POWER4:
|
||||
return "power4";
|
||||
case PPC_POWER5:
|
||||
return "power5";
|
||||
case PPC_POWER5_PLUS:
|
||||
return "power5+";
|
||||
case PPC_CELL:
|
||||
return "cellbe";
|
||||
case PPC_BOOKE:
|
||||
return "booke";
|
||||
case PPC_SMT:
|
||||
return "smt";
|
||||
case PPC_ICACHE_SNOOP:
|
||||
return "ic_snoop";
|
||||
case PPC_ARCH_2_05:
|
||||
return "arch_2_05";
|
||||
case PPC_PA6T:
|
||||
return "pa6t";
|
||||
case PPC_HAS_DFP:
|
||||
return "dfp";
|
||||
case PPC_POWER6_EXT:
|
||||
return "power6x";
|
||||
case PPC_ARCH_2_06:
|
||||
return "arch_2_06";
|
||||
case PPC_HAS_VSX:
|
||||
return "vsx";
|
||||
case PPC_PSERIES_PERFMON_COMPAT:
|
||||
return "archpmu";
|
||||
case PPC_TRUE_LE:
|
||||
return "true_le";
|
||||
case PPC_PPC_LE:
|
||||
return "ppcle";
|
||||
case PPC_ARCH_2_07:
|
||||
return "arch_2_07";
|
||||
case PPC_HTM:
|
||||
return "htm";
|
||||
case PPC_DSCR:
|
||||
return "dscr";
|
||||
case PPC_EBB:
|
||||
return "ebb";
|
||||
case PPC_ISEL:
|
||||
return "isel";
|
||||
case PPC_TAR:
|
||||
return "tar";
|
||||
case PPC_VEC_CRYPTO:
|
||||
return "vcrypto";
|
||||
case PPC_HTM_NOSC:
|
||||
return "htm-nosc";
|
||||
case PPC_ARCH_3_00:
|
||||
return "arch_3_00";
|
||||
case PPC_HAS_IEEE128:
|
||||
return "ieee128";
|
||||
case PPC_DARN:
|
||||
return "darn";
|
||||
case PPC_SCV:
|
||||
return "scv";
|
||||
case PPC_HTM_NO_SUSPEND:
|
||||
return "htm-no-suspend";
|
||||
case PPC_LAST_:
|
||||
break;
|
||||
}
|
||||
return "unknown_feature";
|
||||
if(value >= kConfigsSize)
|
||||
return "unknown feature";
|
||||
return kConfigs[value].proc_cpuinfo_flag;
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user