gendwarfksyms: Clean up kABI rule look-ups

Reduce code duplication by moving kABI rule look-ups to separate
functions.

Signed-off-by: Sami Tolvanen <samitolvanen@google.com>
Reviewed-by: Petr Pavlu <petr.pavlu@suse.com>
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>

diff --git a/scripts/gendwarfksyms/kabi.c b/scripts/gendwarfksyms/kabi.c
index 66f01fcd1607950841807131f0ffe333ae9b3f3b..badf8d46b1540bd3bbf3157fb9fba3d04b651931 100644 (file)
--- a/scripts/gendwarfksyms/kabi.c
+++ b/scripts/gendwarfksyms/kabi.c
@@ -222,33 +222,55 @@ void kabi_read_rules(int fd)
        check(elf_end(elf));
 }
 
-bool kabi_is_declonly(const char *fqn)
+static char *get_enumerator_target(const char *fqn, const char *field)
+{
+       char *target = NULL;
+
+       if (asprintf(&target, "%s %s", fqn, field) < 0)
+               error("asprintf failed for '%s %s'", fqn, field);
+
+       return target;
+}
+
+static struct rule *find_rule(enum kabi_rule_type type, const char *target)
 {
        struct rule *rule;
 
        if (!stable)
-               return false;
-       if (!fqn || !*fqn)
-               return false;
+               return NULL;
+       if (!target || !*target)
+               return NULL;
 
        hash_for_each_possible(rules, rule, hash,
-                              rule_values_hash(KABI_RULE_TYPE_DECLONLY, fqn)) {
-               if (rule->type == KABI_RULE_TYPE_DECLONLY &&
-                   !strcmp(fqn, rule->target))
-                       return true;
+                              rule_values_hash(type, target)) {
+               if (rule->type == type && !strcmp(target, rule->target))
+                       return rule;
        }
 
-       return false;
+       return NULL;
 }
 
-static char *get_enumerator_target(const char *fqn, const char *field)
+static struct rule *find_enumerator_rule(enum kabi_rule_type type,
+                                        const char *fqn, const char *field)
 {
-       char *target = NULL;
+       struct rule *rule;
+       char *target;
 
-       if (asprintf(&target, "%s %s", fqn, field) < 0)
-               error("asprintf failed for '%s %s'", fqn, field);
+       if (!stable)
+               return NULL;
+       if (!fqn || !*fqn || !field || !*field)
+               return NULL;
 
-       return target;
+       target = get_enumerator_target(fqn, field);
+       rule = find_rule(type, target);
+
+       free(target);
+       return rule;
+}
+
+bool kabi_is_declonly(const char *fqn)
+{
+       return !!find_rule(KABI_RULE_TYPE_DECLONLY, fqn);
 }
 
 static unsigned long get_ulong_value(const char *value)
@@ -267,58 +289,23 @@ static unsigned long get_ulong_value(const char *value)
 
 bool kabi_is_enumerator_ignored(const char *fqn, const char *field)
 {
-       bool match = false;
-       struct rule *rule;
-       char *target;
-
-       if (!stable)
-               return false;
-       if (!fqn || !*fqn || !field || !*field)
-               return false;
-
-       target = get_enumerator_target(fqn, field);
-
-       hash_for_each_possible(
-               rules, rule, hash,
-               rule_values_hash(KABI_RULE_TYPE_ENUMERATOR_IGNORE, target)) {
-               if (rule->type == KABI_RULE_TYPE_ENUMERATOR_IGNORE &&
-                   !strcmp(target, rule->target)) {
-                       match = true;
-                       break;
-               }
-       }
-
-       free(target);
-       return match;
+       return !!find_enumerator_rule(KABI_RULE_TYPE_ENUMERATOR_IGNORE, fqn,
+                                     field);
 }
 
 bool kabi_get_enumerator_value(const char *fqn, const char *field,
                               unsigned long *value)
 {
-       bool match = false;
        struct rule *rule;
-       char *target;
 
-       if (!stable)
-               return false;
-       if (!fqn || !*fqn || !field || !*field)
-               return false;
-
-       target = get_enumerator_target(fqn, field);
-
-       hash_for_each_possible(rules, rule, hash,
-                              rule_values_hash(KABI_RULE_TYPE_ENUMERATOR_VALUE,
-                                               target)) {
-               if (rule->type == KABI_RULE_TYPE_ENUMERATOR_VALUE &&
-                   !strcmp(target, rule->target)) {
-                       *value = get_ulong_value(rule->value);
-                       match = true;
-                       break;
-               }
+       rule = find_enumerator_rule(KABI_RULE_TYPE_ENUMERATOR_VALUE, fqn,
+                                   field);
+       if (rule) {
+               *value = get_ulong_value(rule->value);
+               return true;
        }
 
-       free(target);
-       return match;
+       return false;
 }
 
 void kabi_free(void)