prefcnt.c

   1 /*
   2   SPDX-License-Identifier: GPL-2.0-only
   3
   4   Copyright (C) 2006 Mandriva Conectiva S.A.
   5   Copyright (C) 2006 Arnaldo Carvalho de Melo <acme@mandriva.com>
   6 */
   7
   8 #include <assert.h>
   9 #include <dwarf.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 #include "dwarves.h"
  15 #include "dutil.h"
  16
  17 static struct conf_fprintf conf;
  18
  19 static struct conf_load conf_load = {
  20         .conf_fprintf = &conf,
  21 };
  22
  23 static void refcnt_tag(struct tag *tag, const struct cu *cu);
  24
  25 static void refcnt_member(struct class_member *member, const struct cu *cu)
  26 {
  27         if (member->visited)
  28                 return;
  29         member->visited = 1;
  30         if (member->tag.type != 0) { /* if not void */
  31                 struct tag *type = cu__type(cu, member->tag.type);
  32                 if (type != NULL)
  33                         refcnt_tag(type, cu);
  34         }
  35 }
  36
  37 static void refcnt_parameter(const struct parameter *parameter,
  38                              const struct cu *cu)
  39 {
  40         if (parameter->tag.type != 0) { /* if not void */
  41                 struct tag *type = cu__type(cu, parameter->tag.type);
  42                 if (type != NULL)
  43                         refcnt_tag(type, cu);
  44         }
  45 }
  46
  47 static void refcnt_variable(const struct variable *variable,
  48                             const struct cu *cu)
  49 {
  50         if (variable->ip.tag.type != 0) { /* if not void */
  51                 struct tag *type = cu__type(cu, variable->ip.tag.type);
  52                 if (type != NULL)
  53                         refcnt_tag(type, cu);
  54         }
  55 }
  56
  57 static void refcnt_inline_expansion(const struct inline_expansion *exp,
  58                                     const struct cu *cu)
  59 {
  60         if (exp->ip.tag.type != 0) { /* if not void */
  61                 struct tag *type = cu__function(cu, exp->ip.tag.type);
  62                 if (type != NULL)
  63                         refcnt_tag(type, cu);
  64         }
  65 }
  66
  67 static void refcnt_tag(struct tag *tag, const struct cu *cu)
  68 {
  69         struct class_member *member;
  70
  71         tag->visited = 1;
  72
  73         if (tag__is_struct(tag) || tag__is_union(tag)) {
  74                 type__for_each_member(tag__type(tag), member)
  75                         refcnt_member(member, cu);
  76         }
  77 }
  78
  79 static void refcnt_lexblock(const struct lexblock *lexblock, const struct cu *cu)
  80 {
  81         struct tag *pos;
  82
  83         list_for_each_entry(pos, &lexblock->tags, node)
  84                 switch (pos->tag) {
  85                 case DW_TAG_variable:
  86                         refcnt_variable(tag__variable(pos), cu);
  87                         break;
  88                 case DW_TAG_inlined_subroutine:
  89                         refcnt_inline_expansion(tag__inline_expansion(pos), cu);
  90                         break;
  91                 case DW_TAG_lexical_block:
  92                         refcnt_lexblock(tag__lexblock(pos), cu);
  93                         break;
  94                 }
  95 }
  96
  97 static void refcnt_function(struct function *function, const struct cu *cu)
  98 {
  99         struct parameter *parameter;
 100
 101         function->proto.tag.visited = 1;
 102
 103         if (function->proto.tag.type != 0) /* if not void */ {
 104                 struct tag *type = cu__type(cu, function->proto.tag.type);
 105                 if (type != NULL)
 106                         refcnt_tag(type, cu);
 107         }
 108
 109         list_for_each_entry(parameter, &function->proto.parms, tag.node)
 110                 refcnt_parameter(parameter, cu);
 111
 112         refcnt_lexblock(&function->lexblock, cu);
 113 }
 114
 115 static int cu_refcnt_iterator(struct cu *cu, void *cookie __maybe_unused)
 116 {
 117         struct function *pos;
 118         uint32_t id;
 119
 120         cu__for_each_function(cu, id, pos)
 121                 refcnt_function(pos, cu);
 122         return 0;
 123 }
 124
 125 static int lost_iterator(struct tag *tag, struct cu *cu,
 126                          void *cookie __maybe_unused)
 127 {
 128         if (!tag->visited && tag__decl_file(tag, cu)) {
 129                 tag__fprintf(tag, cu, NULL, stdout);
 130                 puts(";\n");
 131         }
 132         return 0;
 133 }
 134
 135 static int cu_lost_iterator(struct cu *cu, void *cookie)
 136 {
 137         return cu__for_all_tags(cu, lost_iterator, cookie);
 138 }
 139
 140 int main(int argc __maybe_unused, char *argv[])
 141 {
 142         int err;
 143         struct cus *cus = cus__new();
 144
 145         if (dwarves__init() || cus == NULL) {
 146                 fputs("prefcnt: insufficient memory\n", stderr);
 147                 return EXIT_FAILURE;
 148         }
 149
 150         dwarves__resolve_cacheline_size(NULL, 0);
 151
 152         err = cus__load_files(cus, &conf_load, argv + 1);
 153         if (err != 0) {
 154                 cus__fprintf_load_files_err(cus, "prefcnt", argv + 1, err, stderr);
 155                 return EXIT_FAILURE;
 156         }
 157
 158         cus__for_each_cu(cus, cu_refcnt_iterator, NULL, NULL);
 159         cus__for_each_cu(cus, cu_lost_iterator, NULL, NULL);
 160
 161         return EXIT_SUCCESS;
 162 }