Merge tag 'iommu-fixes-v5.12-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6-microblaze.git] / 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;
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 }