This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: sched2 seems to be disabled on x86


Neil Booth wrote:-

> Whilst I'd love to take credit for a speed-up, I think the credit lies
> elsewhere.  The output of -fverbose-asm is simply not reporting the
> facts.
> 
> I'm not sure what to do about this as it used to be driven off the
> f_options table, which will eventually cease to exist.

This patch restores the flags (they were only removed to avoid false
success during the transition phase where there were two handlers
for -f options.) which are now harmless.

I'll apply it after an overnight bootstrap.

Neil.

	* toplev.c (flag_dummy): Remove.
	(f_options): Restore flag pointers.

Index: toplev.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/toplev.c,v
retrieving revision 1.792
diff -u -p -r1.792 toplev.c
--- toplev.c	28 Jun 2003 06:18:10 -0000	1.792
+++ toplev.c	28 Jun 2003 22:53:12 -0000
@@ -1043,9 +1043,6 @@ static const param_info lang_independent
   { NULL, 0, NULL }
 };
 
-/* Used for the f_options array temporarily.  */
-static int flag_dummy;
-
 /* Table of language-independent -f options.
    STRING is the option name.  VARIABLE is the address of the variable.
    ON_VALUE is the value to store in VARIABLE
@@ -1054,239 +1051,237 @@ static int flag_dummy;
 
 static const lang_independent_options f_options[] =
 {
-  {"eliminate-dwarf2-dups", &flag_dummy, 1,
+  {"eliminate-dwarf2-dups", &flag_eliminate_dwarf2_dups, 1,
    N_("Perform DWARF2 duplicate elimination") },
-  {"eliminate-unused-debug-types", &flag_dummy, 1,
+  {"eliminate-unused-debug-symbols", &flag_debug_only_used_symbols, 1,
    N_("Perform unused type elimination in debug info") },
-  {"eliminate-unused-debug-symbols", &flag_dummy, 1,
+  {"eliminate-unused-debug-types", &flag_eliminate_unused_debug_types, 1,
    N_("Perform unused type elimination in debug info") },
-  {"float-store", &flag_dummy, 1,
+  {"float-store", &flag_float_store, 1,
    N_("Do not store floats in registers") },
-  {"defer-pop", &flag_dummy, 1,
+  {"defer-pop", &flag_defer_pop, 1,
    N_("Defer popping functions args from stack until later") },
-  {"omit-frame-pointer", &flag_dummy, 1,
+  {"omit-frame-pointer", &flag_omit_frame_pointer, 1,
    N_("When possible do not generate stack frames") },
-  {"optimize-sibling-calls", &flag_dummy, 1,
+  {"optimize-sibling-calls", &flag_optimize_sibling_calls, 1,
    N_("Optimize sibling and tail recursive calls") },
-  {"tracer", &flag_dummy, 1,
+  {"tracer", &flag_tracer, 1,
    N_("Perform superblock formation via tail duplication") },
-  {"unit-at-a-time", &flag_dummy, 1,
+  {"unit-at-a-time", &flag_unit_at_a_time, 1,
    N_("Compile whole compilation unit at a time") },
-  {"cse-follow-jumps", &flag_dummy, 1,
+  {"cse-follow-jumps", &flag_cse_follow_jumps, 1,
    N_("When running CSE, follow jumps to their targets") },
-  {"cse-skip-blocks", &flag_dummy, 1,
+  {"cse-skip-blocks", &flag_cse_skip_blocks, 1,
    N_("When running CSE, follow conditional jumps") },
-  {"expensive-optimizations", &flag_dummy, 1,
+  {"expensive-optimizations", &flag_expensive_optimizations, 1,
    N_("Perform a number of minor, expensive optimizations") },
-  {"thread-jumps", &flag_dummy, 1,
+  {"thread-jumps", &flag_thread_jumps, 1,
    N_("Perform jump threading optimizations") },
-  {"strength-reduce", &flag_dummy, 1,
+  {"strength-reduce", &flag_strength_reduce, 1,
    N_("Perform strength reduction optimizations") },
-  {"unroll-loops", &flag_dummy, 1,
+  {"unroll-loops", &flag_unroll_loops, 1,
    N_("Perform loop unrolling when iteration count is known") },
-  {"unroll-all-loops", &flag_dummy, 1,
+  {"unroll-all-loops", &flag_unroll_all_loops, 1,
    N_("Perform loop unrolling for all loops") },
-  {"old-unroll-loops", &flag_dummy, 1,
+  {"old-unroll-loops", &flag_old_unroll_loops, 1,
    N_("Perform loop unrolling when iteration count is known") },
-  {"old-unroll-all-loops", &flag_dummy, 1,
+  {"old-unroll-all-loops", &flag_old_unroll_all_loops, 1,
    N_("Perform loop unrolling for all loops") },
-  {"peel-loops", &flag_dummy, 1,
+  {"peel-loops", &flag_peel_loops, 1,
    N_("Perform loop peeling") },
-  {"unswitch-loops", &flag_dummy, 1,
+  {"unswitch-loops", &flag_unswitch_loops, 1,
    N_("Perform loop unswitching") },
-  {"prefetch-loop-arrays", &flag_dummy, 1,
+  {"prefetch-loop-arrays", &flag_prefetch_loop_arrays, 1,
    N_("Generate prefetch instructions, if available, for arrays in loops") },
-  {"move-all-movables", &flag_dummy, 1,
+  {"move-all-movables", &flag_move_all_movables, 1,
    N_("Force all loop invariant computations out of loops") },
-  {"reduce-all-givs", &flag_dummy, 1,
+  {"reduce-all-givs", &flag_reduce_all_givs, 1,
    N_("Strength reduce all loop general induction variables") },
-  {"writable-strings", &flag_dummy, 1,
+  {"writable-strings", &flag_writable_strings, 1,
    N_("Store strings in writable data section") },
-  {"peephole", &flag_dummy, 0,
+  {"peephole", &flag_no_peephole, 0,
    N_("Enable machine specific peephole optimizations") },
-  {"force-mem", &flag_dummy, 1,
+  {"force-mem", &flag_force_mem, 1,
    N_("Copy memory operands into registers before using") },
-  {"force-addr", &flag_dummy, 1,
+  {"force-addr", &flag_force_addr, 1,
    N_("Copy memory address constants into regs before using") },
-  {"function-cse", &flag_dummy, 0,
+  {"function-cse", &flag_no_function_cse, 0,
    N_("Allow function addresses to be held in registers") },
-  {"inline-functions", &flag_dummy, 1,
+  {"inline-functions", &flag_inline_functions, 1,
    N_("Integrate simple functions into their callers") },
-  {"keep-inline-functions", &flag_dummy, 1,
+  {"keep-inline-functions", &flag_keep_inline_functions, 1,
    N_("Generate code for funcs even if they are fully inlined") },
-  {"inline", &flag_dummy, 0,
+  {"inline", &flag_no_inline, 0,
    N_("Pay attention to the 'inline' keyword") },
-  {"keep-static-consts", &flag_dummy, 1,
+  {"keep-static-consts", &flag_keep_static_consts, 1,
    N_("Emit static const variables even if they are not used") },
-  {"syntax-only", &flag_dummy, 1,
+  {"syntax-only", &flag_syntax_only, 1,
    N_("Check for syntax errors, then stop") },
-  {"shared-data", &flag_dummy, 1,
+  {"shared-data", &flag_shared_data, 1,
    N_("Mark data as shared rather than private") },
-  {"caller-saves", &flag_dummy, 1,
+  {"caller-saves", &flag_caller_saves, 1,
    N_("Enable saving registers around function calls") },
-  {"pcc-struct-return", &flag_dummy, 1,
+  {"pcc-struct-return", &flag_pcc_struct_return, 1,
    N_("Return 'short' aggregates in memory, not registers") },
-  {"reg-struct-return", &flag_dummy, 0,
+  {"reg-struct-return", &flag_pcc_struct_return, 0,
    N_("Return 'short' aggregates in registers") },
-  {"delayed-branch", &flag_dummy, 1,
+  {"delayed-branch", &flag_delayed_branch, 1,
    N_("Attempt to fill delay slots of branch instructions") },
-  {"gcse", &flag_dummy, 1,
+  {"gcse", &flag_gcse, 1,
    N_("Perform the global common subexpression elimination") },
-  {"gcse-lm", &flag_dummy, 1,
+  {"gcse-lm", &flag_gcse_lm, 1,
    N_("Perform enhanced load motion during global subexpression elimination") },
-  {"gcse-sm", &flag_dummy, 1,
+  {"gcse-sm", &flag_gcse_sm, 1,
    N_("Perform store motion after global subexpression elimination") },
-  {"branch-target-load-optimize", &flag_dummy, 1,
+  {"branch-target-load-optimize", &flag_branch_target_load_optimize, 1,
    N_("Perform branch target load optimization before prologue / epilogue threading") },
-  {"branch-target-load-optimize2", &flag_dummy, 1,
+  {"branch-target-load-optimize2", &flag_branch_target_load_optimize2, 1,
    N_("Perform branch target load optimization after prologue / epilogue threading") },
-  {"loop-optimize", &flag_dummy, 1,
+  {"loop-optimize", &flag_loop_optimize, 1,
    N_("Perform the loop optimizations") },
-  {"crossjumping", &flag_dummy, 1,
+  {"crossjumping", &flag_crossjumping, 1,
    N_("Perform cross-jumping optimization") },
-  {"if-conversion", &flag_dummy, 1,
+  {"if-conversion", &flag_if_conversion, 1,
    N_("Perform conversion of conditional jumps to branchless equivalents") },
-  {"if-conversion2", &flag_dummy, 1,
+  {"if-conversion2", &flag_if_conversion2, 1,
    N_("Perform conversion of conditional jumps to conditional execution") },
-  {"rerun-cse-after-loop", &flag_dummy, 1,
+  {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1,
    N_("Run CSE pass after loop optimizations") },
-  {"rerun-loop-opt", &flag_dummy, 1,
+  {"rerun-loop-opt", &flag_rerun_loop_opt, 1,
    N_("Run the loop optimizer twice") },
-  {"delete-null-pointer-checks", &flag_dummy, 1,
+  {"delete-null-pointer-checks", &flag_delete_null_pointer_checks, 1,
    N_("Delete useless null pointer checks") },
-  {"schedule-insns", &flag_dummy, 1,
+  {"schedule-insns", &flag_schedule_insns, 1,
    N_("Reschedule instructions before register allocation") },
-  {"schedule-insns2", &flag_dummy, 1,
+  {"schedule-insns2", &flag_schedule_insns_after_reload, 1,
    N_("Reschedule instructions after register allocation") },
-  {"sched-interblock",&flag_dummy, 1,
+  {"sched-interblock",&flag_schedule_interblock, 1,
    N_("Enable scheduling across basic blocks") },
-  {"sched-spec",&flag_dummy, 1,
+  {"sched-spec",&flag_schedule_speculative, 1,
    N_("Allow speculative motion of non-loads") },
-  {"sched-spec-load",&flag_dummy, 1,
+  {"sched-spec-load",&flag_schedule_speculative_load, 1,
    N_("Allow speculative motion of some loads") },
-  {"sched-spec-load-dangerous",&flag_dummy, 1,
+  {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1,
    N_("Allow speculative motion of more loads") },
-  {"sched2-use-superblocks", &flag_dummy, 1,
+  {"sched2-use-superblocks", &flag_sched2_use_superblocks, 1,
    N_("If scheduling post reload, do superblock scheduling") },
-  {"sched2-use-traces", &flag_dummy, 1,
+  {"sched2-use-traces", &flag_sched2_use_traces, 1,
    N_("If scheduling post reload, do trace scheduling") },
-  {"branch-count-reg",&flag_dummy, 1,
+  {"branch-count-reg",&flag_branch_on_count_reg, 1,
    N_("Replace add,compare,branch with branch on count reg") },
-  {"pic", &flag_dummy, 1,
+  {"pic", &flag_pic, 1,
    N_("Generate position independent code, if possible") },
-  {"PIC", &flag_dummy, 2, ""},
-  {"pie", &flag_dummy, 1,
+  {"PIC", &flag_pic, 2, ""},
+  {"pie", &flag_pie, 1,
    N_("Generate position independent code for executables, if possible") },
-  {"PIE", &flag_dummy, 2, ""},
-  {"exceptions", &flag_dummy, 1,
+  {"PIE", &flag_pie, 2, ""},
+  {"exceptions", &flag_exceptions, 1,
    N_("Enable exception handling") },
-  {"unwind-tables", &flag_dummy, 1,
+  {"unwind-tables", &flag_unwind_tables, 1,
    N_("Just generate unwind tables for exception handling") },
-  {"asynchronous-unwind-tables", &flag_dummy, 1,
+  {"asynchronous-unwind-tables", &flag_asynchronous_unwind_tables, 1,
    N_("Generate unwind tables exact at each instruction boundary") },
-  {"non-call-exceptions", &flag_dummy, 1,
+  {"non-call-exceptions", &flag_non_call_exceptions, 1,
    N_("Support synchronous non-call exceptions") },
-  {"profile-arcs", &flag_dummy, 1,
+  {"profile-arcs", &profile_arc_flag, 1,
    N_("Insert arc based program profiling code") },
-  {"test-coverage", &flag_dummy, 1,
+  {"test-coverage", &flag_test_coverage, 1,
    N_("Create data files needed by gcov") },
-  {"branch-probabilities", &flag_dummy, 1,
+  {"branch-probabilities", &flag_branch_probabilities, 1,
    N_("Use profiling information for branch probabilities") },
-  {"profile-values", &flag_profile_values, 1,
-   N_("Insert code to profile values of expressions") },
-  {"profile", &flag_dummy, 1,
+  {"profile", &profile_flag, 1,
    N_("Enable basic program profiling code") },
-  {"reorder-blocks", &flag_dummy, 1,
+  {"reorder-blocks", &flag_reorder_blocks, 1,
    N_("Reorder basic blocks to improve code placement") },
-  {"reorder-functions", &flag_dummy, 1,
+  {"reorder-functions", &flag_reorder_functions, 1,
    N_("Reorder functions to improve code placement") },
-  {"rename-registers", &flag_dummy, 1,
+  {"rename-registers", &flag_rename_registers, 1,
    N_("Do the register renaming optimization pass") },
-  {"cprop-registers", &flag_dummy, 1,
+  {"cprop-registers", &flag_cprop_registers, 1,
    N_("Do the register copy-propagation optimization pass") },
-  {"common", &flag_dummy, 0,
+  {"common", &flag_no_common, 0,
    N_("Do not put uninitialized globals in the common section") },
-  {"inhibit-size-directive", &flag_dummy, 1,
+  {"inhibit-size-directive", &flag_inhibit_size_directive, 1,
    N_("Do not generate .size directives") },
-  {"function-sections", &flag_dummy, 1,
+  {"function-sections", &flag_function_sections, 1,
    N_("place each function into its own section") },
-  {"data-sections", &flag_dummy, 1,
+  {"data-sections", &flag_data_sections, 1,
    N_("place data items into their own section") },
-  {"verbose-asm", &flag_dummy, 1,
+  {"verbose-asm", &flag_verbose_asm, 1,
    N_("Add extra commentary to assembler output") },
-  {"gnu-linker", &flag_dummy, 1,
+  {"gnu-linker", &flag_gnu_linker, 1,
    N_("Output GNU ld formatted global initializers") },
-  {"regmove", &flag_dummy, 1,
+  {"regmove", &flag_regmove, 1,
    N_("Enables a register move optimization") },
-  {"optimize-register-move", &flag_dummy, 1,
+  {"optimize-register-move", &flag_regmove, 1,
    N_("Do the full regmove optimization pass") },
-  {"pack-struct", &flag_dummy, 1,
+  {"pack-struct", &flag_pack_struct, 1,
    N_("Pack structure members together without holes") },
-  {"stack-check", &flag_dummy, 1,
+  {"stack-check", &flag_stack_check, 1,
    N_("Insert stack checking code into the program") },
-  {"argument-alias", &flag_dummy, 0,
+  {"argument-alias", &flag_argument_noalias, 0,
    N_("Specify that arguments may alias each other & globals") },
-  {"argument-noalias", &flag_dummy, 1,
+  {"argument-noalias", &flag_argument_noalias, 1,
    N_("Assume arguments may alias globals but not each other") },
-  {"argument-noalias-global", &flag_dummy, 2,
+  {"argument-noalias-global", &flag_argument_noalias, 2,
    N_("Assume arguments do not alias each other or globals") },
-  {"strict-aliasing", &flag_dummy, 1,
+  {"strict-aliasing", &flag_strict_aliasing, 1,
    N_("Assume strict aliasing rules apply") },
-  {"align-loops", &flag_dummy, 0,
+  {"align-loops", &align_loops, 0,
    N_("Align the start of loops") },
-  {"align-jumps", &flag_dummy, 0,
+  {"align-jumps", &align_jumps, 0,
    N_("Align labels which are only reached by jumping") },
-  {"align-labels", &flag_dummy, 0,
+  {"align-labels", &align_labels, 0,
    N_("Align all labels") },
-  {"align-functions", &flag_dummy, 0,
+  {"align-functions", &align_functions, 0,
    N_("Align the start of functions") },
-  {"merge-constants", &flag_dummy, 1,
+  {"merge-constants", &flag_merge_constants, 1,
    N_("Attempt to merge identical constants across compilation units") },
-  {"merge-all-constants", &flag_dummy, 2,
+  {"merge-all-constants", &flag_merge_constants, 2,
    N_("Attempt to merge identical constants and constant variables") },
-  {"dump-unnumbered", &flag_dummy, 1,
+  {"dump-unnumbered", &flag_dump_unnumbered, 1,
    N_("Suppress output of instruction numbers and line number notes in debugging dumps") },
-  {"instrument-functions", &flag_dummy, 1,
+  {"instrument-functions", &flag_instrument_function_entry_exit, 1,
    N_("Instrument function entry/exit with profiling calls") },
-  {"zero-initialized-in-bss", &flag_dummy, 1,
+  {"zero-initialized-in-bss", &flag_zero_initialized_in_bss, 1,
    N_("Put zero initialized data in the bss section") },
-  {"ssa", &flag_dummy, 1,
+  {"ssa", &flag_ssa, 1,
    N_("Enable SSA optimizations") },
-  {"ssa-ccp", &flag_dummy, 1,
+  {"ssa-ccp", &flag_ssa_ccp, 1,
    N_("Enable SSA conditional constant propagation") },
-  {"ssa-dce", &flag_dummy, 1,
+  {"ssa-dce", &flag_ssa_dce, 1,
    N_("Enable aggressive SSA dead code elimination") },
-  {"leading-underscore", &flag_dummy, 1,
+  {"leading-underscore", &flag_leading_underscore, 1,
    N_("External symbols have a leading underscore") },
-  {"ident", &flag_dummy, 0,
+  {"ident", &flag_no_ident, 0,
    N_("Process #ident directives") },
-  { "peephole2", &flag_dummy, 1,
+  { "peephole2", &flag_peephole2, 1,
    N_("Enables an rtl peephole pass run before sched2") },
-  {"finite-math-only", &flag_dummy, 1,
+  {"finite-math-only", &flag_finite_math_only, 1,
    N_("Assume no NaNs or +-Infs are generated") },
-  { "guess-branch-probability", &flag_dummy, 1,
+  { "guess-branch-probability", &flag_guess_branch_prob, 1,
    N_("Enables guessing of branch probabilities") },
-  {"math-errno", &flag_dummy, 1,
+  {"math-errno", &flag_errno_math, 1,
    N_("Set errno after built-in math functions") },
-  {"trapping-math", &flag_dummy, 1,
+  {"trapping-math", &flag_trapping_math, 1,
    N_("Floating-point operations can trap") },
-  {"unsafe-math-optimizations", &flag_dummy, 1,
+  {"unsafe-math-optimizations", &flag_unsafe_math_optimizations, 1,
    N_("Allow math optimizations that may violate IEEE or ANSI standards") },
-  {"signaling-nans", &flag_dummy, 1,
+  {"signaling-nans", &flag_signaling_nans, 1,
    N_("Disable optimizations observable by IEEE signaling NaNs") },
-  {"bounds-check", &flag_dummy, 1,
+  {"bounds-check", &flag_bounds_check, 1,
    N_("Generate code to check bounds before indexing arrays") },
-  {"single-precision-constant", &flag_dummy, 1,
+  {"single-precision-constant", &flag_single_precision_constant, 1,
    N_("Convert floating point constant to single precision constant") },
-  {"time-report", &flag_dummy, 1,
+  {"time-report", &time_report, 1,
    N_("Report time taken by each compiler pass at end of run") },
-  {"mem-report", &flag_dummy, 1,
+  {"mem-report", &mem_report, 1,
    N_("Report on permanent memory allocation at end of run") },
-  { "trapv", &flag_dummy, 1,
+  { "trapv", &flag_trapv, 1,
    N_("Trap for signed overflow in addition / subtraction / multiplication") },
-  { "wrapv", &flag_dummy, 1,
+  { "wrapv", &flag_wrapv, 1,
    N_("Assume signed arithmetic overflow wraps around") },
-  { "new-ra", &flag_dummy, 1,
+  { "new-ra", &flag_new_regalloc, 1,
    N_("Use graph coloring register allocation.") },
 };
 


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]