Studying note of GCC-3.4.6 source (26)

3.3.3.1.2.            Handling common options

For common switches or switches can’t be finished by c_common_handle_option, common_handle_option is invoked.

 

655  static int

656  common_handle_option (size_t scode, const char *arg,                                  in opts.c

657                      int value ATTRIBUTE_UNUSED)

658  {

659    enum opt_code code = (enum opt_code) scode;

660 

661    switch (code)

662    {

663      default:

664        abort ();

665 

666      case OPT__help:

667        print_help ();

668        exit_after_options = true;

669        break;

670 

671      case OPT__param:

672        handle_param (arg);

673        break;

 

Switch –param name=value sets some internal limits used by GCC to determine the amount of optimization to be done, so adjustments to these values are adjustments to the optimization.

The adjustment is done by handle_param.

 

1529 static void

1530 handle_param (const char *carg)                                                                        in opts.c

1531 {

1532   char *equal, *arg;

1533   int value;

1534

1535   arg = xstrdup (carg);

1536   equal = strchr (arg, '=');

1537   if (!equal)

1538     error ("%s: --param arguments should be of the form NAME=VALUE", arg);

1539   else

1540   {

1541     value = integral_argument (equal + 1);

1542     if (value == -1)

1543       error ("invalid --param value `%s'", equal + 1);

1544     else

1545     {

1546       *equal = '/0';

1547       set_param_value (arg, value);

1548     }

1549   }

1550

1551   free (arg);

1552 }

 

The parameter must be positive integer. To set the value, set_param_value is invoked in turn.

 

58    void

59    set_param_value (const char *name, int value)                                              in params.c

60    {

61      size_t i;

62   

63      /* Make sure nobody tries to set a parameter to an invalid value.  */

64      if (value == INVALID_PARAM_VAL)

65        abort ();

66   

67     /* Scan the parameter table to find a matching entry.  */

68      for (i = 0; i < num_compiler_params; ++i)

69        if (strcmp (compiler_params[i].option, name) == 0)

70        {

71          compiler_params[i].value = value;

72          return;

73        }

74   

75     /* If we didn't find this parameter, issue an error message.  */

76      error ("invalid parameter `%s'", name);

77    }

 

The names that can be used by --param are already determined. In general_init, at line 4264, add_params decides the names, and uses lang_independent_params to initialize compiler_params.

 

common_handle_option (continue)

 

675      case OPT__target_help:

676        display_target_options ();

677        exit_after_options = true;

678        break;

679 

680      case OPT__version:

681        print_version (stderr, "");

682        exit_after_options = true;

683        break;

684 

685      case OPT_G:

686        g_switch_value = value;

687        g_switch_set = true;

688        break;

689 

690      case OPT_O:

691      case OPT_Os:

692        /* Currently handled in a prescan.  */

693        break;

694 

695      case OPT_W:

696        /* For backward compatibility, -W is the same as -Wextra.  */

697        set_Wextra (value);

698        break;

699 

700      case OPT_Waggregate_return:

701        warn_aggregate_return = value;

702        break;

703 

704      case OPT_Wcast_align:

705        warn_cast_align = value;

706        break;

707 

708      case OPT_Wdeprecated_declarations:

709        warn_deprecated_decl = value;

710        break;

711 

712      case OPT_Wdisabled_optimization:

713        warn_disabled_optimization = value;

714        break;

715 

716      case OPT_Werror:

717        warnings_are_errors = value;

718        break;

719 

720      case OPT_Wextra:

721        set_Wextra (value);

722       break;

723 

724      case OPT_Winline:

725        warn_inline = value;

726        break;

727 

728      case OPT_Wlarger_than_:

729        larger_than_size = value;

730        warn_larger_than = value != -1;

731        break;

732 

733      case OPT_Wmissing_noreturn:

734        warn_missing_noreturn = value;

735        break;

736 

737      case OPT_Wpacked:

738        warn_packed = value;

739        break;

740 

741      case OPT_Wpadded:

742        warn_padded = value;

743        break;

744 

745      case OPT_Wshadow:

746        warn_shadow = value;

747        break;

748 

749      case OPT_Wstrict_aliasing:

750        warn_strict_aliasing = value;

751        break;

752 

753      case OPT_Wswitch:

754        warn_switch = value;

755        break;

756 

757      case OPT_Wswitch_default:

758        warn_switch_default = value;

759        break;

760 

761      case OPT_Wswitch_enum:

762        warn_switch_enum = value;

763        break;

764 

765      case OPT_Wsystem_headers:

766        warn_system_headers = value;

767        break;

768 

769      case OPT_Wuninitialized:

770        warn_uninitialized = value;

771        break;

772 

773      case OPT_Wunreachable_code:

774        warn_notreached = value;

775        break;

776 

777      case OPT_Wunused:

778        set_Wunused (value);

779        break;

780 

781      case OPT_Wunused_function:

782        warn_unused_function = value;

783        break;

784 

785      case OPT_Wunused_label:

786        warn_unused_label = value;

787        break;

788 

789      case OPT_Wunused_parameter:

790        warn_unused_parameter = value;

791        break;

792 

793      case OPT_Wunused_value:

794        warn_unused_value = value;

795        break;

796 

797      case OPT_Wunused_variable:

798        warn_unused_variable = value;

799        break;

 

In above, the switches encountered and the variables related are:

g_switch_value (-G number), puts global and static objects less than or equal to number bytes into the small data or bss sections instead of the normal data or bss sections. The default value of number is 8. The -msdata option must be set to either sdata or use for this option to have any effect. All modules should be compiled with the same -msdata and -G settings. Compiling with different values for number may or may not work. If it does not work, the linker will detect the error preventing incorrect code from being generated.

Above at line 697, switch –W is handled by set_Wextra.

 

1555 static void

1556 set_Wextra (int setting)                                                                                    in opts.c

1557 {

1558   extra_warnings = setting;

1559   warn_unused_value = setting;

1560   warn_unused_parameter = (setting && maybe_warn_unused_parameter);

1561

1562   /* We save the value of warn_uninitialized, since if they put

1563     -Wuninitialized on the command line, we need to generate a

1564     warning about not using it without also specifying -O.  */

1565   if (setting == 0)

1566     warn_uninitialized = 0;

1567   else if (warn_uninitialized != 1)

1568     warn_uninitialized = 2;

1569 }

 

-W This option enables the issuing of a family of warning messages dealing primarily with code that could possibly cause a problem, but it could also be what was intended by the programmer. This option enables all of the following:

Comparison A warning is issued if an unsigned value is tested for being less than zero. For example, because unsigned values can never be negative, the following test will always be false:

unsigned int x;

. . .

if(x < 0) . . .

Comparison A warning is issued for the comparison of a signed value with an unsigned value. An incorrect result can be produced when the unsigned value is converted to a signed value for the comparison. This warning can be suppressed by -Wno-sign-compare.

Comparison Algebraic notation and the C sytnax for comparison are not the same. A warning will be issued for the following statement:

if(a < b < c) . . .

In algebraic notation this expression is true only if b lies in the open interval between a and c. In C, this expression is the same as the following, which is very different:

int result;

result = a < b;

if(result < b) . . .

Const return Issue a warning for the return value of a function being declared as const. The const declaration has no meaning here because the return value from a function is an rvalue.

Aggregate initializers A warning is issued if initial values are specified for an aggregate data type, but values are not supplied for all members of the aggregate. In the following example an error message would be issued for both the array and the struct:

struct {

int a;

int b;

int c;

} trmp = { 1, 2 };

int arr[10] = { 1, 2, 3, 4, 5 };

No side effect A warning is issued for a statement that has no effect. For example, the result of the following addition is not used:

int a = 1;

int b = 2;

a + b;

Overflow In Fortran, warnings are issued when floating point constant declarations overflow.

Return value Issue a warning if a function is written so that it may or may not return a value, as in the following example which does not return value if x is negative:

ambigret(int x) {

if(x >= 0)

return(x);

}

Static syntax Issue a warning if the keyword static does not come first on a declaration line. This ordering is no longer a requirement in standard C.

Unused arguments If either -Wall or -Wunused is specified along with -W, a warning is issued for any unused arguments in the body of a function.

warn_inline (C, C++, ObjC, -Winline) if nonzero, issues a warning if a function that was declared as inline could not be expanded as inline code.

warn_larger_than (C, C++, ObjC, -Wlarger-than) if nonzero, issues a warning whenever an object larger than size bytes is declared, if the return value from a function is larger than size bytes.

warn_aggregate_return (C, C++, ObjC, -Waggregate-return) if nonzero, issues a warning if a function returns a structure, union, or an array.

warn_cast_align (C, C++, ObjC, -Wcast-align) if nonzero, issues a warning there is a possible problem with the alignment resulting from casting a pointer to a different type. For example, on some machines it is possible to address an int only on 2- or 4-byte boundaries, so casting a char pointer to an int pointer could result in an invalid address value.

warn_deprecated_decl (C, C++, ObjC, -Wdeprecated-declaration) if nonzero, issues warning about the use of items marked with the deprecated attribute unless -Wno-deprecated-declarations is specified.

warn_disabled_optimization (-Wdisabled-optimization) if nonzero, issues a warning if a requested optimization is disabled. This circumstance occurs not because of a problem with your code, but because of a limitation within the compiler itself. GCC will refuse to perform optimizations that are too complex and/or will take too long to perform.

warn_missing_noreturn, if nonzero, warns about functions which might be candidates for attribute noreturn.

warn_packed, if nonzero, warns if packed attribute on struct is unnecessary and inefficient.

warn_padded, if nonzero, warns when gcc pads a structure to an alignment boundary.

warn_shadow, if nonzero, means warn about all declarations which shadow others.

warn_switch_default, if nonzero, warns if a switch does not have a default case.

warn_switch_enum, if nonzero, warns if a switch on an enum fails to have a case for every enum value.

warn_system_headers (C, C++, ObjC, -Wsystem-headers), if nonzero, issues warning messages for code in the system header files as well in the program being compiled. Normally warnings caused by system headers are suppressed. To generate warnings about unknown pragmas in system headers it will be necessary to specify -Wunknown-pragmas because using -Wall only checks the pragmas in the program and ignores the ones in the system headers.

warn_notreached, if nonzero, warns about code which is never reached.

 

common_handle_option (continue)

 

801      case OPT_aux_info:

802      case OPT_aux_info_:

803        aux_info_file_name = arg;

804        flag_gen_aux_info = 1;

805        break;

806 

807      case OPT_auxbase:

808        aux_base_name = arg;

809        break;

810 

811      case OPT_auxbase_strip:

812      {

813        char *tmp = xstrdup (arg);

814        strip_off_ending (tmp, strlen (tmp));

815        if (tmp[0])

816          aux_base_name = tmp;

817      }

818      break;

819 

820      case OPT_d:

821        decode_d_option (arg);

822        break;

823 

824      case OPT_dumpbase:

825        dump_base_name = arg;

826        break;

827 

828      case OPT_fPIC:

829        flag_pic = value + value;

830        break;

831 

832      case OPT_fPIE:

833        flag_pie = value + value;

834        break;

835 

836      case OPT_fabi_version_:

837        flag_abi_version = value;

838        break;

839 

840      case OPT_falign_functions:

841        align_functions = !value;

842        break;

843 

844      case OPT_falign_functions_:

845        align_functions = value;

846        break;

847 

848      case OPT_falign_jumps:

849        align_jumps = !value;

850        break;

851 

852      case OPT_falign_jumps_:

853        align_jumps = value;

854        break;

855 

856      case OPT_falign_labels:

857        align_labels = !value;

858        break;

859 

860      case OPT_falign_labels_:

861        align_labels = value;

862        break;

863 

864      case OPT_falign_loops:

865        align_loops = !value;

866        break;

867 

868      case OPT_falign_loops_:

869        align_loops = value;

870        break;

871 

872      case OPT_fargument_alias:

873        flag_argument_noalias = !value;

874        break;

875 

876      case OPT_fargument_noalias:

877        flag_argument_noalias = value;

878        break;

879 

880      case OPT_fargument_noalias_global:

881        flag_argument_noalias = value + value;

882        break;

883 

884      case OPT_fasynchronous_unwind_tables:

885        flag_asynchronous_unwind_tables = value;

886        break;

887 

888      case OPT_fbounds_check:

889        flag_bounds_check = value;

890        break;

891 

892      case OPT_fbranch_count_reg:

893        flag_branch_on_count_reg = value;

894        break;

895 

896      case OPT_fbranch_probabilities:

897        flag_branch_probabilities_set = true;

898        flag_branch_probabilities = value;

899        break;

900 

901      case OPT_fbranch_target_load_optimize:

902        flag_branch_target_load_optimize = value;

903        break;

904 

905      case OPT_fbranch_target_load_optimize2:

906        flag_branch_target_load_optimize2 = value;

907        break;

 

aux_info_file_name (C, -aux-info filename) outputs prototype declarations for all the functions declared or defined in a single compilation unit (a C source file and all the header files it includes) to the named file

flag_gen_aux_info, if nonzero, means we should be saving declaration info into a .X file.

aux_base_name (-auxbase, -auxbase-strip) specify name to use as a base for auxiliary output files.

flag_abi_version (-fabi-version=) indicates the version of the C++ ABI in use. The following values are allowed:

0: The version of the ABI believed most conformant with the C++ ABI specification. This ABI may change as bugs are discovered and fixed. Therefore, 0 will not necessarily indicate the same ABI in different versions of G++.

1: The version of the ABI first used in G++ 3.2.

2: The version of the ABI first used in G++ 3.4.

Additional positive integers will be assigned as new versions of the ABI become the default version of the ABI.

flag_argument_noalias takes following values.

0 if pointer arguments may alias each other. True in C.

1 if pointer arguments may not alias each other but may alias global variables.

2 if pointer arguments may not alias each other and may not alias global variables. True in Fortran.

It defaults to 0 for C. And the value is passed by following switches.

-fargument-alias specifies that arguments passed to functions may be aliases of one another. That is, two or more parameters may represent the same memory location. It is also possible that an argument can be an alias of a global value. This is the default for C, C++, and ObjC.

-fargument-noalias specifies that arguments passed to functions will never be aliases of one another. That is, two or more parameters will not represent the same memory location. However, it is possible that an argument can be an alias of a global value.

-fargument-noalias-global specifies that arguments passed to functions will never be aliases of one another. That is, two or more parameters will not represent the same memory location. It is also not possible that an argument is an alias of a global value. This is the default for Fortran.

flag_bounds_check (-fbounds-check) causes gcc to generate array bounds checks. For C, C++, ObjC: defaults to off. For Java: defaults to on. For Fortran: defaults to off.

flag_branch_on_count_reg (-fbranch-count-reg) if nonzero, means try to replace add -1,compare,branch tupple by a cheaper branch on a count register.

flag_branch_probabilities (-fbranch-probabilities) if nonzero, after using -fprofile-arcs to compile a program and then running it to create the file containing execution counts for each block of code, the program can be compiled again with this option, and the information from the file is used to optimize the code for the branches that are taken most often. Without this information, GCC will guess which path is taken most often to perform optimization. The information is stored in a file with the name as the source and a .da suffix.

flag_branch_target_load_optimize (-fbranch-target-load-optimize) if nonzero, performs target register optimization before prologue/epilogue threading.

flag_branch_target_load_optimize2 (-fbranch-target-load-optimize2) if nonzero, performs target register optimization after prologue/epilogue threading and jump2.