Use enum properly to directly access kConfig struct (#83)v0.4.0

4 files changed, 99 insertions, 252 deletions

diff --git a/src/cpuinfo_aarch64.c b/src/cpuinfo_aarch64.c
index 57e9c8d..26a07d3 100644
--- a/src/cpuinfo_aarch64.c
+++ b/src/cpuinfo_aarch64.c
@@ -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;
 }
diff --git a/src/cpuinfo_arm.c b/src/cpuinfo_arm.c
index 096e6ae..66c6d91 100644
--- a/src/cpuinfo_arm.c
+++ b/src/cpuinfo_arm.c
@@ -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;
 }
diff --git a/src/cpuinfo_mips.c b/src/cpuinfo_mips.c
index 706d555..8769211 100644
--- a/src/cpuinfo_mips.c
+++ b/src/cpuinfo_mips.c
@@ -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;
 }
diff --git a/src/cpuinfo_ppc.c b/src/cpuinfo_ppc.c
index 53d2059..d6c49f8 100644
--- a/src/cpuinfo_ppc.c
+++ b/src/cpuinfo_ppc.c
@@ -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;
 }