diff --git a/CMakeLists.txt b/CMakeLists.txt
index 73e1eb4..2138601 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -114,9 +114,7 @@ setup_include_and_definitions(utils)
 if(UNIX)
   add_library(unix_based_hardware_detection OBJECT
     ${PROJECT_SOURCE_DIR}/include/internal/hwcaps.h
-    ${PROJECT_SOURCE_DIR}/include/internal/unix_features_aggregator.h
     ${PROJECT_SOURCE_DIR}/src/hwcaps.c
-    ${PROJECT_SOURCE_DIR}/src/unix_features_aggregator.c
   )
   setup_include_and_definitions(unix_based_hardware_detection)
   check_include_file(dlfcn.h HAVE_DLFCN_H)
diff --git a/include/internal/hwcaps.h b/include/internal/hwcaps.h
index 1c99e7b..62037c8 100644
--- a/include/internal/hwcaps.h
+++ b/include/internal/hwcaps.h
@@ -17,6 +17,7 @@
 #ifndef CPU_FEATURES_INCLUDE_INTERNAL_HWCAPS_H_
 #define CPU_FEATURES_INCLUDE_INTERNAL_HWCAPS_H_
 
+#include <stdbool.h>
 #include <stdint.h>
 
 #include "cpu_features_macros.h"
@@ -170,6 +171,8 @@ typedef struct {
 } HardwareCapabilities;
 
 HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void);
+bool CpuFeatures_IsHwCapsSet(const HardwareCapabilities hwcaps_mask,
+                             const HardwareCapabilities hwcaps);
 
 typedef struct {
   char platform[64];       // 0 terminated string
diff --git a/include/internal/unix_features_aggregator.h b/include/internal/unix_features_aggregator.h
deleted file mode 100644
index 56abd6c..0000000
--- a/include/internal/unix_features_aggregator.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2017 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// CapabilityConfig provides a way to map cpu features to hardware caps and
-// /proc/cpuinfo flags. We then provide functions to update capabilities from
-// either source.
-#ifndef CPU_FEATURES_INCLUDE_INTERNAL_LINUX_FEATURES_AGGREGATOR_H_
-#define CPU_FEATURES_INCLUDE_INTERNAL_LINUX_FEATURES_AGGREGATOR_H_
-
-#include <ctype.h>
-#include <stdint.h>
-
-#include "cpu_features_macros.h"
-#include "internal/hwcaps.h"
-#include "internal/string_view.h"
-
-CPU_FEATURES_START_CPP_NAMESPACE
-
-// Use the following macro to declare setter functions to be used in
-// CapabilityConfig.
-#define DECLARE_SETTER(FeatureType, FeatureName)                    \
-  static void set_##FeatureName(void* const features, bool value) { \
-    ((FeatureType*)features)->FeatureName = value;                  \
-  }
-
-// Use the following macro to declare getter functions to be used in
-// CapabilityConfig.
-#define DECLARE_GETTER(FeatureType, FeatureName)       \
-  static int get_##FeatureName(void* const features) { \
-    return ((FeatureType*)features)->FeatureName;      \
-  }
-
-#define DECLARE_SETTER_AND_GETTER(FeatureType, FeatureName) \
-  DECLARE_SETTER(FeatureType, FeatureName)                  \
-  DECLARE_GETTER(FeatureType, FeatureName)
-
-// Describes the relationship between hardware caps and /proc/cpuinfo flags.
-typedef struct {
-  const HardwareCapabilities hwcaps_mask;
-  const char* const proc_cpuinfo_flag;
-  void (*set_bit)(void* const, bool);  // setter for the corresponding bit.
-  int (*get_bit)(void* const);         // getter for the corresponding bit.
-} CapabilityConfig;
-
-// For every config, looks into flags_line for the presence of the
-// corresponding proc_cpuinfo_flag, calls `set_bit` accordingly.
-// Note: features is a pointer to the underlying Feature struct.
-void CpuFeatures_SetFromFlags(const size_t configs_size,
-                              const CapabilityConfig* configs,
-                              const StringView flags_line,
-                              void* const features);
-
-// For every config, looks into hwcaps for the presence of the feature. Calls
-// `set_bit` with true if the hardware capability is found.
-// Note: features is a pointer to the underlying Feature struct.
-void CpuFeatures_OverrideFromHwCaps(const size_t configs_size,
-                                    const CapabilityConfig* configs,
-                                    const HardwareCapabilities hwcaps,
-                                    void* const features);
-
-CPU_FEATURES_END_CPP_NAMESPACE
-#endif  // CPU_FEATURES_INCLUDE_INTERNAL_LINUX_FEATURES_AGGREGATOR_H_
diff --git a/src/cpuinfo_aarch64.c b/src/cpuinfo_aarch64.c
index 195f96f..542663b 100644
--- a/src/cpuinfo_aarch64.c
+++ b/src/cpuinfo_aarch64.c
@@ -21,115 +21,12 @@
 #include "internal/hwcaps.h"
 #include "internal/stack_line_reader.h"
 #include "internal/string_view.h"
-#include "internal/unix_features_aggregator.h"
 
-DECLARE_SETTER_AND_GETTER(Aarch64Features, fp)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, asimd)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, evtstrm)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, aes)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, pmull)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, sha1)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, sha2)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, crc32)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, atomics)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, fphp)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, asimdhp)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, cpuid)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, asimdrdm)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, jscvt)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, fcma)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, lrcpc)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, dcpop)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, sha3)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, sm3)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, sm4)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, asimddp)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, sha512)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, sve)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, asimdfhm)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, dit)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, uscat)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, ilrcpc)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, flagm)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, ssbs)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, sb)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, paca)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, pacg)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, dcpodp)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, sve2)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, sveaes)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, svepmull)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, svebitperm)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, svesha3)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, svesm4)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, flagm2)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, frint)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, svei8mm)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, svef32mm)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, svef64mm)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, svebf16)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, i8mm)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, bf16)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, dgh)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, rng)
-DECLARE_SETTER_AND_GETTER(Aarch64Features, bti)
-
-static const CapabilityConfig kConfigs[] = {
-    // clang-format off
-    [AARCH64_FP] = {{AARCH64_HWCAP_FP, 0}, "fp", &set_fp, &get_fp},
-    [AARCH64_ASIMD] = {{AARCH64_HWCAP_ASIMD, 0}, "asimd", &set_asimd, &get_asimd},
-    [AARCH64_EVTSTRM] = {{AARCH64_HWCAP_EVTSTRM, 0}, "evtstrm", &set_evtstrm, &get_evtstrm},
-    [AARCH64_AES] = {{AARCH64_HWCAP_AES, 0}, "aes", &set_aes, &get_aes},
-    [AARCH64_PMULL] = {{AARCH64_HWCAP_PMULL, 0}, "pmull", &set_pmull, &get_pmull},
-    [AARCH64_SHA1] = {{AARCH64_HWCAP_SHA1, 0}, "sha1", &set_sha1, &get_sha1},
-    [AARCH64_SHA2] = {{AARCH64_HWCAP_SHA2, 0}, "sha2", &set_sha2, &get_sha2},
-    [AARCH64_CRC32] = {{AARCH64_HWCAP_CRC32, 0}, "crc32", &set_crc32, &get_crc32},
-    [AARCH64_ATOMICS] = {{AARCH64_HWCAP_ATOMICS, 0}, "atomics", &set_atomics, &get_atomics},
-    [AARCH64_FPHP] = {{AARCH64_HWCAP_FPHP, 0}, "fphp", &set_fphp, &get_fphp},
-    [AARCH64_ASIMDHP] = {{AARCH64_HWCAP_ASIMDHP, 0}, "asimdhp", &set_asimdhp, &get_asimdhp},
-    [AARCH64_CPUID] = {{AARCH64_HWCAP_CPUID, 0}, "cpuid", &set_cpuid, &get_cpuid},
-    [AARCH64_ASIMDRDM] = {{AARCH64_HWCAP_ASIMDRDM, 0}, "asimdrdm", &set_asimdrdm, &get_asimdrdm},
-    [AARCH64_JSCVT] = {{AARCH64_HWCAP_JSCVT, 0}, "jscvt", &set_jscvt, &get_jscvt},
-    [AARCH64_FCMA] = {{AARCH64_HWCAP_FCMA, 0}, "fcma", &set_fcma, &get_fcma},
-    [AARCH64_LRCPC] = {{AARCH64_HWCAP_LRCPC, 0}, "lrcpc", &set_lrcpc, &get_lrcpc},
-    [AARCH64_DCPOP] = {{AARCH64_HWCAP_DCPOP, 0}, "dcpop", &set_dcpop, &get_dcpop},
-    [AARCH64_SHA3] = {{AARCH64_HWCAP_SHA3, 0}, "sha3", &set_sha3, &get_sha3},
-    [AARCH64_SM3] = {{AARCH64_HWCAP_SM3, 0}, "sm3", &set_sm3, &get_sm3},
-    [AARCH64_SM4] = {{AARCH64_HWCAP_SM4, 0}, "sm4", &set_sm4, &get_sm4},
-    [AARCH64_ASIMDDP] = {{AARCH64_HWCAP_ASIMDDP, 0}, "asimddp", &set_asimddp, &get_asimddp},
-    [AARCH64_SHA512] = {{AARCH64_HWCAP_SHA512, 0}, "sha512", &set_sha512, &get_sha512},
-    [AARCH64_SVE] = {{AARCH64_HWCAP_SVE, 0}, "sve", &set_sve, &get_sve},
-    [AARCH64_ASIMDFHM] = {{AARCH64_HWCAP_ASIMDFHM, 0}, "asimdfhm", &set_asimdfhm, &get_asimdfhm},
-    [AARCH64_DIT] = {{AARCH64_HWCAP_DIT, 0}, "dit", &set_dit, &get_dit},
-    [AARCH64_USCAT] = {{AARCH64_HWCAP_USCAT, 0}, "uscat", &set_uscat, &get_uscat},
-    [AARCH64_ILRCPC] = {{AARCH64_HWCAP_ILRCPC, 0}, "ilrcpc", &set_ilrcpc, &get_ilrcpc},
-    [AARCH64_FLAGM] = {{AARCH64_HWCAP_FLAGM, 0}, "flagm", &set_flagm, &get_flagm},
-    [AARCH64_SSBS] = {{AARCH64_HWCAP_SSBS, 0}, "ssbs", &set_ssbs, &get_ssbs},
-    [AARCH64_SB] = {{AARCH64_HWCAP_SB, 0}, "sb", &set_sb, &get_sb},
-    [AARCH64_PACA] = {{AARCH64_HWCAP_PACA, 0}, "paca", &set_paca, &get_paca},
-    [AARCH64_PACG] = {{AARCH64_HWCAP_PACG, 0}, "pacg", &set_pacg, &get_pacg},
-    [AARCH64_DCPODP] = {{0, AARCH64_HWCAP2_DCPODP}, "dcpodp", &set_dcpodp, &get_dcpodp},
-    [AARCH64_SVE2] = {{0, AARCH64_HWCAP2_SVE2}, "sve2", &set_sve2, &get_sve2},
-    [AARCH64_SVEAES] = {{0, AARCH64_HWCAP2_SVEAES}, "sveaes", &set_sveaes, &get_sveaes},
-    [AARCH64_SVEPMULL] = {{0, AARCH64_HWCAP2_SVEPMULL}, "svepmull", &set_svepmull, &get_svepmull},
-    [AARCH64_SVEBITPERM] = {{0, AARCH64_HWCAP2_SVEBITPERM}, "svebitperm", &set_svebitperm, &get_svebitperm},
-    [AARCH64_SVESHA3] = {{0, AARCH64_HWCAP2_SVESHA3}, "svesha3", &set_svesha3, &get_svesha3},
-    [AARCH64_SVESM4] = {{0, AARCH64_HWCAP2_SVESM4}, "svesm4", &set_svesm4, &get_svesm4},
-    [AARCH64_FLAGM2] = {{0, AARCH64_HWCAP2_FLAGM2}, "flagm2", &set_flagm2, &get_flagm2},
-    [AARCH64_FRINT] = {{0, AARCH64_HWCAP2_FRINT}, "frint", &set_frint, &get_frint},
-    [AARCH64_SVEI8MM] = {{0, AARCH64_HWCAP2_SVEI8MM}, "svei8mm", &set_svei8mm, &get_svei8mm},
-    [AARCH64_SVEF32MM] = {{0, AARCH64_HWCAP2_SVEF32MM}, "svef32mm", &set_svef32mm, &get_svef32mm},
-    [AARCH64_SVEF64MM] = {{0, AARCH64_HWCAP2_SVEF64MM}, "svef64mm", &set_svef64mm, &get_svef64mm},
-    [AARCH64_SVEBF16] = {{0, AARCH64_HWCAP2_SVEBF16}, "svebf16", &set_svebf16, &get_svebf16},
-    [AARCH64_I8MM] = {{0, AARCH64_HWCAP2_I8MM}, "i8mm", &set_i8mm, &get_i8mm},
-    [AARCH64_BF16] = {{0, AARCH64_HWCAP2_BF16}, "bf16", &set_bf16, &get_bf16},
-    [AARCH64_DGH] = {{0, AARCH64_HWCAP2_DGH}, "dgh", &set_dgh, &get_dgh},
-    [AARCH64_RNG] = {{0, AARCH64_HWCAP2_RNG}, "rng", &set_rng, &get_rng},
-    [AARCH64_BTI] = {{0, AARCH64_HWCAP2_BTI}, "bti", &set_bti, &get_bti},
-    // clang-format on
-};
-
-static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig);
+// Generation of feature's getters/setters functions and kGetters, kSetters,
+// kCpuInfoFlags and kHardwareCapabilities global tables.
+#define DEFINE_TABLE_FEATURE_TYPE Aarch64Features
+#define DEFINE_TABLE_DB_FILENAME "cpuinfo_aarch64_db.inl"
+#include "define_tables.h"
 
 static bool HandleAarch64Line(const LineResult result,
                               Aarch64Info* const info) {
@@ -137,7 +34,10 @@ static bool HandleAarch64Line(const LineResult result,
   StringView key, value;
   if (CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value)) {
     if (CpuFeatures_StringView_IsEquals(key, str("Features"))) {
-      CpuFeatures_SetFromFlags(kConfigsSize, kConfigs, value, &info->features);
+      for (size_t i = 0; i < AARCH64_LAST_; ++i) {
+        kSetters[i](&info->features,
+                    CpuFeatures_StringView_HasWord(value, kCpuInfoFlags[i]));
+      }
     } else if (CpuFeatures_StringView_IsEquals(key, str("CPU implementer"))) {
       info->implementer = CpuFeatures_StringView_ParsePositiveNumber(value);
     } else if (CpuFeatures_StringView_IsEquals(key, str("CPU variant"))) {
@@ -168,17 +68,18 @@ 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).
   Aarch64Info info = kEmptyAarch64Info;
 
   FillProcCpuInfoData(&info);
-  CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs,
-                                 CpuFeatures_GetHardwareCapabilities(),
-                                 &info.features);
+  const HardwareCapabilities hwcaps = CpuFeatures_GetHardwareCapabilities();
+  for (size_t i = 0; i < AARCH64_LAST_; ++i) {
+    if (CpuFeatures_IsHwCapsSet(kHardwareCapabilities[i], hwcaps)) {
+      kSetters[i](&info.features, true);
+    }
+  }
 
   return info;
 }
@@ -188,11 +89,11 @@ Aarch64Info GetAarch64Info(void) {
 
 int GetAarch64FeaturesEnumValue(const Aarch64Features* features,
                                 Aarch64FeaturesEnum value) {
-  if (value >= kConfigsSize) return false;
-  return kConfigs[value].get_bit((Aarch64Features*)features);
+  if (value >= AARCH64_LAST_) return false;
+  return kGetters[value](features);
 }
 
 const char* GetAarch64FeaturesEnumName(Aarch64FeaturesEnum value) {
-  if (value >= kConfigsSize) return "unknown feature";
-  return kConfigs[value].proc_cpuinfo_flag;
+  if (value >= AARCH64_LAST_) return "unknown feature";
+  return kCpuInfoFlags[value];
 }
diff --git a/src/cpuinfo_aarch64_db.inl b/src/cpuinfo_aarch64_db.inl
new file mode 100644
index 0000000..b3200f4
--- /dev/null
+++ b/src/cpuinfo_aarch64_db.inl
@@ -0,0 +1,71 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if defined(FEATURE)
+// FEATURE(ENUM, NAME, CPUINFO_FLAG, HWCAP, HWCAP2)
+// clang-format off
+FEATURE(AARCH64_FP, fp, "fp", AARCH64_HWCAP_FP, 0)
+FEATURE(AARCH64_ASIMD, asimd, "asimd", AARCH64_HWCAP_ASIMD, 0)
+FEATURE(AARCH64_EVTSTRM, evtstrm, "evtstrm", AARCH64_HWCAP_EVTSTRM, 0)
+FEATURE(AARCH64_AES, aes, "aes", AARCH64_HWCAP_AES, 0)
+FEATURE(AARCH64_PMULL, pmull, "pmull", AARCH64_HWCAP_PMULL, 0)
+FEATURE(AARCH64_SHA1, sha1, "sha1", AARCH64_HWCAP_SHA1, 0)
+FEATURE(AARCH64_SHA2, sha2, "sha2", AARCH64_HWCAP_SHA2, 0)
+FEATURE(AARCH64_CRC32, crc32, "crc32", AARCH64_HWCAP_CRC32, 0)
+FEATURE(AARCH64_ATOMICS, atomics, "atomics", AARCH64_HWCAP_ATOMICS, 0)
+FEATURE(AARCH64_FPHP, fphp, "fphp", AARCH64_HWCAP_FPHP, 0)
+FEATURE(AARCH64_ASIMDHP, asimdhp, "asimdhp", AARCH64_HWCAP_ASIMDHP, 0)
+FEATURE(AARCH64_CPUID, cpuid, "cpuid", AARCH64_HWCAP_CPUID, 0)
+FEATURE(AARCH64_ASIMDRDM, asimdrdm, "asimdrdm", AARCH64_HWCAP_ASIMDRDM, 0)
+FEATURE(AARCH64_JSCVT, jscvt, "jscvt", AARCH64_HWCAP_JSCVT, 0)
+FEATURE(AARCH64_FCMA, fcma, "fcma", AARCH64_HWCAP_FCMA, 0)
+FEATURE(AARCH64_LRCPC, lrcpc, "lrcpc", AARCH64_HWCAP_LRCPC, 0)
+FEATURE(AARCH64_DCPOP, dcpop, "dcpop", AARCH64_HWCAP_DCPOP, 0)
+FEATURE(AARCH64_SHA3, sha3, "sha3", AARCH64_HWCAP_SHA3, 0)
+FEATURE(AARCH64_SM3, sm3, "sm3", AARCH64_HWCAP_SM3, 0)
+FEATURE(AARCH64_SM4, sm4, "sm4", AARCH64_HWCAP_SM4, 0)
+FEATURE(AARCH64_ASIMDDP, asimddp, "asimddp", AARCH64_HWCAP_ASIMDDP, 0)
+FEATURE(AARCH64_SHA512, sha512, "sha512", AARCH64_HWCAP_SHA512, 0)
+FEATURE(AARCH64_SVE, sve, "sve", AARCH64_HWCAP_SVE, 0)
+FEATURE(AARCH64_ASIMDFHM, asimdfhm, "asimdfhm", AARCH64_HWCAP_ASIMDFHM, 0)
+FEATURE(AARCH64_DIT, dit, "dit", AARCH64_HWCAP_DIT, 0)
+FEATURE(AARCH64_USCAT, uscat, "uscat", AARCH64_HWCAP_USCAT, 0)
+FEATURE(AARCH64_ILRCPC, ilrcpc, "ilrcpc", AARCH64_HWCAP_ILRCPC, 0)
+FEATURE(AARCH64_FLAGM, flagm, "flagm", AARCH64_HWCAP_FLAGM, 0)
+FEATURE(AARCH64_SSBS, ssbs, "ssbs", AARCH64_HWCAP_SSBS, 0)
+FEATURE(AARCH64_SB, sb, "sb", AARCH64_HWCAP_SB, 0)
+FEATURE(AARCH64_PACA, paca, "paca", AARCH64_HWCAP_PACA, 0)
+FEATURE(AARCH64_PACG, pacg, "pacg", AARCH64_HWCAP_PACG, 0)
+FEATURE(AARCH64_DCPODP, dcpodp, "dcpodp", 0, AARCH64_HWCAP2_DCPODP)
+FEATURE(AARCH64_SVE2, sve2, "sve2", 0, AARCH64_HWCAP2_SVE2)
+FEATURE(AARCH64_SVEAES, sveaes, "sveaes", 0, AARCH64_HWCAP2_SVEAES)
+FEATURE(AARCH64_SVEPMULL, svepmull, "svepmull", 0, AARCH64_HWCAP2_SVEPMULL)
+FEATURE(AARCH64_SVEBITPERM, svebitperm, "svebitperm", 0, AARCH64_HWCAP2_SVEBITPERM)
+FEATURE(AARCH64_SVESHA3, svesha3, "svesha3", 0, AARCH64_HWCAP2_SVESHA3)
+FEATURE(AARCH64_SVESM4, svesm4, "svesm4", 0, AARCH64_HWCAP2_SVESM4)
+FEATURE(AARCH64_FLAGM2, flagm2, "flagm2", 0, AARCH64_HWCAP2_FLAGM2)
+FEATURE(AARCH64_FRINT, frint, "frint", 0, AARCH64_HWCAP2_FRINT)
+FEATURE(AARCH64_SVEI8MM, svei8mm, "svei8mm", 0, AARCH64_HWCAP2_SVEI8MM)
+FEATURE(AARCH64_SVEF32MM, svef32mm, "svef32mm", 0, AARCH64_HWCAP2_SVEF32MM)
+FEATURE(AARCH64_SVEF64MM, svef64mm, "svef64mm", 0, AARCH64_HWCAP2_SVEF64MM)
+FEATURE(AARCH64_SVEBF16, svebf16, "svebf16", 0, AARCH64_HWCAP2_SVEBF16)
+FEATURE(AARCH64_I8MM, i8mm, "i8mm", 0, AARCH64_HWCAP2_I8MM)
+FEATURE(AARCH64_BF16, bf16, "bf16", 0, AARCH64_HWCAP2_BF16)
+FEATURE(AARCH64_DGH, dgh, "dgh", 0, AARCH64_HWCAP2_DGH)
+FEATURE(AARCH64_RNG, rng, "rng", 0, AARCH64_HWCAP2_RNG)
+FEATURE(AARCH64_BTI, bti, "bti", 0, AARCH64_HWCAP2_BTI)
+// clang-format on
+#else
+#error "The FEATURE macro must be defined"
+#endif  // FEATURE
diff --git a/src/cpuinfo_arm.c b/src/cpuinfo_arm.c
index 0895a53..add38ce 100644
--- a/src/cpuinfo_arm.c
+++ b/src/cpuinfo_arm.c
@@ -22,69 +22,12 @@
 #include "internal/hwcaps.h"
 #include "internal/stack_line_reader.h"
 #include "internal/string_view.h"
-#include "internal/unix_features_aggregator.h"
 
-DECLARE_SETTER_AND_GETTER(ArmFeatures, swp)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, half)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, thumb)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, _26bit)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, fastmult)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, fpa)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, vfp)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, edsp)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, java)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, iwmmxt)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, crunch)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, thumbee)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, neon)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, vfpv3)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, vfpv3d16)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, tls)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, vfpv4)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, idiva)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, idivt)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, vfpd32)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, lpae)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, evtstrm)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, aes)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, pmull)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, sha1)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, sha2)
-DECLARE_SETTER_AND_GETTER(ArmFeatures, crc32)
-
-static const CapabilityConfig kConfigs[] = {
-    // clang-format off
-    [ARM_SWP] = {{ARM_HWCAP_SWP, 0}, "swp", &set_swp, &get_swp},
-    [ARM_HALF] = {{ARM_HWCAP_HALF, 0}, "half", &set_half, &get_half},
-    [ARM_THUMB] = {{ARM_HWCAP_THUMB, 0}, "thumb", &set_thumb, &get_thumb},
-    [ARM_26BIT] = {{ARM_HWCAP_26BIT, 0}, "26bit", &set__26bit, &get__26bit},
-    [ARM_FASTMULT] = {{ARM_HWCAP_FAST_MULT, 0}, "fastmult", &set_fastmult, &get_fastmult},
-    [ARM_FPA] = {{ARM_HWCAP_FPA, 0}, "fpa", &set_fpa, &get_fpa},
-    [ARM_VFP] = {{ARM_HWCAP_VFP, 0}, "vfp", &set_vfp, &get_vfp},
-    [ARM_EDSP] = {{ARM_HWCAP_EDSP, 0}, "edsp", &set_edsp, &get_edsp},
-    [ARM_JAVA] = {{ARM_HWCAP_JAVA, 0}, "java", &set_java, &get_java},
-    [ARM_IWMMXT] = {{ARM_HWCAP_IWMMXT, 0}, "iwmmxt", &set_iwmmxt, &get_iwmmxt},
-    [ARM_CRUNCH] = {{ARM_HWCAP_CRUNCH, 0}, "crunch", &set_crunch, &get_crunch},
-    [ARM_THUMBEE] = {{ARM_HWCAP_THUMBEE, 0}, "thumbee", &set_thumbee, &get_thumbee},
-    [ARM_NEON] = {{ARM_HWCAP_NEON, 0}, "neon", &set_neon, &get_neon},
-    [ARM_VFPV3] = {{ARM_HWCAP_VFPV3, 0}, "vfpv3", &set_vfpv3, &get_vfpv3},
-    [ARM_VFPV3D16] = {{ARM_HWCAP_VFPV3D16, 0}, "vfpv3d16", &set_vfpv3d16, &get_vfpv3d16},
-    [ARM_TLS] = {{ARM_HWCAP_TLS, 0}, "tls", &set_tls, &get_tls},
-    [ARM_VFPV4] = {{ARM_HWCAP_VFPV4, 0}, "vfpv4", &set_vfpv4, &get_vfpv4},
-    [ARM_IDIVA] = {{ARM_HWCAP_IDIVA, 0}, "idiva", &set_idiva, &get_idiva},
-    [ARM_IDIVT] = {{ARM_HWCAP_IDIVT, 0}, "idivt", &set_idivt, &get_idivt},
-    [ARM_VFPD32] = {{ARM_HWCAP_VFPD32, 0}, "vfpd32", &set_vfpd32, &get_vfpd32},
-    [ARM_LPAE] = {{ARM_HWCAP_LPAE, 0}, "lpae", &set_lpae, &get_lpae},
-    [ARM_EVTSTRM] = {{ARM_HWCAP_EVTSTRM, 0}, "evtstrm", &set_evtstrm, &get_evtstrm},
-    [ARM_AES] = {{0, ARM_HWCAP2_AES}, "aes", &set_aes, &get_aes},
-    [ARM_PMULL] = {{0, ARM_HWCAP2_PMULL}, "pmull", &set_pmull, &get_pmull},
-    [ARM_SHA1] = {{0, ARM_HWCAP2_SHA1}, "sha1", &set_sha1, &get_sha1},
-    [ARM_SHA2] = {{0, ARM_HWCAP2_SHA2}, "sha2", &set_sha2, &get_sha2},
-    [ARM_CRC32] = {{0, ARM_HWCAP2_CRC32}, "crc32", &set_crc32, &get_crc32},
-    // clang-format on
-};
-
-static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig);
+// Generation of feature's getters/setters functions and kGetters, kSetters,
+// kCpuInfoFlags and kHardwareCapabilities global tables.
+#define DEFINE_TABLE_FEATURE_TYPE ArmFeatures
+#define DEFINE_TABLE_DB_FILENAME "cpuinfo_arm_db.inl"
+#include "define_tables.h"
 
 typedef struct {
   bool processor_reports_armv6;
@@ -106,7 +49,10 @@ static bool HandleArmLine(const LineResult result, ArmInfo* const info,
   StringView key, value;
   if (CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value)) {
     if (CpuFeatures_StringView_IsEquals(key, str("Features"))) {
-      CpuFeatures_SetFromFlags(kConfigsSize, kConfigs, value, &info->features);
+      for (size_t i = 0; i < ARM_LAST_; ++i) {
+        kSetters[i](&info->features,
+                    CpuFeatures_StringView_HasWord(value, kCpuInfoFlags[i]));
+      }
     } else if (CpuFeatures_StringView_IsEquals(key, str("CPU implementer"))) {
       info->implementer = CpuFeatures_StringView_ParsePositiveNumber(value);
     } else if (CpuFeatures_StringView_IsEquals(key, str("CPU variant"))) {
@@ -212,9 +158,12 @@ ArmInfo GetArmInfo(void) {
   ProcCpuInfoData proc_cpu_info_data = kEmptyProcCpuInfoData;
 
   FillProcCpuInfoData(&info, &proc_cpu_info_data);
-  CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs,
-                                 CpuFeatures_GetHardwareCapabilities(),
-                                 &info.features);
+  const HardwareCapabilities hwcaps = CpuFeatures_GetHardwareCapabilities();
+  for (size_t i = 0; i < ARM_LAST_; ++i) {
+    if (CpuFeatures_IsHwCapsSet(kHardwareCapabilities[i], hwcaps)) {
+      kSetters[i](&info.features, true);
+    }
+  }
 
   FixErrors(&info, &proc_cpu_info_data);
 
@@ -226,11 +175,11 @@ ArmInfo GetArmInfo(void) {
 
 int GetArmFeaturesEnumValue(const ArmFeatures* features,
                             ArmFeaturesEnum value) {
-  if (value >= kConfigsSize) return false;
-  return kConfigs[value].get_bit((ArmFeatures*)features);
+  if (value >= ARM_LAST_) return false;
+  return kGetters[value](features);
 }
 
 const char* GetArmFeaturesEnumName(ArmFeaturesEnum value) {
-  if (value >= kConfigsSize) return "unknown feature";
-  return kConfigs[value].proc_cpuinfo_flag;
+  if (value >= ARM_LAST_) return "unknown feature";
+  return kCpuInfoFlags[value];
 }
diff --git a/src/cpuinfo_arm_db.inl b/src/cpuinfo_arm_db.inl
new file mode 100644
index 0000000..3270389
--- /dev/null
+++ b/src/cpuinfo_arm_db.inl
@@ -0,0 +1,48 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if defined(FEATURE)
+// FEATURE(ENUM, NAME, CPUINFO_FLAG, HWCAP, HWCAP2)
+// clang-format off
+FEATURE(ARM_SWP, swp, "swp", ARM_HWCAP_SWP, 0)
+FEATURE(ARM_HALF, half, "half", ARM_HWCAP_HALF, 0)
+FEATURE(ARM_THUMB, thumb, "thumb", ARM_HWCAP_THUMB, 0)
+FEATURE(ARM_26BIT, _26bit, "26bit", ARM_HWCAP_26BIT, 0)
+FEATURE(ARM_FASTMULT, fastmult, "fastmult", ARM_HWCAP_FAST_MULT, 0)
+FEATURE(ARM_FPA, fpa, "fpa", ARM_HWCAP_FPA, 0)
+FEATURE(ARM_VFP, vfp, "vfp", ARM_HWCAP_VFP, 0)
+FEATURE(ARM_EDSP, edsp, "edsp", ARM_HWCAP_EDSP, 0)
+FEATURE(ARM_JAVA, java, "java", ARM_HWCAP_JAVA, 0)
+FEATURE(ARM_IWMMXT, iwmmxt, "iwmmxt", ARM_HWCAP_IWMMXT, 0)
+FEATURE(ARM_CRUNCH, crunch, "crunch", ARM_HWCAP_CRUNCH, 0)
+FEATURE(ARM_THUMBEE, thumbee, "thumbee", ARM_HWCAP_THUMBEE, 0)
+FEATURE(ARM_NEON, neon, "neon", ARM_HWCAP_NEON, 0)
+FEATURE(ARM_VFPV3, vfpv3, "vfpv3", ARM_HWCAP_VFPV3, 0)
+FEATURE(ARM_VFPV3D16, vfpv3d16, "vfpv3d16", ARM_HWCAP_VFPV3D16, 0)
+FEATURE(ARM_TLS, tls, "tls", ARM_HWCAP_TLS, 0)
+FEATURE(ARM_VFPV4, vfpv4, "vfpv4", ARM_HWCAP_VFPV4, 0)
+FEATURE(ARM_IDIVA, idiva, "idiva", ARM_HWCAP_IDIVA, 0)
+FEATURE(ARM_IDIVT, idivt, "idivt", ARM_HWCAP_IDIVT, 0)
+FEATURE(ARM_VFPD32, vfpd32, "vfpd32", ARM_HWCAP_VFPD32, 0)
+FEATURE(ARM_LPAE, lpae, "lpae", ARM_HWCAP_LPAE, 0)
+FEATURE(ARM_EVTSTRM, evtstrm, "evtstrm", ARM_HWCAP_EVTSTRM, 0)
+FEATURE(ARM_AES, aes, "aes", 0, ARM_HWCAP2_AES)
+FEATURE(ARM_PMULL, pmull, "pmull", 0, ARM_HWCAP2_PMULL)
+FEATURE(ARM_SHA1, sha1, "sha1", 0, ARM_HWCAP2_SHA1)
+FEATURE(ARM_SHA2, sha2, "sha2", 0, ARM_HWCAP2_SHA2)
+FEATURE(ARM_CRC32, crc32, "crc32", 0, ARM_HWCAP2_CRC32)
+// clang-format on
+#else
+#error "The FEATURE macro must be defined"
+#endif  // FEATURE
diff --git a/src/cpuinfo_mips.c b/src/cpuinfo_mips.c
index 055cf21..8e71a31 100644
--- a/src/cpuinfo_mips.c
+++ b/src/cpuinfo_mips.c
@@ -17,20 +17,15 @@
 #include <assert.h>
 
 #include "internal/filesystem.h"
+#include "internal/hwcaps.h"
 #include "internal/stack_line_reader.h"
 #include "internal/string_view.h"
-#include "internal/unix_features_aggregator.h"
 
-DECLARE_SETTER_AND_GETTER(MipsFeatures, msa)
-DECLARE_SETTER_AND_GETTER(MipsFeatures, eva)
-DECLARE_SETTER_AND_GETTER(MipsFeatures, r6)
-
-static const CapabilityConfig kConfigs[] = {
-    [MIPS_MSA] = {{MIPS_HWCAP_MSA, 0}, "msa", &set_msa, &get_msa},
-    [MIPS_EVA] = {{0, 0}, "eva", &set_eva, &get_eva},
-    [MIPS_R6] = {{MIPS_HWCAP_R6, 0}, "r6", &set_r6, &get_r6},
-};
-static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig);
+// Generation of feature's getters/setters functions and kGetters, kSetters,
+// kCpuInfoFlags and kHardwareCapabilities global tables.
+#define DEFINE_TABLE_FEATURE_TYPE MipsFeatures
+#define DEFINE_TABLE_DB_FILENAME "cpuinfo_mips_db.inl"
+#include "define_tables.h"
 
 static bool HandleMipsLine(const LineResult result,
                            MipsFeatures* const features) {
@@ -38,7 +33,10 @@ static bool HandleMipsLine(const LineResult result,
   // See tests for an example.
   if (CpuFeatures_StringView_GetAttributeKeyValue(result.line, &key, &value)) {
     if (CpuFeatures_StringView_IsEquals(key, str("ASEs implemented"))) {
-      CpuFeatures_SetFromFlags(kConfigsSize, kConfigs, value, features);
+      for (size_t i = 0; i < MIPS_LAST_; ++i) {
+        kSetters[i](features,
+                    CpuFeatures_StringView_HasWord(value, kCpuInfoFlags[i]));
+      }
     }
   }
   return !result.eof;
@@ -61,17 +59,18 @@ 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).
   MipsInfo info = kEmptyMipsInfo;
 
   FillProcCpuInfoData(&info.features);
-  CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs,
-                                 CpuFeatures_GetHardwareCapabilities(),
-                                 &info.features);
+  const HardwareCapabilities hwcaps = CpuFeatures_GetHardwareCapabilities();
+  for (size_t i = 0; i < MIPS_LAST_; ++i) {
+    if (CpuFeatures_IsHwCapsSet(kHardwareCapabilities[i], hwcaps)) {
+      kSetters[i](&info.features, true);
+    }
+  }
   return info;
 }
 
@@ -80,11 +79,11 @@ MipsInfo GetMipsInfo(void) {
 
 int GetMipsFeaturesEnumValue(const MipsFeatures* features,
                              MipsFeaturesEnum value) {
-  if (value >= kConfigsSize) return false;
-  return kConfigs[value].get_bit((MipsFeatures*)features);
+  if (value >= MIPS_LAST_) return false;
+  return kGetters[value](features);
 }
 
 const char* GetMipsFeaturesEnumName(MipsFeaturesEnum value) {
-  if (value >= kConfigsSize) return "unknown feature";
-  return kConfigs[value].proc_cpuinfo_flag;
+  if (value >= MIPS_LAST_) return "unknown feature";
+  return kCpuInfoFlags[value];
 }
diff --git a/src/cpuinfo_mips_db.inl b/src/cpuinfo_mips_db.inl
new file mode 100644
index 0000000..61edb2b
--- /dev/null
+++ b/src/cpuinfo_mips_db.inl
@@ -0,0 +1,24 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if defined(FEATURE)
+// FEATURE(ENUM, NAME, CPUINFO_FLAG, HWCAP, HWCAP2)
+// clang-format off
+FEATURE(MIPS_MSA, msa, "msa", MIPS_HWCAP_MSA, 0)
+FEATURE(MIPS_EVA, eva, "eva", 0, 0)
+FEATURE(MIPS_R6, r6, "r6", MIPS_HWCAP_R6, 0)
+// clang-format on
+#else
+#error "The FEATURE macro must be defined"
+#endif  // FEATURE
diff --git a/src/cpuinfo_ppc.c b/src/cpuinfo_ppc.c
index 4353099..3be2935 100644
--- a/src/cpuinfo_ppc.c
+++ b/src/cpuinfo_ppc.c
@@ -22,96 +22,12 @@
 #include "internal/filesystem.h"
 #include "internal/stack_line_reader.h"
 #include "internal/string_view.h"
-#include "internal/unix_features_aggregator.h"
 
-DECLARE_SETTER_AND_GETTER(PPCFeatures, ppc32)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, ppc64)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, ppc601)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, altivec)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, fpu)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, mmu)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, mac_4xx)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, unifiedcache)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, spe)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, efpsingle)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, efpdouble)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, no_tb)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, power4)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, power5)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, power5plus)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, cell)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, booke)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, smt)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, icachesnoop)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, arch205)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, pa6t)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, dfp)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, power6ext)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, arch206)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, vsx)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, pseries_perfmon_compat)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, truele)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, ppcle)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, arch207)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, htm)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, dscr)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, ebb)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, isel)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, tar)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, vcrypto)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, htm_nosc)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, arch300)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, ieee128)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, darn)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, scv)
-DECLARE_SETTER_AND_GETTER(PPCFeatures, htm_no_suspend)
-
-static const CapabilityConfig kConfigs[] = {
-    // clang-format off
-    [PPC_32] = {{PPC_FEATURE_32, 0}, "ppc32", &set_ppc32, &get_ppc32},
-    [PPC_64] = {{PPC_FEATURE_64, 0}, "ppc64", &set_ppc64, &get_ppc64},
-    [PPC_601_INSTR] = {{PPC_FEATURE_601_INSTR, 0}, "ppc601", &set_ppc601, &get_ppc601},
-    [PPC_HAS_ALTIVEC] = {{PPC_FEATURE_HAS_ALTIVEC, 0}, "altivec", &set_altivec, &get_altivec},
-    [PPC_HAS_FPU] = {{PPC_FEATURE_HAS_FPU, 0}, "fpu", &set_fpu, &get_fpu},
-    [PPC_HAS_MMU] = {{PPC_FEATURE_HAS_MMU, 0}, "mmu", &set_mmu, &get_mmu},
-    [PPC_HAS_4xxMAC] = {{PPC_FEATURE_HAS_4xxMAC, 0}, "4xxmac", &set_mac_4xx, &get_mac_4xx},
-    [PPC_UNIFIED_CACHE] = {{PPC_FEATURE_UNIFIED_CACHE, 0}, "ucache", &set_unifiedcache, &get_unifiedcache},
-    [PPC_HAS_SPE] = {{PPC_FEATURE_HAS_SPE, 0}, "spe", &set_spe, &get_spe},
-    [PPC_HAS_EFP_SINGLE] = {{PPC_FEATURE_HAS_EFP_SINGLE, 0}, "efpsingle", &set_efpsingle, &get_efpsingle},
-    [PPC_HAS_EFP_DOUBLE] = {{PPC_FEATURE_HAS_EFP_DOUBLE, 0}, "efpdouble", &set_efpdouble, &get_efpdouble},
-    [PPC_NO_TB] = {{PPC_FEATURE_NO_TB, 0}, "notb", &set_no_tb, &get_no_tb},
-    [PPC_POWER4] = {{PPC_FEATURE_POWER4, 0}, "power4", &set_power4, &get_power4},
-    [PPC_POWER5] = {{PPC_FEATURE_POWER5, 0}, "power5", &set_power5, &get_power5},
-    [PPC_POWER5_PLUS] = {{PPC_FEATURE_POWER5_PLUS, 0}, "power5+", &set_power5plus, &get_power5plus},
-    [PPC_CELL] = {{PPC_FEATURE_CELL, 0}, "cellbe", &set_cell, &get_cell},
-    [PPC_BOOKE] = {{PPC_FEATURE_BOOKE, 0}, "booke", &set_booke, &get_booke},
-    [PPC_SMT] = {{PPC_FEATURE_SMT, 0}, "smt", &set_smt, &get_smt},
-    [PPC_ICACHE_SNOOP] = {{PPC_FEATURE_ICACHE_SNOOP, 0}, "ic_snoop", &set_icachesnoop, &get_icachesnoop},
-    [PPC_ARCH_2_05] = {{PPC_FEATURE_ARCH_2_05, 0}, "arch_2_05", &set_arch205, &get_arch205},
-    [PPC_PA6T] = {{PPC_FEATURE_PA6T, 0}, "pa6t", &set_pa6t, &get_pa6t},
-    [PPC_HAS_DFP] = {{PPC_FEATURE_HAS_DFP, 0}, "dfp", &set_dfp, &get_dfp},
-    [PPC_POWER6_EXT] = {{PPC_FEATURE_POWER6_EXT, 0}, "power6x", &set_power6ext, &get_power6ext},
-    [PPC_ARCH_2_06] = {{PPC_FEATURE_ARCH_2_06, 0}, "arch_2_06", &set_arch206, &get_arch206},
-    [PPC_HAS_VSX] = {{PPC_FEATURE_HAS_VSX, 0}, "vsx", &set_vsx, &get_vsx},
-    [PPC_PSERIES_PERFMON_COMPAT] = {{PPC_FEATURE_PSERIES_PERFMON_COMPAT, 0}, "archpmu", &set_pseries_perfmon_compat, &get_pseries_perfmon_compat},
-    [PPC_TRUE_LE] = {{PPC_FEATURE_TRUE_LE, 0}, "true_le", &set_truele, &get_truele},
-    [PPC_PPC_LE] = {{PPC_FEATURE_PPC_LE, 0}, "ppcle", &set_ppcle, &get_ppcle},
-    [PPC_ARCH_2_07] = {{0, PPC_FEATURE2_ARCH_2_07}, "arch_2_07", &set_arch207, &get_arch207},
-    [PPC_HTM] = {{0, PPC_FEATURE2_HTM}, "htm", &set_htm, &get_htm},
-    [PPC_DSCR] = {{0, PPC_FEATURE2_DSCR}, "dscr", &set_dscr, &get_dscr},
-    [PPC_EBB] = {{0, PPC_FEATURE2_EBB}, "ebb", &set_ebb, &get_ebb},
-    [PPC_ISEL] = {{0, PPC_FEATURE2_ISEL}, "isel", &set_isel, &get_isel},
-    [PPC_TAR] = {{0, PPC_FEATURE2_TAR}, "tar", &set_tar, &get_tar},
-    [PPC_VEC_CRYPTO] = {{0, PPC_FEATURE2_VEC_CRYPTO}, "vcrypto", &set_vcrypto, &get_vcrypto},
-    [PPC_HTM_NOSC] = {{0, PPC_FEATURE2_HTM_NOSC}, "htm-nosc", &set_htm_nosc, &get_htm_nosc},
-    [PPC_ARCH_3_00] = {{0, PPC_FEATURE2_ARCH_3_00}, "arch_3_00", &set_arch300, &get_arch300},
-    [PPC_HAS_IEEE128] = {{0, PPC_FEATURE2_HAS_IEEE128}, "ieee128", &set_ieee128, &get_ieee128},
-    [PPC_DARN] = {{0, PPC_FEATURE2_DARN}, "darn", &set_darn, &get_darn},
-    [PPC_SCV] = {{0, PPC_FEATURE2_SCV}, "scv", &set_scv, &get_scv},
-    [PPC_HTM_NO_SUSPEND] = {{0, PPC_FEATURE2_HTM_NO_SUSPEND}, "htm-no-suspend", &set_htm_no_suspend, &get_htm_no_suspend},
-    // clang-format on
-};
-static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig);
+// Generation of feature's getters/setters functions and kGetters, kSetters,
+// kCpuInfoFlags and kHardwareCapabilities global tables.
+#define DEFINE_TABLE_FEATURE_TYPE PPCFeatures
+#define DEFINE_TABLE_DB_FILENAME "cpuinfo_ppc_db.inl"
+#include "define_tables.h"
 
 static bool HandlePPCLine(const LineResult result,
                           PPCPlatformStrings* const strings) {
@@ -157,10 +73,12 @@ PPCInfo GetPPCInfo(void) {
    * the auxilary vector.
    */
   PPCInfo info = kEmptyPPCInfo;
-
-  CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs,
-                                 CpuFeatures_GetHardwareCapabilities(),
-                                 &info.features);
+  const HardwareCapabilities hwcaps = CpuFeatures_GetHardwareCapabilities();
+  for (size_t i = 0; i < PPC_LAST_; ++i) {
+    if (CpuFeatures_IsHwCapsSet(kHardwareCapabilities[i], hwcaps)) {
+      kSetters[i](&info.features, true);
+    }
+  }
   return info;
 }
 
@@ -179,11 +97,11 @@ PPCPlatformStrings GetPPCPlatformStrings(void) {
 
 int GetPPCFeaturesEnumValue(const PPCFeatures* features,
                             PPCFeaturesEnum value) {
-  if (value >= kConfigsSize) return false;
-  return kConfigs[value].get_bit((PPCFeatures*)features);
+  if (value >= PPC_LAST_) return false;
+  return kGetters[value](features);
 }
 
 const char* GetPPCFeaturesEnumName(PPCFeaturesEnum value) {
-  if (value >= kConfigsSize) return "unknown feature";
-  return kConfigs[value].proc_cpuinfo_flag;
+  if (value >= PPC_LAST_) return "unknown feature";
+  return kCpuInfoFlags[value];
 }
diff --git a/src/cpuinfo_ppc_db.inl b/src/cpuinfo_ppc_db.inl
new file mode 100644
index 0000000..eb4aaf4
--- /dev/null
+++ b/src/cpuinfo_ppc_db.inl
@@ -0,0 +1,62 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if defined(FEATURE)
+// FEATURE(ENUM, NAME, CPUINFO_FLAG, HWCAP, HWCAP2)
+// clang-format off
+FEATURE(PPC_32, ppc32, "ppc32", PPC_FEATURE_32, 0)
+FEATURE(PPC_64, ppc64, "ppc64", PPC_FEATURE_64, 0)
+FEATURE(PPC_601_INSTR, ppc601, "ppc601", PPC_FEATURE_601_INSTR, 0)
+FEATURE(PPC_HAS_ALTIVEC, altivec, "altivec", PPC_FEATURE_HAS_ALTIVEC, 0)
+FEATURE(PPC_HAS_FPU, fpu, "fpu", PPC_FEATURE_HAS_FPU, 0)
+FEATURE(PPC_HAS_MMU, mmu, "mmu", PPC_FEATURE_HAS_MMU, 0)
+FEATURE(PPC_HAS_4xxMAC, mac_4xx, "4xxmac", PPC_FEATURE_HAS_4xxMAC, 0)
+FEATURE(PPC_UNIFIED_CACHE, unifiedcache, "ucache", PPC_FEATURE_UNIFIED_CACHE, 0)
+FEATURE(PPC_HAS_SPE, spe, "spe", PPC_FEATURE_HAS_SPE, 0)
+FEATURE(PPC_HAS_EFP_SINGLE, efpsingle, "efpsingle", PPC_FEATURE_HAS_EFP_SINGLE, 0)
+FEATURE(PPC_HAS_EFP_DOUBLE, efpdouble, "efpdouble", PPC_FEATURE_HAS_EFP_DOUBLE, 0)
+FEATURE(PPC_NO_TB, no_tb, "notb", PPC_FEATURE_NO_TB, 0)
+FEATURE(PPC_POWER4, power4, "power4", PPC_FEATURE_POWER4, 0)
+FEATURE(PPC_POWER5, power5, "power5", PPC_FEATURE_POWER5, 0)
+FEATURE(PPC_POWER5_PLUS, power5plus, "power5+", PPC_FEATURE_POWER5_PLUS, 0)
+FEATURE(PPC_CELL, cell, "cellbe", PPC_FEATURE_CELL, 0)
+FEATURE(PPC_BOOKE, booke, "booke", PPC_FEATURE_BOOKE, 0)
+FEATURE(PPC_SMT, smt, "smt", PPC_FEATURE_SMT, 0)
+FEATURE(PPC_ICACHE_SNOOP, icachesnoop, "ic_snoop", PPC_FEATURE_ICACHE_SNOOP, 0)
+FEATURE(PPC_ARCH_2_05, arch205, "arch_2_05", PPC_FEATURE_ARCH_2_05, 0)
+FEATURE(PPC_PA6T, pa6t, "pa6t", PPC_FEATURE_PA6T, 0)
+FEATURE(PPC_HAS_DFP, dfp, "dfp", PPC_FEATURE_HAS_DFP, 0)
+FEATURE(PPC_POWER6_EXT, power6ext, "power6x", PPC_FEATURE_POWER6_EXT, 0)
+FEATURE(PPC_ARCH_2_06, arch206, "arch_2_06", PPC_FEATURE_ARCH_2_06, 0)
+FEATURE(PPC_HAS_VSX, vsx, "vsx", PPC_FEATURE_HAS_VSX, 0)
+FEATURE(PPC_PSERIES_PERFMON_COMPAT, pseries_perfmon_compat, "archpmu", PPC_FEATURE_PSERIES_PERFMON_COMPAT, 0)
+FEATURE(PPC_TRUE_LE, truele, "true_le", PPC_FEATURE_TRUE_LE, 0)
+FEATURE(PPC_PPC_LE, ppcle, "ppcle", PPC_FEATURE_PPC_LE, 0)
+FEATURE(PPC_ARCH_2_07, arch207, "arch_2_07", 0, PPC_FEATURE2_ARCH_2_07)
+FEATURE(PPC_HTM, htm, "htm", 0, PPC_FEATURE2_HTM)
+FEATURE(PPC_DSCR, dscr, "dscr", 0, PPC_FEATURE2_DSCR)
+FEATURE(PPC_EBB, ebb, "ebb", 0, PPC_FEATURE2_EBB)
+FEATURE(PPC_ISEL, isel, "isel", 0, PPC_FEATURE2_ISEL)
+FEATURE(PPC_TAR, tar, "tar", 0, PPC_FEATURE2_TAR)
+FEATURE(PPC_VEC_CRYPTO, vcrypto, "vcrypto", 0, PPC_FEATURE2_VEC_CRYPTO)
+FEATURE(PPC_HTM_NOSC, htm_nosc, "htm-nosc", 0, PPC_FEATURE2_HTM_NOSC)
+FEATURE(PPC_ARCH_3_00, arch300, "arch_3_00", 0, PPC_FEATURE2_ARCH_3_00)
+FEATURE(PPC_HAS_IEEE128, ieee128, "ieee128", 0, PPC_FEATURE2_HAS_IEEE128)
+FEATURE(PPC_DARN, darn, "darn", 0, PPC_FEATURE2_DARN)
+FEATURE(PPC_SCV, scv, "scv", 0, PPC_FEATURE2_SCV)
+FEATURE(PPC_HTM_NO_SUSPEND, htm_no_suspend, "htm-no-suspend", 0, PPC_FEATURE2_HTM_NO_SUSPEND)
+// clang-format on
+#else
+#error "The FEATURE macro must be defined"
+#endif  // FEATURE
diff --git a/src/cpuinfo_x86.c b/src/cpuinfo_x86.c
index 9254413..09c707a 100644
--- a/src/cpuinfo_x86.c
+++ b/src/cpuinfo_x86.c
@@ -25,6 +25,13 @@
 #error "Cannot compile cpuinfo_x86 on a non x86 platform."
 #endif
 
+// Generation of feature's getters/setters functions and kGetters, kSetters,
+// kCpuInfoFlags global tables.
+#define DEFINE_TABLE_FEATURE_TYPE X86Features
+#define DEFINE_TABLE_DB_FILENAME "cpuinfo_x86_db.inl"
+#define DEFINE_TABLE_DONT_GENERATE_HWCAPS
+#include "define_tables.h"
+
 // The following includes are necessary to provide SSE detections on pre-AVX
 // microarchitectures.
 #if defined(CPU_FEATURES_OS_WINDOWS)
@@ -1486,259 +1493,13 @@ void FillX86BrandString(char brand_string[49]) {
 
 int GetX86FeaturesEnumValue(const X86Features* features,
                             X86FeaturesEnum value) {
-  switch (value) {
-    case X86_FPU:
-      return features->fpu;
-    case X86_TSC:
-      return features->tsc;
-    case X86_CX8:
-      return features->cx8;
-    case X86_CLFSH:
-      return features->clfsh;
-    case X86_MMX:
-      return features->mmx;
-    case X86_AES:
-      return features->aes;
-    case X86_ERMS:
-      return features->erms;
-    case X86_F16C:
-      return features->f16c;
-    case X86_FMA4:
-      return features->fma4;
-    case X86_FMA3:
-      return features->fma3;
-    case X86_VAES:
-      return features->vaes;
-    case X86_VPCLMULQDQ:
-      return features->vpclmulqdq;
-    case X86_BMI1:
-      return features->bmi1;
-    case X86_HLE:
-      return features->hle;
-    case X86_BMI2:
-      return features->bmi2;
-    case X86_RTM:
-      return features->rtm;
-    case X86_RDSEED:
-      return features->rdseed;
-    case X86_CLFLUSHOPT:
-      return features->clflushopt;
-    case X86_CLWB:
-      return features->clwb;
-    case X86_SSE:
-      return features->sse;
-    case X86_SSE2:
-      return features->sse2;
-    case X86_SSE3:
-      return features->sse3;
-    case X86_SSSE3:
-      return features->ssse3;
-    case X86_SSE4_1:
-      return features->sse4_1;
-    case X86_SSE4_2:
-      return features->sse4_2;
-    case X86_SSE4A:
-      return features->sse4a;
-    case X86_AVX:
-      return features->avx;
-    case X86_AVX2:
-      return features->avx2;
-    case X86_AVX512F:
-      return features->avx512f;
-    case X86_AVX512CD:
-      return features->avx512cd;
-    case X86_AVX512ER:
-      return features->avx512er;
-    case X86_AVX512PF:
-      return features->avx512pf;
-    case X86_AVX512BW:
-      return features->avx512bw;
-    case X86_AVX512DQ:
-      return features->avx512dq;
-    case X86_AVX512VL:
-      return features->avx512vl;
-    case X86_AVX512IFMA:
-      return features->avx512ifma;
-    case X86_AVX512VBMI:
-      return features->avx512vbmi;
-    case X86_AVX512VBMI2:
-      return features->avx512vbmi2;
-    case X86_AVX512VNNI:
-      return features->avx512vnni;
-    case X86_AVX512BITALG:
-      return features->avx512bitalg;
-    case X86_AVX512VPOPCNTDQ:
-      return features->avx512vpopcntdq;
-    case X86_AVX512_4VNNIW:
-      return features->avx512_4vnniw;
-    case X86_AVX512_4VBMI2:
-      return features->avx512_4vbmi2;
-    case X86_AVX512_SECOND_FMA:
-      return features->avx512_second_fma;
-    case X86_AVX512_4FMAPS:
-      return features->avx512_4fmaps;
-    case X86_AVX512_BF16:
-      return features->avx512_bf16;
-    case X86_AVX512_VP2INTERSECT:
-      return features->avx512_vp2intersect;
-    case X86_AMX_BF16:
-      return features->amx_bf16;
-    case X86_AMX_TILE:
-      return features->amx_tile;
-    case X86_AMX_INT8:
-      return features->amx_int8;
-    case X86_PCLMULQDQ:
-      return features->pclmulqdq;
-    case X86_SMX:
-      return features->smx;
-    case X86_SGX:
-      return features->sgx;
-    case X86_CX16:
-      return features->cx16;
-    case X86_SHA:
-      return features->sha;
-    case X86_POPCNT:
-      return features->popcnt;
-    case X86_MOVBE:
-      return features->movbe;
-    case X86_RDRND:
-      return features->rdrnd;
-    case X86_DCA:
-      return features->dca;
-    case X86_SS:
-      return features->ss;
-    case X86_LAST_:
-      break;
-  }
-  return false;
+  if (value >= X86_LAST_) return false;
+  return kGetters[value](features);
 }
 
 const char* GetX86FeaturesEnumName(X86FeaturesEnum value) {
-  switch (value) {
-    case X86_FPU:
-      return "fpu";
-    case X86_TSC:
-      return "tsc";
-    case X86_CX8:
-      return "cx8";
-    case X86_CLFSH:
-      return "clfsh";
-    case X86_MMX:
-      return "mmx";
-    case X86_AES:
-      return "aes";
-    case X86_ERMS:
-      return "erms";
-    case X86_F16C:
-      return "f16c";
-    case X86_FMA4:
-      return "fma4";
-    case X86_FMA3:
-      return "fma3";
-    case X86_VAES:
-      return "vaes";
-    case X86_VPCLMULQDQ:
-      return "vpclmulqdq";
-    case X86_BMI1:
-      return "bmi1";
-    case X86_HLE:
-      return "hle";
-    case X86_BMI2:
-      return "bmi2";
-    case X86_RTM:
-      return "rtm";
-    case X86_RDSEED:
-      return "rdseed";
-    case X86_CLFLUSHOPT:
-      return "clflushopt";
-    case X86_CLWB:
-      return "clwb";
-    case X86_SSE:
-      return "sse";
-    case X86_SSE2:
-      return "sse2";
-    case X86_SSE3:
-      return "sse3";
-    case X86_SSSE3:
-      return "ssse3";
-    case X86_SSE4_1:
-      return "sse4_1";
-    case X86_SSE4_2:
-      return "sse4_2";
-    case X86_SSE4A:
-      return "sse4a";
-    case X86_AVX:
-      return "avx";
-    case X86_AVX2:
-      return "avx2";
-    case X86_AVX512F:
-      return "avx512f";
-    case X86_AVX512CD:
-      return "avx512cd";
-    case X86_AVX512ER:
-      return "avx512er";
-    case X86_AVX512PF:
-      return "avx512pf";
-    case X86_AVX512BW:
-      return "avx512bw";
-    case X86_AVX512DQ:
-      return "avx512dq";
-    case X86_AVX512VL:
-      return "avx512vl";
-    case X86_AVX512IFMA:
-      return "avx512ifma";
-    case X86_AVX512VBMI:
-      return "avx512vbmi";
-    case X86_AVX512VBMI2:
-      return "avx512vbmi2";
-    case X86_AVX512VNNI:
-      return "avx512vnni";
-    case X86_AVX512BITALG:
-      return "avx512bitalg";
-    case X86_AVX512VPOPCNTDQ:
-      return "avx512vpopcntdq";
-    case X86_AVX512_4VNNIW:
-      return "avx512_4vnniw";
-    case X86_AVX512_4VBMI2:
-      return "avx512_4vbmi2";
-    case X86_AVX512_SECOND_FMA:
-      return "avx512_second_fma";
-    case X86_AVX512_4FMAPS:
-      return "avx512_4fmaps";
-    case X86_AVX512_BF16:
-      return "avx512_bf16";
-    case X86_AVX512_VP2INTERSECT:
-      return "avx512_vp2intersect";
-    case X86_AMX_BF16:
-      return "amx_bf16";
-    case X86_AMX_TILE:
-      return "amx_tile";
-    case X86_AMX_INT8:
-      return "amx_int8";
-    case X86_PCLMULQDQ:
-      return "pclmulqdq";
-    case X86_SMX:
-      return "smx";
-    case X86_SGX:
-      return "sgx";
-    case X86_CX16:
-      return "cx16";
-    case X86_SHA:
-      return "sha";
-    case X86_POPCNT:
-      return "popcnt";
-    case X86_MOVBE:
-      return "movbe";
-    case X86_RDRND:
-      return "rdrnd";
-    case X86_DCA:
-      return "dca";
-    case X86_SS:
-      return "ss";
-    case X86_LAST_:
-      break;
-  }
-  return "unknown_feature";
+  if (value >= X86_LAST_) return "unknown_feature";
+  return kCpuInfoFlags[value];
 }
 
 const char* GetX86MicroarchitectureName(X86Microarchitecture uarch) {
diff --git a/src/cpuinfo_x86_db.inl b/src/cpuinfo_x86_db.inl
new file mode 100644
index 0000000..3ea280d
--- /dev/null
+++ b/src/cpuinfo_x86_db.inl
@@ -0,0 +1,81 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if defined(FEATURE)
+// FEATURE(ENUM, NAME, CPUINFO_FLAG, HWCAP, HWCAP2)
+// clang-format off
+FEATURE(X86_FPU, fpu, "fpu", 0, 0)
+FEATURE(X86_TSC, tsc, "tsc", 0, 0)
+FEATURE(X86_CX8, cx8, "cx8", 0, 0)
+FEATURE(X86_CLFSH, clfsh, "clfsh", 0, 0)
+FEATURE(X86_MMX, mmx, "mmx", 0, 0)
+FEATURE(X86_AES, aes, "aes", 0, 0)
+FEATURE(X86_ERMS, erms, "erms", 0, 0)
+FEATURE(X86_F16C, f16c, "f16c", 0, 0)
+FEATURE(X86_FMA4, fma4, "fma4", 0, 0)
+FEATURE(X86_FMA3, fma3, "fma3", 0, 0)
+FEATURE(X86_VAES, vaes, "vaes", 0, 0)
+FEATURE(X86_VPCLMULQDQ, vpclmulqdq, "vpclmulqdq", 0, 0)
+FEATURE(X86_BMI1, bmi1, "bmi1", 0, 0)
+FEATURE(X86_HLE, hle, "hle", 0, 0)
+FEATURE(X86_BMI2, bmi2, "bmi2", 0, 0)
+FEATURE(X86_RTM, rtm, "rtm", 0, 0)
+FEATURE(X86_RDSEED, rdseed, "rdseed", 0, 0)
+FEATURE(X86_CLFLUSHOPT, clflushopt, "clflushopt", 0, 0)
+FEATURE(X86_CLWB, clwb, "clwb", 0, 0)
+FEATURE(X86_SSE, sse, "sse", 0, 0)
+FEATURE(X86_SSE2, sse2, "sse2", 0, 0)
+FEATURE(X86_SSE3, sse3, "sse3", 0, 0)
+FEATURE(X86_SSSE3, ssse3, "ssse3", 0, 0)
+FEATURE(X86_SSE4_1, sse4_1, "sse4_1", 0, 0)
+FEATURE(X86_SSE4_2, sse4_2, "sse4_2", 0, 0)
+FEATURE(X86_SSE4A, sse4a, "sse4a", 0, 0)
+FEATURE(X86_AVX, avx, "avx", 0, 0)
+FEATURE(X86_AVX2, avx2, "avx2", 0, 0)
+FEATURE(X86_AVX512F, avx512f, "avx512f", 0, 0)
+FEATURE(X86_AVX512CD, avx512cd, "avx512cd", 0, 0)
+FEATURE(X86_AVX512ER, avx512er, "avx512er", 0, 0)
+FEATURE(X86_AVX512PF, avx512pf, "avx512pf", 0, 0)
+FEATURE(X86_AVX512BW, avx512bw, "avx512bw", 0, 0)
+FEATURE(X86_AVX512DQ, avx512dq, "avx512dq", 0, 0)
+FEATURE(X86_AVX512VL, avx512vl, "avx512vl", 0, 0)
+FEATURE(X86_AVX512IFMA, avx512ifma, "avx512ifma", 0, 0)
+FEATURE(X86_AVX512VBMI, avx512vbmi, "avx512vbmi", 0, 0)
+FEATURE(X86_AVX512VBMI2, avx512vbmi2, "avx512vbmi2", 0, 0)
+FEATURE(X86_AVX512VNNI, avx512vnni, "avx512vnni", 0, 0)
+FEATURE(X86_AVX512BITALG, avx512bitalg, "avx512bitalg", 0, 0)
+FEATURE(X86_AVX512VPOPCNTDQ, avx512vpopcntdq, "avx512vpopcntdq", 0, 0)
+FEATURE(X86_AVX512_4VNNIW, avx512_4vnniw, "avx512_4vnniw", 0, 0)
+FEATURE(X86_AVX512_4VBMI2, avx512_4vbmi2, "avx512_4vbmi2", 0, 0)
+FEATURE(X86_AVX512_SECOND_FMA, avx512_second_fma, "avx512_second_fma", 0, 0)
+FEATURE(X86_AVX512_4FMAPS, avx512_4fmaps, "avx512_4fmaps", 0, 0)
+FEATURE(X86_AVX512_BF16, avx512_bf16, "avx512_bf16", 0, 0)
+FEATURE(X86_AVX512_VP2INTERSECT, avx512_vp2intersect, "avx512_vp2intersect", 0, 0)
+FEATURE(X86_AMX_BF16, amx_bf16, "amx_bf16", 0, 0)
+FEATURE(X86_AMX_TILE, amx_tile, "amx_tile", 0, 0)
+FEATURE(X86_AMX_INT8, amx_int8, "amx_int8", 0, 0)
+FEATURE(X86_PCLMULQDQ, pclmulqdq, "pclmulqdq", 0, 0)
+FEATURE(X86_SMX, smx, "smx", 0, 0)
+FEATURE(X86_SGX, sgx, "sgx", 0, 0)
+FEATURE(X86_CX16, cx16, "cx16", 0, 0)
+FEATURE(X86_SHA, sha, "sha", 0, 0)
+FEATURE(X86_POPCNT, popcnt, "popcnt", 0, 0)
+FEATURE(X86_MOVBE, movbe, "movbe", 0, 0)
+FEATURE(X86_RDRND, rdrnd, "rdrnd", 0, 0)
+FEATURE(X86_DCA, dca, "dca", 0, 0)
+FEATURE(X86_SS, ss, "ss", 0, 0)
+// clang-format on
+#else
+#error "The FEATURE macro must be defined"
+#endif  // FEATURE
diff --git a/src/define_tables.h b/src/define_tables.h
new file mode 100644
index 0000000..cb5ff37
--- /dev/null
+++ b/src/define_tables.h
@@ -0,0 +1,72 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// The following preprocessor constants must be defined before including this
+// file:
+//  - DEFINE_TABLE_FEATURE_TYPE, the underlying type (e.g. X86Features)
+//  - DEFINE_TABLE_DB_FILENAME, the db file (e.g. "cpuinfo_x86_db.inl")
+
+// This file is to be included once per `cpuinfo_XXX.c` in order to construct
+// feature getters and setters functions as well as several enum indexed tables
+// from the db file.
+// - `kGetters` a table of getters function pointers from feature enum to
+// retrieve a feature,
+// - `kSetters` a table of setters function pointers from feature enum to set a
+// feature,
+// - `kCpuInfoFlags` a table of strings from feature enum to /proc/cpuinfo
+// flags,
+// - `kHardwareCapabilities` a table of HardwareCapabilities structs indexed by
+// their feature enum.
+
+#ifndef SRC_DEFINE_TABLES_H_
+#define SRC_DEFINE_TABLES_H_
+
+#define FEATURE(ENUM, NAME, CPUINFO_FLAG, HWCAP, HWCAP2) [ENUM] = CPUINFO_FLAG,
+static const char* kCpuInfoFlags[] = {
+#include DEFINE_TABLE_DB_FILENAME
+};
+#undef FEATURE
+
+#ifndef DEFINE_TABLE_DONT_GENERATE_HWCAPS
+#define FEATURE(ENUM, NAME, CPUINFO_FLAG, HWCAP, HWCAP2) \
+  [ENUM] = (HardwareCapabilities){HWCAP, HWCAP2},
+static const HardwareCapabilities kHardwareCapabilities[] = {
+#include DEFINE_TABLE_DB_FILENAME
+};
+#undef FEATURE
+#endif  // DEFINE_TABLE_DONT_GENERATE_HWCAPS
+
+#define FEATURE(ENUM, NAME, CPUINFO_FLAG, HWCAP, HWCAP2)                    \
+  static void set_##ENUM(DEFINE_TABLE_FEATURE_TYPE* features, bool value) { \
+    features->NAME = value;                                                 \
+  }                                                                         \
+  static int get_##ENUM(const DEFINE_TABLE_FEATURE_TYPE* features) {        \
+    return features->NAME;                                                  \
+  }
+#include DEFINE_TABLE_DB_FILENAME
+#undef FEATURE
+
+#define FEATURE(ENUM, NAME, CPUINFO_FLAG, HWCAP, HWCAP2) [ENUM] = set_##ENUM,
+static void (*const kSetters[])(DEFINE_TABLE_FEATURE_TYPE*, bool) = {
+#include DEFINE_TABLE_DB_FILENAME
+};
+#undef FEATURE
+
+#define FEATURE(ENUM, NAME, CPUINFO_FLAG, HWCAP, HWCAP2) [ENUM] = get_##ENUM,
+static int (*const kGetters[])(const DEFINE_TABLE_FEATURE_TYPE*) = {
+#include DEFINE_TABLE_DB_FILENAME
+};
+#undef FEATURE
+
+#endif  // SRC_DEFINE_TABLES_H_
diff --git a/src/hwcaps.c b/src/hwcaps.c
index 1592d17..dd17e3b 100644
--- a/src/hwcaps.c
+++ b/src/hwcaps.c
@@ -21,6 +21,24 @@
 #include "internal/filesystem.h"
 #include "internal/string_view.h"
 
+static bool IsSet(const uint32_t mask, const uint32_t value) {
+  if (mask == 0) return false;
+  return (value & mask) == mask;
+}
+
+bool CpuFeatures_IsHwCapsSet(const HardwareCapabilities hwcaps_mask,
+                             const HardwareCapabilities hwcaps) {
+  return IsSet(hwcaps_mask.hwcaps, hwcaps.hwcaps) ||
+         IsSet(hwcaps_mask.hwcaps2, hwcaps.hwcaps2);
+}
+
+#ifdef CPU_FEATURES_TEST
+// In test mode, hwcaps_for_testing will define the following functions.
+HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void);
+PlatformType CpuFeatures_GetPlatformType(void);
+#else
+
+// Debug facilities
 #if defined(NDEBUG)
 #define D(...)
 #else
@@ -36,9 +54,12 @@
 // Implementation of GetElfHwcapFromGetauxval
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(CPU_FEATURES_MOCK_GET_ELF_HWCAP_FROM_GETAUXVAL)
-// Implementation will be provided by test/hwcaps_for_testing.cc.
-#elif defined(HAVE_STRONG_GETAUXVAL)
+#define AT_HWCAP 16
+#define AT_HWCAP2 26
+#define AT_PLATFORM 15
+#define AT_BASE_PLATFORM 24
+
+#if defined(HAVE_STRONG_GETAUXVAL)
 #include <sys/auxv.h>
 static unsigned long GetElfHwcapFromGetauxval(uint32_t hwcap_type) {
   return getauxval(hwcap_type);
@@ -60,10 +81,6 @@ static unsigned long GetElfHwcapFromGetauxval(uint32_t hwcap_type) {
 // initialization layer.
 
 #include <dlfcn.h>
-#define AT_HWCAP 16
-#define AT_HWCAP2 26
-#define AT_PLATFORM 15
-#define AT_BASE_PLATFORM 24
 
 typedef unsigned long getauxval_func_t(unsigned long);
 
@@ -161,3 +178,5 @@ PlatformType CpuFeatures_GetPlatformType(void) {
                                       sizeof(type.base_platform));
   return type;
 }
+
+#endif  // CPU_FEATURES_TEST
diff --git a/src/unix_features_aggregator.c b/src/unix_features_aggregator.c
deleted file mode 100644
index cc79d14..0000000
--- a/src/unix_features_aggregator.c
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2017 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "internal/unix_features_aggregator.h"
-
-#include "internal/string_view.h"
-
-void CpuFeatures_SetFromFlags(const size_t configs_size,
-                              const CapabilityConfig* configs,
-                              const StringView flags_line,
-                              void* const features) {
-  size_t i = 0;
-  for (; i < configs_size; ++i) {
-    const CapabilityConfig config = configs[i];
-    config.set_bit(features, CpuFeatures_StringView_HasWord(
-                                 flags_line, config.proc_cpuinfo_flag));
-  }
-}
-
-static bool IsSet(const uint32_t mask, const uint32_t value) {
-  if (mask == 0) return false;
-  return (value & mask) == mask;
-}
-
-static bool IsHwCapsSet(const HardwareCapabilities hwcaps_mask,
-                        const HardwareCapabilities hwcaps) {
-  return IsSet(hwcaps_mask.hwcaps, hwcaps.hwcaps) ||
-         IsSet(hwcaps_mask.hwcaps2, hwcaps.hwcaps2);
-}
-
-void CpuFeatures_OverrideFromHwCaps(const size_t configs_size,
-                                    const CapabilityConfig* configs,
-                                    const HardwareCapabilities hwcaps,
-                                    void* const features) {
-  size_t i = 0;
-  for (; i < configs_size; ++i) {
-    const CapabilityConfig* config = &configs[i];
-    if (IsHwCapsSet(config->hwcaps_mask, hwcaps)) {
-      config->set_bit(features, true);
-    }
-  }
-}
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 834eec1..c10e617 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -12,7 +12,6 @@ add_library(filesystem_for_testing filesystem_for_testing.cc)
 target_compile_definitions(filesystem_for_testing PUBLIC CPU_FEATURES_MOCK_FILESYSTEM)
 ##------------------------------------------------------------------------------
 add_library(hwcaps_for_testing hwcaps_for_testing.cc)
-target_compile_definitions(hwcaps_for_testing PUBLIC CPU_FEATURES_MOCK_GET_ELF_HWCAP_FROM_GETAUXVAL)
 target_link_libraries(hwcaps_for_testing filesystem_for_testing)
 ##------------------------------------------------------------------------------
 add_library(stack_line_reader ../src/stack_line_reader.c)
@@ -23,7 +22,7 @@ add_library(stack_line_reader_for_test ../src/stack_line_reader.c)
 target_compile_definitions(stack_line_reader_for_test PUBLIC STACK_LINE_READER_BUFFER_SIZE=16)
 target_link_libraries(stack_line_reader_for_test string_view filesystem_for_testing)
 ##------------------------------------------------------------------------------
-add_library(all_libraries ../src/stack_line_reader.c ../src/unix_features_aggregator.c)
+add_library(all_libraries ../src/hwcaps.c  ../src/stack_line_reader.c)
 target_link_libraries(all_libraries hwcaps_for_testing stack_line_reader string_view)
 
 #
@@ -46,11 +45,6 @@ add_executable(stack_line_reader_test stack_line_reader_test.cc)
 target_link_libraries(stack_line_reader_test stack_line_reader_for_test)
 add_test(NAME stack_line_reader_test COMMAND stack_line_reader_test)
 ##------------------------------------------------------------------------------
-## unix_features_aggregator_test
-add_executable(unix_features_aggregator_test unix_features_aggregator_test.cc)
-target_link_libraries(unix_features_aggregator_test all_libraries)
-add_test(NAME unix_features_aggregator_test COMMAND unix_features_aggregator_test)
-##------------------------------------------------------------------------------
 ## cpuinfo_x86_test
 if(PROCESSOR_IS_X86)
   add_executable(cpuinfo_x86_test cpuinfo_x86_test.cc ../src/cpuinfo_x86.c)
diff --git a/test/unix_features_aggregator_test.cc b/test/unix_features_aggregator_test.cc
deleted file mode 100644
index 3a36804..0000000
--- a/test/unix_features_aggregator_test.cc
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright 2017 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "internal/unix_features_aggregator.h"
-
-#include <array>
-
-#include "gtest/gtest.h"
-
-namespace cpu_features {
-
-namespace {
-
-struct Features {
-  bool a = false;
-  bool b = false;
-  bool c = false;
-};
-
-enum eFeatures { TEST_a, TEST_b, TEST_c };
-
-DECLARE_SETTER_AND_GETTER(Features, a)
-DECLARE_SETTER_AND_GETTER(Features, b)
-DECLARE_SETTER_AND_GETTER(Features, c)
-
-class LinuxFeatureAggregatorTest : public testing::Test {
- public:
-  const std::array<CapabilityConfig, 3> kConfigs = {
-      {{{0b0001, 0b0000}, "a", &set_a, &get_a},
-       {{0b0010, 0b0000}, "b", &set_b, &get_b},
-       {{0b0000, 0b1100}, "c", &set_c, &get_c}}};
-};
-
-TEST_F(LinuxFeatureAggregatorTest, FromFlagsEmpty) {
-  Features features;
-  CpuFeatures_SetFromFlags(kConfigs.size(), kConfigs.data(), str(""),
-                           &features);
-  EXPECT_FALSE(features.a);
-  EXPECT_FALSE(features.b);
-  EXPECT_FALSE(features.c);
-
-  EXPECT_FALSE(kConfigs[TEST_a].get_bit(&features));
-}
-
-TEST_F(LinuxFeatureAggregatorTest, FromFlagsAllSet) {
-  Features features;
-  CpuFeatures_SetFromFlags(kConfigs.size(), kConfigs.data(), str("a c b"),
-                           &features);
-  EXPECT_TRUE(features.a);
-  EXPECT_TRUE(features.b);
-  EXPECT_TRUE(features.c);
-
-  EXPECT_TRUE(kConfigs[TEST_a].get_bit(&features));
-}
-
-TEST_F(LinuxFeatureAggregatorTest, FromFlagsOnlyA) {
-  Features features;
-  CpuFeatures_SetFromFlags(kConfigs.size(), kConfigs.data(), str("a"),
-                           &features);
-  EXPECT_TRUE(features.a);
-  EXPECT_FALSE(features.b);
-  EXPECT_FALSE(features.c);
-
-  EXPECT_TRUE(kConfigs[TEST_a].get_bit(&features));
-  EXPECT_FALSE(kConfigs[TEST_b].get_bit(&features));
-  EXPECT_FALSE(kConfigs[TEST_c].get_bit(&features));
-}
-
-TEST_F(LinuxFeatureAggregatorTest, FromHwcapsNone) {
-  HardwareCapabilities capability;
-  capability.hwcaps = 0;   // matches none
-  capability.hwcaps2 = 0;  // matches none
-  Features features;
-  CpuFeatures_OverrideFromHwCaps(kConfigs.size(), kConfigs.data(), capability,
-                                 &features);
-  EXPECT_FALSE(features.a);
-  EXPECT_FALSE(features.b);
-  EXPECT_FALSE(features.c);
-}
-
-TEST_F(LinuxFeatureAggregatorTest, FromHwcapsSet) {
-  HardwareCapabilities capability;
-  capability.hwcaps = 0b0010;   // matches b but not a
-  capability.hwcaps2 = 0b1111;  // matches c
-  Features features;
-  CpuFeatures_OverrideFromHwCaps(kConfigs.size(), kConfigs.data(), capability,
-                                 &features);
-  EXPECT_FALSE(features.a);
-  EXPECT_TRUE(features.b);
-  EXPECT_TRUE(features.c);
-}
-
-}  // namespace
-}  // namespace cpu_features