~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/genksyms/genksyms.c

Version: ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp