scripts/genksyms/genksyms.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* Generate kernel symbol version hashes.
   3    Copyright 1996, 1997 Linux International.
   4
   5    New implementation contributed by Richard Henderson <rth@tamu.edu>
   6    Based on original work by Bjorn Ekwall <bj0rn@blox.se>
   7
   8    This file was part of the Linux modutils 2.4.22: moved back into the
   9    kernel sources by Rusty Russell/Kai Germaschewski.
  10
  11  */
  12
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <stdlib.h>
  16 #include <unistd.h>
  17 #include <assert.h>
  18 #include <stdarg.h>
  19 #ifdef __GNU_LIBRARY__
  20 #include <getopt.h>
  21 #endif                          /* __GNU_LIBRARY__ */
  22
  23 #include "genksyms.h"
  24 /*----------------------------------------------------------------------*/
  25
  26 #define HASH_BUCKETS  4096
  27
  28 static struct symbol *symtab[HASH_BUCKETS];
  29 static FILE *debugfile;
  30
  31 int cur_line = 1;
  32 char *cur_filename, *source_file;
  33 int in_source_file;
  34
  35 static int flag_debug, flag_dump_defs, flag_reference, flag_dump_types,
  36            flag_preserve, flag_warnings, flag_rel_crcs;
  37
  38 static int errors;
  39 static int nsyms;
  40
  41 static struct symbol *expansion_trail;
  42 static struct symbol *visited_symbols;
  43
  44 static const struct {
  45         int n;
  46         const char *name;
  47 } symbol_types[] = {
  48         [SYM_NORMAL]     = { 0, NULL},
  49         [SYM_TYPEDEF]    = {'t', "typedef"},
  50         [SYM_ENUM]       = {'e', "enum"},
  51         [SYM_STRUCT]     = {'s', "struct"},
  52         [SYM_UNION]      = {'u', "union"},
  53         [SYM_ENUM_CONST] = {'E', "enum constant"},
  54 };
  55
  56 static int equal_list(struct string_list *a, struct string_list *b);
  57 static void print_list(FILE * f, struct string_list *list);
  58 static struct string_list *concat_list(struct string_list *start, ...);
  59 static struct string_list *mk_node(const char *string);
  60 static void print_location(void);
  61 static void print_type_name(enum symbol_type type, const char *name);
  62
  63 /*----------------------------------------------------------------------*/
  64
  65 static const unsigned int crctab32[] = {
  66         0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U,
  67         0x706af48fU, 0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U,
  68         0xe0d5e91eU, 0x97d2d988U, 0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U,
  69         0x90bf1d91U, 0x1db71064U, 0x6ab020f2U, 0xf3b97148U, 0x84be41deU,
  70         0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U, 0x83d385c7U, 0x136c9856U,
  71         0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU, 0x63066cd9U,
  72         0xfa0f3d63U, 0x8d080df5U, 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U,
  73         0xa2677172U, 0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU,
  74         0x35b5a8faU, 0x42b2986cU, 0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U,
  75         0x45df5c75U, 0xdcd60dcfU, 0xabd13d59U, 0x26d930acU, 0x51de003aU,
  76         0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U, 0x56b3c423U, 0xcfba9599U,
  77         0xb8bda50fU, 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U, 0xb10be924U,
  78         0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU, 0x76dc4190U,
  79         0x01db7106U, 0x98d220bcU, 0xefd5102aU, 0x71b18589U, 0x06b6b51fU,
  80         0x9fbfe4a5U, 0xe8b8d433U, 0x7807c9a2U, 0x0f00f934U, 0x9609a88eU,
  81         0xe10e9818U, 0x7f6a0dbbU, 0x086d3d2dU, 0x91646c97U, 0xe6635c01U,
  82         0x6b6b51f4U, 0x1c6c6162U, 0x856530d8U, 0xf262004eU, 0x6c0695edU,
  83         0x1b01a57bU, 0x8208f4c1U, 0xf50fc457U, 0x65b0d9c6U, 0x12b7e950U,
  84         0x8bbeb8eaU, 0xfcb9887cU, 0x62dd1ddfU, 0x15da2d49U, 0x8cd37cf3U,
  85         0xfbd44c65U, 0x4db26158U, 0x3ab551ceU, 0xa3bc0074U, 0xd4bb30e2U,
  86         0x4adfa541U, 0x3dd895d7U, 0xa4d1c46dU, 0xd3d6f4fbU, 0x4369e96aU,
  87         0x346ed9fcU, 0xad678846U, 0xda60b8d0U, 0x44042d73U, 0x33031de5U,
  88         0xaa0a4c5fU, 0xdd0d7cc9U, 0x5005713cU, 0x270241aaU, 0xbe0b1010U,
  89         0xc90c2086U, 0x5768b525U, 0x206f85b3U, 0xb966d409U, 0xce61e49fU,
  90         0x5edef90eU, 0x29d9c998U, 0xb0d09822U, 0xc7d7a8b4U, 0x59b33d17U,
  91         0x2eb40d81U, 0xb7bd5c3bU, 0xc0ba6cadU, 0xedb88320U, 0x9abfb3b6U,
  92         0x03b6e20cU, 0x74b1d29aU, 0xead54739U, 0x9dd277afU, 0x04db2615U,
  93         0x73dc1683U, 0xe3630b12U, 0x94643b84U, 0x0d6d6a3eU, 0x7a6a5aa8U,
  94         0xe40ecf0bU, 0x9309ff9dU, 0x0a00ae27U, 0x7d079eb1U, 0xf00f9344U,
  95         0x8708a3d2U, 0x1e01f268U, 0x6906c2feU, 0xf762575dU, 0x806567cbU,
  96         0x196c3671U, 0x6e6b06e7U, 0xfed41b76U, 0x89d32be0U, 0x10da7a5aU,
  97         0x67dd4accU, 0xf9b9df6fU, 0x8ebeeff9U, 0x17b7be43U, 0x60b08ed5U,
  98         0xd6d6a3e8U, 0xa1d1937eU, 0x38d8c2c4U, 0x4fdff252U, 0xd1bb67f1U,
  99         0xa6bc5767U, 0x3fb506ddU, 0x48b2364bU, 0xd80d2bdaU, 0xaf0a1b4cU,
 100         0x36034af6U, 0x41047a60U, 0xdf60efc3U, 0xa867df55U, 0x316e8eefU,
 101         0x4669be79U, 0xcb61b38cU, 0xbc66831aU, 0x256fd2a0U, 0x5268e236U,
 102         0xcc0c7795U, 0xbb0b4703U, 0x220216b9U, 0x5505262fU, 0xc5ba3bbeU,
 103         0xb2bd0b28U, 0x2bb45a92U, 0x5cb36a04U, 0xc2d7ffa7U, 0xb5d0cf31U,
 104         0x2cd99e8bU, 0x5bdeae1dU, 0x9b64c2b0U, 0xec63f226U, 0x756aa39cU,
 105         0x026d930aU, 0x9c0906a9U, 0xeb0e363fU, 0x72076785U, 0x05005713U,
 106         0x95bf4a82U, 0xe2b87a14U, 0x7bb12baeU, 0x0cb61b38U, 0x92d28e9bU,
 107         0xe5d5be0dU, 0x7cdcefb7U, 0x0bdbdf21U, 0x86d3d2d4U, 0xf1d4e242U,
 108         0x68ddb3f8U, 0x1fda836eU, 0x81be16cdU, 0xf6b9265bU, 0x6fb077e1U,
 109         0x18b74777U, 0x88085ae6U, 0xff0f6a70U, 0x66063bcaU, 0x11010b5cU,
 110         0x8f659effU, 0xf862ae69U, 0x616bffd3U, 0x166ccf45U, 0xa00ae278U,
 111         0xd70dd2eeU, 0x4e048354U, 0x3903b3c2U, 0xa7672661U, 0xd06016f7U,
 112         0x4969474dU, 0x3e6e77dbU, 0xaed16a4aU, 0xd9d65adcU, 0x40df0b66U,
 113         0x37d83bf0U, 0xa9bcae53U, 0xdebb9ec5U, 0x47b2cf7fU, 0x30b5ffe9U,
 114         0xbdbdf21cU, 0xcabac28aU, 0x53b39330U, 0x24b4a3a6U, 0xbad03605U,
 115         0xcdd70693U, 0x54de5729U, 0x23d967bfU, 0xb3667a2eU, 0xc4614ab8U,
 116         0x5d681b02U, 0x2a6f2b94U, 0xb40bbe37U, 0xc30c8ea1U, 0x5a05df1bU,
 117         0x2d02ef8dU
 118 };
 119
 120 static unsigned long partial_crc32_one(unsigned char c, unsigned long crc)
 121 {
 122         return crctab32[(crc ^ c) & 0xff] ^ (crc >> 8);
 123 }
 124
 125 static unsigned long partial_crc32(const char *s, unsigned long crc)
 126 {
 127         while (*s)
 128                 crc = partial_crc32_one(*s++, crc);
 129         return crc;
 130 }
 131
 132 static unsigned long crc32(const char *s)
 133 {
 134         return partial_crc32(s, 0xffffffff) ^ 0xffffffff;
 135 }
 136
 137 /*----------------------------------------------------------------------*/
 138
 139 static enum symbol_type map_to_ns(enum symbol_type t)
 140 {
 141         switch (t) {
 142         case SYM_ENUM_CONST:
 143         case SYM_NORMAL:
 144         case SYM_TYPEDEF:
 145                 return SYM_NORMAL;
 146         case SYM_ENUM:
 147         case SYM_STRUCT:
 148         case SYM_UNION:
 149                 return SYM_STRUCT;
 150         }
 151         return t;
 152 }
 153
 154 struct symbol *find_symbol(const char *name, enum symbol_type ns, int exact)
 155 {
 156         unsigned long h = crc32(name) % HASH_BUCKETS;
 157         struct symbol *sym;
 158
 159         for (sym = symtab[h]; sym; sym = sym->hash_next)
 160                 if (map_to_ns(sym->type) == map_to_ns(ns) &&
 161                     strcmp(name, sym->name) == 0 &&
 162                     sym->is_declared)
 163                         break;
 164
 165         if (exact && sym && sym->type != ns)
 166                 return NULL;
 167         return sym;
 168 }
 169
 170 static int is_unknown_symbol(struct symbol *sym)
 171 {
 172         struct string_list *defn;
 173
 174         return ((sym->type == SYM_STRUCT ||
 175                  sym->type == SYM_UNION ||
 176                  sym->type == SYM_ENUM) &&
 177                 (defn = sym->defn)  && defn->tag == SYM_NORMAL &&
 178                         strcmp(defn->string, "}") == 0 &&
 179                 (defn = defn->next) && defn->tag == SYM_NORMAL &&
 180                         strcmp(defn->string, "UNKNOWN") == 0 &&
 181                 (defn = defn->next) && defn->tag == SYM_NORMAL &&
 182                         strcmp(defn->string, "{") == 0);
 183 }
 184
 185 static struct symbol *__add_symbol(const char *name, enum symbol_type type,
 186                             struct string_list *defn, int is_extern,
 187                             int is_reference)
 188 {
 189         unsigned long h;
 190         struct symbol *sym;
 191         enum symbol_status status = STATUS_UNCHANGED;
 192         /* The parser adds symbols in the order their declaration completes,
 193          * so it is safe to store the value of the previous enum constant in
 194          * a static variable.
 195          */
 196         static int enum_counter;
 197         static struct string_list *last_enum_expr;
 198
 199         if (type == SYM_ENUM_CONST) {
 200                 if (defn) {
 201                         free_list(last_enum_expr, NULL);
 202                         last_enum_expr = copy_list_range(defn, NULL);
 203                         enum_counter = 1;
 204                 } else {
 205                         struct string_list *expr;
 206                         char buf[20];
 207
 208                         snprintf(buf, sizeof(buf), "%d", enum_counter++);
 209                         if (last_enum_expr) {
 210                                 expr = copy_list_range(last_enum_expr, NULL);
 211                                 defn = concat_list(mk_node("("),
 212                                                    expr,
 213                                                    mk_node(")"),
 214                                                    mk_node("+"),
 215                                                    mk_node(buf), NULL);
 216                         } else {
 217                                 defn = mk_node(buf);
 218                         }
 219                 }
 220         } else if (type == SYM_ENUM) {
 221                 free_list(last_enum_expr, NULL);
 222                 last_enum_expr = NULL;
 223                 enum_counter = 0;
 224                 if (!name)
 225                         /* Anonymous enum definition, nothing more to do */
 226                         return NULL;
 227         }
 228
 229         h = crc32(name) % HASH_BUCKETS;
 230         for (sym = symtab[h]; sym; sym = sym->hash_next) {
 231                 if (map_to_ns(sym->type) == map_to_ns(type) &&
 232                     strcmp(name, sym->name) == 0) {
 233                         if (is_reference)
 234                                 /* fall through */ ;
 235                         else if (sym->type == type &&
 236                                  equal_list(sym->defn, defn)) {
 237                                 if (!sym->is_declared && sym->is_override) {
 238                                         print_location();
 239                                         print_type_name(type, name);
 240                                         fprintf(stderr, " modversion is "
 241                                                 "unchanged\n");
 242                                 }
 243                                 sym->is_declared = 1;
 244                                 return sym;
 245                         } else if (!sym->is_declared) {
 246                                 if (sym->is_override && flag_preserve) {
 247                                         print_location();
 248                                         fprintf(stderr, "ignoring ");
 249                                         print_type_name(type, name);
 250                                         fprintf(stderr, " modversion change\n");
 251                                         sym->is_declared = 1;
 252                                         return sym;
 253                                 } else {
 254                                         status = is_unknown_symbol(sym) ?
 255                                                 STATUS_DEFINED : STATUS_MODIFIED;
 256                                 }
 257                         } else {
 258                                 error_with_pos("redefinition of %s", name);
 259                                 return sym;
 260                         }
 261                         break;
 262                 }
 263         }
 264
 265         if (sym) {
 266                 struct symbol **psym;
 267
 268                 for (psym = &symtab[h]; *psym; psym = &(*psym)->hash_next) {
 269                         if (*psym == sym) {
 270                                 *psym = sym->hash_next;
 271                                 break;
 272                         }
 273                 }
 274                 --nsyms;
 275         }
 276
 277         sym = xmalloc(sizeof(*sym));
 278         sym->name = name;
 279         sym->type = type;
 280         sym->defn = defn;
 281         sym->expansion_trail = NULL;
 282         sym->visited = NULL;
 283         sym->is_extern = is_extern;
 284
 285         sym->hash_next = symtab[h];
 286         symtab[h] = sym;
 287
 288         sym->is_declared = !is_reference;
 289         sym->status = status;
 290         sym->is_override = 0;
 291
 292         if (flag_debug) {
 293                 if (symbol_types[type].name)
 294                         fprintf(debugfile, "Defn for %s %s == <",
 295                                 symbol_types[type].name, name);
 296                 else
 297                         fprintf(debugfile, "Defn for type%d %s == <",
 298                                 type, name);
 299                 if (is_extern)
 300                         fputs("extern ", debugfile);
 301                 print_list(debugfile, defn);
 302                 fputs(">\n", debugfile);
 303         }
 304
 305         ++nsyms;
 306         return sym;
 307 }
 308
 309 struct symbol *add_symbol(const char *name, enum symbol_type type,
 310                           struct string_list *defn, int is_extern)
 311 {
 312         return __add_symbol(name, type, defn, is_extern, 0);
 313 }
 314
 315 static struct symbol *add_reference_symbol(const char *name, enum symbol_type type,
 316                                     struct string_list *defn, int is_extern)
 317 {
 318         return __add_symbol(name, type, defn, is_extern, 1);
 319 }
 320
 321 /*----------------------------------------------------------------------*/
 322
 323 void free_node(struct string_list *node)
 324 {
 325         free(node->string);
 326         free(node);
 327 }
 328
 329 void free_list(struct string_list *s, struct string_list *e)
 330 {
 331         while (s != e) {
 332                 struct string_list *next = s->next;
 333                 free_node(s);
 334                 s = next;
 335         }
 336 }
 337
 338 static struct string_list *mk_node(const char *string)
 339 {
 340         struct string_list *newnode;
 341
 342         newnode = xmalloc(sizeof(*newnode));
 343         newnode->string = xstrdup(string);
 344         newnode->tag = SYM_NORMAL;
 345         newnode->next = NULL;
 346
 347         return newnode;
 348 }
 349
 350 static struct string_list *concat_list(struct string_list *start, ...)
 351 {
 352         va_list ap;
 353         struct string_list *n, *n2;
 354
 355         if (!start)
 356                 return NULL;
 357         for (va_start(ap, start); (n = va_arg(ap, struct string_list *));) {
 358                 for (n2 = n; n2->next; n2 = n2->next)
 359                         ;
 360                 n2->next = start;
 361                 start = n;
 362         }
 363         va_end(ap);
 364         return start;
 365 }
 366
 367 struct string_list *copy_node(struct string_list *node)
 368 {
 369         struct string_list *newnode;
 370
 371         newnode = xmalloc(sizeof(*newnode));
 372         newnode->string = xstrdup(node->string);
 373         newnode->tag = node->tag;
 374
 375         return newnode;
 376 }
 377
 378 struct string_list *copy_list_range(struct string_list *start,
 379                                     struct string_list *end)
 380 {
 381         struct string_list *res, *n;
 382
 383         if (start == end)
 384                 return NULL;
 385         n = res = copy_node(start);
 386         for (start = start->next; start != end; start = start->next) {
 387                 n->next = copy_node(start);
 388                 n = n->next;
 389         }
 390         n->next = NULL;
 391         return res;
 392 }
 393
 394 static int equal_list(struct string_list *a, struct string_list *b)
 395 {
 396         while (a && b) {
 397                 if (a->tag != b->tag || strcmp(a->string, b->string))
 398                         return 0;
 399                 a = a->next;
 400                 b = b->next;
 401         }
 402
 403         return !a && !b;
 404 }
 405
 406 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
 407
 408 static struct string_list *read_node(FILE *f)
 409 {
 410         char buffer[256];
 411         struct string_list node = {
 412                 .string = buffer,
 413                 .tag = SYM_NORMAL };
 414         int c, in_string = 0;
 415
 416         while ((c = fgetc(f)) != EOF) {
 417                 if (!in_string && c == ' ') {
 418                         if (node.string == buffer)
 419                                 continue;
 420                         break;
 421                 } else if (c == '"') {
 422                         in_string = !in_string;
 423                 } else if (c == '\n') {
 424                         if (node.string == buffer)
 425                                 return NULL;
 426                         ungetc(c, f);
 427                         break;
 428                 }
 429                 if (node.string >= buffer + sizeof(buffer) - 1) {
 430                         fprintf(stderr, "Token too long\n");
 431                         exit(1);
 432                 }
 433                 *node.string++ = c;
 434         }
 435         if (node.string == buffer)
 436                 return NULL;
 437         *node.string = 0;
 438         node.string = buffer;
 439
 440         if (node.string[1] == '#') {
 441                 size_t n;
 442
 443                 for (n = 0; n < ARRAY_SIZE(symbol_types); n++) {
 444                         if (node.string[0] == symbol_types[n].n) {
 445                                 node.tag = n;
 446                                 node.string += 2;
 447                                 return copy_node(&node);
 448                         }
 449                 }
 450                 fprintf(stderr, "Unknown type %c\n", node.string[0]);
 451                 exit(1);
 452         }
 453         return copy_node(&node);
 454 }
 455
 456 static void read_reference(FILE *f)
 457 {
 458         while (!feof(f)) {
 459                 struct string_list *defn = NULL;
 460                 struct string_list *sym, *def;
 461                 int is_extern = 0, is_override = 0;
 462                 struct symbol *subsym;
 463
 464                 sym = read_node(f);
 465                 if (sym && sym->tag == SYM_NORMAL &&
 466                     !strcmp(sym->string, "override")) {
 467                         is_override = 1;
 468                         free_node(sym);
 469                         sym = read_node(f);
 470                 }
 471                 if (!sym)
 472                         continue;
 473                 def = read_node(f);
 474                 if (def && def->tag == SYM_NORMAL &&
 475                     !strcmp(def->string, "extern")) {
 476                         is_extern = 1;
 477                         free_node(def);
 478                         def = read_node(f);
 479                 }
 480                 while (def) {
 481                         def->next = defn;
 482                         defn = def;
 483                         def = read_node(f);
 484                 }
 485                 subsym = add_reference_symbol(xstrdup(sym->string), sym->tag,
 486                                               defn, is_extern);
 487                 subsym->is_override = is_override;
 488                 free_node(sym);
 489         }
 490 }
 491
 492 static void print_node(FILE * f, struct string_list *list)
 493 {
 494         if (symbol_types[list->tag].n) {
 495                 putc(symbol_types[list->tag].n, f);
 496                 putc('#', f);
 497         }
 498         fputs(list->string, f);
 499 }
 500
 501 static void print_list(FILE * f, struct string_list *list)
 502 {
 503         struct string_list **e, **b;
 504         struct string_list *tmp, **tmp2;
 505         int elem = 1;
 506
 507         if (list == NULL) {
 508                 fputs("(nil)", f);
 509                 return;
 510         }
 511
 512         tmp = list;
 513         while ((tmp = tmp->next) != NULL)
 514                 elem++;
 515
 516         b = alloca(elem * sizeof(*e));
 517         e = b + elem;
 518         tmp2 = e - 1;
 519
 520         (*tmp2--) = list;
 521         while ((list = list->next) != NULL)
 522                 *(tmp2--) = list;
 523
 524         while (b != e) {
 525                 print_node(f, *b++);
 526                 putc(' ', f);
 527         }
 528 }
 529
 530 static unsigned long expand_and_crc_sym(struct symbol *sym, unsigned long crc)
 531 {
 532         struct string_list *list = sym->defn;
 533         struct string_list **e, **b;
 534         struct string_list *tmp, **tmp2;
 535         int elem = 1;
 536
 537         if (!list)
 538                 return crc;
 539
 540         tmp = list;
 541         while ((tmp = tmp->next) != NULL)
 542                 elem++;
 543
 544         b = alloca(elem * sizeof(*e));
 545         e = b + elem;
 546         tmp2 = e - 1;
 547
 548         *(tmp2--) = list;
 549         while ((list = list->next) != NULL)
 550                 *(tmp2--) = list;
 551
 552         while (b != e) {
 553                 struct string_list *cur;
 554                 struct symbol *subsym;
 555
 556                 cur = *(b++);
 557                 switch (cur->tag) {
 558                 case SYM_NORMAL:
 559                         if (flag_dump_defs)
 560                                 fprintf(debugfile, "%s ", cur->string);
 561                         crc = partial_crc32(cur->string, crc);
 562                         crc = partial_crc32_one(' ', crc);
 563                         break;
 564
 565                 case SYM_ENUM_CONST:
 566                 case SYM_TYPEDEF:
 567                         subsym = find_symbol(cur->string, cur->tag, 0);
 568                         /* FIXME: Bad reference files can segfault here. */
 569                         if (subsym->expansion_trail) {
 570                                 if (flag_dump_defs)
 571                                         fprintf(debugfile, "%s ", cur->string);
 572                                 crc = partial_crc32(cur->string, crc);
 573                                 crc = partial_crc32_one(' ', crc);
 574                         } else {
 575                                 subsym->expansion_trail = expansion_trail;
 576                                 expansion_trail = subsym;
 577                                 crc = expand_and_crc_sym(subsym, crc);
 578                         }
 579                         break;
 580
 581                 case SYM_STRUCT:
 582                 case SYM_UNION:
 583                 case SYM_ENUM:
 584                         subsym = find_symbol(cur->string, cur->tag, 0);
 585                         if (!subsym) {
 586                                 struct string_list *n;
 587
 588                                 error_with_pos("expand undefined %s %s",
 589                                                symbol_types[cur->tag].name,
 590                                                cur->string);
 591                                 n = concat_list(mk_node
 592                                                 (symbol_types[cur->tag].name),
 593                                                 mk_node(cur->string),
 594                                                 mk_node("{"),
 595                                                 mk_node("UNKNOWN"),
 596                                                 mk_node("}"), NULL);
 597                                 subsym =
 598                                     add_symbol(cur->string, cur->tag, n, 0);
 599                         }
 600                         if (subsym->expansion_trail) {
 601                                 if (flag_dump_defs) {
 602                                         fprintf(debugfile, "%s %s ",
 603                                                 symbol_types[cur->tag].name,
 604                                                 cur->string);
 605                                 }
 606
 607                                 crc = partial_crc32(symbol_types[cur->tag].name,
 608                                                     crc);
 609                                 crc = partial_crc32_one(' ', crc);
 610                                 crc = partial_crc32(cur->string, crc);
 611                                 crc = partial_crc32_one(' ', crc);
 612                         } else {
 613                                 subsym->expansion_trail = expansion_trail;
 614                                 expansion_trail = subsym;
 615                                 crc = expand_and_crc_sym(subsym, crc);
 616                         }
 617                         break;
 618                 }
 619         }
 620
 621         {
 622                 static struct symbol **end = &visited_symbols;
 623
 624                 if (!sym->visited) {
 625                         *end = sym;
 626                         end = &sym->visited;
 627                         sym->visited = (struct symbol *)-1L;
 628                 }
 629         }
 630
 631         return crc;
 632 }
 633
 634 void export_symbol(const char *name)
 635 {
 636         struct symbol *sym;
 637
 638         sym = find_symbol(name, SYM_NORMAL, 0);
 639         if (!sym)
 640                 error_with_pos("export undefined symbol %s", name);
 641         else {
 642                 unsigned long crc;
 643                 int has_changed = 0;
 644
 645                 if (flag_dump_defs)
 646                         fprintf(debugfile, "Export %s == <", name);
 647
 648                 expansion_trail = (struct symbol *)-1L;
 649
 650                 sym->expansion_trail = expansion_trail;
 651                 expansion_trail = sym;
 652                 crc = expand_and_crc_sym(sym, 0xffffffff) ^ 0xffffffff;
 653
 654                 sym = expansion_trail;
 655                 while (sym != (struct symbol *)-1L) {
 656                         struct symbol *n = sym->expansion_trail;
 657
 658                         if (sym->status != STATUS_UNCHANGED) {
 659                                 if (!has_changed) {
 660                                         print_location();
 661                                         fprintf(stderr, "%s: %s: modversion "
 662                                                 "changed because of changes "
 663                                                 "in ", flag_preserve ? "error" :
 664                                                        "warning", name);
 665                                 } else
 666                                         fprintf(stderr, ", ");
 667                                 print_type_name(sym->type, sym->name);
 668                                 if (sym->status == STATUS_DEFINED)
 669                                         fprintf(stderr, " (became defined)");
 670                                 has_changed = 1;
 671                                 if (flag_preserve)
 672                                         errors++;
 673                         }
 674                         sym->expansion_trail = 0;
 675                         sym = n;
 676                 }
 677                 if (has_changed)
 678                         fprintf(stderr, "\n");
 679
 680                 if (flag_dump_defs)
 681                         fputs(">\n", debugfile);
 682
 683                 /* Used as a linker script. */
 684                 printf(!flag_rel_crcs ? "__crc_%s = 0x%08lx;\n" :
 685                        "SECTIONS { .rodata : ALIGN(4) { "
 686                        "__crc_%s = .; LONG(0x%08lx); } }\n",
 687                        name, crc);
 688         }
 689 }
 690
 691 /*----------------------------------------------------------------------*/
 692
 693 static void print_location(void)
 694 {
 695         fprintf(stderr, "%s:%d: ", cur_filename ? : "<stdin>", cur_line);
 696 }
 697
 698 static void print_type_name(enum symbol_type type, const char *name)
 699 {
 700         if (symbol_types[type].name)
 701                 fprintf(stderr, "%s %s", symbol_types[type].name, name);
 702         else
 703                 fprintf(stderr, "%s", name);
 704 }
 705
 706 void error_with_pos(const char *fmt, ...)
 707 {
 708         va_list args;
 709
 710         if (flag_warnings) {
 711                 print_location();
 712
 713                 va_start(args, fmt);
 714                 vfprintf(stderr, fmt, args);
 715                 va_end(args);
 716                 putc('\n', stderr);
 717
 718                 errors++;
 719         }
 720 }
 721
 722 static void genksyms_usage(void)
 723 {
 724         fputs("Usage:\n" "genksyms [-adDTwqhVR] > /path/to/.tmp_obj.ver\n" "\n"
 725 #ifdef __GNU_LIBRARY__
 726               "  -s, --symbol-prefix   Select symbol prefix\n"
 727               "  -d, --debug           Increment the debug level (repeatable)\n"
 728               "  -D, --dump            Dump expanded symbol defs (for debugging only)\n"
 729               "  -r, --reference file  Read reference symbols from a file\n"
 730               "  -T, --dump-types file Dump expanded types into file\n"
 731               "  -p, --preserve        Preserve reference modversions or fail\n"
 732               "  -w, --warnings        Enable warnings\n"
 733               "  -q, --quiet           Disable warnings (default)\n"
 734               "  -h, --help            Print this message\n"
 735               "  -V, --version         Print the release version\n"
 736               "  -R, --relative-crc    Emit section relative symbol CRCs\n"
 737 #else                           /* __GNU_LIBRARY__ */
 738               "  -s                    Select symbol prefix\n"
 739               "  -d                    Increment the debug level (repeatable)\n"
 740               "  -D                    Dump expanded symbol defs (for debugging only)\n"
 741               "  -r file               Read reference symbols from a file\n"
 742               "  -T file               Dump expanded types into file\n"
 743               "  -p                    Preserve reference modversions or fail\n"
 744               "  -w                    Enable warnings\n"
 745               "  -q                    Disable warnings (default)\n"
 746               "  -h                    Print this message\n"
 747               "  -V                    Print the release version\n"
 748               "  -R                    Emit section relative symbol CRCs\n"
 749 #endif                          /* __GNU_LIBRARY__ */
 750               , stderr);
 751 }
 752
 753 int main(int argc, char **argv)
 754 {
 755         FILE *dumpfile = NULL, *ref_file = NULL;
 756         int o;
 757
 758 #ifdef __GNU_LIBRARY__
 759         struct option long_opts[] = {
 760                 {"debug", 0, 0, 'd'},
 761                 {"warnings", 0, 0, 'w'},
 762                 {"quiet", 0, 0, 'q'},
 763                 {"dump", 0, 0, 'D'},
 764                 {"reference", 1, 0, 'r'},
 765                 {"dump-types", 1, 0, 'T'},
 766                 {"preserve", 0, 0, 'p'},
 767                 {"version", 0, 0, 'V'},
 768                 {"help", 0, 0, 'h'},
 769                 {"relative-crc", 0, 0, 'R'},
 770                 {0, 0, 0, 0}
 771         };
 772
 773         while ((o = getopt_long(argc, argv, "s:dwqVDr:T:phR",
 774                                 &long_opts[0], NULL)) != EOF)
 775 #else                           /* __GNU_LIBRARY__ */
 776         while ((o = getopt(argc, argv, "s:dwqVDr:T:phR")) != EOF)
 777 #endif                          /* __GNU_LIBRARY__ */
 778                 switch (o) {
 779                 case 'd':
 780                         flag_debug++;
 781                         break;
 782                 case 'w':
 783                         flag_warnings = 1;
 784                         break;
 785                 case 'q':
 786                         flag_warnings = 0;
 787                         break;
 788                 case 'V':
 789                         fputs("genksyms version 2.5.60\n", stderr);
 790                         break;
 791                 case 'D':
 792                         flag_dump_defs = 1;
 793                         break;
 794                 case 'r':
 795                         flag_reference = 1;
 796                         ref_file = fopen(optarg, "r");
 797                         if (!ref_file) {
 798                                 perror(optarg);
 799                                 return 1;
 800                         }
 801                         break;
 802                 case 'T':
 803                         flag_dump_types = 1;
 804                         dumpfile = fopen(optarg, "w");
 805                         if (!dumpfile) {
 806                                 perror(optarg);
 807                                 return 1;
 808                         }
 809                         break;
 810                 case 'p':
 811                         flag_preserve = 1;
 812                         break;
 813                 case 'h':
 814                         genksyms_usage();
 815                         return 0;
 816                 case 'R':
 817                         flag_rel_crcs = 1;
 818                         break;
 819                 default:
 820                         genksyms_usage();
 821                         return 1;
 822                 }
 823         {
 824                 extern int yydebug;
 825                 extern int yy_flex_debug;
 826
 827                 yydebug = (flag_debug > 1);
 828                 yy_flex_debug = (flag_debug > 2);
 829
 830                 debugfile = stderr;
 831                 /* setlinebuf(debugfile); */
 832         }
 833
 834         if (flag_reference) {
 835                 read_reference(ref_file);
 836                 fclose(ref_file);
 837         }
 838
 839         yyparse();
 840
 841         if (flag_dump_types && visited_symbols) {
 842                 while (visited_symbols != (struct symbol *)-1L) {
 843                         struct symbol *sym = visited_symbols;
 844
 845                         if (sym->is_override)
 846                                 fputs("override ", dumpfile);
 847                         if (symbol_types[sym->type].n) {
 848                                 putc(symbol_types[sym->type].n, dumpfile);
 849                                 putc('#', dumpfile);
 850                         }
 851                         fputs(sym->name, dumpfile);
 852                         putc(' ', dumpfile);
 853                         if (sym->is_extern)
 854                                 fputs("extern ", dumpfile);
 855                         print_list(dumpfile, sym->defn);
 856                         putc('\n', dumpfile);
 857
 858                         visited_symbols = sym->visited;
 859                         sym->visited = NULL;
 860                 }
 861         }
 862
 863         if (flag_debug) {
 864                 fprintf(debugfile, "Hash table occupancy %d/%d = %g\n",
 865                         nsyms, HASH_BUCKETS,
 866                         (double)nsyms / (double)HASH_BUCKETS);
 867         }
 868
 869         if (dumpfile)
 870                 fclose(dumpfile);
 871
 872         return errors != 0;
 873 }