![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to toplev.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 1.x] / gcc|
Return to toplev.c CVS log | Up to [GCC 1.x] / gcc |
1.1 ! root 1: /* Top level of GNU C compiler ! 2: Copyright (C) 1987 Free Software Foundation, Inc. ! 3: ! 4: This file is part of GNU CC. ! 5: ! 6: GNU CC is distributed in the hope that it will be useful, ! 7: but WITHOUT ANY WARRANTY. No author or distributor ! 8: accepts responsibility to anyone for the consequences of using it ! 9: or for whether it serves any particular purpose or works at all, ! 10: unless he says so in writing. Refer to the GNU CC General Public ! 11: License for full details. ! 12: ! 13: Everyone is granted permission to copy, modify and redistribute ! 14: GNU CC, but only under the conditions described in the ! 15: GNU CC General Public License. A copy of this license is ! 16: supposed to have been given to you along with GNU CC so you ! 17: can know your rights and responsibilities. It should be in a ! 18: file named COPYING. Among other things, the copyright notice ! 19: and this notice must be preserved on all copies. */ ! 20: ! 21: ! 22: /* This is the top level of cc1. ! 23: It parses command args, opens files, invokes the various passes ! 24: in the proper order, and counts the time used by each. ! 25: Error messages and low-level interface to malloc also handled here. */ ! 26: ! 27: #include "config.h" ! 28: #include <stdio.h> ! 29: #include <signal.h> ! 30: #include <strings.h> ! 31: #include <sys/time.h> ! 32: #include <sys/resource.h> ! 33: #ifndef _TYPES_ ! 34: #include <sys/types.h> ! 35: #endif ! 36: #include <sys/stat.h> ! 37: #include "tree.h" ! 38: #include "c-tree.h" ! 39: #include "rtl.h" ! 40: ! 41: extern void dump_tree (); ! 42: extern int yydebug; ! 43: ! 44: extern FILE *finput; ! 45: ! 46: extern void init_lex (); ! 47: extern void init_decl_processing (); ! 48: extern void init_tree (); ! 49: extern void init_rtl (); ! 50: extern rtx expand_function (); ! 51: extern void init_optabs (); ! 52: extern void dump_flow_info (); ! 53: extern void dump_local_alloc (); ! 54: ! 55: /* Bit flags that specify the machine subtype we are compiling for. ! 56: Bits are tested using macros TARGET_... defined in the tm-...h file ! 57: and set by `-m...' switches. */ ! 58: ! 59: int target_flags; ! 60: ! 61: /* Name of current real source file (what was input to cpp). ! 62: # commands in the input that specify file names ! 63: change this value. */ ! 64: ! 65: extern char *input_filename; ! 66: ! 67: /* Current line number in real source file. */ ! 68: ! 69: extern int lineno; ! 70: ! 71: /* FUNCTION_DECL for function now being parsed or compiled. */ ! 72: ! 73: extern tree current_function_decl; ! 74: ! 75: /* Name to use as base of names for dump output files. */ ! 76: ! 77: char *dump_base_name; ! 78: ! 79: /* Flags saying which kinds of debugging dump have been requested. */ ! 80: ! 81: int tree_dump = 0; ! 82: int rtl_dump = 0; ! 83: int rtl_dump_and_exit = 0; ! 84: int jump_opt_dump = 0; ! 85: int cse_dump = 0; ! 86: int loop_dump = 0; ! 87: int flow_dump = 0; ! 88: int combine_dump = 0; ! 89: int local_reg_dump = 0; ! 90: int global_reg_dump = 0; ! 91: ! 92: /* 1 => write gdb debugging output (using symout.c). -g ! 93: 2 => write dbx debugging output (using dbxout.c). -G */ ! 94: ! 95: int write_symbols = 0; ! 96: ! 97: /* Nonzero means do optimizations. -opt. */ ! 98: ! 99: int optimize = 0; ! 100: ! 101: /* Nonzero for -optforcemem: load memory value into a register ! 102: before arithmetic on it. This makes better cse but slower compilation. */ ! 103: ! 104: int force_mem = 0; ! 105: ! 106: /* Nonzero for -optforcemem: load memory address into a register before ! 107: reference to memory. This makes better cse but slower compilation. */ ! 108: ! 109: int force_addr = 0; ! 110: ! 111: /* Nonzero means do stupid register allocation. -noreg. ! 112: This an OPTIMIZE are controlled by different switches in cc1, ! 113: but normally cc controls them both with the -O switch. */ ! 114: ! 115: int obey_regdecls = 0; ! 116: ! 117: /* Don't print functions as they are compiled and don't print ! 118: times taken by the various passes. -quiet. */ ! 119: ! 120: int quiet_flag = 0; ! 121: ! 122: /* Don't print warning messages. -w. */ ! 123: ! 124: int inhibit_warnings = 0; ! 125: ! 126: /* Number of error messages and warning messages so far. */ ! 127: ! 128: int errorcount = 0; ! 129: int warningcount = 0; ! 130: ! 131: /* Nonzero for -pedantic switch: warn about anything ! 132: that standard C forbids. */ ! 133: ! 134: int pedantic = 0; ! 135: ! 136: /* Name for output file of assembly code, specified with -o. */ ! 137: ! 138: char *asm_file_name; ! 139: ! 140: /* Name for output file of GDB symbol segment, specified with -symout. */ ! 141: ! 142: char *sym_file_name; ! 143: ! 144: /* Output files for assembler code (real compiler output) ! 145: and debugging dumps. */ ! 146: ! 147: FILE *asm_out_file; ! 148: FILE *tree_dump_file; ! 149: FILE *rtl_dump_file; ! 150: FILE *jump_opt_dump_file; ! 151: FILE *cse_dump_file; ! 152: FILE *loop_dump_file; ! 153: FILE *flow_dump_file; ! 154: FILE *combine_dump_file; ! 155: FILE *local_reg_dump_file; ! 156: FILE *global_reg_dump_file; ! 157: ! 158: /* Time accumulators, to count the total time spent in various passes. */ ! 159: ! 160: int parse_time; ! 161: int varconst_time; ! 162: int expand_time; ! 163: int jump_time; ! 164: int cse_time; ! 165: int loop_time; ! 166: int flow_time; ! 167: int combine_time; ! 168: int local_alloc_time; ! 169: int global_alloc_time; ! 170: int final_time; ! 171: int symout_time; ! 172: int dump_time; ! 173: ! 174: /* Return time used so far, in microseconds. */ ! 175: ! 176: gettime () ! 177: { ! 178: struct rusage rusage; ! 179: if (quiet_flag) ! 180: return 0; ! 181: getrusage (0, &rusage); ! 182: return (rusage.ru_utime.tv_sec * 1000000 + rusage.ru_utime.tv_usec ! 183: + rusage.ru_stime.tv_sec * 1000000 + rusage.ru_stime.tv_usec); ! 184: } ! 185: ! 186: #define TIMEVAR(VAR, BODY) \ ! 187: { int otime = gettime (); BODY; VAR += gettime () - otime; } ! 188: ! 189: print_time (str, total) ! 190: char *str; ! 191: int total; ! 192: { ! 193: printf ("time in %s: %d.%06d\n", str, total / 1000000, total % 1000000); ! 194: } ! 195: ! 196: /* Count an error or warning. Return 1 if the message should be printed. */ ! 197: ! 198: int ! 199: count_error (warningp) ! 200: int warningp; ! 201: { ! 202: if (warningp && inhibit_warnings) ! 203: return 0; ! 204: ! 205: if (warningp) ! 206: warningcount++; ! 207: else ! 208: errorcount++; ! 209: ! 210: /* If we are printing function names, make sure error message ! 211: starts at beginning of line. */ ! 212: if (!quiet_flag) ! 213: fprintf (stderr, "\n"); ! 214: ! 215: return 1; ! 216: } ! 217: ! 218: /* Print a fatal error message. NAME is the text. ! 219: Also include a system error message based on `errno'. */ ! 220: ! 221: int ! 222: pfatal_with_name (name) ! 223: { ! 224: fprintf (stderr, "cc1: "); ! 225: perror (name); ! 226: exit (35); ! 227: } ! 228: ! 229: void ! 230: fatal (s) ! 231: char *s; ! 232: { ! 233: yyerror (s, 0); ! 234: exit (34); ! 235: } ! 236: ! 237: /* Called when the start of a function definition is parsed, ! 238: this function prints on stderr the name of the function. */ ! 239: ! 240: void ! 241: announce_function (decl) ! 242: tree decl; ! 243: { ! 244: if (! quiet_flag) ! 245: { ! 246: fprintf (stderr, " %s", IDENTIFIER_POINTER (DECL_NAME (decl))); ! 247: fflush (stderr); ! 248: } ! 249: } ! 250: ! 251: static tree last_error_function; ! 252: ! 253: /* Report an error at the current line number. ! 254: S and V are a string and an arg for `printf'. */ ! 255: ! 256: void ! 257: yyerror (s, v) ! 258: char *s; ! 259: int v; /* @@also used as pointer */ ! 260: { ! 261: yylineerror (lineno, s, v); ! 262: } ! 263: ! 264: /* Report an error at line LINE. ! 265: S and V are a string and an arg for `printf'. */ ! 266: ! 267: yylineerror (line, s, v) ! 268: int line; ! 269: char *s; ! 270: int v; ! 271: { ! 272: count_error (0); ! 273: ! 274: if (last_error_function != current_function_decl) ! 275: { ! 276: fprintf (stderr, "In function %s:\n", ! 277: IDENTIFIER_POINTER (DECL_NAME (current_function_decl))); ! 278: last_error_function = current_function_decl; ! 279: } ! 280: fprintf (stderr, "%s:%d: ", input_filename, line); ! 281: fprintf (stderr, s, v); ! 282: fprintf (stderr, "\n"); ! 283: } ! 284: ! 285: /* Report a warning at the current line number. ! 286: S and V are a string and an arg for `printf'. */ ! 287: ! 288: void ! 289: warning (s, v) ! 290: char *s; ! 291: int v; /* @@also used as pointer */ ! 292: { ! 293: warning_with_line (lineno, s, v); ! 294: } ! 295: ! 296: /* Report a warning at line LINE. ! 297: S and V are a string and an arg for `printf'. */ ! 298: ! 299: warning_with_line (line, s, v) ! 300: int line; ! 301: char *s; ! 302: int v; ! 303: { ! 304: if (count_error (1) == 0) ! 305: return; ! 306: ! 307: if (last_error_function != current_function_decl) ! 308: { ! 309: fprintf (stderr, "In function %s:\n", ! 310: IDENTIFIER_POINTER (DECL_NAME (current_function_decl))); ! 311: last_error_function = current_function_decl; ! 312: } ! 313: fprintf (stderr, "%s:%d: ", input_filename, line); ! 314: ! 315: fprintf (stderr, "warning: "); ! 316: fprintf (stderr, s, v); ! 317: fprintf (stderr, "\n"); ! 318: } ! 319: ! 320: /* When `malloc.c' is compiled with `rcheck' defined, ! 321: it calls this function to report clobberage. */ ! 322: ! 323: botch (s) ! 324: { ! 325: abort (); ! 326: } ! 327: ! 328: /* Same as `malloc' but report error if no memory available. */ ! 329: ! 330: xmalloc (size) ! 331: unsigned size; ! 332: { ! 333: register int value = (int) malloc (size); ! 334: if (value == 0) ! 335: fatal ("Virtual memory exhausted."); ! 336: return value; ! 337: } ! 338: ! 339: /* Same as `realloc' but report error if no memory available. */ ! 340: ! 341: int ! 342: xrealloc (ptr, size) ! 343: char *ptr; ! 344: int size; ! 345: { ! 346: int result = realloc (ptr, size); ! 347: if (!result) ! 348: abort (); ! 349: return result; ! 350: } ! 351: ! 352: /* Return the logarithm of X, base 2, considering X unsigned, ! 353: if X is a power of 2. Otherwise, returns -1. */ ! 354: ! 355: int ! 356: exact_log2 (x) ! 357: register unsigned int x; ! 358: { ! 359: register int log = 0; ! 360: for (log = 0; log < HOST_BITS_PER_INT; log++) ! 361: if (x == (1 << log)) ! 362: return log; ! 363: return -1; ! 364: } ! 365: ! 366: /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X. ! 367: If X is 0, return -1. */ ! 368: ! 369: int ! 370: floor_log2 (x) ! 371: register unsigned int x; ! 372: { ! 373: register int log = 0; ! 374: for (log = 0; log < HOST_BITS_PER_INT; log++) ! 375: if ((x & ((-1) << log)) == 0) ! 376: return log - 1; ! 377: return HOST_BITS_PER_INT - 1; ! 378: } ! 379: ! 380: /* Compile an entire file of output from cpp, named NAME. ! 381: Write a file of assembly output and various debugging dumps. */ ! 382: ! 383: static void ! 384: compile_file (name) ! 385: char *name; ! 386: { ! 387: tree globals; ! 388: int start_time; ! 389: int dump_base_name_length = strlen (dump_base_name); ! 390: ! 391: parse_time = 0; ! 392: varconst_time = 0; ! 393: expand_time = 0; ! 394: jump_time = 0; ! 395: cse_time = 0; ! 396: loop_time = 0; ! 397: flow_time = 0; ! 398: combine_time = 0; ! 399: local_alloc_time = 0; ! 400: global_alloc_time = 0; ! 401: final_time = 0; ! 402: symout_time = 0; ! 403: dump_time; ! 404: ! 405: /* Open input file. */ ! 406: ! 407: finput = fopen (name, "r"); ! 408: if (finput == 0) ! 409: pfatal_with_name (name); ! 410: ! 411: /* Initialize data in various passes. */ ! 412: ! 413: init_tree (); ! 414: init_lex (); ! 415: init_rtl (); ! 416: init_decl_processing (); ! 417: init_optabs (); ! 418: ! 419: /* If tree dump desired, open the output file. */ ! 420: if (tree_dump) ! 421: { ! 422: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6); ! 423: strcpy (dumpname, dump_base_name); ! 424: strcat (dumpname, ".tree"); ! 425: tree_dump_file = fopen (dumpname, "w"); ! 426: if (tree_dump_file == 0) ! 427: pfatal_with_name (dumpname); ! 428: } ! 429: ! 430: /* If rtl dump desired, open the output file. */ ! 431: if (rtl_dump) ! 432: { ! 433: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6); ! 434: strcpy (dumpname, dump_base_name); ! 435: strcat (dumpname, ".rtl"); ! 436: rtl_dump_file = fopen (dumpname, "w"); ! 437: if (rtl_dump_file == 0) ! 438: pfatal_with_name (dumpname); ! 439: } ! 440: ! 441: /* If jump_opt dump desired, open the output file. */ ! 442: if (jump_opt_dump) ! 443: { ! 444: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6); ! 445: strcpy (dumpname, dump_base_name); ! 446: strcat (dumpname, ".jump"); ! 447: jump_opt_dump_file = fopen (dumpname, "w"); ! 448: if (jump_opt_dump_file == 0) ! 449: pfatal_with_name (dumpname); ! 450: } ! 451: ! 452: /* If cse dump desired, open the output file. */ ! 453: if (cse_dump) ! 454: { ! 455: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6); ! 456: strcpy (dumpname, dump_base_name); ! 457: strcat (dumpname, ".cse"); ! 458: cse_dump_file = fopen (dumpname, "w"); ! 459: if (cse_dump_file == 0) ! 460: pfatal_with_name (dumpname); ! 461: } ! 462: ! 463: /* If loop dump desired, open the output file. */ ! 464: if (loop_dump) ! 465: { ! 466: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6); ! 467: strcpy (dumpname, dump_base_name); ! 468: strcat (dumpname, ".loop"); ! 469: loop_dump_file = fopen (dumpname, "w"); ! 470: if (loop_dump_file == 0) ! 471: pfatal_with_name (dumpname); ! 472: } ! 473: ! 474: /* If flow dump desired, open the output file. */ ! 475: if (flow_dump) ! 476: { ! 477: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6); ! 478: strcpy (dumpname, dump_base_name); ! 479: strcat (dumpname, ".flow"); ! 480: flow_dump_file = fopen (dumpname, "w"); ! 481: if (flow_dump_file == 0) ! 482: pfatal_with_name (dumpname); ! 483: } ! 484: ! 485: /* If combine dump desired, open the output file. */ ! 486: if (combine_dump) ! 487: { ! 488: register char *dumpname = (char *) xmalloc (dump_base_name_length + 10); ! 489: strcpy (dumpname, dump_base_name); ! 490: strcat (dumpname, ".combine"); ! 491: combine_dump_file = fopen (dumpname, "w"); ! 492: if (combine_dump_file == 0) ! 493: pfatal_with_name (dumpname); ! 494: } ! 495: ! 496: /* If local_reg dump desired, open the output file. */ ! 497: if (local_reg_dump) ! 498: { ! 499: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6); ! 500: strcpy (dumpname, dump_base_name); ! 501: strcat (dumpname, ".lreg"); ! 502: local_reg_dump_file = fopen (dumpname, "w"); ! 503: if (local_reg_dump_file == 0) ! 504: pfatal_with_name (dumpname); ! 505: } ! 506: ! 507: /* If global_reg dump desired, open the output file. */ ! 508: if (global_reg_dump) ! 509: { ! 510: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6); ! 511: strcpy (dumpname, dump_base_name); ! 512: strcat (dumpname, ".greg"); ! 513: global_reg_dump_file = fopen (dumpname, "w"); ! 514: if (global_reg_dump_file == 0) ! 515: pfatal_with_name (dumpname); ! 516: } ! 517: ! 518: /* Open assembler code output file. */ ! 519: ! 520: { ! 521: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6); ! 522: strcpy (dumpname, dump_base_name); ! 523: strcat (dumpname, ".s"); ! 524: asm_out_file = fopen (asm_file_name ? asm_file_name : dumpname, "w"); ! 525: if (asm_out_file == 0) ! 526: pfatal_with_name (asm_file_name ? asm_file_name : dumpname); ! 527: } ! 528: ! 529: input_filename = name; ! 530: ! 531: /* the beginning of the file is a new line; check for # */ ! 532: /* With luck, we discover the real source file's name from that ! 533: and put it in input_filename. */ ! 534: check_newline (); ! 535: ! 536: /* If GDB symbol table desired, open the GDB symbol output file. */ ! 537: if (write_symbols == 1) ! 538: { ! 539: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6); ! 540: strcpy (dumpname, dump_base_name); ! 541: strcat (dumpname, ".sym"); ! 542: if (sym_file_name == 0) ! 543: sym_file_name = dumpname; ! 544: symout_init (sym_file_name, asm_out_file, input_filename); ! 545: } ! 546: ! 547: /* If dbx symbol table desired, initialize writing it ! 548: and output the predefined types. */ ! 549: if (write_symbols == 2) ! 550: dbxout_init (asm_out_file, input_filename); ! 551: ! 552: /* Initialize yet another pass. */ ! 553: ! 554: init_final (input_filename); ! 555: ! 556: start_time = gettime (); ! 557: ! 558: /* Call the parser, which parses the entire file ! 559: (calling rest_of_compilation for each function). */ ! 560: ! 561: yyparse (); ! 562: ! 563: /* Compilation is now finished except for writing ! 564: what's left of the symbol table output. */ ! 565: ! 566: parse_time += gettime () - start_time; ! 567: ! 568: globals = getdecls (); ! 569: ! 570: /* Do dbx symbols */ ! 571: if (write_symbols == 2) ! 572: TIMEVAR (symout_time, ! 573: { ! 574: dbxout_tags (gettags ()); ! 575: dbxout_types (get_permanent_types ()); ! 576: }); ! 577: ! 578: /* Do gdb symbols */ ! 579: if (write_symbols == 1) ! 580: TIMEVAR (symout_time, ! 581: { ! 582: struct stat statbuf; ! 583: fstat (fileno (finput), &statbuf); ! 584: symout_types (get_permanent_types ()); ! 585: symout_top_blocks (globals, gettags ()); ! 586: symout_finish (name, statbuf.st_ctime); ! 587: }); ! 588: ! 589: /* Close non-debugging input and output files. */ ! 590: ! 591: fclose (finput); ! 592: fclose (asm_out_file); ! 593: ! 594: if (!quiet_flag) ! 595: fprintf (stderr,"\n"); ! 596: ! 597: /* Dump the global nodes and close the tree dump file. */ ! 598: if (tree_dump) ! 599: { ! 600: dump_tree (tree_dump_file, globals); ! 601: fclose (tree_dump_file); ! 602: } ! 603: ! 604: /* Close all other dump files. */ ! 605: ! 606: if (rtl_dump) ! 607: fclose (rtl_dump_file); ! 608: ! 609: if (jump_opt_dump) ! 610: fclose (jump_opt_dump_file); ! 611: ! 612: if (cse_dump) ! 613: fclose (cse_dump_file); ! 614: ! 615: if (loop_dump) ! 616: fclose (loop_dump_file); ! 617: ! 618: if (flow_dump) ! 619: fclose (flow_dump_file); ! 620: ! 621: if (combine_dump) ! 622: { ! 623: dump_combine_total_stats (combine_dump_file); ! 624: fclose (combine_dump_file); ! 625: } ! 626: ! 627: if (local_reg_dump) ! 628: fclose (local_reg_dump_file); ! 629: ! 630: if (global_reg_dump) ! 631: fclose (global_reg_dump_file); ! 632: ! 633: /* Print the times. */ ! 634: ! 635: if (! quiet_flag) ! 636: { ! 637: print_time ("parse", parse_time); ! 638: print_time ("expand", expand_time); ! 639: print_time ("jump", jump_time); ! 640: print_time ("cse", cse_time); ! 641: print_time ("loop", loop_time); ! 642: print_time ("flow", flow_time); ! 643: print_time ("combine", combine_time); ! 644: print_time ("local-alloc", local_alloc_time); ! 645: print_time ("global-alloc", global_alloc_time); ! 646: print_time ("final", final_time); ! 647: print_time ("varconst", varconst_time); ! 648: print_time ("symout", symout_time); ! 649: print_time ("dump", dump_time); ! 650: } ! 651: } ! 652: ! 653: /* This is called from finish_function (within yyparse) ! 654: after each top-level definition is parsed, and from ! 655: finish_decl (also within yyparse) for each other top-level declaration. ! 656: It is supposed to compile that function or variable ! 657: and output the assembler code for it. ! 658: After we return, the tree storage is freed. */ ! 659: ! 660: void ! 661: rest_of_compilation (decl, top_level) ! 662: tree decl; ! 663: int top_level; ! 664: { ! 665: register rtx insns; ! 666: int start_time = gettime (); ! 667: int tem; ! 668: ! 669: /* Declarations of variables, and of functions defined elsewhere. */ ! 670: ! 671: if ((TREE_CODE (decl) == VAR_DECL ! 672: || (TREE_CODE (decl) == FUNCTION_DECL ! 673: && DECL_INITIAL (decl) == 0)) ! 674: && (TREE_STATIC (decl) || TREE_EXTERNAL (decl))) ! 675: { ! 676: TIMEVAR (varconst_time, ! 677: { ! 678: assemble_variable (decl, top_level); ! 679: if (write_symbols == 2) ! 680: dbxout_symbol (decl, 0); ! 681: }); ! 682: } ! 683: ! 684: /* Function definitions are the real work ! 685: (all the rest of this function). */ ! 686: ! 687: else if (TREE_CODE (decl) == FUNCTION_DECL ! 688: && DECL_INITIAL (decl)) ! 689: { ! 690: /* Dump the function's tree if we are dumping trees. */ ! 691: ! 692: if (tree_dump) ! 693: TIMEVAR (dump_time, ! 694: dump_tree (tree_dump_file, decl)); ! 695: ! 696: /* Output some preliminaries for assembler. */ ! 697: ! 698: TIMEVAR (varconst_time, assemble_function (decl)); ! 699: ! 700: /* Generate rtl code for this function (see stmt.c, expr.c). */ ! 701: ! 702: TIMEVAR (expand_time, ! 703: { ! 704: init_emit (write_symbols); ! 705: insns = expand_function (decl, !optimize); ! 706: }); ! 707: ! 708: /* Dump the rtl code if we are dumping rtl. */ ! 709: ! 710: if (rtl_dump) ! 711: TIMEVAR (dump_time, ! 712: { ! 713: fprintf (rtl_dump_file, "\n;; Function %s\n\n", ! 714: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 715: print_rtl (rtl_dump_file, insns); ! 716: fflush (rtl_dump_file); ! 717: }); ! 718: ! 719: if (rtl_dump_and_exit) ! 720: goto exit_rest_of_compilation; ! 721: ! 722: /* Do jump optimization the first time, if -opt. */ ! 723: ! 724: if (optimize) ! 725: TIMEVAR (jump_time, jump_optimize (insns, 0)); ! 726: ! 727: /* Dump rtl code after jump, if we are doing that. */ ! 728: ! 729: if (jump_opt_dump) ! 730: TIMEVAR (dump_time, ! 731: { ! 732: fprintf (jump_opt_dump_file, "\n;; Function %s\n\n", ! 733: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 734: print_rtl (jump_opt_dump_file, insns); ! 735: fflush (jump_opt_dump_file); ! 736: }); ! 737: ! 738: /* Perform common subexpression elimination. ! 739: Nonzero value from `cse_main' means that jumps were simplified ! 740: and some code may now be unreachable, so do ! 741: jump optimization again. */ ! 742: ! 743: if (optimize) ! 744: { ! 745: TIMEVAR (cse_time, reg_scan (insns, max_reg_num ())); ! 746: ! 747: TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num ())); ! 748: ! 749: if (tem) ! 750: TIMEVAR (jump_time, jump_optimize (insns, 0)); ! 751: } ! 752: ! 753: /* Dump rtl code after cse, if we are doing that. */ ! 754: ! 755: if (cse_dump) ! 756: TIMEVAR (dump_time, ! 757: { ! 758: fprintf (cse_dump_file, "\n;; Function %s\n\n", ! 759: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 760: print_rtl (cse_dump_file, insns); ! 761: fflush (cse_dump_file); ! 762: }); ! 763: ! 764: /* Move constant computations out of loops. */ ! 765: ! 766: if (optimize) ! 767: { ! 768: TIMEVAR (loop_time, loop_optimize (insns, max_reg_num ())); ! 769: } ! 770: ! 771: /* Dump rtl code after loop opt, if we are doing that. */ ! 772: ! 773: if (loop_dump) ! 774: TIMEVAR (dump_time, ! 775: { ! 776: fprintf (loop_dump_file, "\n;; Function %s\n\n", ! 777: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 778: print_rtl (loop_dump_file, insns); ! 779: fflush (loop_dump_file); ! 780: }); ! 781: ! 782: /* Now we choose between stupid (pcc-like) register allocation ! 783: (if we got the -noreg switch and not -opt) ! 784: and smart register allocation. */ ! 785: ! 786: if (optimize) /* Stupid allocation probably won't work */ ! 787: obey_regdecls = 0; /* if optimizations being done. */ ! 788: ! 789: /* Print function header into flow dump now ! 790: because doing the flow analysis makes some of the dump. */ ! 791: ! 792: if (flow_dump) ! 793: TIMEVAR (dump_time, ! 794: { ! 795: fprintf (flow_dump_file, "\n;; Function %s\n\n", ! 796: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 797: }); ! 798: ! 799: if (obey_regdecls) ! 800: { ! 801: TIMEVAR (flow_time, ! 802: { ! 803: regclass (insns, max_reg_num ()); ! 804: stupid_life_analysis (insns, max_reg_num (), ! 805: flow_dump_file); ! 806: }); ! 807: } ! 808: else ! 809: { ! 810: /* Do control and data flow analysis, ! 811: and write some of the results to dump file. */ ! 812: ! 813: TIMEVAR (flow_time, flow_analysis (insns, max_reg_num (), ! 814: flow_dump_file)); ! 815: } ! 816: ! 817: /* Dump rtl after flow analysis. */ ! 818: ! 819: if (flow_dump) ! 820: TIMEVAR (dump_time, ! 821: { ! 822: print_rtl (flow_dump_file, insns); ! 823: fflush (flow_dump_file); ! 824: }); ! 825: ! 826: /* If -opt, try combining insns through substitution. */ ! 827: ! 828: if (optimize) ! 829: TIMEVAR (combine_time, combine_instructions (insns, max_reg_num ())); ! 830: ! 831: /* Dump rtl code after insn combination. */ ! 832: ! 833: if (combine_dump) ! 834: TIMEVAR (dump_time, ! 835: { ! 836: fprintf (combine_dump_file, "\n;; Function %s\n\n", ! 837: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 838: dump_combine_stats (combine_dump_file); ! 839: print_rtl (combine_dump_file, insns); ! 840: fflush (combine_dump_file); ! 841: }); ! 842: ! 843: /* Unless we did stupid register allocation, ! 844: allocate pseudo-regs that are used only within 1 basic block. */ ! 845: ! 846: if (!obey_regdecls) ! 847: TIMEVAR (local_alloc_time, ! 848: { ! 849: regclass (insns, max_reg_num ()); ! 850: local_alloc (); ! 851: }); ! 852: ! 853: /* Dump rtl code after allocating regs within basic blocks. */ ! 854: ! 855: if (local_reg_dump) ! 856: TIMEVAR (dump_time, ! 857: { ! 858: fprintf (local_reg_dump_file, "\n;; Function %s\n\n", ! 859: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 860: dump_flow_info (local_reg_dump_file); ! 861: dump_local_alloc (local_reg_dump_file); ! 862: print_rtl (local_reg_dump_file, insns); ! 863: fflush (local_reg_dump_file); ! 864: }); ! 865: ! 866: if (global_reg_dump) ! 867: TIMEVAR (dump_time, ! 868: fprintf (global_reg_dump_file, "\n;; Function %s\n\n", ! 869: IDENTIFIER_POINTER (DECL_NAME (decl)))); ! 870: ! 871: /* Unless we did stupid register allocation, ! 872: allocate remaining pseudo-regs, then do the reload pass ! 873: fixing up any insns that are invalid. */ ! 874: ! 875: TIMEVAR (global_alloc_time, ! 876: { ! 877: if (!obey_regdecls) ! 878: global_alloc (global_reg_dump ? global_reg_dump_file : 0); ! 879: else ! 880: reload (insns, 0, ! 881: global_reg_dump ? global_reg_dump_file : 0); ! 882: }); ! 883: ! 884: if (global_reg_dump) ! 885: TIMEVAR (dump_time, ! 886: { ! 887: dump_global_regs (global_reg_dump_file); ! 888: print_rtl (global_reg_dump_file, insns); ! 889: fflush (global_reg_dump_file); ! 890: }); ! 891: ! 892: /* One more attempt to remove jumps to .+1 ! 893: left by dead-store-elimination. ! 894: Also do cross-jumping this time. */ ! 895: ! 896: if (optimize) ! 897: TIMEVAR (jump_time, jump_optimize (insns, 1)); ! 898: ! 899: /* Now turn the rtl into assembler code. */ ! 900: ! 901: TIMEVAR (final_time, ! 902: { ! 903: final (insns, asm_out_file, ! 904: IDENTIFIER_POINTER (DECL_NAME (decl)), ! 905: write_symbols, optimize); ! 906: fflush (asm_out_file); ! 907: }); ! 908: ! 909: /* Write GDB symbols if requested */ ! 910: ! 911: if (write_symbols == 1) ! 912: TIMEVAR (symout_time, ! 913: { ! 914: symout_types (get_permanent_types ()); ! 915: symout_types (get_temporary_types ()); ! 916: ! 917: DECL_BLOCK_SYMTAB_ADDRESS (decl) ! 918: = symout_function (DECL_INITIAL (decl), ! 919: DECL_ARGUMENTS (decl), 0); ! 920: }); ! 921: ! 922: /* Write DBX symbols if requested */ ! 923: ! 924: if (write_symbols == 2) ! 925: TIMEVAR (symout_time, dbxout_function (decl)); ! 926: } ! 927: ! 928: exit_rest_of_compilation: ! 929: ! 930: /* The parsing time is all the time spent in yyparse ! 931: *except* what is spent in this function. */ ! 932: ! 933: parse_time -= gettime () - start_time; ! 934: } ! 935: ! 936: /* Entry point of cc1. Decode command args, then call compile_file. ! 937: Exit code is 34 if fatal error, else 33 if have error messages, ! 938: else 1 if have warnings, else 0. */ ! 939: ! 940: int ! 941: main (argc, argv, envp) ! 942: int argc; ! 943: char **argv; ! 944: char **envp; ! 945: { ! 946: register int i; ! 947: char *filename; ! 948: ! 949: target_flags = 0; ! 950: set_target_switch (""); ! 951: ! 952: for (i = 1; i < argc; i++) ! 953: if (argv[i][0] == '-') ! 954: { ! 955: register char *str = argv[i] + 1; ! 956: if (str[0] == 'Y') ! 957: str++; ! 958: ! 959: if (str[0] == 'm') ! 960: set_target_switch (&str[1]); ! 961: else if (!strcmp (str, "dumpbase")) ! 962: { ! 963: dump_base_name = argv[++i]; ! 964: } ! 965: else if (str[0] == 'd') ! 966: { ! 967: register char *p = &str[1]; ! 968: while (*p) ! 969: switch (*p++) ! 970: { ! 971: case 'c': ! 972: combine_dump = 1; ! 973: break; ! 974: case 'f': ! 975: flow_dump = 1; ! 976: break; ! 977: case 'g': ! 978: global_reg_dump = 1; ! 979: break; ! 980: case 'j': ! 981: jump_opt_dump = 1; ! 982: break; ! 983: case 'l': ! 984: local_reg_dump = 1; ! 985: break; ! 986: case 'L': ! 987: loop_dump = 1; ! 988: break; ! 989: case 'r': ! 990: rtl_dump = 1; ! 991: break; ! 992: case 's': ! 993: cse_dump = 1; ! 994: break; ! 995: case 't': ! 996: tree_dump = 1; ! 997: break; ! 998: case 'y': ! 999: yydebug = 1; ! 1000: break; ! 1001: } ! 1002: } ! 1003: else if (!strcmp (str, "quiet")) ! 1004: quiet_flag = 1; ! 1005: else if (!strcmp (str, "opt")) ! 1006: optimize = 1; ! 1007: else if (!strcmp (str, "optforcemem")) ! 1008: force_mem = 1; ! 1009: else if (!strcmp (str, "optforceaddr")) ! 1010: force_addr = 1; ! 1011: else if (!strcmp (str, "noreg")) ! 1012: obey_regdecls = 1; ! 1013: else if (!strcmp (str, "w")) ! 1014: inhibit_warnings = 1; ! 1015: else if (!strcmp (str, "g")) ! 1016: write_symbols = 1; ! 1017: else if (!strcmp (str, "G")) ! 1018: write_symbols = 2; ! 1019: else if (!strcmp (str, "symout")) ! 1020: { ! 1021: if (write_symbols == 0) ! 1022: write_symbols = 1; ! 1023: sym_file_name = argv[++i]; ! 1024: } ! 1025: else if (!strcmp (str, "o")) ! 1026: { ! 1027: asm_file_name = argv[++i]; ! 1028: } ! 1029: else ! 1030: yylineerror (0, "Invalid switch, %s.", argv[i]); ! 1031: } ! 1032: else ! 1033: filename = argv[i]; ! 1034: ! 1035: if (filename == 0) ! 1036: fatal ("no input file specified"); ! 1037: ! 1038: if (dump_base_name == 0) ! 1039: dump_base_name = filename; ! 1040: compile_file (filename); ! 1041: ! 1042: if (errorcount) ! 1043: return 33; ! 1044: else ! 1045: return (warningcount > 0); ! 1046: } ! 1047: ! 1048: /* Decode -m switches. */ ! 1049: ! 1050: /* Here is a table, controlled by the tm-...h file, listing each -m switch ! 1051: and which bits in `target_switches' it should set or clear. ! 1052: If VALUE is positive, it is bits to set. ! 1053: If VALUE is negative, -VALUE is bits to clear. ! 1054: (The sign bit is not used so there is no confusion.) */ ! 1055: ! 1056: struct {char *name; int value;} target_switches [] ! 1057: = TARGET_SWITCHES; ! 1058: ! 1059: /* Decode the switch -mNAME. */ ! 1060: ! 1061: set_target_switch (name) ! 1062: char *name; ! 1063: { ! 1064: register int j = 0; ! 1065: for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++) ! 1066: if (!strcmp (target_switches[j].name, name)) ! 1067: { ! 1068: if (target_switches[j].value < 0) ! 1069: target_flags &= ~-target_switches[j].value; ! 1070: else ! 1071: target_flags |= target_switches[j].value; ! 1072: break; ! 1073: } ! 1074: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.