scripts/mkdep.c

   1 /*
   2  * Originally by Linus Torvalds.
   3  * Smart CONFIG_* processing by Werner Almesberger, Michael Chastain.
   4  *
   5  * Usage: mkdep file ...
   6  *
   7  * Read source files and output makefile dependency lines for them.
   8  * I make simple dependency lines for #include <*.h> and #include "*.h".
   9  * I also find instances of CONFIG_FOO and generate dependencies
  10  *    like include/config/foo.h.
  11  */
  12
  13 #include <ctype.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <unistd.h>
  18
  19 #include <sys/fcntl.h>
  20 #include <sys/mman.h>
  21 #include <sys/stat.h>
  22 #include <sys/types.h>
  23
  24
  25
  26 char __depname[512] = "\n\t@touch ";
  27 #define depname (__depname+9)
  28 int hasdep;
  29
  30 struct path_struct {
  31         int len;
  32         char buffer[256-sizeof(int)];
  33 } path_array[2] = {
  34         {  0, "" },
  35         {  0, "" }
  36 };
  37
  38
  39
  40 /*
  41  * This records all the configuration options seen.
  42  * In perl this would be a hash, but here it's a long string
  43  * of values separated by newlines.  This is simple and
  44  * extremely fast.
  45  */
  46 char * str_config  = NULL;
  47 int    size_config = 0;
  48 int    len_config  = 0;
  49
  50
  51
  52 /*
  53  * Grow the configuration string to a desired length.
  54  * Usually the first growth is plenty.
  55  */
  56 void grow_config(int len)
  57 {
  58         if (str_config == NULL) {
  59                 len_config  = 0;
  60                 size_config = 4096;
  61                 str_config  = malloc(4096);
  62                 if (str_config == NULL)
  63                         { perror("malloc"); exit(1); }
  64         }
  65
  66         while (len_config + len > size_config) {
  67                 str_config = realloc(str_config, size_config *= 2);
  68                 if (str_config == NULL)
  69                         { perror("malloc"); exit(1); }
  70         }
  71 }
  72
  73
  74
  75 /*
  76  * Lookup a value in the configuration string.
  77  */
  78 int is_defined_config(const char * name, int len)
  79 {
  80         const char * pconfig;
  81         const char * plast = str_config + len_config - len;
  82         for ( pconfig = str_config + 1; pconfig < plast; pconfig++ ) {
  83                 if (pconfig[ -1] == '\n'
  84                 &&  pconfig[len] == '\n'
  85                 &&  !memcmp(pconfig, name, len))
  86                         return 1;
  87         }
  88         return 0;
  89 }
  90
  91
  92
  93 /*
  94  * Add a new value to the configuration string.
  95  */
  96 void define_config(int convert, const char * name, int len)
  97 {
  98         grow_config(len + 1);
  99
 100         memcpy(str_config+len_config, name, len);
 101
 102         if (convert) {
 103                 int i;
 104                 for (i = 0; i < len; i++) {
 105                         char c = str_config[len_config+i];
 106                         if (isupper(c)) c = tolower(c);
 107                         if (c == '_')   c = '/';
 108                         str_config[len_config+i] = c;
 109                 }
 110         }
 111
 112         len_config += len;
 113         str_config[len_config++] = '\n';
 114 }
 115
 116
 117
 118 /*
 119  * Clear the set of configuration strings.
 120  */
 121 void clear_config(void)
 122 {
 123         len_config = 0;
 124         define_config(0, "", 0);
 125 }
 126
 127
 128
 129 /*
 130  * Handle an #include line.
 131  */
 132 void handle_include(int type, const char * name, int len)
 133 {
 134         struct path_struct *path = path_array+type;
 135
 136         if (len == 14 && !memcmp(name, "linux/config.h", len))
 137                 return;
 138
 139         if (len >= 7 && !memcmp(name, "config/", 7))
 140                 define_config(0, name+7, len-7-2);
 141
 142         memcpy(path->buffer+path->len, name, len);
 143         path->buffer[path->len+len] = '\0';
 144         if (access(path->buffer, F_OK) != 0)
 145                 return;
 146
 147         if (!hasdep) {
 148                 hasdep = 1;
 149                 printf("%s:", depname);
 150         }
 151         printf(" \\\n   %s", path->buffer);
 152 }
 153
 154
 155
 156 /*
 157  * Record the use of a CONFIG_* word.
 158  */
 159 void use_config(const char * name, int len)
 160 {
 161         char *pc;
 162         int i;
 163
 164         pc = path_array[0].buffer + path_array[0].len;
 165         memcpy(pc, "config/", 7);
 166         pc += 7;
 167
 168         for (i = 0; i < len; i++) {
 169             char c = name[i];
 170             if (isupper(c)) c = tolower(c);
 171             if (c == '_')   c = '/';
 172             pc[i] = c;
 173         }
 174         pc[len] = '\0';
 175
 176         if (is_defined_config(pc, len))
 177             return;
 178
 179         define_config(0, pc, len);
 180
 181         if (!hasdep) {
 182                 hasdep = 1;
 183                 printf("%s: ", depname);
 184         }
 185         printf(" \\\n   $(wildcard %s.h)", path_array[0].buffer);
 186 }
 187
 188
 189
 190 /*
 191  * Macros for stunningly fast map-based character access.
 192  * __buf is a register which holds the current word of the input.
 193  * Thus, there is one memory access per sizeof(unsigned long) characters.
 194  */
 195
 196 #if defined(__alpha__) || defined(__i386__) || defined(__arm__)
 197 #define LE_MACHINE
 198 #endif
 199
 200 #ifdef LE_MACHINE
 201 #define next_byte(x) (x >>= 8)
 202 #define current ((unsigned char) __buf)
 203 #else
 204 #define next_byte(x) (x <<= 8)
 205 #define current (__buf >> 8*(sizeof(unsigned long)-1))
 206 #endif
 207
 208 #define GETNEXT { \
 209         next_byte(__buf); \
 210         if ((unsigned long) next % sizeof(unsigned long) == 0) { \
 211                 if (next >= end) \
 212                         break; \
 213                 __buf = * (unsigned long *) next; \
 214         } \
 215         next++; \
 216 }
 217
 218 /*
 219  * State machine macros.
 220  */
 221 #define CASE(c,label) if (current == c) goto label
 222 #define NOTCASE(c,label) if (current != c) goto label
 223
 224 /*
 225  * Yet another state machine speedup.
 226  */
 227 #define MAX2(a,b) ((a)>(b)?(a):(b))
 228 #define MIN2(a,b) ((a)<(b)?(a):(b))
 229 #define MAX6(a,b,c,d,e,f) (MAX2(a,MAX2(b,MAX2(c,MAX2(d,MAX2(e,f))))))
 230 #define MIN6(a,b,c,d,e,f) (MIN2(a,MIN2(b,MIN2(c,MIN2(d,MIN2(e,f))))))
 231
 232
 233
 234 /*
 235  * The state machine looks for (approximately) these Perl regular expressions:
 236  *
 237  *    m|\/\*.*?\*\/|
 238  *    m|'.*?'|
 239  *    m|".*?"|
 240  *    m|#\s*include\s*"(.*?)"|
 241  *    m|#\s*include\s*<(.*?>"|
 242  *    m|#\s*(?define|undef)\s*CONFIG_(\w*)|
 243  *    m|(?!\w)CONFIG_|
 244  *    m|__SMP__|
 245  *
 246  * About 98% of the CPU time is spent here, and most of that is in
 247  * the 'start' paragraph.  Because the current characters are
 248  * in a register, the start loop usually eats 4 or 8 characters
 249  * per memory read.  The MAX6 and MIN6 tests dispose of most
 250  * input characters with 1 or 2 comparisons.
 251  */
 252 void state_machine(const char * map, const char * end)
 253 {
 254         const char * next = map;
 255         const char * map_dot;
 256         unsigned long __buf = 0;
 257
 258         for (;;) {
 259 start:
 260         GETNEXT
 261 __start:
 262         if (current > MAX6('/','\'','"','#','C','_')) goto start;
 263         if (current < MIN6('/','\'','"','#','C','_')) goto start;
 264         CASE('/',  slash);
 265         CASE('\'', squote);
 266         CASE('"',  dquote);
 267         CASE('#',  pound);
 268         CASE('C',  cee);
 269         CASE('_',  underscore);
 270         goto start;
 271
 272 /* / */
 273 slash:
 274         GETNEXT
 275         NOTCASE('*', __start);
 276 slash_star_dot_star:
 277         GETNEXT
 278 __slash_star_dot_star:
 279         NOTCASE('*', slash_star_dot_star);
 280         GETNEXT
 281         NOTCASE('/', __slash_star_dot_star);
 282         goto start;
 283
 284 /* '.*?' */
 285 squote:
 286         GETNEXT
 287         CASE('\'', start);
 288         NOTCASE('\\', squote);
 289         GETNEXT
 290         goto squote;
 291
 292 /* ".*?" */
 293 dquote:
 294         GETNEXT
 295         CASE('"', start);
 296         NOTCASE('\\', dquote);
 297         GETNEXT
 298         goto dquote;
 299
 300 /* #\s* */
 301 pound:
 302         GETNEXT
 303         CASE(' ',  pound);
 304         CASE('\t', pound);
 305         CASE('i',  pound_i);
 306         CASE('d',  pound_d);
 307         CASE('u',  pound_u);
 308         goto __start;
 309
 310 /* #\s*i */
 311 pound_i:
 312         GETNEXT NOTCASE('n', __start);
 313         GETNEXT NOTCASE('c', __start);
 314         GETNEXT NOTCASE('l', __start);
 315         GETNEXT NOTCASE('u', __start);
 316         GETNEXT NOTCASE('d', __start);
 317         GETNEXT NOTCASE('e', __start);
 318         goto pound_include;
 319
 320 /* #\s*include\s* */
 321 pound_include:
 322         GETNEXT
 323         CASE(' ',  pound_include);
 324         CASE('\t', pound_include);
 325         map_dot = next;
 326         CASE('"',  pound_include_dquote);
 327         CASE('<',  pound_include_langle);
 328         goto __start;
 329
 330 /* #\s*include\s*"(.*)" */
 331 pound_include_dquote:
 332         GETNEXT
 333         CASE('\n', start);
 334         NOTCASE('"', pound_include_dquote);
 335         handle_include(1, map_dot, next - map_dot - 1);
 336         goto start;
 337
 338 /* #\s*include\s*<(.*)> */
 339 pound_include_langle:
 340         GETNEXT
 341         CASE('\n', start);
 342         NOTCASE('>', pound_include_langle);
 343         handle_include(0, map_dot, next - map_dot - 1);
 344         goto start;
 345
 346 /* #\s*d */
 347 pound_d:
 348         GETNEXT NOTCASE('e', __start);
 349         GETNEXT NOTCASE('f', __start);
 350         GETNEXT NOTCASE('i', __start);
 351         GETNEXT NOTCASE('n', __start);
 352         GETNEXT NOTCASE('e', __start);
 353         goto pound_define_undef;
 354
 355 /* #\s*u */
 356 pound_u:
 357         GETNEXT NOTCASE('n', __start);
 358         GETNEXT NOTCASE('d', __start);
 359         GETNEXT NOTCASE('e', __start);
 360         GETNEXT NOTCASE('f', __start);
 361         goto pound_define_undef;
 362
 363 /* #\s*(define|undef)\s*CONFIG_(\w*) */
 364 pound_define_undef:
 365         GETNEXT
 366         CASE(' ',  pound_define_undef);
 367         CASE('\t', pound_define_undef);
 368
 369                 NOTCASE('C', __start);
 370         GETNEXT NOTCASE('O', __start);
 371         GETNEXT NOTCASE('N', __start);
 372         GETNEXT NOTCASE('F', __start);
 373         GETNEXT NOTCASE('I', __start);
 374         GETNEXT NOTCASE('G', __start);
 375         GETNEXT NOTCASE('_', __start);
 376
 377         map_dot = next;
 378 pound_define_undef_CONFIG_word:
 379         GETNEXT
 380         if (isalnum(current) || current == '_')
 381                 goto pound_define_undef_CONFIG_word;
 382         define_config(1, map_dot, next - map_dot - 1);
 383         goto __start;
 384
 385 /* \<CONFIG_(\w*) */
 386 cee:
 387         if (next >= map+2 && (isalnum(next[-2]) || next[-2] == '_'))
 388                 goto start;
 389         GETNEXT NOTCASE('O', __start);
 390         GETNEXT NOTCASE('N', __start);
 391         GETNEXT NOTCASE('F', __start);
 392         GETNEXT NOTCASE('I', __start);
 393         GETNEXT NOTCASE('G', __start);
 394         GETNEXT NOTCASE('_', __start);
 395
 396         map_dot = next;
 397 cee_CONFIG_word:
 398         GETNEXT
 399         if (isalnum(current) || current == '_')
 400                 goto cee_CONFIG_word;
 401         use_config(map_dot, next - map_dot - 1);
 402         goto __start;
 403
 404 /* __SMP__ */
 405 underscore:
 406         GETNEXT NOTCASE('_', __start);
 407         GETNEXT NOTCASE('S', __start);
 408         GETNEXT NOTCASE('M', __start);
 409         GETNEXT NOTCASE('P', __start);
 410         GETNEXT NOTCASE('_', __start);
 411         GETNEXT NOTCASE('_', __start);
 412         use_config("SMP", 3);
 413         goto __start;
 414
 415     }
 416 }
 417
 418
 419
 420 /*
 421  * Generate dependencies for one file.
 422  */
 423 void do_depend(const char * filename, const char * command)
 424 {
 425         int mapsize;
 426         int pagesizem1 = getpagesize()-1;
 427         int fd;
 428         struct stat st;
 429         char * map;
 430
 431         fd = open(filename, O_RDONLY);
 432         if (fd < 0) {
 433                 perror(filename);
 434                 return;
 435         }
 436
 437         fstat(fd, &st);
 438         if (st.st_size == 0) {
 439                 fprintf(stderr,"%s is empty\n",filename);
 440                 close(fd);
 441                 return;
 442         }
 443
 444         mapsize = st.st_size;
 445         mapsize = (mapsize+pagesizem1) & ~pagesizem1;
 446         map = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, fd, 0);
 447         if ((long) map == -1) {
 448                 perror("mkdep: mmap");
 449                 close(fd);
 450                 return;
 451         }
 452         if ((unsigned long) map % sizeof(unsigned long) != 0)
 453         {
 454                 fprintf(stderr, "do_depend: map not aligned\n");
 455                 exit(1);
 456         }
 457
 458         hasdep = 0;
 459         clear_config();
 460         state_machine(map, map+st.st_size);
 461         if (hasdep)
 462                 puts(command);
 463
 464         munmap(map, mapsize);
 465         close(fd);
 466 }
 467
 468
 469
 470 /*
 471  * Generate dependencies for all files.
 472  */
 473 int main(int argc, char **argv)
 474 {
 475         int len;
 476         char *hpath;
 477
 478         hpath = getenv("HPATH");
 479         if (!hpath) {
 480                 fputs("mkdep: HPATH not set in environment.  "
 481                       "Don't bypass the top level Makefile.\n", stderr);
 482                 return 1;
 483         }
 484         len = strlen(hpath);
 485         memcpy(path_array[0].buffer, hpath, len);
 486         if (len && hpath[len-1] != '/')
 487                 path_array[0].buffer[len++] = '/';
 488         path_array[0].buffer[len] = '\0';
 489         path_array[0].len = len;
 490
 491         while (--argc > 0) {
 492                 const char * filename = *++argv;
 493                 const char * command  = __depname;
 494                 len = strlen(filename);
 495                 memcpy(depname, filename, len+1);
 496                 if (len > 2 && filename[len-2] == '.') {
 497                         if (filename[len-1] == 'c' || filename[len-1] == 'S') {
 498                             depname[len-1] = 'o';
 499                             command = "";
 500                         }
 501                 }
 502                 do_depend(filename, command);
 503         }
 504         return 0;
 505 }