/* This file is auto-generated by optc-save-gen.awk.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "opts.h"
#include "intl.h"

#include "flags.h"
#include "target.h"

#include "diagnostic-color.h"
#include "pretty-print.h"

/* Save optimization variables into a structure.  */
void
cl_optimization_save (struct cl_optimization *ptr, struct gcc_options *opts)
{
  gcc_assert (IN_RANGE (opts->x_optimize, 0, 255));
  gcc_assert (IN_RANGE (opts->x_optimize_size, 0, 255));
  gcc_assert (IN_RANGE (opts->x_flag_aggressive_loop_optimizations, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_asynchronous_unwind_tables, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_branch_on_count_reg, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_branch_probabilities, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_branch_target_load_optimize, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_branch_target_load_optimize2, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_btr_bb_exclusive, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_caller_saves, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_combine_stack_adjustments, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_no_common, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_compare_elim_after_reload, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_conserve_stack, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_cprop_registers, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_crossjumping, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_cse_follow_jumps, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_cx_fortran_rules, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_cx_limited_range, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_data_sections, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_dce, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_defer_pop, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_delayed_branch, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_delete_null_pointer_checks, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_devirtualize, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_devirtualize_speculatively, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_dse, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_early_inlining, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_exceptions, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_expensive_optimizations, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_finite_math_only, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_float_store, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_forward_propagate, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_gcse, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_gcse_after_reload, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_gcse_las, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_gcse_lm, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_gcse_sm, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_graphite_identity, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_guess_branch_prob, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_hoist_adjacent_loads, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_if_conversion, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_if_conversion2, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_no_inline, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_inline_atomics, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_inline_functions, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_inline_functions_called_once, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_inline_small_functions, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ipa_cp, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ipa_cp_clone, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ipa_profile, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ipa_pta, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ipa_pure_const, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ipa_reference, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ipa_sra, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ira_hoist_pressure, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ira_loop_pressure, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_isolate_erroneous_paths_attribute, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_isolate_erroneous_paths_dereference, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ivopts, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_jump_tables, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_live_range_shrinkage, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_loop_block, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_loop_interchange, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_loop_optimize_isl, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_loop_parallelize_all, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_loop_strip_mine, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_errno_math, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_merge_constants, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_modulo_sched, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_move_loop_invariants, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_non_call_exceptions, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_nothrow_opt, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_omit_frame_pointer, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_opt_info, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_optimize_sibling_calls, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_optimize_strlen, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_pack_struct, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_peel_loops, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_no_peephole, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_peephole2, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_predictive_commoning, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_prefetch_loop_arrays, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_pcc_struct_return, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_rename_registers, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_reorder_blocks, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_reorder_blocks_and_partition, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_reorder_functions, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_rerun_cse_after_loop, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_resched_modulo_sched, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_rounding_math, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_rtti, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_sched_critical_path_heuristic, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_sched_dep_count_heuristic, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_sched_group_heuristic, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_schedule_interblock, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_sched_last_insn_heuristic, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_sched_pressure, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_sched_rank_heuristic, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_schedule_speculative, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_sched_spec_insn_heuristic, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_schedule_speculative_load, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_schedule_speculative_load_dangerous, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_sched2_use_superblocks, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_schedule_insns, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_schedule_insns_after_reload, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_section_anchors, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_sel_sched_pipelining, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_sel_sched_pipelining_outer_loops, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_sel_sched_reschedule_pipelined, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_selective_scheduling, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_selective_scheduling2, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_setstackexecutable, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_short_double, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_short_enums, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_short_wchar, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_shrink_wrap, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_signaling_nans, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_signed_zeros, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_single_precision_constant, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_split_ivs_in_unroller, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_split_wide_types, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_strict_aliasing, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_strict_enums, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_thread_jumps, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_threadsafe_statics, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_toplevel_reorder, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_trapping_math, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_trapv, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_bit_ccp, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_builtin_call_dce, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_ccp, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_ch, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ssa_coalesce_vars, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_copy_prop, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_copyrename, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_cselim, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_dce, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_dom, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_dse, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_forwprop, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_fre, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_loop_distribute_patterns, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_loop_distribution, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_loop_if_convert, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_loop_if_convert_stores, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_loop_im, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_loop_ivcanon, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_loop_optimize, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_loop_vectorize, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_live_range_split, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_partial_pre, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_phiprop, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_pre, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_pta, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_reassoc, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_scev_cprop, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_sink, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_slp_vectorize, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_slsr, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_sra, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_switch_conversion, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_tail_merge, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_ter, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_vectorize, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_vrp, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_unit_at_a_time, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_unroll_all_loops, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_unroll_loops, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_unsafe_loop_optimizations, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_unsafe_math_optimizations, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_unswitch_loops, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_unwind_tables, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_var_tracking, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_var_tracking_assignments, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_var_tracking_assignments_toggle, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_var_tracking_uninit, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_variable_expansion_in_unroller, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_value_profile_transformations, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_web, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_whole_program, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_wrapv, -128, 127));

  ptr->x_align_functions = opts->x_align_functions;
  ptr->x_align_jumps = opts->x_align_jumps;
  ptr->x_align_labels = opts->x_align_labels;
  ptr->x_align_loops = opts->x_align_loops;
  ptr->x_flag_sched_stalled_insns = opts->x_flag_sched_stalled_insns;
  ptr->x_flag_sched_stalled_insns_dep = opts->x_flag_sched_stalled_insns_dep;
  ptr->x_flag_fp_contract_mode = opts->x_flag_fp_contract_mode;
  ptr->x_optimize = opts->x_optimize;
  ptr->x_optimize_size = opts->x_optimize_size;
  ptr->x_flag_aggressive_loop_optimizations = opts->x_flag_aggressive_loop_optimizations;
  ptr->x_flag_asynchronous_unwind_tables = opts->x_flag_asynchronous_unwind_tables;
  ptr->x_flag_branch_on_count_reg = opts->x_flag_branch_on_count_reg;
  ptr->x_flag_branch_probabilities = opts->x_flag_branch_probabilities;
  ptr->x_flag_branch_target_load_optimize = opts->x_flag_branch_target_load_optimize;
  ptr->x_flag_branch_target_load_optimize2 = opts->x_flag_branch_target_load_optimize2;
  ptr->x_flag_btr_bb_exclusive = opts->x_flag_btr_bb_exclusive;
  ptr->x_flag_caller_saves = opts->x_flag_caller_saves;
  ptr->x_flag_combine_stack_adjustments = opts->x_flag_combine_stack_adjustments;
  ptr->x_flag_no_common = opts->x_flag_no_common;
  ptr->x_flag_compare_elim_after_reload = opts->x_flag_compare_elim_after_reload;
  ptr->x_flag_conserve_stack = opts->x_flag_conserve_stack;
  ptr->x_flag_cprop_registers = opts->x_flag_cprop_registers;
  ptr->x_flag_crossjumping = opts->x_flag_crossjumping;
  ptr->x_flag_cse_follow_jumps = opts->x_flag_cse_follow_jumps;
  ptr->x_flag_cx_fortran_rules = opts->x_flag_cx_fortran_rules;
  ptr->x_flag_cx_limited_range = opts->x_flag_cx_limited_range;
  ptr->x_flag_data_sections = opts->x_flag_data_sections;
  ptr->x_flag_dce = opts->x_flag_dce;
  ptr->x_flag_defer_pop = opts->x_flag_defer_pop;
  ptr->x_flag_delayed_branch = opts->x_flag_delayed_branch;
  ptr->x_flag_delete_null_pointer_checks = opts->x_flag_delete_null_pointer_checks;
  ptr->x_flag_devirtualize = opts->x_flag_devirtualize;
  ptr->x_flag_devirtualize_speculatively = opts->x_flag_devirtualize_speculatively;
  ptr->x_flag_dse = opts->x_flag_dse;
  ptr->x_flag_early_inlining = opts->x_flag_early_inlining;
  ptr->x_flag_exceptions = opts->x_flag_exceptions;
  ptr->x_flag_expensive_optimizations = opts->x_flag_expensive_optimizations;
  ptr->x_flag_finite_math_only = opts->x_flag_finite_math_only;
  ptr->x_flag_float_store = opts->x_flag_float_store;
  ptr->x_flag_forward_propagate = opts->x_flag_forward_propagate;
  ptr->x_flag_gcse = opts->x_flag_gcse;
  ptr->x_flag_gcse_after_reload = opts->x_flag_gcse_after_reload;
  ptr->x_flag_gcse_las = opts->x_flag_gcse_las;
  ptr->x_flag_gcse_lm = opts->x_flag_gcse_lm;
  ptr->x_flag_gcse_sm = opts->x_flag_gcse_sm;
  ptr->x_flag_graphite_identity = opts->x_flag_graphite_identity;
  ptr->x_flag_guess_branch_prob = opts->x_flag_guess_branch_prob;
  ptr->x_flag_hoist_adjacent_loads = opts->x_flag_hoist_adjacent_loads;
  ptr->x_flag_if_conversion = opts->x_flag_if_conversion;
  ptr->x_flag_if_conversion2 = opts->x_flag_if_conversion2;
  ptr->x_flag_no_inline = opts->x_flag_no_inline;
  ptr->x_flag_inline_atomics = opts->x_flag_inline_atomics;
  ptr->x_flag_inline_functions = opts->x_flag_inline_functions;
  ptr->x_flag_inline_functions_called_once = opts->x_flag_inline_functions_called_once;
  ptr->x_flag_inline_small_functions = opts->x_flag_inline_small_functions;
  ptr->x_flag_ipa_cp = opts->x_flag_ipa_cp;
  ptr->x_flag_ipa_cp_clone = opts->x_flag_ipa_cp_clone;
  ptr->x_flag_ipa_profile = opts->x_flag_ipa_profile;
  ptr->x_flag_ipa_pta = opts->x_flag_ipa_pta;
  ptr->x_flag_ipa_pure_const = opts->x_flag_ipa_pure_const;
  ptr->x_flag_ipa_reference = opts->x_flag_ipa_reference;
  ptr->x_flag_ipa_sra = opts->x_flag_ipa_sra;
  ptr->x_flag_ira_hoist_pressure = opts->x_flag_ira_hoist_pressure;
  ptr->x_flag_ira_loop_pressure = opts->x_flag_ira_loop_pressure;
  ptr->x_flag_isolate_erroneous_paths_attribute = opts->x_flag_isolate_erroneous_paths_attribute;
  ptr->x_flag_isolate_erroneous_paths_dereference = opts->x_flag_isolate_erroneous_paths_dereference;
  ptr->x_flag_ivopts = opts->x_flag_ivopts;
  ptr->x_flag_jump_tables = opts->x_flag_jump_tables;
  ptr->x_flag_live_range_shrinkage = opts->x_flag_live_range_shrinkage;
  ptr->x_flag_loop_block = opts->x_flag_loop_block;
  ptr->x_flag_loop_interchange = opts->x_flag_loop_interchange;
  ptr->x_flag_loop_optimize_isl = opts->x_flag_loop_optimize_isl;
  ptr->x_flag_loop_parallelize_all = opts->x_flag_loop_parallelize_all;
  ptr->x_flag_loop_strip_mine = opts->x_flag_loop_strip_mine;
  ptr->x_flag_errno_math = opts->x_flag_errno_math;
  ptr->x_flag_merge_constants = opts->x_flag_merge_constants;
  ptr->x_flag_modulo_sched = opts->x_flag_modulo_sched;
  ptr->x_flag_move_loop_invariants = opts->x_flag_move_loop_invariants;
  ptr->x_flag_non_call_exceptions = opts->x_flag_non_call_exceptions;
  ptr->x_flag_nothrow_opt = opts->x_flag_nothrow_opt;
  ptr->x_flag_omit_frame_pointer = opts->x_flag_omit_frame_pointer;
  ptr->x_flag_opt_info = opts->x_flag_opt_info;
  ptr->x_flag_optimize_sibling_calls = opts->x_flag_optimize_sibling_calls;
  ptr->x_flag_optimize_strlen = opts->x_flag_optimize_strlen;
  ptr->x_flag_pack_struct = opts->x_flag_pack_struct;
  ptr->x_flag_peel_loops = opts->x_flag_peel_loops;
  ptr->x_flag_no_peephole = opts->x_flag_no_peephole;
  ptr->x_flag_peephole2 = opts->x_flag_peephole2;
  ptr->x_flag_predictive_commoning = opts->x_flag_predictive_commoning;
  ptr->x_flag_prefetch_loop_arrays = opts->x_flag_prefetch_loop_arrays;
  ptr->x_flag_pcc_struct_return = opts->x_flag_pcc_struct_return;
  ptr->x_flag_rename_registers = opts->x_flag_rename_registers;
  ptr->x_flag_reorder_blocks = opts->x_flag_reorder_blocks;
  ptr->x_flag_reorder_blocks_and_partition = opts->x_flag_reorder_blocks_and_partition;
  ptr->x_flag_reorder_functions = opts->x_flag_reorder_functions;
  ptr->x_flag_rerun_cse_after_loop = opts->x_flag_rerun_cse_after_loop;
  ptr->x_flag_resched_modulo_sched = opts->x_flag_resched_modulo_sched;
  ptr->x_flag_rounding_math = opts->x_flag_rounding_math;
  ptr->x_flag_rtti = opts->x_flag_rtti;
  ptr->x_flag_sched_critical_path_heuristic = opts->x_flag_sched_critical_path_heuristic;
  ptr->x_flag_sched_dep_count_heuristic = opts->x_flag_sched_dep_count_heuristic;
  ptr->x_flag_sched_group_heuristic = opts->x_flag_sched_group_heuristic;
  ptr->x_flag_schedule_interblock = opts->x_flag_schedule_interblock;
  ptr->x_flag_sched_last_insn_heuristic = opts->x_flag_sched_last_insn_heuristic;
  ptr->x_flag_sched_pressure = opts->x_flag_sched_pressure;
  ptr->x_flag_sched_rank_heuristic = opts->x_flag_sched_rank_heuristic;
  ptr->x_flag_schedule_speculative = opts->x_flag_schedule_speculative;
  ptr->x_flag_sched_spec_insn_heuristic = opts->x_flag_sched_spec_insn_heuristic;
  ptr->x_flag_schedule_speculative_load = opts->x_flag_schedule_speculative_load;
  ptr->x_flag_schedule_speculative_load_dangerous = opts->x_flag_schedule_speculative_load_dangerous;
  ptr->x_flag_sched2_use_superblocks = opts->x_flag_sched2_use_superblocks;
  ptr->x_flag_schedule_insns = opts->x_flag_schedule_insns;
  ptr->x_flag_schedule_insns_after_reload = opts->x_flag_schedule_insns_after_reload;
  ptr->x_flag_section_anchors = opts->x_flag_section_anchors;
  ptr->x_flag_sel_sched_pipelining = opts->x_flag_sel_sched_pipelining;
  ptr->x_flag_sel_sched_pipelining_outer_loops = opts->x_flag_sel_sched_pipelining_outer_loops;
  ptr->x_flag_sel_sched_reschedule_pipelined = opts->x_flag_sel_sched_reschedule_pipelined;
  ptr->x_flag_selective_scheduling = opts->x_flag_selective_scheduling;
  ptr->x_flag_selective_scheduling2 = opts->x_flag_selective_scheduling2;
  ptr->x_flag_setstackexecutable = opts->x_flag_setstackexecutable;
  ptr->x_flag_short_double = opts->x_flag_short_double;
  ptr->x_flag_short_enums = opts->x_flag_short_enums;
  ptr->x_flag_short_wchar = opts->x_flag_short_wchar;
  ptr->x_flag_shrink_wrap = opts->x_flag_shrink_wrap;
  ptr->x_flag_signaling_nans = opts->x_flag_signaling_nans;
  ptr->x_flag_signed_zeros = opts->x_flag_signed_zeros;
  ptr->x_flag_single_precision_constant = opts->x_flag_single_precision_constant;
  ptr->x_flag_split_ivs_in_unroller = opts->x_flag_split_ivs_in_unroller;
  ptr->x_flag_split_wide_types = opts->x_flag_split_wide_types;
  ptr->x_flag_strict_aliasing = opts->x_flag_strict_aliasing;
  ptr->x_flag_strict_enums = opts->x_flag_strict_enums;
  ptr->x_flag_thread_jumps = opts->x_flag_thread_jumps;
  ptr->x_flag_threadsafe_statics = opts->x_flag_threadsafe_statics;
  ptr->x_flag_toplevel_reorder = opts->x_flag_toplevel_reorder;
  ptr->x_flag_trapping_math = opts->x_flag_trapping_math;
  ptr->x_flag_trapv = opts->x_flag_trapv;
  ptr->x_flag_tree_bit_ccp = opts->x_flag_tree_bit_ccp;
  ptr->x_flag_tree_builtin_call_dce = opts->x_flag_tree_builtin_call_dce;
  ptr->x_flag_tree_ccp = opts->x_flag_tree_ccp;
  ptr->x_flag_tree_ch = opts->x_flag_tree_ch;
  ptr->x_flag_ssa_coalesce_vars = opts->x_flag_ssa_coalesce_vars;
  ptr->x_flag_tree_copy_prop = opts->x_flag_tree_copy_prop;
  ptr->x_flag_tree_copyrename = opts->x_flag_tree_copyrename;
  ptr->x_flag_tree_cselim = opts->x_flag_tree_cselim;
  ptr->x_flag_tree_dce = opts->x_flag_tree_dce;
  ptr->x_flag_tree_dom = opts->x_flag_tree_dom;
  ptr->x_flag_tree_dse = opts->x_flag_tree_dse;
  ptr->x_flag_tree_forwprop = opts->x_flag_tree_forwprop;
  ptr->x_flag_tree_fre = opts->x_flag_tree_fre;
  ptr->x_flag_tree_loop_distribute_patterns = opts->x_flag_tree_loop_distribute_patterns;
  ptr->x_flag_tree_loop_distribution = opts->x_flag_tree_loop_distribution;
  ptr->x_flag_tree_loop_if_convert = opts->x_flag_tree_loop_if_convert;
  ptr->x_flag_tree_loop_if_convert_stores = opts->x_flag_tree_loop_if_convert_stores;
  ptr->x_flag_tree_loop_im = opts->x_flag_tree_loop_im;
  ptr->x_flag_tree_loop_ivcanon = opts->x_flag_tree_loop_ivcanon;
  ptr->x_flag_tree_loop_optimize = opts->x_flag_tree_loop_optimize;
  ptr->x_flag_tree_loop_vectorize = opts->x_flag_tree_loop_vectorize;
  ptr->x_flag_tree_live_range_split = opts->x_flag_tree_live_range_split;
  ptr->x_flag_tree_partial_pre = opts->x_flag_tree_partial_pre;
  ptr->x_flag_tree_phiprop = opts->x_flag_tree_phiprop;
  ptr->x_flag_tree_pre = opts->x_flag_tree_pre;
  ptr->x_flag_tree_pta = opts->x_flag_tree_pta;
  ptr->x_flag_tree_reassoc = opts->x_flag_tree_reassoc;
  ptr->x_flag_tree_scev_cprop = opts->x_flag_tree_scev_cprop;
  ptr->x_flag_tree_sink = opts->x_flag_tree_sink;
  ptr->x_flag_tree_slp_vectorize = opts->x_flag_tree_slp_vectorize;
  ptr->x_flag_tree_slsr = opts->x_flag_tree_slsr;
  ptr->x_flag_tree_sra = opts->x_flag_tree_sra;
  ptr->x_flag_tree_switch_conversion = opts->x_flag_tree_switch_conversion;
  ptr->x_flag_tree_tail_merge = opts->x_flag_tree_tail_merge;
  ptr->x_flag_tree_ter = opts->x_flag_tree_ter;
  ptr->x_flag_tree_vectorize = opts->x_flag_tree_vectorize;
  ptr->x_flag_tree_vrp = opts->x_flag_tree_vrp;
  ptr->x_flag_unit_at_a_time = opts->x_flag_unit_at_a_time;
  ptr->x_flag_unroll_all_loops = opts->x_flag_unroll_all_loops;
  ptr->x_flag_unroll_loops = opts->x_flag_unroll_loops;
  ptr->x_flag_unsafe_loop_optimizations = opts->x_flag_unsafe_loop_optimizations;
  ptr->x_flag_unsafe_math_optimizations = opts->x_flag_unsafe_math_optimizations;
  ptr->x_flag_unswitch_loops = opts->x_flag_unswitch_loops;
  ptr->x_flag_unwind_tables = opts->x_flag_unwind_tables;
  ptr->x_flag_var_tracking = opts->x_flag_var_tracking;
  ptr->x_flag_var_tracking_assignments = opts->x_flag_var_tracking_assignments;
  ptr->x_flag_var_tracking_assignments_toggle = opts->x_flag_var_tracking_assignments_toggle;
  ptr->x_flag_var_tracking_uninit = opts->x_flag_var_tracking_uninit;
  ptr->x_flag_variable_expansion_in_unroller = opts->x_flag_variable_expansion_in_unroller;
  ptr->x_flag_value_profile_transformations = opts->x_flag_value_profile_transformations;
  ptr->x_flag_web = opts->x_flag_web;
  ptr->x_flag_whole_program = opts->x_flag_whole_program;
  ptr->x_flag_wrapv = opts->x_flag_wrapv;
}

/* Restore optimization options from a structure.  */
void
cl_optimization_restore (struct gcc_options *opts, struct cl_optimization *ptr)
{
  opts->x_align_functions = ptr->x_align_functions;
  opts->x_align_jumps = ptr->x_align_jumps;
  opts->x_align_labels = ptr->x_align_labels;
  opts->x_align_loops = ptr->x_align_loops;
  opts->x_flag_sched_stalled_insns = ptr->x_flag_sched_stalled_insns;
  opts->x_flag_sched_stalled_insns_dep = ptr->x_flag_sched_stalled_insns_dep;
  opts->x_flag_fp_contract_mode = ptr->x_flag_fp_contract_mode;
  opts->x_optimize = ptr->x_optimize;
  opts->x_optimize_size = ptr->x_optimize_size;
  opts->x_flag_aggressive_loop_optimizations = ptr->x_flag_aggressive_loop_optimizations;
  opts->x_flag_asynchronous_unwind_tables = ptr->x_flag_asynchronous_unwind_tables;
  opts->x_flag_branch_on_count_reg = ptr->x_flag_branch_on_count_reg;
  opts->x_flag_branch_probabilities = ptr->x_flag_branch_probabilities;
  opts->x_flag_branch_target_load_optimize = ptr->x_flag_branch_target_load_optimize;
  opts->x_flag_branch_target_load_optimize2 = ptr->x_flag_branch_target_load_optimize2;
  opts->x_flag_btr_bb_exclusive = ptr->x_flag_btr_bb_exclusive;
  opts->x_flag_caller_saves = ptr->x_flag_caller_saves;
  opts->x_flag_combine_stack_adjustments = ptr->x_flag_combine_stack_adjustments;
  opts->x_flag_no_common = ptr->x_flag_no_common;
  opts->x_flag_compare_elim_after_reload = ptr->x_flag_compare_elim_after_reload;
  opts->x_flag_conserve_stack = ptr->x_flag_conserve_stack;
  opts->x_flag_cprop_registers = ptr->x_flag_cprop_registers;
  opts->x_flag_crossjumping = ptr->x_flag_crossjumping;
  opts->x_flag_cse_follow_jumps = ptr->x_flag_cse_follow_jumps;
  opts->x_flag_cx_fortran_rules = ptr->x_flag_cx_fortran_rules;
  opts->x_flag_cx_limited_range = ptr->x_flag_cx_limited_range;
  opts->x_flag_data_sections = ptr->x_flag_data_sections;
  opts->x_flag_dce = ptr->x_flag_dce;
  opts->x_flag_defer_pop = ptr->x_flag_defer_pop;
  opts->x_flag_delayed_branch = ptr->x_flag_delayed_branch;
  opts->x_flag_delete_null_pointer_checks = ptr->x_flag_delete_null_pointer_checks;
  opts->x_flag_devirtualize = ptr->x_flag_devirtualize;
  opts->x_flag_devirtualize_speculatively = ptr->x_flag_devirtualize_speculatively;
  opts->x_flag_dse = ptr->x_flag_dse;
  opts->x_flag_early_inlining = ptr->x_flag_early_inlining;
  opts->x_flag_exceptions = ptr->x_flag_exceptions;
  opts->x_flag_expensive_optimizations = ptr->x_flag_expensive_optimizations;
  opts->x_flag_finite_math_only = ptr->x_flag_finite_math_only;
  opts->x_flag_float_store = ptr->x_flag_float_store;
  opts->x_flag_forward_propagate = ptr->x_flag_forward_propagate;
  opts->x_flag_gcse = ptr->x_flag_gcse;
  opts->x_flag_gcse_after_reload = ptr->x_flag_gcse_after_reload;
  opts->x_flag_gcse_las = ptr->x_flag_gcse_las;
  opts->x_flag_gcse_lm = ptr->x_flag_gcse_lm;
  opts->x_flag_gcse_sm = ptr->x_flag_gcse_sm;
  opts->x_flag_graphite_identity = ptr->x_flag_graphite_identity;
  opts->x_flag_guess_branch_prob = ptr->x_flag_guess_branch_prob;
  opts->x_flag_hoist_adjacent_loads = ptr->x_flag_hoist_adjacent_loads;
  opts->x_flag_if_conversion = ptr->x_flag_if_conversion;
  opts->x_flag_if_conversion2 = ptr->x_flag_if_conversion2;
  opts->x_flag_no_inline = ptr->x_flag_no_inline;
  opts->x_flag_inline_atomics = ptr->x_flag_inline_atomics;
  opts->x_flag_inline_functions = ptr->x_flag_inline_functions;
  opts->x_flag_inline_functions_called_once = ptr->x_flag_inline_functions_called_once;
  opts->x_flag_inline_small_functions = ptr->x_flag_inline_small_functions;
  opts->x_flag_ipa_cp = ptr->x_flag_ipa_cp;
  opts->x_flag_ipa_cp_clone = ptr->x_flag_ipa_cp_clone;
  opts->x_flag_ipa_profile = ptr->x_flag_ipa_profile;
  opts->x_flag_ipa_pta = ptr->x_flag_ipa_pta;
  opts->x_flag_ipa_pure_const = ptr->x_flag_ipa_pure_const;
  opts->x_flag_ipa_reference = ptr->x_flag_ipa_reference;
  opts->x_flag_ipa_sra = ptr->x_flag_ipa_sra;
  opts->x_flag_ira_hoist_pressure = ptr->x_flag_ira_hoist_pressure;
  opts->x_flag_ira_loop_pressure = ptr->x_flag_ira_loop_pressure;
  opts->x_flag_isolate_erroneous_paths_attribute = ptr->x_flag_isolate_erroneous_paths_attribute;
  opts->x_flag_isolate_erroneous_paths_dereference = ptr->x_flag_isolate_erroneous_paths_dereference;
  opts->x_flag_ivopts = ptr->x_flag_ivopts;
  opts->x_flag_jump_tables = ptr->x_flag_jump_tables;
  opts->x_flag_live_range_shrinkage = ptr->x_flag_live_range_shrinkage;
  opts->x_flag_loop_block = ptr->x_flag_loop_block;
  opts->x_flag_loop_interchange = ptr->x_flag_loop_interchange;
  opts->x_flag_loop_optimize_isl = ptr->x_flag_loop_optimize_isl;
  opts->x_flag_loop_parallelize_all = ptr->x_flag_loop_parallelize_all;
  opts->x_flag_loop_strip_mine = ptr->x_flag_loop_strip_mine;
  opts->x_flag_errno_math = ptr->x_flag_errno_math;
  opts->x_flag_merge_constants = ptr->x_flag_merge_constants;
  opts->x_flag_modulo_sched = ptr->x_flag_modulo_sched;
  opts->x_flag_move_loop_invariants = ptr->x_flag_move_loop_invariants;
  opts->x_flag_non_call_exceptions = ptr->x_flag_non_call_exceptions;
  opts->x_flag_nothrow_opt = ptr->x_flag_nothrow_opt;
  opts->x_flag_omit_frame_pointer = ptr->x_flag_omit_frame_pointer;
  opts->x_flag_opt_info = ptr->x_flag_opt_info;
  opts->x_flag_optimize_sibling_calls = ptr->x_flag_optimize_sibling_calls;
  opts->x_flag_optimize_strlen = ptr->x_flag_optimize_strlen;
  opts->x_flag_pack_struct = ptr->x_flag_pack_struct;
  opts->x_flag_peel_loops = ptr->x_flag_peel_loops;
  opts->x_flag_no_peephole = ptr->x_flag_no_peephole;
  opts->x_flag_peephole2 = ptr->x_flag_peephole2;
  opts->x_flag_predictive_commoning = ptr->x_flag_predictive_commoning;
  opts->x_flag_prefetch_loop_arrays = ptr->x_flag_prefetch_loop_arrays;
  opts->x_flag_pcc_struct_return = ptr->x_flag_pcc_struct_return;
  opts->x_flag_rename_registers = ptr->x_flag_rename_registers;
  opts->x_flag_reorder_blocks = ptr->x_flag_reorder_blocks;
  opts->x_flag_reorder_blocks_and_partition = ptr->x_flag_reorder_blocks_and_partition;
  opts->x_flag_reorder_functions = ptr->x_flag_reorder_functions;
  opts->x_flag_rerun_cse_after_loop = ptr->x_flag_rerun_cse_after_loop;
  opts->x_flag_resched_modulo_sched = ptr->x_flag_resched_modulo_sched;
  opts->x_flag_rounding_math = ptr->x_flag_rounding_math;
  opts->x_flag_rtti = ptr->x_flag_rtti;
  opts->x_flag_sched_critical_path_heuristic = ptr->x_flag_sched_critical_path_heuristic;
  opts->x_flag_sched_dep_count_heuristic = ptr->x_flag_sched_dep_count_heuristic;
  opts->x_flag_sched_group_heuristic = ptr->x_flag_sched_group_heuristic;
  opts->x_flag_schedule_interblock = ptr->x_flag_schedule_interblock;
  opts->x_flag_sched_last_insn_heuristic = ptr->x_flag_sched_last_insn_heuristic;
  opts->x_flag_sched_pressure = ptr->x_flag_sched_pressure;
  opts->x_flag_sched_rank_heuristic = ptr->x_flag_sched_rank_heuristic;
  opts->x_flag_schedule_speculative = ptr->x_flag_schedule_speculative;
  opts->x_flag_sched_spec_insn_heuristic = ptr->x_flag_sched_spec_insn_heuristic;
  opts->x_flag_schedule_speculative_load = ptr->x_flag_schedule_speculative_load;
  opts->x_flag_schedule_speculative_load_dangerous = ptr->x_flag_schedule_speculative_load_dangerous;
  opts->x_flag_sched2_use_superblocks = ptr->x_flag_sched2_use_superblocks;
  opts->x_flag_schedule_insns = ptr->x_flag_schedule_insns;
  opts->x_flag_schedule_insns_after_reload = ptr->x_flag_schedule_insns_after_reload;
  opts->x_flag_section_anchors = ptr->x_flag_section_anchors;
  opts->x_flag_sel_sched_pipelining = ptr->x_flag_sel_sched_pipelining;
  opts->x_flag_sel_sched_pipelining_outer_loops = ptr->x_flag_sel_sched_pipelining_outer_loops;
  opts->x_flag_sel_sched_reschedule_pipelined = ptr->x_flag_sel_sched_reschedule_pipelined;
  opts->x_flag_selective_scheduling = ptr->x_flag_selective_scheduling;
  opts->x_flag_selective_scheduling2 = ptr->x_flag_selective_scheduling2;
  opts->x_flag_setstackexecutable = ptr->x_flag_setstackexecutable;
  opts->x_flag_short_double = ptr->x_flag_short_double;
  opts->x_flag_short_enums = ptr->x_flag_short_enums;
  opts->x_flag_short_wchar = ptr->x_flag_short_wchar;
  opts->x_flag_shrink_wrap = ptr->x_flag_shrink_wrap;
  opts->x_flag_signaling_nans = ptr->x_flag_signaling_nans;
  opts->x_flag_signed_zeros = ptr->x_flag_signed_zeros;
  opts->x_flag_single_precision_constant = ptr->x_flag_single_precision_constant;
  opts->x_flag_split_ivs_in_unroller = ptr->x_flag_split_ivs_in_unroller;
  opts->x_flag_split_wide_types = ptr->x_flag_split_wide_types;
  opts->x_flag_strict_aliasing = ptr->x_flag_strict_aliasing;
  opts->x_flag_strict_enums = ptr->x_flag_strict_enums;
  opts->x_flag_thread_jumps = ptr->x_flag_thread_jumps;
  opts->x_flag_threadsafe_statics = ptr->x_flag_threadsafe_statics;
  opts->x_flag_toplevel_reorder = ptr->x_flag_toplevel_reorder;
  opts->x_flag_trapping_math = ptr->x_flag_trapping_math;
  opts->x_flag_trapv = ptr->x_flag_trapv;
  opts->x_flag_tree_bit_ccp = ptr->x_flag_tree_bit_ccp;
  opts->x_flag_tree_builtin_call_dce = ptr->x_flag_tree_builtin_call_dce;
  opts->x_flag_tree_ccp = ptr->x_flag_tree_ccp;
  opts->x_flag_tree_ch = ptr->x_flag_tree_ch;
  opts->x_flag_ssa_coalesce_vars = ptr->x_flag_ssa_coalesce_vars;
  opts->x_flag_tree_copy_prop = ptr->x_flag_tree_copy_prop;
  opts->x_flag_tree_copyrename = ptr->x_flag_tree_copyrename;
  opts->x_flag_tree_cselim = ptr->x_flag_tree_cselim;
  opts->x_flag_tree_dce = ptr->x_flag_tree_dce;
  opts->x_flag_tree_dom = ptr->x_flag_tree_dom;
  opts->x_flag_tree_dse = ptr->x_flag_tree_dse;
  opts->x_flag_tree_forwprop = ptr->x_flag_tree_forwprop;
  opts->x_flag_tree_fre = ptr->x_flag_tree_fre;
  opts->x_flag_tree_loop_distribute_patterns = ptr->x_flag_tree_loop_distribute_patterns;
  opts->x_flag_tree_loop_distribution = ptr->x_flag_tree_loop_distribution;
  opts->x_flag_tree_loop_if_convert = ptr->x_flag_tree_loop_if_convert;
  opts->x_flag_tree_loop_if_convert_stores = ptr->x_flag_tree_loop_if_convert_stores;
  opts->x_flag_tree_loop_im = ptr->x_flag_tree_loop_im;
  opts->x_flag_tree_loop_ivcanon = ptr->x_flag_tree_loop_ivcanon;
  opts->x_flag_tree_loop_optimize = ptr->x_flag_tree_loop_optimize;
  opts->x_flag_tree_loop_vectorize = ptr->x_flag_tree_loop_vectorize;
  opts->x_flag_tree_live_range_split = ptr->x_flag_tree_live_range_split;
  opts->x_flag_tree_partial_pre = ptr->x_flag_tree_partial_pre;
  opts->x_flag_tree_phiprop = ptr->x_flag_tree_phiprop;
  opts->x_flag_tree_pre = ptr->x_flag_tree_pre;
  opts->x_flag_tree_pta = ptr->x_flag_tree_pta;
  opts->x_flag_tree_reassoc = ptr->x_flag_tree_reassoc;
  opts->x_flag_tree_scev_cprop = ptr->x_flag_tree_scev_cprop;
  opts->x_flag_tree_sink = ptr->x_flag_tree_sink;
  opts->x_flag_tree_slp_vectorize = ptr->x_flag_tree_slp_vectorize;
  opts->x_flag_tree_slsr = ptr->x_flag_tree_slsr;
  opts->x_flag_tree_sra = ptr->x_flag_tree_sra;
  opts->x_flag_tree_switch_conversion = ptr->x_flag_tree_switch_conversion;
  opts->x_flag_tree_tail_merge = ptr->x_flag_tree_tail_merge;
  opts->x_flag_tree_ter = ptr->x_flag_tree_ter;
  opts->x_flag_tree_vectorize = ptr->x_flag_tree_vectorize;
  opts->x_flag_tree_vrp = ptr->x_flag_tree_vrp;
  opts->x_flag_unit_at_a_time = ptr->x_flag_unit_at_a_time;
  opts->x_flag_unroll_all_loops = ptr->x_flag_unroll_all_loops;
  opts->x_flag_unroll_loops = ptr->x_flag_unroll_loops;
  opts->x_flag_unsafe_loop_optimizations = ptr->x_flag_unsafe_loop_optimizations;
  opts->x_flag_unsafe_math_optimizations = ptr->x_flag_unsafe_math_optimizations;
  opts->x_flag_unswitch_loops = ptr->x_flag_unswitch_loops;
  opts->x_flag_unwind_tables = ptr->x_flag_unwind_tables;
  opts->x_flag_var_tracking = ptr->x_flag_var_tracking;
  opts->x_flag_var_tracking_assignments = ptr->x_flag_var_tracking_assignments;
  opts->x_flag_var_tracking_assignments_toggle = ptr->x_flag_var_tracking_assignments_toggle;
  opts->x_flag_var_tracking_uninit = ptr->x_flag_var_tracking_uninit;
  opts->x_flag_variable_expansion_in_unroller = ptr->x_flag_variable_expansion_in_unroller;
  opts->x_flag_value_profile_transformations = ptr->x_flag_value_profile_transformations;
  opts->x_flag_web = ptr->x_flag_web;
  opts->x_flag_whole_program = ptr->x_flag_whole_program;
  opts->x_flag_wrapv = ptr->x_flag_wrapv;
  targetm.override_options_after_change ();
}

/* Print optimization options from a structure.  */
void
cl_optimization_print (FILE *file,
                       int indent_to,
                       struct cl_optimization *ptr)
{
  fputs ("\n", file);
  if (ptr->x_align_functions)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "align_functions",
             ptr->x_align_functions);

  if (ptr->x_align_jumps)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "align_jumps",
             ptr->x_align_jumps);

  if (ptr->x_align_labels)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "align_labels",
             ptr->x_align_labels);

  if (ptr->x_align_loops)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "align_loops",
             ptr->x_align_loops);

  if (ptr->x_flag_sched_stalled_insns)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sched_stalled_insns",
             ptr->x_flag_sched_stalled_insns);

  if (ptr->x_flag_sched_stalled_insns_dep)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sched_stalled_insns_dep",
             ptr->x_flag_sched_stalled_insns_dep);

  fprintf (file, "%*s%s (%#x)\n",
           indent_to, "",
           "flag_fp_contract_mode",
           (int) ptr->x_flag_fp_contract_mode);

  if (ptr->x_optimize)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "optimize",
             ptr->x_optimize);

  if (ptr->x_optimize_size)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "optimize_size",
             ptr->x_optimize_size);

  if (ptr->x_flag_aggressive_loop_optimizations)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_aggressive_loop_optimizations",
             ptr->x_flag_aggressive_loop_optimizations);

  if (ptr->x_flag_asynchronous_unwind_tables)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_asynchronous_unwind_tables",
             ptr->x_flag_asynchronous_unwind_tables);

  if (ptr->x_flag_branch_on_count_reg)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_branch_on_count_reg",
             ptr->x_flag_branch_on_count_reg);

  if (ptr->x_flag_branch_probabilities)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_branch_probabilities",
             ptr->x_flag_branch_probabilities);

  if (ptr->x_flag_branch_target_load_optimize)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_branch_target_load_optimize",
             ptr->x_flag_branch_target_load_optimize);

  if (ptr->x_flag_branch_target_load_optimize2)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_branch_target_load_optimize2",
             ptr->x_flag_branch_target_load_optimize2);

  if (ptr->x_flag_btr_bb_exclusive)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_btr_bb_exclusive",
             ptr->x_flag_btr_bb_exclusive);

  if (ptr->x_flag_caller_saves)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_caller_saves",
             ptr->x_flag_caller_saves);

  if (ptr->x_flag_combine_stack_adjustments)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_combine_stack_adjustments",
             ptr->x_flag_combine_stack_adjustments);

  if (ptr->x_flag_no_common)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_no_common",
             ptr->x_flag_no_common);

  if (ptr->x_flag_compare_elim_after_reload)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_compare_elim_after_reload",
             ptr->x_flag_compare_elim_after_reload);

  if (ptr->x_flag_conserve_stack)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_conserve_stack",
             ptr->x_flag_conserve_stack);

  if (ptr->x_flag_cprop_registers)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_cprop_registers",
             ptr->x_flag_cprop_registers);

  if (ptr->x_flag_crossjumping)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_crossjumping",
             ptr->x_flag_crossjumping);

  if (ptr->x_flag_cse_follow_jumps)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_cse_follow_jumps",
             ptr->x_flag_cse_follow_jumps);

  if (ptr->x_flag_cx_fortran_rules)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_cx_fortran_rules",
             ptr->x_flag_cx_fortran_rules);

  if (ptr->x_flag_cx_limited_range)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_cx_limited_range",
             ptr->x_flag_cx_limited_range);

  if (ptr->x_flag_data_sections)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_data_sections",
             ptr->x_flag_data_sections);

  if (ptr->x_flag_dce)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_dce",
             ptr->x_flag_dce);

  if (ptr->x_flag_defer_pop)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_defer_pop",
             ptr->x_flag_defer_pop);

  if (ptr->x_flag_delayed_branch)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_delayed_branch",
             ptr->x_flag_delayed_branch);

  if (ptr->x_flag_delete_null_pointer_checks)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_delete_null_pointer_checks",
             ptr->x_flag_delete_null_pointer_checks);

  if (ptr->x_flag_devirtualize)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_devirtualize",
             ptr->x_flag_devirtualize);

  if (ptr->x_flag_devirtualize_speculatively)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_devirtualize_speculatively",
             ptr->x_flag_devirtualize_speculatively);

  if (ptr->x_flag_dse)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_dse",
             ptr->x_flag_dse);

  if (ptr->x_flag_early_inlining)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_early_inlining",
             ptr->x_flag_early_inlining);

  if (ptr->x_flag_exceptions)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_exceptions",
             ptr->x_flag_exceptions);

  if (ptr->x_flag_expensive_optimizations)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_expensive_optimizations",
             ptr->x_flag_expensive_optimizations);

  if (ptr->x_flag_finite_math_only)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_finite_math_only",
             ptr->x_flag_finite_math_only);

  if (ptr->x_flag_float_store)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_float_store",
             ptr->x_flag_float_store);

  if (ptr->x_flag_forward_propagate)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_forward_propagate",
             ptr->x_flag_forward_propagate);

  if (ptr->x_flag_gcse)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_gcse",
             ptr->x_flag_gcse);

  if (ptr->x_flag_gcse_after_reload)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_gcse_after_reload",
             ptr->x_flag_gcse_after_reload);

  if (ptr->x_flag_gcse_las)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_gcse_las",
             ptr->x_flag_gcse_las);

  if (ptr->x_flag_gcse_lm)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_gcse_lm",
             ptr->x_flag_gcse_lm);

  if (ptr->x_flag_gcse_sm)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_gcse_sm",
             ptr->x_flag_gcse_sm);

  if (ptr->x_flag_graphite_identity)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_graphite_identity",
             ptr->x_flag_graphite_identity);

  if (ptr->x_flag_guess_branch_prob)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_guess_branch_prob",
             ptr->x_flag_guess_branch_prob);

  if (ptr->x_flag_hoist_adjacent_loads)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_hoist_adjacent_loads",
             ptr->x_flag_hoist_adjacent_loads);

  if (ptr->x_flag_if_conversion)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_if_conversion",
             ptr->x_flag_if_conversion);

  if (ptr->x_flag_if_conversion2)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_if_conversion2",
             ptr->x_flag_if_conversion2);

  if (ptr->x_flag_no_inline)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_no_inline",
             ptr->x_flag_no_inline);

  if (ptr->x_flag_inline_atomics)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_inline_atomics",
             ptr->x_flag_inline_atomics);

  if (ptr->x_flag_inline_functions)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_inline_functions",
             ptr->x_flag_inline_functions);

  if (ptr->x_flag_inline_functions_called_once)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_inline_functions_called_once",
             ptr->x_flag_inline_functions_called_once);

  if (ptr->x_flag_inline_small_functions)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_inline_small_functions",
             ptr->x_flag_inline_small_functions);

  if (ptr->x_flag_ipa_cp)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ipa_cp",
             ptr->x_flag_ipa_cp);

  if (ptr->x_flag_ipa_cp_clone)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ipa_cp_clone",
             ptr->x_flag_ipa_cp_clone);

  if (ptr->x_flag_ipa_profile)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ipa_profile",
             ptr->x_flag_ipa_profile);

  if (ptr->x_flag_ipa_pta)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ipa_pta",
             ptr->x_flag_ipa_pta);

  if (ptr->x_flag_ipa_pure_const)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ipa_pure_const",
             ptr->x_flag_ipa_pure_const);

  if (ptr->x_flag_ipa_reference)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ipa_reference",
             ptr->x_flag_ipa_reference);

  if (ptr->x_flag_ipa_sra)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ipa_sra",
             ptr->x_flag_ipa_sra);

  if (ptr->x_flag_ira_hoist_pressure)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ira_hoist_pressure",
             ptr->x_flag_ira_hoist_pressure);

  if (ptr->x_flag_ira_loop_pressure)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ira_loop_pressure",
             ptr->x_flag_ira_loop_pressure);

  if (ptr->x_flag_isolate_erroneous_paths_attribute)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_isolate_erroneous_paths_attribute",
             ptr->x_flag_isolate_erroneous_paths_attribute);

  if (ptr->x_flag_isolate_erroneous_paths_dereference)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_isolate_erroneous_paths_dereference",
             ptr->x_flag_isolate_erroneous_paths_dereference);

  if (ptr->x_flag_ivopts)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ivopts",
             ptr->x_flag_ivopts);

  if (ptr->x_flag_jump_tables)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_jump_tables",
             ptr->x_flag_jump_tables);

  if (ptr->x_flag_live_range_shrinkage)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_live_range_shrinkage",
             ptr->x_flag_live_range_shrinkage);

  if (ptr->x_flag_loop_block)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_loop_block",
             ptr->x_flag_loop_block);

  if (ptr->x_flag_loop_interchange)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_loop_interchange",
             ptr->x_flag_loop_interchange);

  if (ptr->x_flag_loop_optimize_isl)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_loop_optimize_isl",
             ptr->x_flag_loop_optimize_isl);

  if (ptr->x_flag_loop_parallelize_all)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_loop_parallelize_all",
             ptr->x_flag_loop_parallelize_all);

  if (ptr->x_flag_loop_strip_mine)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_loop_strip_mine",
             ptr->x_flag_loop_strip_mine);

  if (ptr->x_flag_errno_math)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_errno_math",
             ptr->x_flag_errno_math);

  if (ptr->x_flag_merge_constants)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_merge_constants",
             ptr->x_flag_merge_constants);

  if (ptr->x_flag_modulo_sched)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_modulo_sched",
             ptr->x_flag_modulo_sched);

  if (ptr->x_flag_move_loop_invariants)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_move_loop_invariants",
             ptr->x_flag_move_loop_invariants);

  if (ptr->x_flag_non_call_exceptions)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_non_call_exceptions",
             ptr->x_flag_non_call_exceptions);

  if (ptr->x_flag_nothrow_opt)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_nothrow_opt",
             ptr->x_flag_nothrow_opt);

  if (ptr->x_flag_omit_frame_pointer)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_omit_frame_pointer",
             ptr->x_flag_omit_frame_pointer);

  if (ptr->x_flag_opt_info)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_opt_info",
             ptr->x_flag_opt_info);

  if (ptr->x_flag_optimize_sibling_calls)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_optimize_sibling_calls",
             ptr->x_flag_optimize_sibling_calls);

  if (ptr->x_flag_optimize_strlen)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_optimize_strlen",
             ptr->x_flag_optimize_strlen);

  if (ptr->x_flag_pack_struct)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_pack_struct",
             ptr->x_flag_pack_struct);

  if (ptr->x_flag_peel_loops)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_peel_loops",
             ptr->x_flag_peel_loops);

  if (ptr->x_flag_no_peephole)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_no_peephole",
             ptr->x_flag_no_peephole);

  if (ptr->x_flag_peephole2)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_peephole2",
             ptr->x_flag_peephole2);

  if (ptr->x_flag_predictive_commoning)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_predictive_commoning",
             ptr->x_flag_predictive_commoning);

  if (ptr->x_flag_prefetch_loop_arrays)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_prefetch_loop_arrays",
             ptr->x_flag_prefetch_loop_arrays);

  if (ptr->x_flag_pcc_struct_return)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_pcc_struct_return",
             ptr->x_flag_pcc_struct_return);

  if (ptr->x_flag_rename_registers)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_rename_registers",
             ptr->x_flag_rename_registers);

  if (ptr->x_flag_reorder_blocks)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_reorder_blocks",
             ptr->x_flag_reorder_blocks);

  if (ptr->x_flag_reorder_blocks_and_partition)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_reorder_blocks_and_partition",
             ptr->x_flag_reorder_blocks_and_partition);

  if (ptr->x_flag_reorder_functions)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_reorder_functions",
             ptr->x_flag_reorder_functions);

  if (ptr->x_flag_rerun_cse_after_loop)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_rerun_cse_after_loop",
             ptr->x_flag_rerun_cse_after_loop);

  if (ptr->x_flag_resched_modulo_sched)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_resched_modulo_sched",
             ptr->x_flag_resched_modulo_sched);

  if (ptr->x_flag_rounding_math)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_rounding_math",
             ptr->x_flag_rounding_math);

  if (ptr->x_flag_rtti)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_rtti",
             ptr->x_flag_rtti);

  if (ptr->x_flag_sched_critical_path_heuristic)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sched_critical_path_heuristic",
             ptr->x_flag_sched_critical_path_heuristic);

  if (ptr->x_flag_sched_dep_count_heuristic)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sched_dep_count_heuristic",
             ptr->x_flag_sched_dep_count_heuristic);

  if (ptr->x_flag_sched_group_heuristic)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sched_group_heuristic",
             ptr->x_flag_sched_group_heuristic);

  if (ptr->x_flag_schedule_interblock)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_schedule_interblock",
             ptr->x_flag_schedule_interblock);

  if (ptr->x_flag_sched_last_insn_heuristic)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sched_last_insn_heuristic",
             ptr->x_flag_sched_last_insn_heuristic);

  if (ptr->x_flag_sched_pressure)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sched_pressure",
             ptr->x_flag_sched_pressure);

  if (ptr->x_flag_sched_rank_heuristic)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sched_rank_heuristic",
             ptr->x_flag_sched_rank_heuristic);

  if (ptr->x_flag_schedule_speculative)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_schedule_speculative",
             ptr->x_flag_schedule_speculative);

  if (ptr->x_flag_sched_spec_insn_heuristic)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sched_spec_insn_heuristic",
             ptr->x_flag_sched_spec_insn_heuristic);

  if (ptr->x_flag_schedule_speculative_load)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_schedule_speculative_load",
             ptr->x_flag_schedule_speculative_load);

  if (ptr->x_flag_schedule_speculative_load_dangerous)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_schedule_speculative_load_dangerous",
             ptr->x_flag_schedule_speculative_load_dangerous);

  if (ptr->x_flag_sched2_use_superblocks)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sched2_use_superblocks",
             ptr->x_flag_sched2_use_superblocks);

  if (ptr->x_flag_schedule_insns)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_schedule_insns",
             ptr->x_flag_schedule_insns);

  if (ptr->x_flag_schedule_insns_after_reload)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_schedule_insns_after_reload",
             ptr->x_flag_schedule_insns_after_reload);

  if (ptr->x_flag_section_anchors)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_section_anchors",
             ptr->x_flag_section_anchors);

  if (ptr->x_flag_sel_sched_pipelining)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sel_sched_pipelining",
             ptr->x_flag_sel_sched_pipelining);

  if (ptr->x_flag_sel_sched_pipelining_outer_loops)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sel_sched_pipelining_outer_loops",
             ptr->x_flag_sel_sched_pipelining_outer_loops);

  if (ptr->x_flag_sel_sched_reschedule_pipelined)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_sel_sched_reschedule_pipelined",
             ptr->x_flag_sel_sched_reschedule_pipelined);

  if (ptr->x_flag_selective_scheduling)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_selective_scheduling",
             ptr->x_flag_selective_scheduling);

  if (ptr->x_flag_selective_scheduling2)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_selective_scheduling2",
             ptr->x_flag_selective_scheduling2);

  if (ptr->x_flag_setstackexecutable)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_setstackexecutable",
             ptr->x_flag_setstackexecutable);

  if (ptr->x_flag_short_double)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_short_double",
             ptr->x_flag_short_double);

  if (ptr->x_flag_short_enums)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_short_enums",
             ptr->x_flag_short_enums);

  if (ptr->x_flag_short_wchar)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_short_wchar",
             ptr->x_flag_short_wchar);

  if (ptr->x_flag_shrink_wrap)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_shrink_wrap",
             ptr->x_flag_shrink_wrap);

  if (ptr->x_flag_signaling_nans)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_signaling_nans",
             ptr->x_flag_signaling_nans);

  if (ptr->x_flag_signed_zeros)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_signed_zeros",
             ptr->x_flag_signed_zeros);

  if (ptr->x_flag_single_precision_constant)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_single_precision_constant",
             ptr->x_flag_single_precision_constant);

  if (ptr->x_flag_split_ivs_in_unroller)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_split_ivs_in_unroller",
             ptr->x_flag_split_ivs_in_unroller);

  if (ptr->x_flag_split_wide_types)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_split_wide_types",
             ptr->x_flag_split_wide_types);

  if (ptr->x_flag_strict_aliasing)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_strict_aliasing",
             ptr->x_flag_strict_aliasing);

  if (ptr->x_flag_strict_enums)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_strict_enums",
             ptr->x_flag_strict_enums);

  if (ptr->x_flag_thread_jumps)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_thread_jumps",
             ptr->x_flag_thread_jumps);

  if (ptr->x_flag_threadsafe_statics)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_threadsafe_statics",
             ptr->x_flag_threadsafe_statics);

  if (ptr->x_flag_toplevel_reorder)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_toplevel_reorder",
             ptr->x_flag_toplevel_reorder);

  if (ptr->x_flag_trapping_math)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_trapping_math",
             ptr->x_flag_trapping_math);

  if (ptr->x_flag_trapv)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_trapv",
             ptr->x_flag_trapv);

  if (ptr->x_flag_tree_bit_ccp)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_bit_ccp",
             ptr->x_flag_tree_bit_ccp);

  if (ptr->x_flag_tree_builtin_call_dce)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_builtin_call_dce",
             ptr->x_flag_tree_builtin_call_dce);

  if (ptr->x_flag_tree_ccp)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_ccp",
             ptr->x_flag_tree_ccp);

  if (ptr->x_flag_tree_ch)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_ch",
             ptr->x_flag_tree_ch);

  if (ptr->x_flag_ssa_coalesce_vars)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ssa_coalesce_vars",
             ptr->x_flag_ssa_coalesce_vars);

  if (ptr->x_flag_tree_copy_prop)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_copy_prop",
             ptr->x_flag_tree_copy_prop);

  if (ptr->x_flag_tree_copyrename)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_copyrename",
             ptr->x_flag_tree_copyrename);

  if (ptr->x_flag_tree_cselim)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_cselim",
             ptr->x_flag_tree_cselim);

  if (ptr->x_flag_tree_dce)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_dce",
             ptr->x_flag_tree_dce);

  if (ptr->x_flag_tree_dom)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_dom",
             ptr->x_flag_tree_dom);

  if (ptr->x_flag_tree_dse)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_dse",
             ptr->x_flag_tree_dse);

  if (ptr->x_flag_tree_forwprop)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_forwprop",
             ptr->x_flag_tree_forwprop);

  if (ptr->x_flag_tree_fre)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_fre",
             ptr->x_flag_tree_fre);

  if (ptr->x_flag_tree_loop_distribute_patterns)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_loop_distribute_patterns",
             ptr->x_flag_tree_loop_distribute_patterns);

  if (ptr->x_flag_tree_loop_distribution)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_loop_distribution",
             ptr->x_flag_tree_loop_distribution);

  if (ptr->x_flag_tree_loop_if_convert)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_loop_if_convert",
             ptr->x_flag_tree_loop_if_convert);

  if (ptr->x_flag_tree_loop_if_convert_stores)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_loop_if_convert_stores",
             ptr->x_flag_tree_loop_if_convert_stores);

  if (ptr->x_flag_tree_loop_im)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_loop_im",
             ptr->x_flag_tree_loop_im);

  if (ptr->x_flag_tree_loop_ivcanon)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_loop_ivcanon",
             ptr->x_flag_tree_loop_ivcanon);

  if (ptr->x_flag_tree_loop_optimize)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_loop_optimize",
             ptr->x_flag_tree_loop_optimize);

  if (ptr->x_flag_tree_loop_vectorize)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_loop_vectorize",
             ptr->x_flag_tree_loop_vectorize);

  if (ptr->x_flag_tree_live_range_split)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_live_range_split",
             ptr->x_flag_tree_live_range_split);

  if (ptr->x_flag_tree_partial_pre)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_partial_pre",
             ptr->x_flag_tree_partial_pre);

  if (ptr->x_flag_tree_phiprop)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_phiprop",
             ptr->x_flag_tree_phiprop);

  if (ptr->x_flag_tree_pre)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_pre",
             ptr->x_flag_tree_pre);

  if (ptr->x_flag_tree_pta)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_pta",
             ptr->x_flag_tree_pta);

  if (ptr->x_flag_tree_reassoc)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_reassoc",
             ptr->x_flag_tree_reassoc);

  if (ptr->x_flag_tree_scev_cprop)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_scev_cprop",
             ptr->x_flag_tree_scev_cprop);

  if (ptr->x_flag_tree_sink)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_sink",
             ptr->x_flag_tree_sink);

  if (ptr->x_flag_tree_slp_vectorize)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_slp_vectorize",
             ptr->x_flag_tree_slp_vectorize);

  if (ptr->x_flag_tree_slsr)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_slsr",
             ptr->x_flag_tree_slsr);

  if (ptr->x_flag_tree_sra)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_sra",
             ptr->x_flag_tree_sra);

  if (ptr->x_flag_tree_switch_conversion)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_switch_conversion",
             ptr->x_flag_tree_switch_conversion);

  if (ptr->x_flag_tree_tail_merge)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_tail_merge",
             ptr->x_flag_tree_tail_merge);

  if (ptr->x_flag_tree_ter)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_ter",
             ptr->x_flag_tree_ter);

  if (ptr->x_flag_tree_vectorize)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_vectorize",
             ptr->x_flag_tree_vectorize);

  if (ptr->x_flag_tree_vrp)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_vrp",
             ptr->x_flag_tree_vrp);

  if (ptr->x_flag_unit_at_a_time)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_unit_at_a_time",
             ptr->x_flag_unit_at_a_time);

  if (ptr->x_flag_unroll_all_loops)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_unroll_all_loops",
             ptr->x_flag_unroll_all_loops);

  if (ptr->x_flag_unroll_loops)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_unroll_loops",
             ptr->x_flag_unroll_loops);

  if (ptr->x_flag_unsafe_loop_optimizations)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_unsafe_loop_optimizations",
             ptr->x_flag_unsafe_loop_optimizations);

  if (ptr->x_flag_unsafe_math_optimizations)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_unsafe_math_optimizations",
             ptr->x_flag_unsafe_math_optimizations);

  if (ptr->x_flag_unswitch_loops)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_unswitch_loops",
             ptr->x_flag_unswitch_loops);

  if (ptr->x_flag_unwind_tables)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_unwind_tables",
             ptr->x_flag_unwind_tables);

  if (ptr->x_flag_var_tracking)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_var_tracking",
             ptr->x_flag_var_tracking);

  if (ptr->x_flag_var_tracking_assignments)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_var_tracking_assignments",
             ptr->x_flag_var_tracking_assignments);

  if (ptr->x_flag_var_tracking_assignments_toggle)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_var_tracking_assignments_toggle",
             ptr->x_flag_var_tracking_assignments_toggle);

  if (ptr->x_flag_var_tracking_uninit)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_var_tracking_uninit",
             ptr->x_flag_var_tracking_uninit);

  if (ptr->x_flag_variable_expansion_in_unroller)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_variable_expansion_in_unroller",
             ptr->x_flag_variable_expansion_in_unroller);

  if (ptr->x_flag_value_profile_transformations)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_value_profile_transformations",
             ptr->x_flag_value_profile_transformations);

  if (ptr->x_flag_web)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_web",
             ptr->x_flag_web);

  if (ptr->x_flag_whole_program)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_whole_program",
             ptr->x_flag_whole_program);

  if (ptr->x_flag_wrapv)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_wrapv",
             ptr->x_flag_wrapv);

}

/* Save selected option variables into a structure.  */
void
cl_target_option_save (struct cl_target_option *ptr, struct gcc_options *opts)
{
  if (targetm.target_option.save)
    targetm.target_option.save (ptr, opts);

  ptr->x_recip_mask = opts->x_recip_mask;
  ptr->x_ix86_isa_flags = opts->x_ix86_isa_flags;
  ptr->x_ix86_fpmath = opts->x_ix86_fpmath;
  ptr->x_target_flags = opts->x_target_flags;
}

/* Restore selected current options from a structure.  */
void
cl_target_option_restore (struct gcc_options *opts, struct cl_target_option *ptr)
{
  opts->x_recip_mask = ptr->x_recip_mask;
  opts->x_ix86_isa_flags = ptr->x_ix86_isa_flags;
  opts->x_ix86_fpmath = ptr->x_ix86_fpmath;
  opts->x_target_flags = ptr->x_target_flags;

  if (targetm.target_option.restore)
    targetm.target_option.restore (opts, ptr);
}

/* Print optimization options from a structure.  */
void
cl_target_option_print (FILE *file,
                        int indent,
                        struct cl_target_option *ptr)
{
  fputs ("\n", file);
  if (ptr->x_ix86_isa_flags)
    fprintf (file, "%*s%s (%#" HOST_WIDE_INT_PRINT "x)\n",
             indent, "",
             "ix86_isa_flags",
             ptr->x_ix86_isa_flags);

  if (ptr->x_ix86_fpmath)
    fprintf (file, "%*s%s (%#x)\n",
             indent, "",
             "ix86_fpmath",
             ptr->x_ix86_fpmath);

  if (ptr->x_target_flags)
    fprintf (file, "%*s%s (%#x)\n",
             indent, "",
             "target_flags",
             ptr->x_target_flags);


  if (targetm.target_option.print)
    targetm.target_option.print (file, indent, ptr);
}
