Studying note of GCC-3.4.6 source (21)

3.3. Handling switches

3.3.1. Options related to optimization

Back to decode_options, at line 480, for C++, initialize_diagnostics in lang_hooks points to cxx_initialize_diagnostics. It setups diagnostics facility which will give out adequate and correct error message. We skip it as it is not close relate to compilation.

 

decode_options (continue)

 

489    /* Scan to see what optimization level has been specified. That will

490      determine the default value of many flags. */

491    for (i = 1; i < argc; i++)

492    {

493      if (!strcmp (argv[i], "-O"))

494      {

495        optimize = 1;

496        optimize_size = 0;

497      }

498      else if (argv[i][0] == '-' && argv[i][1] == 'O')

499      {

500        /* Handle -Os, -O2, -O3, -O69, ... */

501        const char *p = &argv[i][2];

502 

503        if ((p[0] == 's') && (p[1] == 0))

504        {

505          optimize_size = 1;

506 

507          /* Optimizing for size forces optimize to be 2. */

508          optimize = 2;

509        }

510        else

511        {

512          const int optimize_val = read_integral_parameter (p, p - 2, -1);

513          if (optimize_val != -1)

514          {

515            optimize = optimize_val;

516            optimize_size = 0;

517          }

518        }

519      }

520    }

 

In GCC, following switches indicate level of optimization^[8]

-O: The compiler attempts to reduce both code size and execution time, but not to make modifications that would cause difficulties with debugging. Turns on the options -fno_optimize_size, -fdefer_pop, -fthread_jumps, -jguess_branch_prob, -cprop-registers, and -fdelayed_branch. The -fomit_frame_pointer flag is set only if the debugger is able to work without it on this platform.

-O0: The default. Disables all optimizations. Turns off all size optimization and sets -fno-merge-constants.

-O1: The same as -O.

-O2: This level turns on all optimizations that do not involve size and speed trade-offs. In addition to the options turned on for -O, this level turns on -foptimize-sibling-calls, -fcse-follow-jumps, -fcse-skip-blocks, -fgcse, -fexpensive-optimizations, -fstrength-reduce, -frerun-loop-opt, -fschedule-insns, -fdelete-null-pointer-checks, -fschedule-insn-after-reload, -frerun-cse-after-loop, -fpeephole2, -fforce-mem, -fcaller-saves, -fstruct-aliasing, -fregmove, and -freorder-blocks. This level does no loop unrolling, inlining, nor register renaming.

-O3: In addition to the options turned on for -O2, this level turns on -finline-functions and -frename-registers.

-Os: Optimizes for size. All of the -O2 options flags are set. The -falign-loops, -falign-jumps, -falign-labels, and -falign-functions are all set to 1, which prevents any space being inserted for alignment.

 

decode_options (continue)

 

522    if (!optimize)

523    {

524      flag_merge_constants = 0;

525    }

526 

527    if (optimize >= 1)

528    {

529      flag_defer_pop = 1;

530      flag_thread_jumps = 1;

531  #ifdef DELAY_SLOTS

532      flag_delayed_branch = 1;

533  #endif

534  #ifdef CAN_DEBUG_WITHOUT_FP

535      flag_omit_frame_pointer = 1;

536  #endif

537      flag_guess_branch_prob = 1;

538      flag_cprop_registers = 1;

539      flag_loop_optimize = 1;

540      flag_if_conversion = 1;

541      flag_if_conversion2 = 1;

542    }

543 

544    if (optimize >= 2)

545    {

546      flag_crossjumping = 1;

547      flag_optimize_sibling_calls = 1;

548      flag_cse_follow_jumps = 1;

549      flag_cse_skip_blocks = 1;

550      flag_gcse = 1;

551      flag_expensive_optimizations = 1;

552      flag_strength_reduce = 1;

553      flag_rerun_cse_after_loop = 1;

554      flag_rerun_loop_opt = 1;

555      flag_caller_saves = 1;

556      flag_force_mem = 1;

557      flag_peephole2 = 1;

558  #ifdef INSN_SCHEDULING

559      flag_schedule_insns = 1;

560      flag_schedule_insns_after_reload = 1;

561  #endif

562      flag_regmove = 1;

563      flag_strict_aliasing = 1;

564      flag_delete_null_pointer_checks = 1;

565      flag_reorder_blocks = 1;

566      flag_reorder_functions = 1;

567      flag_unit_at_a_time = 1;

568    }

569 

570    if (optimize >= 3)

571    {

572      flag_inline_functions = 1;

573      flag_rename_registers = 1;

574      flag_unswitch_loops = 1;

575      flag_web = 1;

576    }

577 

578    if (optimize < 2 || optimize_size)

579    {

580      align_loops = 1;

581      align_jumps = 1;

582      align_labels = 1;

583      align_functions = 1;

584 

585      /* Don't reorder blocks when optimizing for size because extra

586        jump insns may be created; also barrier may create extra padding.

587 

588        More correctly we should have a block reordering mode that tried

589        to minimize the combined size of all the jumps. This would more

590        or less automatically remove extra jumps, but would also try to

591        use more short jumps instead of long jumps. */

592      flag_reorder_blocks = 0;

593    }

 

Above at line 531, macro DELAY_SLOTS is output by tool genattr according to the presence of define_delay pattern in machine description file. And INSN_SCHEDULING at line 558 is defined by genattr too.

Besides, there are long list of variables that we need first understand their usage.

flag_merge_constants (-fmerge-constants, -fmerge-all-constants), it will attempt to merge identical constant across constant sections, if 1 only string constants and constants from constant pool, if 2 also constant variables.

flag_defer_pop (–fdef-pop), if nonzero, the arguments that were pushed onto the stack to make a function call are not popped off immediately after the return of the function, but are allowed to accumulate along with the arguments of several function calls, and the stack is later cleared of them all.

flag_thread_jumps (-fthread-jumps), if nonzero, if the value of the conditional expression of a jump goes to a location where the values are such that another jump will also be taken, the original jump is redirected to the final destination.

flag_omit_frame_pointer (-fomit-frame-pointer), if nonzero, doesn’t store the frame pointer in a register for functions that don’t need one, thus omitting the code to store and retrieve the address as well as making another register available for general use. This flag is automatically set for all levels of -O optimization, but only if the debugger can be run without a frame pointer. If the debugger cannot be run with this setting you will have to set it explicitly. Some platforms have no frame pointer and this flag will have no effect.

flag_guess_branch_prob, if nonzero, will try to guess branch probabilities.

flag_cprop_registers, after register allocation and post-register allocation instruction splitting, we perform a copy-propagation pass to try to reduce scheduling dependencies and occasionally eliminate the copy.

flag_rename_registers, if nonzero, registers should be renamed.

flag_loop_optimize, if nonzero, means perform loop optimizer.

flag_if_conversion, if nonzero, means perform if conversion.

flag_if_conversion2, if nonzero, means perform if conversion after reload.

flag_crossjumping, if nonzero, means perform crossjumping.

flag_optimize_sibling_calls, if nonzero, allows GCC to optimize sibling and tail recursive calls.

flag_cse_follow_jumps (-fcse-follow-jumps), if nonzero, when the target of a jump cannot be reached any other way except by the jump being taken, the common subexpression elimination scan follows the path of the jump. That is, any values that exist before the jump is taken will always exist at the point of the destination of the jump and can be used there. This flag is set by -O2, -O3, and -Os, but can be overridden by -fno-cse-follow-jumps.

flag_cse_skip_blocks (-fcse-skip-blocks), if nonzero, if the body of an if statement is simple enough that it does not contain code that would disrupt the previously calculated values, the common subexpression analysis flow skips over the if statement and is applied to the statements that follow it. This flag is set by -O2, -O3, and -Os, but can be overridden by -fno-cse-skip-blocks.

flag_gcse, if nonzero, means perform global common subexpression elimination (CSE).

flag_expensive_optimizations (-fexpensive-optimizations), if nonzero, enables a few optimizations that are effective but cost in terms of compile time. For example, common subexpression elimination is run again following global common subexpression elimination. Some of the other optimizations are carried out in more depth when this flag is set. This flag is set by -O2, -O3, and -Os, but can be overridden by -fno-expensive-optimizations.

flag_strength_reduce (-fstrength-reduce), if nonzero, performs loop strength reduction and elimination variables being used inside loops. This is the process of replacing time-consuming operations, such as multiply and divide, with simpler and faster operations, such as add and subtract. This option is always set by -funroll_loops and -funroll-all-loops. It is also set by -O2, -O3, and –Os but can be overridden by -fno-strength-reduce. As a simple example, the following loop uses a temporary variable to contain a calculated index:

for(int i=0; i<10; i++) {

index = i * 2;

frammis(valarr[index]);

}

The internal variable index can be eliminated, and the multiplication can be changed to a simple shift resulting in the following:

for(int i=0; i<10; i++) {

frammis(valarr[i << 1]);

}

Shifting the loop counter one position to the left effectively doubles it, and the value is then used directly as the index on the array without being stored in a temporary variable.

flag_rerun_cse_after_loop (-frerun-cse-after-loop), if nonzero, will cause the common subexpression optimization to be applied again following loop optimizations. This is done because it is possible that loop optimization creates the presence of new subexpressions. This flag is set by -O2, -O3, and -Os, but can be overridden by -fno-rerun-cse-after-loop. This increases compilation time about 20% and picks up a few more common expressions.

flag_rerun_loop_opt (-frerun-loop-opt), if nonzero, runs the loop optimization twice. The second time does not unroll loops, but it does analyze the loops again with the instructions from the first optimization pass removed. This flag is set by -O2, -O3, and -Os, but can be overridden by -fno-rerun-loop-opt.

flag_caller_saves (-fcaller-saves), if nonzero, extra instructions are included to save registers before a function call and then restore them afterward. The registers can then be used in the function call and inside the function itself. Only registers that contain useful values are saved, and then only if it seems better to save and restore than it does to reload the value later, when it is needed again. This option is enabled by default on some machines and is always enabled by -O2, -O3, and -Os, but can be overridden by -fno-caller-saves.

flag_force_mem (-fforce-mem), if nonzero, values must be copied into registers to have arithmetic performed on them. This improves the generated code because values needed will often have been previously loaded into a register and do not need to be loaded again. This flag is set by -O2, -O3, and –Os.

flag_peephole2 (-fpeephole2), if nonzero, enables RTL peephole optimization after registers have been allocated but before scheduling. The optimization is a machine specific translation of one specific set of instructions into another. This option is platform dependent and may have no effect. There is no effect unless optimization is also specified. This flag is set by -O2, -O3, and -Os, but can be overridden by -fno-peephole2.

flag_schedule_insns (-fscedule-insns), if nonzero, on machines that have relatively slow floating point or memory access operations when compared to other operations, and on machines that support the execution of more than one instruction at a time, an attempt is made to change the order of the instructions to eliminate stalling. Other instructions are executed during the time the slower instruction is being executed. This flag is set by -O2, -O3, and -Os, but can be overridden by -fno-scedule-insns.

flag_schedule_insns_after_reload (-fscedule-insns2), if nonzero, this is the same as -fschedule_insns except that it is performed after allocation of both the global registers and the local registers for each function. This can be effective on machines with a small number of registers and relatively slow instructions to load registers. This flag is set by -O2, -O3, and -Os, but can be overridden by -fno-scedule-insns2.

flag_regmove (-foptimize-register-move, -fregmove), if nonzero, register allocation is optimized by changing the assignment of registers used in operations that move data from one memory location to another. This is especially effective on machines that have instructions that can move data directly from one memory location to another. This flag is set by -O2, -O3, and -Os, but can be overridden by -fno-optimize-register-move.

flag_strict_aliasing (-fstrict-aliasing), if nonzero, the strictest aliasing rules are applied depending on the language being compiled.With strict aliasing in C, for example, an int cannot be the alias of a double or a pointer, but it can be the alias of an unsigned int. Even with strict aliasing there is not a problem with union members as long as the references are through the union and not through a pointer to the address of a union member. The following code could cause a problem:

int *iptr;

union {

int ivalue;

double dvalue;

} migs;

. . .

migs.ivalue = 45;

iptr = &migs.ivalue;

frammis(*iptr);

migs.dvalue = 88.6;

frammis(*iptr);

In this example is possible that strict aliasing would not recognize that the value pointed to by iptr had changed between the two function calls. However, referring to the union members directly would not cause a problem.

flag_delete_null_pointer_checks (-fdelete-null-pointer-checks), if nonzero, the code that checks for an attempt to dereference a null pointer is removed if dataflow analysis indicates that the pointer cannot be null. In some environments it is possible to process the result of an attempt to dereference a null pointer, so this option should not be used in programs that rely on these checks. This flag is set by -O2, -O3, and -Os, but can be overridden by -fno-delete-null-pointer-checks.

flag_reorder_blocks, if nonzero, basic blocks should be reordered.

flag_reorder_functions, if nonzero, functions should be reordered.

flag_unit_at_a_time, if nonzero, we perform whole unit at a time compilation.

flag_inline_functions (-finline-functions), if nonzero, the compiler is allowed to select certain simple functions to be expanded in line at the point of the function call. If the function is declared in such a way that all calls to it are known (for example, a static function in a C source file cannot be addressed from outside the file) the body of the function is omitted because it is never actually called. This option is automatically turned on by -O3 unless the -fno-inline-functions flag is specified.

flag_unswitch_loops, if nonzero, enables loop unswitching.

flag_web, if nonzero, means performs web construction pass.

align_loops (-falign-loop[=number]), aligns the top of loops to a boundary that is a power of 2 equal to or greater than number, but only if it is not necessary to skip more than number bytes to do it. For example, if number is 20, the resulting alignment is on a 32-byte boundary as long as no more than 20 bytes must be skipped to place it there. This option could make code larger because of the insertion of dummy instructions to bring about alignment, but, depending on the machine, the loop could execute faster because of branching to an aligned location from the bottom of each iteration. If number is not specified, the machine default is used, which is normally 1. Specifying number as 1 is equivalent to -fno-align-loops, and no alignment takes place.

align_jumps (–falign-jumps[=number]), aligns branch targets that cannot be reached any other way to a boundary that is a power of 2 equal to or greater than number, but only if it is not necessary to skip no more than number bytes to do it. For example, if number is 20 the resulting alignment is on a 32-byte boundary as long as no more than 20 bytes must be skipped to place it there. Unlike the similar option -falign-labels, this option does not require the insertion of dummy instructions before the branch target. If number is not specified the machine default is used, which is normally 1. Specifying the number as 1 is equivalent to -fno-align-jumps and no alignment takes place.

align_labels (–align-labels[=number]), aligns the targets of all branches to a boundary that is a power of 2 equal to or greater than number, but only if it is not necessary to skip no more than number bytes to do it. For example, if number is 20, the resulting alignment is on a 32-byte boundary as long as no more than 20 bytes must be skipped to place it there. This option can make code slower and larger because of the insertion of dummy instructions before the branch target. For a similar, but cheaper, version of this option see -falign-jumps. If -falign-loops or -falign-jumps is used, with a greater value than number, the greater value is used here. If number is not specified, the machine default is used, which is normally 1. Specifying number as 1 is equivalent to -fno-align-labels and no alignment takes place.

align_functions (–align-functions[=number]), aligns the starting address of functions on a boundary that is a power of 2 equal to or greater than number, but only if it is necessary to skip no more than number bytes to do it. For example, if number is 20, the resulting alignment is on a 32 byte boundary as long as no more than 20 bytes must be skipped to place it there. Setting number to a power of 2 causes all functions to be aligned to the boundary. If the number is not specified the machine default is used. For some machines the number is rounded up to a power of 2 thus aligning all functions. Specifying number as 1 is equivalent to -fno-align-functions and no alignment will take place.

 

decode_options (continue)

 

595    /* Initialize whether `char' is signed. */

596    flag_signed_char = DEFAULT_SIGNED_CHAR;

597  #ifdef DEFAULT_SHORT_ENUMS

598    /* Initialize how much space enums occupy, by default. */

599    flag_short_enums = DEFAULT_SHORT_ENUMS;

600  #endif

601 

602    /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can

603      modify it. */

604    target_flags = 0;

605    set_target_switch ("");

606 

607    /* Unwind tables are always present in an ABI-conformant IA-64

608      object file, so the default should be ON. */

609  #ifdef IA64_UNWIND_INFO

610    flag_unwind_tables = IA64_UNWIND_INFO;

611  #endif

612 

613  #ifdef OPTIMIZATION_OPTIONS

614    /* Allow default optimizations to be specified on a per-machine basis. */

615    OPTIMIZATION_OPTIONS (optimize, optimize_size);

616  #endif

 

At line 596, DEFAULT_SIGNED_CHAR is defined as 1 if `char' should by default be signed; else as 0. And DEFAULT_SHORT_ENUMS is only defined for DSP1600 chip.