projects/linux·blob master · refs

850 lines · 20.7 KiB

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