/* 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 "inchash.h"
#include "hash-set.h"
#include "machmode.h"
#include "vec.h"
#include "double-int.h"
#include "input.h"
#include "alias.h"
#include "symtab.h"
#include "wide-int.h"
#include "inchash.h"
#include "tree.h"
#include "fold-const.h"
#include "tree-ssa-alias.h"
#include "is-a.h"
#include "predict.h"
#include "function.h"
#include "basic-block.h"
#include "gimple-expr.h"
#include "gimple.h"
#include "data-streamer.h"
#include "ipa-ref.h"
#include "cgraph.h"

#include "cpplib.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, 1));
  gcc_assert (IN_RANGE (opts->x_optimize_debug, 0, 1));
  gcc_assert (IN_RANGE (opts->x_flag_aggressive_loop_optimizations, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_associative_math, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_asynchronous_unwind_tables, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_auto_inc_dec, -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_code_hoisting, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_combine_stack_adjustments, -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_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_dead_exceptions, -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_fp_int_builtin_inexact, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_no_function_cse, -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, -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_indirect_inlining, -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_bit_cp, -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_icf, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ipa_icf_functions, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ipa_icf_variables, -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_ra, -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_ipa_vrp, -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_ira_share_save_slots, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ira_share_spill_slots, -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_keep_gc_roots_live, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_lifetime_dse, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_limit_function_alignment, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_live_range_shrinkage, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_loop_nest_optimize, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_loop_parallelize_all, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_lra_remat, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_errno_math, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_modulo_sched, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_modulo_sched_allow_regmoves, -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_partial_inlining, -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_plt, -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_printf_return_value, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_reciprocal_math, -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_fusion, -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_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_shrink_wrap_separate, -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_loops, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_split_paths, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_split_wide_types, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ssa_backprop, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_ssa_phiopt, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_stack_protect, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_stdarg_opt, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_store_merging, -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_strict_overflow, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_strict_volatile_bitfields, -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_tracer, -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_tree_coalesce_vars, -128, 127));
  gcc_assert (IN_RANGE (opts->x_flag_tree_copy_prop, -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_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_unconstrained_commons, -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_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_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_tree_parallelize_loops = opts->x_flag_tree_parallelize_loops;
  ptr->x_flag_fp_contract_mode = opts->x_flag_fp_contract_mode;
  ptr->x_flag_ira_algorithm = opts->x_flag_ira_algorithm;
  ptr->x_flag_ira_region = opts->x_flag_ira_region;
  ptr->x_flag_reorder_blocks_algorithm = opts->x_flag_reorder_blocks_algorithm;
  ptr->x_flag_simd_cost_model = opts->x_flag_simd_cost_model;
  ptr->x_flag_stack_reuse = opts->x_flag_stack_reuse;
  ptr->x_flag_vect_cost_model = opts->x_flag_vect_cost_model;
  ptr->x_optimize = opts->x_optimize;
  ptr->x_optimize_size = opts->x_optimize_size;
  ptr->x_optimize_debug = opts->x_optimize_debug;
  ptr->x_flag_aggressive_loop_optimizations = opts->x_flag_aggressive_loop_optimizations;
  ptr->x_flag_associative_math = opts->x_flag_associative_math;
  ptr->x_flag_asynchronous_unwind_tables = opts->x_flag_asynchronous_unwind_tables;
  ptr->x_flag_auto_inc_dec = opts->x_flag_auto_inc_dec;
  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_code_hoisting = opts->x_flag_code_hoisting;
  ptr->x_flag_combine_stack_adjustments = opts->x_flag_combine_stack_adjustments;
  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_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_dead_exceptions = opts->x_flag_delete_dead_exceptions;
  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_fp_int_builtin_inexact = opts->x_flag_fp_int_builtin_inexact;
  ptr->x_flag_no_function_cse = opts->x_flag_no_function_cse;
  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 = opts->x_flag_graphite;
  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_indirect_inlining = opts->x_flag_indirect_inlining;
  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_bit_cp = opts->x_flag_ipa_bit_cp;
  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_icf = opts->x_flag_ipa_icf;
  ptr->x_flag_ipa_icf_functions = opts->x_flag_ipa_icf_functions;
  ptr->x_flag_ipa_icf_variables = opts->x_flag_ipa_icf_variables;
  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_ra = opts->x_flag_ipa_ra;
  ptr->x_flag_ipa_reference = opts->x_flag_ipa_reference;
  ptr->x_flag_ipa_sra = opts->x_flag_ipa_sra;
  ptr->x_flag_ipa_vrp = opts->x_flag_ipa_vrp;
  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_ira_share_save_slots = opts->x_flag_ira_share_save_slots;
  ptr->x_flag_ira_share_spill_slots = opts->x_flag_ira_share_spill_slots;
  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_keep_gc_roots_live = opts->x_flag_keep_gc_roots_live;
  ptr->x_flag_lifetime_dse = opts->x_flag_lifetime_dse;
  ptr->x_flag_limit_function_alignment = opts->x_flag_limit_function_alignment;
  ptr->x_flag_live_range_shrinkage = opts->x_flag_live_range_shrinkage;
  ptr->x_flag_loop_nest_optimize = opts->x_flag_loop_nest_optimize;
  ptr->x_flag_loop_parallelize_all = opts->x_flag_loop_parallelize_all;
  ptr->x_flag_lra_remat = opts->x_flag_lra_remat;
  ptr->x_flag_errno_math = opts->x_flag_errno_math;
  ptr->x_flag_modulo_sched = opts->x_flag_modulo_sched;
  ptr->x_flag_modulo_sched_allow_regmoves = opts->x_flag_modulo_sched_allow_regmoves;
  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_partial_inlining = opts->x_flag_partial_inlining;
  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_plt = opts->x_flag_plt;
  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_printf_return_value = opts->x_flag_printf_return_value;
  ptr->x_flag_reciprocal_math = opts->x_flag_reciprocal_math;
  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_fusion = opts->x_flag_schedule_fusion;
  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_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_shrink_wrap_separate = opts->x_flag_shrink_wrap_separate;
  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_loops = opts->x_flag_split_loops;
  ptr->x_flag_split_paths = opts->x_flag_split_paths;
  ptr->x_flag_split_wide_types = opts->x_flag_split_wide_types;
  ptr->x_flag_ssa_backprop = opts->x_flag_ssa_backprop;
  ptr->x_flag_ssa_phiopt = opts->x_flag_ssa_phiopt;
  ptr->x_flag_stack_protect = opts->x_flag_stack_protect;
  ptr->x_flag_stdarg_opt = opts->x_flag_stdarg_opt;
  ptr->x_flag_store_merging = opts->x_flag_store_merging;
  ptr->x_flag_strict_aliasing = opts->x_flag_strict_aliasing;
  ptr->x_flag_strict_enums = opts->x_flag_strict_enums;
  ptr->x_flag_strict_overflow = opts->x_flag_strict_overflow;
  ptr->x_flag_strict_volatile_bitfields = opts->x_flag_strict_volatile_bitfields;
  ptr->x_flag_thread_jumps = opts->x_flag_thread_jumps;
  ptr->x_flag_threadsafe_statics = opts->x_flag_threadsafe_statics;
  ptr->x_flag_tracer = opts->x_flag_tracer;
  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_tree_coalesce_vars = opts->x_flag_tree_coalesce_vars;
  ptr->x_flag_tree_copy_prop = opts->x_flag_tree_copy_prop;
  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_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_unconstrained_commons = opts->x_flag_unconstrained_commons;
  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_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_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_tree_parallelize_loops = ptr->x_flag_tree_parallelize_loops;
  opts->x_flag_fp_contract_mode = ptr->x_flag_fp_contract_mode;
  opts->x_flag_ira_algorithm = ptr->x_flag_ira_algorithm;
  opts->x_flag_ira_region = ptr->x_flag_ira_region;
  opts->x_flag_reorder_blocks_algorithm = ptr->x_flag_reorder_blocks_algorithm;
  opts->x_flag_simd_cost_model = ptr->x_flag_simd_cost_model;
  opts->x_flag_stack_reuse = ptr->x_flag_stack_reuse;
  opts->x_flag_vect_cost_model = ptr->x_flag_vect_cost_model;
  opts->x_optimize = ptr->x_optimize;
  opts->x_optimize_size = ptr->x_optimize_size;
  opts->x_optimize_debug = ptr->x_optimize_debug;
  opts->x_flag_aggressive_loop_optimizations = ptr->x_flag_aggressive_loop_optimizations;
  opts->x_flag_associative_math = ptr->x_flag_associative_math;
  opts->x_flag_asynchronous_unwind_tables = ptr->x_flag_asynchronous_unwind_tables;
  opts->x_flag_auto_inc_dec = ptr->x_flag_auto_inc_dec;
  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_code_hoisting = ptr->x_flag_code_hoisting;
  opts->x_flag_combine_stack_adjustments = ptr->x_flag_combine_stack_adjustments;
  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_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_dead_exceptions = ptr->x_flag_delete_dead_exceptions;
  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_fp_int_builtin_inexact = ptr->x_flag_fp_int_builtin_inexact;
  opts->x_flag_no_function_cse = ptr->x_flag_no_function_cse;
  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 = ptr->x_flag_graphite;
  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_indirect_inlining = ptr->x_flag_indirect_inlining;
  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_bit_cp = ptr->x_flag_ipa_bit_cp;
  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_icf = ptr->x_flag_ipa_icf;
  opts->x_flag_ipa_icf_functions = ptr->x_flag_ipa_icf_functions;
  opts->x_flag_ipa_icf_variables = ptr->x_flag_ipa_icf_variables;
  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_ra = ptr->x_flag_ipa_ra;
  opts->x_flag_ipa_reference = ptr->x_flag_ipa_reference;
  opts->x_flag_ipa_sra = ptr->x_flag_ipa_sra;
  opts->x_flag_ipa_vrp = ptr->x_flag_ipa_vrp;
  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_ira_share_save_slots = ptr->x_flag_ira_share_save_slots;
  opts->x_flag_ira_share_spill_slots = ptr->x_flag_ira_share_spill_slots;
  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_keep_gc_roots_live = ptr->x_flag_keep_gc_roots_live;
  opts->x_flag_lifetime_dse = ptr->x_flag_lifetime_dse;
  opts->x_flag_limit_function_alignment = ptr->x_flag_limit_function_alignment;
  opts->x_flag_live_range_shrinkage = ptr->x_flag_live_range_shrinkage;
  opts->x_flag_loop_nest_optimize = ptr->x_flag_loop_nest_optimize;
  opts->x_flag_loop_parallelize_all = ptr->x_flag_loop_parallelize_all;
  opts->x_flag_lra_remat = ptr->x_flag_lra_remat;
  opts->x_flag_errno_math = ptr->x_flag_errno_math;
  opts->x_flag_modulo_sched = ptr->x_flag_modulo_sched;
  opts->x_flag_modulo_sched_allow_regmoves = ptr->x_flag_modulo_sched_allow_regmoves;
  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_partial_inlining = ptr->x_flag_partial_inlining;
  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_plt = ptr->x_flag_plt;
  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_printf_return_value = ptr->x_flag_printf_return_value;
  opts->x_flag_reciprocal_math = ptr->x_flag_reciprocal_math;
  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_fusion = ptr->x_flag_schedule_fusion;
  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_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_shrink_wrap_separate = ptr->x_flag_shrink_wrap_separate;
  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_loops = ptr->x_flag_split_loops;
  opts->x_flag_split_paths = ptr->x_flag_split_paths;
  opts->x_flag_split_wide_types = ptr->x_flag_split_wide_types;
  opts->x_flag_ssa_backprop = ptr->x_flag_ssa_backprop;
  opts->x_flag_ssa_phiopt = ptr->x_flag_ssa_phiopt;
  opts->x_flag_stack_protect = ptr->x_flag_stack_protect;
  opts->x_flag_stdarg_opt = ptr->x_flag_stdarg_opt;
  opts->x_flag_store_merging = ptr->x_flag_store_merging;
  opts->x_flag_strict_aliasing = ptr->x_flag_strict_aliasing;
  opts->x_flag_strict_enums = ptr->x_flag_strict_enums;
  opts->x_flag_strict_overflow = ptr->x_flag_strict_overflow;
  opts->x_flag_strict_volatile_bitfields = ptr->x_flag_strict_volatile_bitfields;
  opts->x_flag_thread_jumps = ptr->x_flag_thread_jumps;
  opts->x_flag_threadsafe_statics = ptr->x_flag_threadsafe_statics;
  opts->x_flag_tracer = ptr->x_flag_tracer;
  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_tree_coalesce_vars = ptr->x_flag_tree_coalesce_vars;
  opts->x_flag_tree_copy_prop = ptr->x_flag_tree_copy_prop;
  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_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_unconstrained_commons = ptr->x_flag_unconstrained_commons;
  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_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_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);

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

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

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

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

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

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

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

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

  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_optimize_debug)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "optimize_debug",
             ptr->x_optimize_debug);

  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_associative_math)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_associative_math",
             ptr->x_flag_associative_math);

  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_auto_inc_dec)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_auto_inc_dec",
             ptr->x_flag_auto_inc_dec);

  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_code_hoisting)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_code_hoisting",
             ptr->x_flag_code_hoisting);

  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_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_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_dead_exceptions)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_delete_dead_exceptions",
             ptr->x_flag_delete_dead_exceptions);

  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_fp_int_builtin_inexact)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_fp_int_builtin_inexact",
             ptr->x_flag_fp_int_builtin_inexact);

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

  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)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_graphite",
             ptr->x_flag_graphite);

  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_indirect_inlining)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_indirect_inlining",
             ptr->x_flag_indirect_inlining);

  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_bit_cp)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ipa_bit_cp",
             ptr->x_flag_ipa_bit_cp);

  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_icf)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ipa_icf",
             ptr->x_flag_ipa_icf);

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

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

  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_ra)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ipa_ra",
             ptr->x_flag_ipa_ra);

  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_ipa_vrp)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ipa_vrp",
             ptr->x_flag_ipa_vrp);

  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_ira_share_save_slots)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ira_share_save_slots",
             ptr->x_flag_ira_share_save_slots);

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

  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_keep_gc_roots_live)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_keep_gc_roots_live",
             ptr->x_flag_keep_gc_roots_live);

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

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

  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_nest_optimize)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_loop_nest_optimize",
             ptr->x_flag_loop_nest_optimize);

  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_lra_remat)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_lra_remat",
             ptr->x_flag_lra_remat);

  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_modulo_sched)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_modulo_sched",
             ptr->x_flag_modulo_sched);

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

  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_partial_inlining)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_partial_inlining",
             ptr->x_flag_partial_inlining);

  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_plt)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_plt",
             ptr->x_flag_plt);

  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_printf_return_value)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_printf_return_value",
             ptr->x_flag_printf_return_value);

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

  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_fusion)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_schedule_fusion",
             ptr->x_flag_schedule_fusion);

  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_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_shrink_wrap_separate)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_shrink_wrap_separate",
             ptr->x_flag_shrink_wrap_separate);

  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_loops)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_split_loops",
             ptr->x_flag_split_loops);

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

  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_ssa_backprop)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_ssa_backprop",
             ptr->x_flag_ssa_backprop);

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

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

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

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

  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_strict_overflow)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_strict_overflow",
             ptr->x_flag_strict_overflow);

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

  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_tracer)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tracer",
             ptr->x_flag_tracer);

  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_tree_coalesce_vars)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_tree_coalesce_vars",
             ptr->x_flag_tree_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_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_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_unconstrained_commons)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_unconstrained_commons",
             ptr->x_flag_unconstrained_commons);

  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_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_wrapv)
    fprintf (file, "%*s%s (%#x)\n",
             indent_to, "",
             "flag_wrapv",
             ptr->x_flag_wrapv);

}

/* Print different optimization variables from structures provided as arguments.  */
void
cl_optimization_print_diff (FILE *file,
                            int indent_to,
                            struct cl_optimization *ptr1,
                            struct cl_optimization *ptr2)
{
  fputs ("\n", file);
  if (ptr1->x_align_functions != ptr2->x_align_functions)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "align_functions",
             ptr1->x_align_functions,
             ptr2->x_align_functions);

  if (ptr1->x_align_jumps != ptr2->x_align_jumps)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "align_jumps",
             ptr1->x_align_jumps,
             ptr2->x_align_jumps);

  if (ptr1->x_align_labels != ptr2->x_align_labels)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "align_labels",
             ptr1->x_align_labels,
             ptr2->x_align_labels);

  if (ptr1->x_align_loops != ptr2->x_align_loops)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "align_loops",
             ptr1->x_align_loops,
             ptr2->x_align_loops);

  if (ptr1->x_flag_sched_stalled_insns != ptr2->x_flag_sched_stalled_insns)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sched_stalled_insns",
             ptr1->x_flag_sched_stalled_insns,
             ptr2->x_flag_sched_stalled_insns);

  if (ptr1->x_flag_sched_stalled_insns_dep != ptr2->x_flag_sched_stalled_insns_dep)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sched_stalled_insns_dep",
             ptr1->x_flag_sched_stalled_insns_dep,
             ptr2->x_flag_sched_stalled_insns_dep);

  if (ptr1->x_flag_tree_parallelize_loops != ptr2->x_flag_tree_parallelize_loops)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_parallelize_loops",
             ptr1->x_flag_tree_parallelize_loops,
             ptr2->x_flag_tree_parallelize_loops);

  if (ptr1->x_flag_fp_contract_mode != ptr2->x_flag_fp_contract_mode)
  fprintf (file, "%*s%s (%#x/%#x)\n",
           indent_to, "",
           "flag_fp_contract_mode",
           (int) ptr1->x_flag_fp_contract_mode,
           (int) ptr2->x_flag_fp_contract_mode);

  if (ptr1->x_flag_ira_algorithm != ptr2->x_flag_ira_algorithm)
  fprintf (file, "%*s%s (%#x/%#x)\n",
           indent_to, "",
           "flag_ira_algorithm",
           (int) ptr1->x_flag_ira_algorithm,
           (int) ptr2->x_flag_ira_algorithm);

  if (ptr1->x_flag_ira_region != ptr2->x_flag_ira_region)
  fprintf (file, "%*s%s (%#x/%#x)\n",
           indent_to, "",
           "flag_ira_region",
           (int) ptr1->x_flag_ira_region,
           (int) ptr2->x_flag_ira_region);

  if (ptr1->x_flag_reorder_blocks_algorithm != ptr2->x_flag_reorder_blocks_algorithm)
  fprintf (file, "%*s%s (%#x/%#x)\n",
           indent_to, "",
           "flag_reorder_blocks_algorithm",
           (int) ptr1->x_flag_reorder_blocks_algorithm,
           (int) ptr2->x_flag_reorder_blocks_algorithm);

  if (ptr1->x_flag_simd_cost_model != ptr2->x_flag_simd_cost_model)
  fprintf (file, "%*s%s (%#x/%#x)\n",
           indent_to, "",
           "flag_simd_cost_model",
           (int) ptr1->x_flag_simd_cost_model,
           (int) ptr2->x_flag_simd_cost_model);

  if (ptr1->x_flag_stack_reuse != ptr2->x_flag_stack_reuse)
  fprintf (file, "%*s%s (%#x/%#x)\n",
           indent_to, "",
           "flag_stack_reuse",
           (int) ptr1->x_flag_stack_reuse,
           (int) ptr2->x_flag_stack_reuse);

  if (ptr1->x_flag_vect_cost_model != ptr2->x_flag_vect_cost_model)
  fprintf (file, "%*s%s (%#x/%#x)\n",
           indent_to, "",
           "flag_vect_cost_model",
           (int) ptr1->x_flag_vect_cost_model,
           (int) ptr2->x_flag_vect_cost_model);

  if (ptr1->x_optimize != ptr2->x_optimize)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "optimize",
             ptr1->x_optimize,
             ptr2->x_optimize);

  if (ptr1->x_optimize_size != ptr2->x_optimize_size)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "optimize_size",
             ptr1->x_optimize_size,
             ptr2->x_optimize_size);

  if (ptr1->x_optimize_debug != ptr2->x_optimize_debug)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "optimize_debug",
             ptr1->x_optimize_debug,
             ptr2->x_optimize_debug);

  if (ptr1->x_flag_aggressive_loop_optimizations != ptr2->x_flag_aggressive_loop_optimizations)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_aggressive_loop_optimizations",
             ptr1->x_flag_aggressive_loop_optimizations,
             ptr2->x_flag_aggressive_loop_optimizations);

  if (ptr1->x_flag_associative_math != ptr2->x_flag_associative_math)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_associative_math",
             ptr1->x_flag_associative_math,
             ptr2->x_flag_associative_math);

  if (ptr1->x_flag_asynchronous_unwind_tables != ptr2->x_flag_asynchronous_unwind_tables)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_asynchronous_unwind_tables",
             ptr1->x_flag_asynchronous_unwind_tables,
             ptr2->x_flag_asynchronous_unwind_tables);

  if (ptr1->x_flag_auto_inc_dec != ptr2->x_flag_auto_inc_dec)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_auto_inc_dec",
             ptr1->x_flag_auto_inc_dec,
             ptr2->x_flag_auto_inc_dec);

  if (ptr1->x_flag_branch_on_count_reg != ptr2->x_flag_branch_on_count_reg)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_branch_on_count_reg",
             ptr1->x_flag_branch_on_count_reg,
             ptr2->x_flag_branch_on_count_reg);

  if (ptr1->x_flag_branch_probabilities != ptr2->x_flag_branch_probabilities)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_branch_probabilities",
             ptr1->x_flag_branch_probabilities,
             ptr2->x_flag_branch_probabilities);

  if (ptr1->x_flag_branch_target_load_optimize != ptr2->x_flag_branch_target_load_optimize)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_branch_target_load_optimize",
             ptr1->x_flag_branch_target_load_optimize,
             ptr2->x_flag_branch_target_load_optimize);

  if (ptr1->x_flag_branch_target_load_optimize2 != ptr2->x_flag_branch_target_load_optimize2)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_branch_target_load_optimize2",
             ptr1->x_flag_branch_target_load_optimize2,
             ptr2->x_flag_branch_target_load_optimize2);

  if (ptr1->x_flag_btr_bb_exclusive != ptr2->x_flag_btr_bb_exclusive)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_btr_bb_exclusive",
             ptr1->x_flag_btr_bb_exclusive,
             ptr2->x_flag_btr_bb_exclusive);

  if (ptr1->x_flag_caller_saves != ptr2->x_flag_caller_saves)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_caller_saves",
             ptr1->x_flag_caller_saves,
             ptr2->x_flag_caller_saves);

  if (ptr1->x_flag_code_hoisting != ptr2->x_flag_code_hoisting)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_code_hoisting",
             ptr1->x_flag_code_hoisting,
             ptr2->x_flag_code_hoisting);

  if (ptr1->x_flag_combine_stack_adjustments != ptr2->x_flag_combine_stack_adjustments)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_combine_stack_adjustments",
             ptr1->x_flag_combine_stack_adjustments,
             ptr2->x_flag_combine_stack_adjustments);

  if (ptr1->x_flag_compare_elim_after_reload != ptr2->x_flag_compare_elim_after_reload)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_compare_elim_after_reload",
             ptr1->x_flag_compare_elim_after_reload,
             ptr2->x_flag_compare_elim_after_reload);

  if (ptr1->x_flag_conserve_stack != ptr2->x_flag_conserve_stack)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_conserve_stack",
             ptr1->x_flag_conserve_stack,
             ptr2->x_flag_conserve_stack);

  if (ptr1->x_flag_cprop_registers != ptr2->x_flag_cprop_registers)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_cprop_registers",
             ptr1->x_flag_cprop_registers,
             ptr2->x_flag_cprop_registers);

  if (ptr1->x_flag_crossjumping != ptr2->x_flag_crossjumping)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_crossjumping",
             ptr1->x_flag_crossjumping,
             ptr2->x_flag_crossjumping);

  if (ptr1->x_flag_cse_follow_jumps != ptr2->x_flag_cse_follow_jumps)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_cse_follow_jumps",
             ptr1->x_flag_cse_follow_jumps,
             ptr2->x_flag_cse_follow_jumps);

  if (ptr1->x_flag_cx_fortran_rules != ptr2->x_flag_cx_fortran_rules)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_cx_fortran_rules",
             ptr1->x_flag_cx_fortran_rules,
             ptr2->x_flag_cx_fortran_rules);

  if (ptr1->x_flag_cx_limited_range != ptr2->x_flag_cx_limited_range)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_cx_limited_range",
             ptr1->x_flag_cx_limited_range,
             ptr2->x_flag_cx_limited_range);

  if (ptr1->x_flag_dce != ptr2->x_flag_dce)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_dce",
             ptr1->x_flag_dce,
             ptr2->x_flag_dce);

  if (ptr1->x_flag_defer_pop != ptr2->x_flag_defer_pop)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_defer_pop",
             ptr1->x_flag_defer_pop,
             ptr2->x_flag_defer_pop);

  if (ptr1->x_flag_delayed_branch != ptr2->x_flag_delayed_branch)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_delayed_branch",
             ptr1->x_flag_delayed_branch,
             ptr2->x_flag_delayed_branch);

  if (ptr1->x_flag_delete_dead_exceptions != ptr2->x_flag_delete_dead_exceptions)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_delete_dead_exceptions",
             ptr1->x_flag_delete_dead_exceptions,
             ptr2->x_flag_delete_dead_exceptions);

  if (ptr1->x_flag_delete_null_pointer_checks != ptr2->x_flag_delete_null_pointer_checks)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_delete_null_pointer_checks",
             ptr1->x_flag_delete_null_pointer_checks,
             ptr2->x_flag_delete_null_pointer_checks);

  if (ptr1->x_flag_devirtualize != ptr2->x_flag_devirtualize)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_devirtualize",
             ptr1->x_flag_devirtualize,
             ptr2->x_flag_devirtualize);

  if (ptr1->x_flag_devirtualize_speculatively != ptr2->x_flag_devirtualize_speculatively)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_devirtualize_speculatively",
             ptr1->x_flag_devirtualize_speculatively,
             ptr2->x_flag_devirtualize_speculatively);

  if (ptr1->x_flag_dse != ptr2->x_flag_dse)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_dse",
             ptr1->x_flag_dse,
             ptr2->x_flag_dse);

  if (ptr1->x_flag_early_inlining != ptr2->x_flag_early_inlining)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_early_inlining",
             ptr1->x_flag_early_inlining,
             ptr2->x_flag_early_inlining);

  if (ptr1->x_flag_exceptions != ptr2->x_flag_exceptions)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_exceptions",
             ptr1->x_flag_exceptions,
             ptr2->x_flag_exceptions);

  if (ptr1->x_flag_expensive_optimizations != ptr2->x_flag_expensive_optimizations)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_expensive_optimizations",
             ptr1->x_flag_expensive_optimizations,
             ptr2->x_flag_expensive_optimizations);

  if (ptr1->x_flag_finite_math_only != ptr2->x_flag_finite_math_only)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_finite_math_only",
             ptr1->x_flag_finite_math_only,
             ptr2->x_flag_finite_math_only);

  if (ptr1->x_flag_float_store != ptr2->x_flag_float_store)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_float_store",
             ptr1->x_flag_float_store,
             ptr2->x_flag_float_store);

  if (ptr1->x_flag_forward_propagate != ptr2->x_flag_forward_propagate)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_forward_propagate",
             ptr1->x_flag_forward_propagate,
             ptr2->x_flag_forward_propagate);

  if (ptr1->x_flag_fp_int_builtin_inexact != ptr2->x_flag_fp_int_builtin_inexact)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_fp_int_builtin_inexact",
             ptr1->x_flag_fp_int_builtin_inexact,
             ptr2->x_flag_fp_int_builtin_inexact);

  if (ptr1->x_flag_no_function_cse != ptr2->x_flag_no_function_cse)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_no_function_cse",
             ptr1->x_flag_no_function_cse,
             ptr2->x_flag_no_function_cse);

  if (ptr1->x_flag_gcse != ptr2->x_flag_gcse)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_gcse",
             ptr1->x_flag_gcse,
             ptr2->x_flag_gcse);

  if (ptr1->x_flag_gcse_after_reload != ptr2->x_flag_gcse_after_reload)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_gcse_after_reload",
             ptr1->x_flag_gcse_after_reload,
             ptr2->x_flag_gcse_after_reload);

  if (ptr1->x_flag_gcse_las != ptr2->x_flag_gcse_las)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_gcse_las",
             ptr1->x_flag_gcse_las,
             ptr2->x_flag_gcse_las);

  if (ptr1->x_flag_gcse_lm != ptr2->x_flag_gcse_lm)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_gcse_lm",
             ptr1->x_flag_gcse_lm,
             ptr2->x_flag_gcse_lm);

  if (ptr1->x_flag_gcse_sm != ptr2->x_flag_gcse_sm)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_gcse_sm",
             ptr1->x_flag_gcse_sm,
             ptr2->x_flag_gcse_sm);

  if (ptr1->x_flag_graphite != ptr2->x_flag_graphite)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_graphite",
             ptr1->x_flag_graphite,
             ptr2->x_flag_graphite);

  if (ptr1->x_flag_graphite_identity != ptr2->x_flag_graphite_identity)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_graphite_identity",
             ptr1->x_flag_graphite_identity,
             ptr2->x_flag_graphite_identity);

  if (ptr1->x_flag_guess_branch_prob != ptr2->x_flag_guess_branch_prob)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_guess_branch_prob",
             ptr1->x_flag_guess_branch_prob,
             ptr2->x_flag_guess_branch_prob);

  if (ptr1->x_flag_hoist_adjacent_loads != ptr2->x_flag_hoist_adjacent_loads)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_hoist_adjacent_loads",
             ptr1->x_flag_hoist_adjacent_loads,
             ptr2->x_flag_hoist_adjacent_loads);

  if (ptr1->x_flag_if_conversion != ptr2->x_flag_if_conversion)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_if_conversion",
             ptr1->x_flag_if_conversion,
             ptr2->x_flag_if_conversion);

  if (ptr1->x_flag_if_conversion2 != ptr2->x_flag_if_conversion2)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_if_conversion2",
             ptr1->x_flag_if_conversion2,
             ptr2->x_flag_if_conversion2);

  if (ptr1->x_flag_indirect_inlining != ptr2->x_flag_indirect_inlining)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_indirect_inlining",
             ptr1->x_flag_indirect_inlining,
             ptr2->x_flag_indirect_inlining);

  if (ptr1->x_flag_no_inline != ptr2->x_flag_no_inline)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_no_inline",
             ptr1->x_flag_no_inline,
             ptr2->x_flag_no_inline);

  if (ptr1->x_flag_inline_atomics != ptr2->x_flag_inline_atomics)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_inline_atomics",
             ptr1->x_flag_inline_atomics,
             ptr2->x_flag_inline_atomics);

  if (ptr1->x_flag_inline_functions != ptr2->x_flag_inline_functions)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_inline_functions",
             ptr1->x_flag_inline_functions,
             ptr2->x_flag_inline_functions);

  if (ptr1->x_flag_inline_functions_called_once != ptr2->x_flag_inline_functions_called_once)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_inline_functions_called_once",
             ptr1->x_flag_inline_functions_called_once,
             ptr2->x_flag_inline_functions_called_once);

  if (ptr1->x_flag_inline_small_functions != ptr2->x_flag_inline_small_functions)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_inline_small_functions",
             ptr1->x_flag_inline_small_functions,
             ptr2->x_flag_inline_small_functions);

  if (ptr1->x_flag_ipa_bit_cp != ptr2->x_flag_ipa_bit_cp)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_bit_cp",
             ptr1->x_flag_ipa_bit_cp,
             ptr2->x_flag_ipa_bit_cp);

  if (ptr1->x_flag_ipa_cp != ptr2->x_flag_ipa_cp)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_cp",
             ptr1->x_flag_ipa_cp,
             ptr2->x_flag_ipa_cp);

  if (ptr1->x_flag_ipa_cp_clone != ptr2->x_flag_ipa_cp_clone)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_cp_clone",
             ptr1->x_flag_ipa_cp_clone,
             ptr2->x_flag_ipa_cp_clone);

  if (ptr1->x_flag_ipa_icf != ptr2->x_flag_ipa_icf)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_icf",
             ptr1->x_flag_ipa_icf,
             ptr2->x_flag_ipa_icf);

  if (ptr1->x_flag_ipa_icf_functions != ptr2->x_flag_ipa_icf_functions)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_icf_functions",
             ptr1->x_flag_ipa_icf_functions,
             ptr2->x_flag_ipa_icf_functions);

  if (ptr1->x_flag_ipa_icf_variables != ptr2->x_flag_ipa_icf_variables)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_icf_variables",
             ptr1->x_flag_ipa_icf_variables,
             ptr2->x_flag_ipa_icf_variables);

  if (ptr1->x_flag_ipa_profile != ptr2->x_flag_ipa_profile)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_profile",
             ptr1->x_flag_ipa_profile,
             ptr2->x_flag_ipa_profile);

  if (ptr1->x_flag_ipa_pta != ptr2->x_flag_ipa_pta)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_pta",
             ptr1->x_flag_ipa_pta,
             ptr2->x_flag_ipa_pta);

  if (ptr1->x_flag_ipa_pure_const != ptr2->x_flag_ipa_pure_const)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_pure_const",
             ptr1->x_flag_ipa_pure_const,
             ptr2->x_flag_ipa_pure_const);

  if (ptr1->x_flag_ipa_ra != ptr2->x_flag_ipa_ra)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_ra",
             ptr1->x_flag_ipa_ra,
             ptr2->x_flag_ipa_ra);

  if (ptr1->x_flag_ipa_reference != ptr2->x_flag_ipa_reference)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_reference",
             ptr1->x_flag_ipa_reference,
             ptr2->x_flag_ipa_reference);

  if (ptr1->x_flag_ipa_sra != ptr2->x_flag_ipa_sra)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_sra",
             ptr1->x_flag_ipa_sra,
             ptr2->x_flag_ipa_sra);

  if (ptr1->x_flag_ipa_vrp != ptr2->x_flag_ipa_vrp)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ipa_vrp",
             ptr1->x_flag_ipa_vrp,
             ptr2->x_flag_ipa_vrp);

  if (ptr1->x_flag_ira_hoist_pressure != ptr2->x_flag_ira_hoist_pressure)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ira_hoist_pressure",
             ptr1->x_flag_ira_hoist_pressure,
             ptr2->x_flag_ira_hoist_pressure);

  if (ptr1->x_flag_ira_loop_pressure != ptr2->x_flag_ira_loop_pressure)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ira_loop_pressure",
             ptr1->x_flag_ira_loop_pressure,
             ptr2->x_flag_ira_loop_pressure);

  if (ptr1->x_flag_ira_share_save_slots != ptr2->x_flag_ira_share_save_slots)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ira_share_save_slots",
             ptr1->x_flag_ira_share_save_slots,
             ptr2->x_flag_ira_share_save_slots);

  if (ptr1->x_flag_ira_share_spill_slots != ptr2->x_flag_ira_share_spill_slots)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ira_share_spill_slots",
             ptr1->x_flag_ira_share_spill_slots,
             ptr2->x_flag_ira_share_spill_slots);

  if (ptr1->x_flag_isolate_erroneous_paths_attribute != ptr2->x_flag_isolate_erroneous_paths_attribute)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_isolate_erroneous_paths_attribute",
             ptr1->x_flag_isolate_erroneous_paths_attribute,
             ptr2->x_flag_isolate_erroneous_paths_attribute);

  if (ptr1->x_flag_isolate_erroneous_paths_dereference != ptr2->x_flag_isolate_erroneous_paths_dereference)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_isolate_erroneous_paths_dereference",
             ptr1->x_flag_isolate_erroneous_paths_dereference,
             ptr2->x_flag_isolate_erroneous_paths_dereference);

  if (ptr1->x_flag_ivopts != ptr2->x_flag_ivopts)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ivopts",
             ptr1->x_flag_ivopts,
             ptr2->x_flag_ivopts);

  if (ptr1->x_flag_jump_tables != ptr2->x_flag_jump_tables)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_jump_tables",
             ptr1->x_flag_jump_tables,
             ptr2->x_flag_jump_tables);

  if (ptr1->x_flag_keep_gc_roots_live != ptr2->x_flag_keep_gc_roots_live)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_keep_gc_roots_live",
             ptr1->x_flag_keep_gc_roots_live,
             ptr2->x_flag_keep_gc_roots_live);

  if (ptr1->x_flag_lifetime_dse != ptr2->x_flag_lifetime_dse)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_lifetime_dse",
             ptr1->x_flag_lifetime_dse,
             ptr2->x_flag_lifetime_dse);

  if (ptr1->x_flag_limit_function_alignment != ptr2->x_flag_limit_function_alignment)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_limit_function_alignment",
             ptr1->x_flag_limit_function_alignment,
             ptr2->x_flag_limit_function_alignment);

  if (ptr1->x_flag_live_range_shrinkage != ptr2->x_flag_live_range_shrinkage)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_live_range_shrinkage",
             ptr1->x_flag_live_range_shrinkage,
             ptr2->x_flag_live_range_shrinkage);

  if (ptr1->x_flag_loop_nest_optimize != ptr2->x_flag_loop_nest_optimize)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_loop_nest_optimize",
             ptr1->x_flag_loop_nest_optimize,
             ptr2->x_flag_loop_nest_optimize);

  if (ptr1->x_flag_loop_parallelize_all != ptr2->x_flag_loop_parallelize_all)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_loop_parallelize_all",
             ptr1->x_flag_loop_parallelize_all,
             ptr2->x_flag_loop_parallelize_all);

  if (ptr1->x_flag_lra_remat != ptr2->x_flag_lra_remat)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_lra_remat",
             ptr1->x_flag_lra_remat,
             ptr2->x_flag_lra_remat);

  if (ptr1->x_flag_errno_math != ptr2->x_flag_errno_math)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_errno_math",
             ptr1->x_flag_errno_math,
             ptr2->x_flag_errno_math);

  if (ptr1->x_flag_modulo_sched != ptr2->x_flag_modulo_sched)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_modulo_sched",
             ptr1->x_flag_modulo_sched,
             ptr2->x_flag_modulo_sched);

  if (ptr1->x_flag_modulo_sched_allow_regmoves != ptr2->x_flag_modulo_sched_allow_regmoves)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_modulo_sched_allow_regmoves",
             ptr1->x_flag_modulo_sched_allow_regmoves,
             ptr2->x_flag_modulo_sched_allow_regmoves);

  if (ptr1->x_flag_move_loop_invariants != ptr2->x_flag_move_loop_invariants)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_move_loop_invariants",
             ptr1->x_flag_move_loop_invariants,
             ptr2->x_flag_move_loop_invariants);

  if (ptr1->x_flag_non_call_exceptions != ptr2->x_flag_non_call_exceptions)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_non_call_exceptions",
             ptr1->x_flag_non_call_exceptions,
             ptr2->x_flag_non_call_exceptions);

  if (ptr1->x_flag_nothrow_opt != ptr2->x_flag_nothrow_opt)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_nothrow_opt",
             ptr1->x_flag_nothrow_opt,
             ptr2->x_flag_nothrow_opt);

  if (ptr1->x_flag_omit_frame_pointer != ptr2->x_flag_omit_frame_pointer)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_omit_frame_pointer",
             ptr1->x_flag_omit_frame_pointer,
             ptr2->x_flag_omit_frame_pointer);

  if (ptr1->x_flag_opt_info != ptr2->x_flag_opt_info)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_opt_info",
             ptr1->x_flag_opt_info,
             ptr2->x_flag_opt_info);

  if (ptr1->x_flag_optimize_sibling_calls != ptr2->x_flag_optimize_sibling_calls)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_optimize_sibling_calls",
             ptr1->x_flag_optimize_sibling_calls,
             ptr2->x_flag_optimize_sibling_calls);

  if (ptr1->x_flag_optimize_strlen != ptr2->x_flag_optimize_strlen)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_optimize_strlen",
             ptr1->x_flag_optimize_strlen,
             ptr2->x_flag_optimize_strlen);

  if (ptr1->x_flag_pack_struct != ptr2->x_flag_pack_struct)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_pack_struct",
             ptr1->x_flag_pack_struct,
             ptr2->x_flag_pack_struct);

  if (ptr1->x_flag_partial_inlining != ptr2->x_flag_partial_inlining)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_partial_inlining",
             ptr1->x_flag_partial_inlining,
             ptr2->x_flag_partial_inlining);

  if (ptr1->x_flag_peel_loops != ptr2->x_flag_peel_loops)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_peel_loops",
             ptr1->x_flag_peel_loops,
             ptr2->x_flag_peel_loops);

  if (ptr1->x_flag_no_peephole != ptr2->x_flag_no_peephole)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_no_peephole",
             ptr1->x_flag_no_peephole,
             ptr2->x_flag_no_peephole);

  if (ptr1->x_flag_peephole2 != ptr2->x_flag_peephole2)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_peephole2",
             ptr1->x_flag_peephole2,
             ptr2->x_flag_peephole2);

  if (ptr1->x_flag_plt != ptr2->x_flag_plt)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_plt",
             ptr1->x_flag_plt,
             ptr2->x_flag_plt);

  if (ptr1->x_flag_predictive_commoning != ptr2->x_flag_predictive_commoning)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_predictive_commoning",
             ptr1->x_flag_predictive_commoning,
             ptr2->x_flag_predictive_commoning);

  if (ptr1->x_flag_prefetch_loop_arrays != ptr2->x_flag_prefetch_loop_arrays)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_prefetch_loop_arrays",
             ptr1->x_flag_prefetch_loop_arrays,
             ptr2->x_flag_prefetch_loop_arrays);

  if (ptr1->x_flag_printf_return_value != ptr2->x_flag_printf_return_value)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_printf_return_value",
             ptr1->x_flag_printf_return_value,
             ptr2->x_flag_printf_return_value);

  if (ptr1->x_flag_reciprocal_math != ptr2->x_flag_reciprocal_math)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_reciprocal_math",
             ptr1->x_flag_reciprocal_math,
             ptr2->x_flag_reciprocal_math);

  if (ptr1->x_flag_pcc_struct_return != ptr2->x_flag_pcc_struct_return)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_pcc_struct_return",
             ptr1->x_flag_pcc_struct_return,
             ptr2->x_flag_pcc_struct_return);

  if (ptr1->x_flag_rename_registers != ptr2->x_flag_rename_registers)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_rename_registers",
             ptr1->x_flag_rename_registers,
             ptr2->x_flag_rename_registers);

  if (ptr1->x_flag_reorder_blocks != ptr2->x_flag_reorder_blocks)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_reorder_blocks",
             ptr1->x_flag_reorder_blocks,
             ptr2->x_flag_reorder_blocks);

  if (ptr1->x_flag_reorder_blocks_and_partition != ptr2->x_flag_reorder_blocks_and_partition)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_reorder_blocks_and_partition",
             ptr1->x_flag_reorder_blocks_and_partition,
             ptr2->x_flag_reorder_blocks_and_partition);

  if (ptr1->x_flag_reorder_functions != ptr2->x_flag_reorder_functions)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_reorder_functions",
             ptr1->x_flag_reorder_functions,
             ptr2->x_flag_reorder_functions);

  if (ptr1->x_flag_rerun_cse_after_loop != ptr2->x_flag_rerun_cse_after_loop)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_rerun_cse_after_loop",
             ptr1->x_flag_rerun_cse_after_loop,
             ptr2->x_flag_rerun_cse_after_loop);

  if (ptr1->x_flag_resched_modulo_sched != ptr2->x_flag_resched_modulo_sched)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_resched_modulo_sched",
             ptr1->x_flag_resched_modulo_sched,
             ptr2->x_flag_resched_modulo_sched);

  if (ptr1->x_flag_rounding_math != ptr2->x_flag_rounding_math)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_rounding_math",
             ptr1->x_flag_rounding_math,
             ptr2->x_flag_rounding_math);

  if (ptr1->x_flag_rtti != ptr2->x_flag_rtti)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_rtti",
             ptr1->x_flag_rtti,
             ptr2->x_flag_rtti);

  if (ptr1->x_flag_sched_critical_path_heuristic != ptr2->x_flag_sched_critical_path_heuristic)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sched_critical_path_heuristic",
             ptr1->x_flag_sched_critical_path_heuristic,
             ptr2->x_flag_sched_critical_path_heuristic);

  if (ptr1->x_flag_sched_dep_count_heuristic != ptr2->x_flag_sched_dep_count_heuristic)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sched_dep_count_heuristic",
             ptr1->x_flag_sched_dep_count_heuristic,
             ptr2->x_flag_sched_dep_count_heuristic);

  if (ptr1->x_flag_sched_group_heuristic != ptr2->x_flag_sched_group_heuristic)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sched_group_heuristic",
             ptr1->x_flag_sched_group_heuristic,
             ptr2->x_flag_sched_group_heuristic);

  if (ptr1->x_flag_schedule_interblock != ptr2->x_flag_schedule_interblock)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_schedule_interblock",
             ptr1->x_flag_schedule_interblock,
             ptr2->x_flag_schedule_interblock);

  if (ptr1->x_flag_sched_last_insn_heuristic != ptr2->x_flag_sched_last_insn_heuristic)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sched_last_insn_heuristic",
             ptr1->x_flag_sched_last_insn_heuristic,
             ptr2->x_flag_sched_last_insn_heuristic);

  if (ptr1->x_flag_sched_pressure != ptr2->x_flag_sched_pressure)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sched_pressure",
             ptr1->x_flag_sched_pressure,
             ptr2->x_flag_sched_pressure);

  if (ptr1->x_flag_sched_rank_heuristic != ptr2->x_flag_sched_rank_heuristic)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sched_rank_heuristic",
             ptr1->x_flag_sched_rank_heuristic,
             ptr2->x_flag_sched_rank_heuristic);

  if (ptr1->x_flag_schedule_speculative != ptr2->x_flag_schedule_speculative)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_schedule_speculative",
             ptr1->x_flag_schedule_speculative,
             ptr2->x_flag_schedule_speculative);

  if (ptr1->x_flag_sched_spec_insn_heuristic != ptr2->x_flag_sched_spec_insn_heuristic)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sched_spec_insn_heuristic",
             ptr1->x_flag_sched_spec_insn_heuristic,
             ptr2->x_flag_sched_spec_insn_heuristic);

  if (ptr1->x_flag_schedule_speculative_load != ptr2->x_flag_schedule_speculative_load)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_schedule_speculative_load",
             ptr1->x_flag_schedule_speculative_load,
             ptr2->x_flag_schedule_speculative_load);

  if (ptr1->x_flag_schedule_speculative_load_dangerous != ptr2->x_flag_schedule_speculative_load_dangerous)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_schedule_speculative_load_dangerous",
             ptr1->x_flag_schedule_speculative_load_dangerous,
             ptr2->x_flag_schedule_speculative_load_dangerous);

  if (ptr1->x_flag_sched2_use_superblocks != ptr2->x_flag_sched2_use_superblocks)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sched2_use_superblocks",
             ptr1->x_flag_sched2_use_superblocks,
             ptr2->x_flag_sched2_use_superblocks);

  if (ptr1->x_flag_schedule_fusion != ptr2->x_flag_schedule_fusion)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_schedule_fusion",
             ptr1->x_flag_schedule_fusion,
             ptr2->x_flag_schedule_fusion);

  if (ptr1->x_flag_schedule_insns != ptr2->x_flag_schedule_insns)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_schedule_insns",
             ptr1->x_flag_schedule_insns,
             ptr2->x_flag_schedule_insns);

  if (ptr1->x_flag_schedule_insns_after_reload != ptr2->x_flag_schedule_insns_after_reload)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_schedule_insns_after_reload",
             ptr1->x_flag_schedule_insns_after_reload,
             ptr2->x_flag_schedule_insns_after_reload);

  if (ptr1->x_flag_section_anchors != ptr2->x_flag_section_anchors)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_section_anchors",
             ptr1->x_flag_section_anchors,
             ptr2->x_flag_section_anchors);

  if (ptr1->x_flag_sel_sched_pipelining != ptr2->x_flag_sel_sched_pipelining)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sel_sched_pipelining",
             ptr1->x_flag_sel_sched_pipelining,
             ptr2->x_flag_sel_sched_pipelining);

  if (ptr1->x_flag_sel_sched_pipelining_outer_loops != ptr2->x_flag_sel_sched_pipelining_outer_loops)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sel_sched_pipelining_outer_loops",
             ptr1->x_flag_sel_sched_pipelining_outer_loops,
             ptr2->x_flag_sel_sched_pipelining_outer_loops);

  if (ptr1->x_flag_sel_sched_reschedule_pipelined != ptr2->x_flag_sel_sched_reschedule_pipelined)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_sel_sched_reschedule_pipelined",
             ptr1->x_flag_sel_sched_reschedule_pipelined,
             ptr2->x_flag_sel_sched_reschedule_pipelined);

  if (ptr1->x_flag_selective_scheduling != ptr2->x_flag_selective_scheduling)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_selective_scheduling",
             ptr1->x_flag_selective_scheduling,
             ptr2->x_flag_selective_scheduling);

  if (ptr1->x_flag_selective_scheduling2 != ptr2->x_flag_selective_scheduling2)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_selective_scheduling2",
             ptr1->x_flag_selective_scheduling2,
             ptr2->x_flag_selective_scheduling2);

  if (ptr1->x_flag_setstackexecutable != ptr2->x_flag_setstackexecutable)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_setstackexecutable",
             ptr1->x_flag_setstackexecutable,
             ptr2->x_flag_setstackexecutable);

  if (ptr1->x_flag_short_enums != ptr2->x_flag_short_enums)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_short_enums",
             ptr1->x_flag_short_enums,
             ptr2->x_flag_short_enums);

  if (ptr1->x_flag_short_wchar != ptr2->x_flag_short_wchar)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_short_wchar",
             ptr1->x_flag_short_wchar,
             ptr2->x_flag_short_wchar);

  if (ptr1->x_flag_shrink_wrap != ptr2->x_flag_shrink_wrap)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_shrink_wrap",
             ptr1->x_flag_shrink_wrap,
             ptr2->x_flag_shrink_wrap);

  if (ptr1->x_flag_shrink_wrap_separate != ptr2->x_flag_shrink_wrap_separate)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_shrink_wrap_separate",
             ptr1->x_flag_shrink_wrap_separate,
             ptr2->x_flag_shrink_wrap_separate);

  if (ptr1->x_flag_signaling_nans != ptr2->x_flag_signaling_nans)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_signaling_nans",
             ptr1->x_flag_signaling_nans,
             ptr2->x_flag_signaling_nans);

  if (ptr1->x_flag_signed_zeros != ptr2->x_flag_signed_zeros)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_signed_zeros",
             ptr1->x_flag_signed_zeros,
             ptr2->x_flag_signed_zeros);

  if (ptr1->x_flag_single_precision_constant != ptr2->x_flag_single_precision_constant)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_single_precision_constant",
             ptr1->x_flag_single_precision_constant,
             ptr2->x_flag_single_precision_constant);

  if (ptr1->x_flag_split_ivs_in_unroller != ptr2->x_flag_split_ivs_in_unroller)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_split_ivs_in_unroller",
             ptr1->x_flag_split_ivs_in_unroller,
             ptr2->x_flag_split_ivs_in_unroller);

  if (ptr1->x_flag_split_loops != ptr2->x_flag_split_loops)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_split_loops",
             ptr1->x_flag_split_loops,
             ptr2->x_flag_split_loops);

  if (ptr1->x_flag_split_paths != ptr2->x_flag_split_paths)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_split_paths",
             ptr1->x_flag_split_paths,
             ptr2->x_flag_split_paths);

  if (ptr1->x_flag_split_wide_types != ptr2->x_flag_split_wide_types)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_split_wide_types",
             ptr1->x_flag_split_wide_types,
             ptr2->x_flag_split_wide_types);

  if (ptr1->x_flag_ssa_backprop != ptr2->x_flag_ssa_backprop)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ssa_backprop",
             ptr1->x_flag_ssa_backprop,
             ptr2->x_flag_ssa_backprop);

  if (ptr1->x_flag_ssa_phiopt != ptr2->x_flag_ssa_phiopt)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_ssa_phiopt",
             ptr1->x_flag_ssa_phiopt,
             ptr2->x_flag_ssa_phiopt);

  if (ptr1->x_flag_stack_protect != ptr2->x_flag_stack_protect)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_stack_protect",
             ptr1->x_flag_stack_protect,
             ptr2->x_flag_stack_protect);

  if (ptr1->x_flag_stdarg_opt != ptr2->x_flag_stdarg_opt)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_stdarg_opt",
             ptr1->x_flag_stdarg_opt,
             ptr2->x_flag_stdarg_opt);

  if (ptr1->x_flag_store_merging != ptr2->x_flag_store_merging)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_store_merging",
             ptr1->x_flag_store_merging,
             ptr2->x_flag_store_merging);

  if (ptr1->x_flag_strict_aliasing != ptr2->x_flag_strict_aliasing)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_strict_aliasing",
             ptr1->x_flag_strict_aliasing,
             ptr2->x_flag_strict_aliasing);

  if (ptr1->x_flag_strict_enums != ptr2->x_flag_strict_enums)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_strict_enums",
             ptr1->x_flag_strict_enums,
             ptr2->x_flag_strict_enums);

  if (ptr1->x_flag_strict_overflow != ptr2->x_flag_strict_overflow)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_strict_overflow",
             ptr1->x_flag_strict_overflow,
             ptr2->x_flag_strict_overflow);

  if (ptr1->x_flag_strict_volatile_bitfields != ptr2->x_flag_strict_volatile_bitfields)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_strict_volatile_bitfields",
             ptr1->x_flag_strict_volatile_bitfields,
             ptr2->x_flag_strict_volatile_bitfields);

  if (ptr1->x_flag_thread_jumps != ptr2->x_flag_thread_jumps)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_thread_jumps",
             ptr1->x_flag_thread_jumps,
             ptr2->x_flag_thread_jumps);

  if (ptr1->x_flag_threadsafe_statics != ptr2->x_flag_threadsafe_statics)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_threadsafe_statics",
             ptr1->x_flag_threadsafe_statics,
             ptr2->x_flag_threadsafe_statics);

  if (ptr1->x_flag_tracer != ptr2->x_flag_tracer)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tracer",
             ptr1->x_flag_tracer,
             ptr2->x_flag_tracer);

  if (ptr1->x_flag_trapping_math != ptr2->x_flag_trapping_math)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_trapping_math",
             ptr1->x_flag_trapping_math,
             ptr2->x_flag_trapping_math);

  if (ptr1->x_flag_trapv != ptr2->x_flag_trapv)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_trapv",
             ptr1->x_flag_trapv,
             ptr2->x_flag_trapv);

  if (ptr1->x_flag_tree_bit_ccp != ptr2->x_flag_tree_bit_ccp)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_bit_ccp",
             ptr1->x_flag_tree_bit_ccp,
             ptr2->x_flag_tree_bit_ccp);

  if (ptr1->x_flag_tree_builtin_call_dce != ptr2->x_flag_tree_builtin_call_dce)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_builtin_call_dce",
             ptr1->x_flag_tree_builtin_call_dce,
             ptr2->x_flag_tree_builtin_call_dce);

  if (ptr1->x_flag_tree_ccp != ptr2->x_flag_tree_ccp)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_ccp",
             ptr1->x_flag_tree_ccp,
             ptr2->x_flag_tree_ccp);

  if (ptr1->x_flag_tree_ch != ptr2->x_flag_tree_ch)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_ch",
             ptr1->x_flag_tree_ch,
             ptr2->x_flag_tree_ch);

  if (ptr1->x_flag_tree_coalesce_vars != ptr2->x_flag_tree_coalesce_vars)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_coalesce_vars",
             ptr1->x_flag_tree_coalesce_vars,
             ptr2->x_flag_tree_coalesce_vars);

  if (ptr1->x_flag_tree_copy_prop != ptr2->x_flag_tree_copy_prop)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_copy_prop",
             ptr1->x_flag_tree_copy_prop,
             ptr2->x_flag_tree_copy_prop);

  if (ptr1->x_flag_tree_cselim != ptr2->x_flag_tree_cselim)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_cselim",
             ptr1->x_flag_tree_cselim,
             ptr2->x_flag_tree_cselim);

  if (ptr1->x_flag_tree_dce != ptr2->x_flag_tree_dce)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_dce",
             ptr1->x_flag_tree_dce,
             ptr2->x_flag_tree_dce);

  if (ptr1->x_flag_tree_dom != ptr2->x_flag_tree_dom)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_dom",
             ptr1->x_flag_tree_dom,
             ptr2->x_flag_tree_dom);

  if (ptr1->x_flag_tree_dse != ptr2->x_flag_tree_dse)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_dse",
             ptr1->x_flag_tree_dse,
             ptr2->x_flag_tree_dse);

  if (ptr1->x_flag_tree_forwprop != ptr2->x_flag_tree_forwprop)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_forwprop",
             ptr1->x_flag_tree_forwprop,
             ptr2->x_flag_tree_forwprop);

  if (ptr1->x_flag_tree_fre != ptr2->x_flag_tree_fre)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_fre",
             ptr1->x_flag_tree_fre,
             ptr2->x_flag_tree_fre);

  if (ptr1->x_flag_tree_loop_distribute_patterns != ptr2->x_flag_tree_loop_distribute_patterns)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_loop_distribute_patterns",
             ptr1->x_flag_tree_loop_distribute_patterns,
             ptr2->x_flag_tree_loop_distribute_patterns);

  if (ptr1->x_flag_tree_loop_distribution != ptr2->x_flag_tree_loop_distribution)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_loop_distribution",
             ptr1->x_flag_tree_loop_distribution,
             ptr2->x_flag_tree_loop_distribution);

  if (ptr1->x_flag_tree_loop_if_convert != ptr2->x_flag_tree_loop_if_convert)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_loop_if_convert",
             ptr1->x_flag_tree_loop_if_convert,
             ptr2->x_flag_tree_loop_if_convert);

  if (ptr1->x_flag_tree_loop_im != ptr2->x_flag_tree_loop_im)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_loop_im",
             ptr1->x_flag_tree_loop_im,
             ptr2->x_flag_tree_loop_im);

  if (ptr1->x_flag_tree_loop_ivcanon != ptr2->x_flag_tree_loop_ivcanon)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_loop_ivcanon",
             ptr1->x_flag_tree_loop_ivcanon,
             ptr2->x_flag_tree_loop_ivcanon);

  if (ptr1->x_flag_tree_loop_optimize != ptr2->x_flag_tree_loop_optimize)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_loop_optimize",
             ptr1->x_flag_tree_loop_optimize,
             ptr2->x_flag_tree_loop_optimize);

  if (ptr1->x_flag_tree_loop_vectorize != ptr2->x_flag_tree_loop_vectorize)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_loop_vectorize",
             ptr1->x_flag_tree_loop_vectorize,
             ptr2->x_flag_tree_loop_vectorize);

  if (ptr1->x_flag_tree_live_range_split != ptr2->x_flag_tree_live_range_split)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_live_range_split",
             ptr1->x_flag_tree_live_range_split,
             ptr2->x_flag_tree_live_range_split);

  if (ptr1->x_flag_tree_partial_pre != ptr2->x_flag_tree_partial_pre)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_partial_pre",
             ptr1->x_flag_tree_partial_pre,
             ptr2->x_flag_tree_partial_pre);

  if (ptr1->x_flag_tree_phiprop != ptr2->x_flag_tree_phiprop)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_phiprop",
             ptr1->x_flag_tree_phiprop,
             ptr2->x_flag_tree_phiprop);

  if (ptr1->x_flag_tree_pre != ptr2->x_flag_tree_pre)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_pre",
             ptr1->x_flag_tree_pre,
             ptr2->x_flag_tree_pre);

  if (ptr1->x_flag_tree_pta != ptr2->x_flag_tree_pta)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_pta",
             ptr1->x_flag_tree_pta,
             ptr2->x_flag_tree_pta);

  if (ptr1->x_flag_tree_reassoc != ptr2->x_flag_tree_reassoc)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_reassoc",
             ptr1->x_flag_tree_reassoc,
             ptr2->x_flag_tree_reassoc);

  if (ptr1->x_flag_tree_scev_cprop != ptr2->x_flag_tree_scev_cprop)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_scev_cprop",
             ptr1->x_flag_tree_scev_cprop,
             ptr2->x_flag_tree_scev_cprop);

  if (ptr1->x_flag_tree_sink != ptr2->x_flag_tree_sink)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_sink",
             ptr1->x_flag_tree_sink,
             ptr2->x_flag_tree_sink);

  if (ptr1->x_flag_tree_slp_vectorize != ptr2->x_flag_tree_slp_vectorize)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_slp_vectorize",
             ptr1->x_flag_tree_slp_vectorize,
             ptr2->x_flag_tree_slp_vectorize);

  if (ptr1->x_flag_tree_slsr != ptr2->x_flag_tree_slsr)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_slsr",
             ptr1->x_flag_tree_slsr,
             ptr2->x_flag_tree_slsr);

  if (ptr1->x_flag_tree_sra != ptr2->x_flag_tree_sra)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_sra",
             ptr1->x_flag_tree_sra,
             ptr2->x_flag_tree_sra);

  if (ptr1->x_flag_tree_switch_conversion != ptr2->x_flag_tree_switch_conversion)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_switch_conversion",
             ptr1->x_flag_tree_switch_conversion,
             ptr2->x_flag_tree_switch_conversion);

  if (ptr1->x_flag_tree_tail_merge != ptr2->x_flag_tree_tail_merge)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_tail_merge",
             ptr1->x_flag_tree_tail_merge,
             ptr2->x_flag_tree_tail_merge);

  if (ptr1->x_flag_tree_ter != ptr2->x_flag_tree_ter)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_ter",
             ptr1->x_flag_tree_ter,
             ptr2->x_flag_tree_ter);

  if (ptr1->x_flag_tree_vectorize != ptr2->x_flag_tree_vectorize)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_vectorize",
             ptr1->x_flag_tree_vectorize,
             ptr2->x_flag_tree_vectorize);

  if (ptr1->x_flag_tree_vrp != ptr2->x_flag_tree_vrp)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_tree_vrp",
             ptr1->x_flag_tree_vrp,
             ptr2->x_flag_tree_vrp);

  if (ptr1->x_flag_unconstrained_commons != ptr2->x_flag_unconstrained_commons)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_unconstrained_commons",
             ptr1->x_flag_unconstrained_commons,
             ptr2->x_flag_unconstrained_commons);

  if (ptr1->x_flag_unroll_all_loops != ptr2->x_flag_unroll_all_loops)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_unroll_all_loops",
             ptr1->x_flag_unroll_all_loops,
             ptr2->x_flag_unroll_all_loops);

  if (ptr1->x_flag_unroll_loops != ptr2->x_flag_unroll_loops)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_unroll_loops",
             ptr1->x_flag_unroll_loops,
             ptr2->x_flag_unroll_loops);

  if (ptr1->x_flag_unsafe_math_optimizations != ptr2->x_flag_unsafe_math_optimizations)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_unsafe_math_optimizations",
             ptr1->x_flag_unsafe_math_optimizations,
             ptr2->x_flag_unsafe_math_optimizations);

  if (ptr1->x_flag_unswitch_loops != ptr2->x_flag_unswitch_loops)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_unswitch_loops",
             ptr1->x_flag_unswitch_loops,
             ptr2->x_flag_unswitch_loops);

  if (ptr1->x_flag_unwind_tables != ptr2->x_flag_unwind_tables)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_unwind_tables",
             ptr1->x_flag_unwind_tables,
             ptr2->x_flag_unwind_tables);

  if (ptr1->x_flag_var_tracking != ptr2->x_flag_var_tracking)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_var_tracking",
             ptr1->x_flag_var_tracking,
             ptr2->x_flag_var_tracking);

  if (ptr1->x_flag_var_tracking_assignments != ptr2->x_flag_var_tracking_assignments)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_var_tracking_assignments",
             ptr1->x_flag_var_tracking_assignments,
             ptr2->x_flag_var_tracking_assignments);

  if (ptr1->x_flag_var_tracking_assignments_toggle != ptr2->x_flag_var_tracking_assignments_toggle)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_var_tracking_assignments_toggle",
             ptr1->x_flag_var_tracking_assignments_toggle,
             ptr2->x_flag_var_tracking_assignments_toggle);

  if (ptr1->x_flag_var_tracking_uninit != ptr2->x_flag_var_tracking_uninit)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_var_tracking_uninit",
             ptr1->x_flag_var_tracking_uninit,
             ptr2->x_flag_var_tracking_uninit);

  if (ptr1->x_flag_variable_expansion_in_unroller != ptr2->x_flag_variable_expansion_in_unroller)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_variable_expansion_in_unroller",
             ptr1->x_flag_variable_expansion_in_unroller,
             ptr2->x_flag_variable_expansion_in_unroller);

  if (ptr1->x_flag_value_profile_transformations != ptr2->x_flag_value_profile_transformations)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_value_profile_transformations",
             ptr1->x_flag_value_profile_transformations,
             ptr2->x_flag_value_profile_transformations);

  if (ptr1->x_flag_web != ptr2->x_flag_web)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_web",
             ptr1->x_flag_web,
             ptr2->x_flag_web);

  if (ptr1->x_flag_wrapv != ptr2->x_flag_wrapv)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent_to, "",
             "flag_wrapv",
             ptr1->x_flag_wrapv,
             ptr2->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_isa_flags2 = opts->x_ix86_isa_flags2;
  ptr->x_ix86_fpmath = opts->x_ix86_fpmath;
  ptr->x_target_flags = opts->x_target_flags;
  ptr->x_ix86_target_flags = opts->x_ix86_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_isa_flags2 = ptr->x_ix86_isa_flags2;
  opts->x_ix86_fpmath = ptr->x_ix86_fpmath;
  opts->x_target_flags = ptr->x_target_flags;
  opts->x_ix86_target_flags = ptr->x_ix86_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_isa_flags2)
    fprintf (file, "%*s%s (%#" HOST_WIDE_INT_PRINT "x)\n",
             indent, "",
             "ix86_isa_flags2",
             ptr->x_ix86_isa_flags2);

  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 (ptr->x_ix86_target_flags)
    fprintf (file, "%*s%s (%#x)\n",
             indent, "",
             "ix86_target_flags",
             ptr->x_ix86_target_flags);


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

/* Print different target option variables from structures provided as arguments.  */
void
cl_target_option_print_diff (FILE *file,
                             int indent ATTRIBUTE_UNUSED,
                             struct cl_target_option *ptr1 ATTRIBUTE_UNUSED,
                             struct cl_target_option *ptr2 ATTRIBUTE_UNUSED)
{
  fputs ("\n", file);
  if (ptr1->x_ix86_isa_flags != ptr2->x_ix86_isa_flags)
    fprintf (file, "%*s%s (%#" HOST_WIDE_INT_PRINT "x/%#" HOST_WIDE_INT_PRINT "x)\n",
             indent, "",
             "ix86_isa_flags",
             ptr1->x_ix86_isa_flags,
             ptr2->x_ix86_isa_flags);

  if (ptr1->x_ix86_isa_flags2 != ptr2->x_ix86_isa_flags2)
    fprintf (file, "%*s%s (%#" HOST_WIDE_INT_PRINT "x/%#" HOST_WIDE_INT_PRINT "x)\n",
             indent, "",
             "ix86_isa_flags2",
             ptr1->x_ix86_isa_flags2,
             ptr2->x_ix86_isa_flags2);

  if (ptr1->x_ix86_fpmath != ptr2->x_ix86_fpmath)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent, "",
             "ix86_fpmath",
             ptr1->x_ix86_fpmath,
             ptr2->x_ix86_fpmath);

  if (ptr1->x_target_flags != ptr2->x_target_flags)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent, "",
             "target_flags",
             ptr1->x_target_flags,
             ptr2->x_target_flags);

  if (ptr1->x_ix86_target_flags != ptr2->x_ix86_target_flags)
    fprintf (file, "%*s%s (%#x/%#x)\n",
             indent, "",
             "ix86_target_flags",
             ptr1->x_ix86_target_flags,
             ptr2->x_ix86_target_flags);

}

/* Compare two target options  */
bool
cl_target_option_eq (struct cl_target_option const *ptr1 ATTRIBUTE_UNUSED,
                     struct cl_target_option const *ptr2 ATTRIBUTE_UNUSED)
{
  if (ptr1->x_ix86_arch_string != ptr2->x_ix86_arch_string
      && (!ptr1->x_ix86_arch_string || !ptr2->x_ix86_arch_string
          || strcmp (ptr1->x_ix86_arch_string, ptr2->x_ix86_arch_string)))
    return false;
  if (ptr1->x_ix86_recip_name != ptr2->x_ix86_recip_name
      && (!ptr1->x_ix86_recip_name || !ptr2->x_ix86_recip_name
          || strcmp (ptr1->x_ix86_recip_name, ptr2->x_ix86_recip_name)))
    return false;
  if (ptr1->x_ix86_tune_ctrl_string != ptr2->x_ix86_tune_ctrl_string
      && (!ptr1->x_ix86_tune_ctrl_string || !ptr2->x_ix86_tune_ctrl_string
          || strcmp (ptr1->x_ix86_tune_ctrl_string, ptr2->x_ix86_tune_ctrl_string)))
    return false;
  if (ptr1->x_ix86_tune_memcpy_strategy != ptr2->x_ix86_tune_memcpy_strategy
      && (!ptr1->x_ix86_tune_memcpy_strategy || !ptr2->x_ix86_tune_memcpy_strategy
          || strcmp (ptr1->x_ix86_tune_memcpy_strategy, ptr2->x_ix86_tune_memcpy_strategy)))
    return false;
  if (ptr1->x_ix86_tune_memset_strategy != ptr2->x_ix86_tune_memset_strategy
      && (!ptr1->x_ix86_tune_memset_strategy || !ptr2->x_ix86_tune_memset_strategy
          || strcmp (ptr1->x_ix86_tune_memset_strategy, ptr2->x_ix86_tune_memset_strategy)))
    return false;
  if (ptr1->x_ix86_tune_string != ptr2->x_ix86_tune_string
      && (!ptr1->x_ix86_tune_string || !ptr2->x_ix86_tune_string
          || strcmp (ptr1->x_ix86_tune_string, ptr2->x_ix86_tune_string)))
    return false;
  if (ptr1->x_ix86_isa_flags2_explicit != ptr2->x_ix86_isa_flags2_explicit)
    return false;
  if (ptr1->x_ix86_isa_flags_explicit != ptr2->x_ix86_isa_flags_explicit)
    return false;
  if (ptr1->x_ix86_asm_dialect != ptr2->x_ix86_asm_dialect)
    return false;
  if (ptr1->x_ix86_abi != ptr2->x_ix86_abi)
    return false;
  if (ptr1->x_ix86_cmodel != ptr2->x_ix86_cmodel)
    return false;
  if (ptr1->x_ix86_veclibabi_type != ptr2->x_ix86_veclibabi_type)
    return false;
  if (ptr1->x_ix86_pmode != ptr2->x_ix86_pmode)
    return false;
  if (ptr1->x_ix86_stack_protector_guard != ptr2->x_ix86_stack_protector_guard)
    return false;
  if (ptr1->x_ix86_stringop_alg != ptr2->x_ix86_stringop_alg)
    return false;
  if (ptr1->x_ix86_tls_dialect != ptr2->x_ix86_tls_dialect)
    return false;
  if (ptr1->x_ix86_branch_cost != ptr2->x_ix86_branch_cost)
    return false;
  if (ptr1->x_ix86_dump_tunes != ptr2->x_ix86_dump_tunes)
    return false;
  if (ptr1->x_ix86_force_align_arg_pointer != ptr2->x_ix86_force_align_arg_pointer)
    return false;
  if (ptr1->x_ix86_force_drap != ptr2->x_ix86_force_drap)
    return false;
  if (ptr1->x_ix86_incoming_stack_boundary_arg != ptr2->x_ix86_incoming_stack_boundary_arg)
    return false;
  if (ptr1->x_ix86_preferred_stack_boundary_arg != ptr2->x_ix86_preferred_stack_boundary_arg)
    return false;
  if (ptr1->x_ix86_regparm != ptr2->x_ix86_regparm)
    return false;
  if (ptr1->x_ix86_section_threshold != ptr2->x_ix86_section_threshold)
    return false;
  if (ptr1->x_ix86_sse2avx != ptr2->x_ix86_sse2avx)
    return false;
  if (ptr1->x_ix86_tune_no_default != ptr2->x_ix86_tune_no_default)
    return false;
  if (ptr1->x_recip_mask_explicit != ptr2->x_recip_mask_explicit)
    return false;
  if (ptr1->arch != ptr2->arch)
    return false;
  if (ptr1->arch_specified != ptr2->arch_specified)
    return false;
  if (ptr1->branch_cost != ptr2->branch_cost)
    return false;
  if (ptr1->prefetch_sse != ptr2->prefetch_sse)
    return false;
  if (ptr1->schedule != ptr2->schedule)
    return false;
  if (ptr1->tune != ptr2->tune)
    return false;
  if (ptr1->tune_defaulted != ptr2->tune_defaulted)
    return false;
  if (ptr1->x_recip_mask != ptr2->x_recip_mask)
    return false;
  if (ptr1->x_target_flags != ptr2->x_target_flags)
    return false;
  if (ptr1->x_ix86_isa_flags != ptr2->x_ix86_isa_flags)
    return false;
  if (ptr1->x_ix86_isa_flags2 != ptr2->x_ix86_isa_flags2)
    return false;
  if (ptr1->x_ix86_fpmath != ptr2->x_ix86_fpmath)
    return false;
  if (ptr1->x_ix86_target_flags != ptr2->x_ix86_target_flags)
    return false;
  return true;
}

/* Hash target options  */
hashval_t
cl_target_option_hash (struct cl_target_option const *ptr ATTRIBUTE_UNUSED)
{
  inchash::hash hstate;
  if (ptr->x_ix86_arch_string)
    hstate.add (ptr->x_ix86_arch_string, strlen (ptr->x_ix86_arch_string));
  else
    hstate.add_int (0);
  if (ptr->x_ix86_recip_name)
    hstate.add (ptr->x_ix86_recip_name, strlen (ptr->x_ix86_recip_name));
  else
    hstate.add_int (0);
  if (ptr->x_ix86_tune_ctrl_string)
    hstate.add (ptr->x_ix86_tune_ctrl_string, strlen (ptr->x_ix86_tune_ctrl_string));
  else
    hstate.add_int (0);
  if (ptr->x_ix86_tune_memcpy_strategy)
    hstate.add (ptr->x_ix86_tune_memcpy_strategy, strlen (ptr->x_ix86_tune_memcpy_strategy));
  else
    hstate.add_int (0);
  if (ptr->x_ix86_tune_memset_strategy)
    hstate.add (ptr->x_ix86_tune_memset_strategy, strlen (ptr->x_ix86_tune_memset_strategy));
  else
    hstate.add_int (0);
  if (ptr->x_ix86_tune_string)
    hstate.add (ptr->x_ix86_tune_string, strlen (ptr->x_ix86_tune_string));
  else
    hstate.add_int (0);
  hstate.add_wide_int (ptr->x_ix86_isa_flags2_explicit);
  hstate.add_wide_int (ptr->x_ix86_isa_flags_explicit);
  hstate.add_wide_int (ptr->x_ix86_asm_dialect);
  hstate.add_wide_int (ptr->x_ix86_abi);
  hstate.add_wide_int (ptr->x_ix86_cmodel);
  hstate.add_wide_int (ptr->x_ix86_veclibabi_type);
  hstate.add_wide_int (ptr->x_ix86_pmode);
  hstate.add_wide_int (ptr->x_ix86_stack_protector_guard);
  hstate.add_wide_int (ptr->x_ix86_stringop_alg);
  hstate.add_wide_int (ptr->x_ix86_tls_dialect);
  hstate.add_wide_int (ptr->x_ix86_branch_cost);
  hstate.add_wide_int (ptr->x_ix86_dump_tunes);
  hstate.add_wide_int (ptr->x_ix86_force_align_arg_pointer);
  hstate.add_wide_int (ptr->x_ix86_force_drap);
  hstate.add_wide_int (ptr->x_ix86_incoming_stack_boundary_arg);
  hstate.add_wide_int (ptr->x_ix86_preferred_stack_boundary_arg);
  hstate.add_wide_int (ptr->x_ix86_regparm);
  hstate.add_wide_int (ptr->x_ix86_section_threshold);
  hstate.add_wide_int (ptr->x_ix86_sse2avx);
  hstate.add_wide_int (ptr->x_ix86_tune_no_default);
  hstate.add_wide_int (ptr->x_recip_mask_explicit);
  hstate.add_wide_int (ptr->arch);
  hstate.add_wide_int (ptr->arch_specified);
  hstate.add_wide_int (ptr->branch_cost);
  hstate.add_wide_int (ptr->prefetch_sse);
  hstate.add_wide_int (ptr->schedule);
  hstate.add_wide_int (ptr->tune);
  hstate.add_wide_int (ptr->tune_defaulted);
  hstate.add_wide_int (ptr->x_recip_mask);
  hstate.add_wide_int (ptr->x_target_flags);
  hstate.add_wide_int (ptr->x_ix86_isa_flags);
  hstate.add_wide_int (ptr->x_ix86_isa_flags2);
  hstate.add_wide_int (ptr->x_ix86_fpmath);
  hstate.add_wide_int (ptr->x_ix86_target_flags);
  return hstate.end ();
}

/* Stream out target options  */
void
cl_target_option_stream_out (struct output_block *ob ATTRIBUTE_UNUSED,
                             struct bitpack_d *bp ATTRIBUTE_UNUSED,
                             struct cl_target_option *ptr ATTRIBUTE_UNUSED)
{
  bp_pack_string (ob, bp, ptr->x_ix86_arch_string, true);
  bp_pack_string (ob, bp, ptr->x_ix86_recip_name, true);
  bp_pack_string (ob, bp, ptr->x_ix86_tune_ctrl_string, true);
  bp_pack_string (ob, bp, ptr->x_ix86_tune_memcpy_strategy, true);
  bp_pack_string (ob, bp, ptr->x_ix86_tune_memset_strategy, true);
  bp_pack_string (ob, bp, ptr->x_ix86_tune_string, true);
  bp_pack_value (bp, ptr->x_ix86_isa_flags2_explicit, 64);
  bp_pack_value (bp, ptr->x_ix86_isa_flags_explicit, 64);
  bp_pack_value (bp, ptr->x_ix86_asm_dialect, 64);
  bp_pack_value (bp, ptr->x_ix86_abi, 64);
  bp_pack_value (bp, ptr->x_ix86_cmodel, 64);
  bp_pack_value (bp, ptr->x_ix86_veclibabi_type, 64);
  bp_pack_value (bp, ptr->x_ix86_pmode, 64);
  bp_pack_value (bp, ptr->x_ix86_stack_protector_guard, 64);
  bp_pack_value (bp, ptr->x_ix86_stringop_alg, 64);
  bp_pack_value (bp, ptr->x_ix86_tls_dialect, 64);
  bp_pack_value (bp, ptr->x_ix86_branch_cost, 64);
  bp_pack_value (bp, ptr->x_ix86_dump_tunes, 64);
  bp_pack_value (bp, ptr->x_ix86_force_align_arg_pointer, 64);
  bp_pack_value (bp, ptr->x_ix86_force_drap, 64);
  bp_pack_value (bp, ptr->x_ix86_incoming_stack_boundary_arg, 64);
  bp_pack_value (bp, ptr->x_ix86_preferred_stack_boundary_arg, 64);
  bp_pack_value (bp, ptr->x_ix86_regparm, 64);
  bp_pack_value (bp, ptr->x_ix86_section_threshold, 64);
  bp_pack_value (bp, ptr->x_ix86_sse2avx, 64);
  bp_pack_value (bp, ptr->x_ix86_tune_no_default, 64);
  bp_pack_value (bp, ptr->x_recip_mask_explicit, 64);
  bp_pack_value (bp, ptr->arch, 64);
  bp_pack_value (bp, ptr->arch_specified, 64);
  bp_pack_value (bp, ptr->branch_cost, 64);
  bp_pack_value (bp, ptr->prefetch_sse, 64);
  bp_pack_value (bp, ptr->schedule, 64);
  bp_pack_value (bp, ptr->tune, 64);
  bp_pack_value (bp, ptr->tune_defaulted, 64);
  bp_pack_value (bp, ptr->x_recip_mask, 64);
  bp_pack_value (bp, ptr->x_target_flags, 64);
  bp_pack_value (bp, ptr->x_ix86_isa_flags, 64);
  bp_pack_value (bp, ptr->x_ix86_isa_flags2, 64);
  bp_pack_value (bp, ptr->x_ix86_fpmath, 64);
  bp_pack_value (bp, ptr->x_ix86_target_flags, 64);
}

/* Stream in target options  */
void
cl_target_option_stream_in (struct data_in *data_in ATTRIBUTE_UNUSED,
                            struct bitpack_d *bp ATTRIBUTE_UNUSED,
                            struct cl_target_option *ptr ATTRIBUTE_UNUSED)
{
  ptr->x_ix86_arch_string = bp_unpack_string (data_in, bp);
  if (ptr->x_ix86_arch_string)
    ptr->x_ix86_arch_string = xstrdup (ptr->x_ix86_arch_string);
  ptr->x_ix86_recip_name = bp_unpack_string (data_in, bp);
  if (ptr->x_ix86_recip_name)
    ptr->x_ix86_recip_name = xstrdup (ptr->x_ix86_recip_name);
  ptr->x_ix86_tune_ctrl_string = bp_unpack_string (data_in, bp);
  if (ptr->x_ix86_tune_ctrl_string)
    ptr->x_ix86_tune_ctrl_string = xstrdup (ptr->x_ix86_tune_ctrl_string);
  ptr->x_ix86_tune_memcpy_strategy = bp_unpack_string (data_in, bp);
  if (ptr->x_ix86_tune_memcpy_strategy)
    ptr->x_ix86_tune_memcpy_strategy = xstrdup (ptr->x_ix86_tune_memcpy_strategy);
  ptr->x_ix86_tune_memset_strategy = bp_unpack_string (data_in, bp);
  if (ptr->x_ix86_tune_memset_strategy)
    ptr->x_ix86_tune_memset_strategy = xstrdup (ptr->x_ix86_tune_memset_strategy);
  ptr->x_ix86_tune_string = bp_unpack_string (data_in, bp);
  if (ptr->x_ix86_tune_string)
    ptr->x_ix86_tune_string = xstrdup (ptr->x_ix86_tune_string);
  ptr->x_ix86_isa_flags2_explicit = (HOST_WIDE_INT) bp_unpack_value (bp, 64);
  ptr->x_ix86_isa_flags_explicit = (HOST_WIDE_INT) bp_unpack_value (bp, 64);
  ptr->x_ix86_asm_dialect = (enum asm_dialect) bp_unpack_value (bp, 64);
  ptr->x_ix86_abi = (enum calling_abi) bp_unpack_value (bp, 64);
  ptr->x_ix86_cmodel = (enum cmodel) bp_unpack_value (bp, 64);
  ptr->x_ix86_veclibabi_type = (enum ix86_veclibabi) bp_unpack_value (bp, 64);
  ptr->x_ix86_pmode = (enum pmode) bp_unpack_value (bp, 64);
  ptr->x_ix86_stack_protector_guard = (enum stack_protector_guard) bp_unpack_value (bp, 64);
  ptr->x_ix86_stringop_alg = (enum stringop_alg) bp_unpack_value (bp, 64);
  ptr->x_ix86_tls_dialect = (enum tls_dialect) bp_unpack_value (bp, 64);
  ptr->x_ix86_branch_cost = (int) bp_unpack_value (bp, 64);
  ptr->x_ix86_dump_tunes = (int) bp_unpack_value (bp, 64);
  ptr->x_ix86_force_align_arg_pointer = (int) bp_unpack_value (bp, 64);
  ptr->x_ix86_force_drap = (int) bp_unpack_value (bp, 64);
  ptr->x_ix86_incoming_stack_boundary_arg = (int) bp_unpack_value (bp, 64);
  ptr->x_ix86_preferred_stack_boundary_arg = (int) bp_unpack_value (bp, 64);
  ptr->x_ix86_regparm = (int) bp_unpack_value (bp, 64);
  ptr->x_ix86_section_threshold = (int) bp_unpack_value (bp, 64);
  ptr->x_ix86_sse2avx = (int) bp_unpack_value (bp, 64);
  ptr->x_ix86_tune_no_default = (int) bp_unpack_value (bp, 64);
  ptr->x_recip_mask_explicit = (int) bp_unpack_value (bp, 64);
  ptr->arch = (unsigned char) bp_unpack_value (bp, 64);
  ptr->arch_specified = (unsigned char) bp_unpack_value (bp, 64);
  ptr->branch_cost = (unsigned char) bp_unpack_value (bp, 64);
  ptr->prefetch_sse = (unsigned char) bp_unpack_value (bp, 64);
  ptr->schedule = (unsigned char) bp_unpack_value (bp, 64);
  ptr->tune = (unsigned char) bp_unpack_value (bp, 64);
  ptr->tune_defaulted = (unsigned char) bp_unpack_value (bp, 64);
  ptr->x_recip_mask = (int) bp_unpack_value (bp, 64);
  ptr->x_target_flags = (int ) bp_unpack_value (bp, 64);
  ptr->x_ix86_isa_flags = (HOST_WIDE_INT ) bp_unpack_value (bp, 64);
  ptr->x_ix86_isa_flags2 = (HOST_WIDE_INT ) bp_unpack_value (bp, 64);
  ptr->x_ix86_fpmath = (enum fpmath_unit ) bp_unpack_value (bp, 64);
  ptr->x_ix86_target_flags = (int ) bp_unpack_value (bp, 64);
}

/* Hash optimization options  */
hashval_t
cl_optimization_hash (struct cl_optimization const *ptr ATTRIBUTE_UNUSED)
{
  inchash::hash hstate;
  hstate.add_wide_int (ptr->x_align_functions);
  hstate.add_wide_int (ptr->x_align_jumps);
  hstate.add_wide_int (ptr->x_align_labels);
  hstate.add_wide_int (ptr->x_align_loops);
  hstate.add_wide_int (ptr->x_flag_associative_math);
  hstate.add_wide_int (ptr->x_flag_asynchronous_unwind_tables);
  hstate.add_wide_int (ptr->x_flag_auto_inc_dec);
  hstate.add_wide_int (ptr->x_flag_branch_on_count_reg);
  hstate.add_wide_int (ptr->x_flag_branch_probabilities);
  hstate.add_wide_int (ptr->x_flag_branch_target_load_optimize);
  hstate.add_wide_int (ptr->x_flag_branch_target_load_optimize2);
  hstate.add_wide_int (ptr->x_flag_btr_bb_exclusive);
  hstate.add_wide_int (ptr->x_flag_caller_saves);
  hstate.add_wide_int (ptr->x_flag_code_hoisting);
  hstate.add_wide_int (ptr->x_flag_combine_stack_adjustments);
  hstate.add_wide_int (ptr->x_flag_compare_elim_after_reload);
  hstate.add_wide_int (ptr->x_flag_conserve_stack);
  hstate.add_wide_int (ptr->x_flag_cprop_registers);
  hstate.add_wide_int (ptr->x_flag_crossjumping);
  hstate.add_wide_int (ptr->x_flag_cse_follow_jumps);
  hstate.add_wide_int (ptr->x_flag_cx_fortran_rules);
  hstate.add_wide_int (ptr->x_flag_cx_limited_range);
  hstate.add_wide_int (ptr->x_flag_dce);
  hstate.add_wide_int (ptr->x_flag_defer_pop);
  hstate.add_wide_int (ptr->x_flag_delayed_branch);
  hstate.add_wide_int (ptr->x_flag_delete_dead_exceptions);
  hstate.add_wide_int (ptr->x_flag_delete_null_pointer_checks);
  hstate.add_wide_int (ptr->x_flag_devirtualize);
  hstate.add_wide_int (ptr->x_flag_devirtualize_speculatively);
  hstate.add_wide_int (ptr->x_flag_dse);
  hstate.add_wide_int (ptr->x_flag_early_inlining);
  hstate.add_wide_int (ptr->x_flag_exceptions);
  hstate.add_wide_int (ptr->x_flag_expensive_optimizations);
  hstate.add_wide_int (ptr->x_flag_finite_math_only);
  hstate.add_wide_int (ptr->x_flag_float_store);
  hstate.add_wide_int (ptr->x_flag_forward_propagate);
  hstate.add_wide_int (ptr->x_flag_fp_contract_mode);
  hstate.add_wide_int (ptr->x_flag_fp_int_builtin_inexact);
  hstate.add_wide_int (ptr->x_flag_no_function_cse);
  hstate.add_wide_int (ptr->x_flag_gcse);
  hstate.add_wide_int (ptr->x_flag_gcse_after_reload);
  hstate.add_wide_int (ptr->x_flag_gcse_las);
  hstate.add_wide_int (ptr->x_flag_gcse_lm);
  hstate.add_wide_int (ptr->x_flag_gcse_sm);
  hstate.add_wide_int (ptr->x_flag_graphite);
  hstate.add_wide_int (ptr->x_flag_graphite_identity);
  hstate.add_wide_int (ptr->x_flag_guess_branch_prob);
  hstate.add_wide_int (ptr->x_flag_hoist_adjacent_loads);
  hstate.add_wide_int (ptr->x_flag_if_conversion);
  hstate.add_wide_int (ptr->x_flag_if_conversion2);
  hstate.add_wide_int (ptr->x_flag_indirect_inlining);
  hstate.add_wide_int (ptr->x_flag_no_inline);
  hstate.add_wide_int (ptr->x_flag_inline_atomics);
  hstate.add_wide_int (ptr->x_flag_inline_functions);
  hstate.add_wide_int (ptr->x_flag_inline_functions_called_once);
  hstate.add_wide_int (ptr->x_flag_inline_small_functions);
  hstate.add_wide_int (ptr->x_flag_ipa_bit_cp);
  hstate.add_wide_int (ptr->x_flag_ipa_cp);
  hstate.add_wide_int (ptr->x_flag_ipa_cp_clone);
  hstate.add_wide_int (ptr->x_flag_ipa_icf);
  hstate.add_wide_int (ptr->x_flag_ipa_icf_functions);
  hstate.add_wide_int (ptr->x_flag_ipa_icf_variables);
  hstate.add_wide_int (ptr->x_flag_ipa_profile);
  hstate.add_wide_int (ptr->x_flag_ipa_pta);
  hstate.add_wide_int (ptr->x_flag_ipa_pure_const);
  hstate.add_wide_int (ptr->x_flag_ipa_ra);
  hstate.add_wide_int (ptr->x_flag_ipa_reference);
  hstate.add_wide_int (ptr->x_flag_ipa_sra);
  hstate.add_wide_int (ptr->x_flag_ipa_vrp);
  hstate.add_wide_int (ptr->x_flag_ira_algorithm);
  hstate.add_wide_int (ptr->x_flag_ira_hoist_pressure);
  hstate.add_wide_int (ptr->x_flag_ira_loop_pressure);
  hstate.add_wide_int (ptr->x_flag_ira_region);
  hstate.add_wide_int (ptr->x_flag_ira_share_save_slots);
  hstate.add_wide_int (ptr->x_flag_ira_share_spill_slots);
  hstate.add_wide_int (ptr->x_flag_isolate_erroneous_paths_attribute);
  hstate.add_wide_int (ptr->x_flag_isolate_erroneous_paths_dereference);
  hstate.add_wide_int (ptr->x_flag_ivopts);
  hstate.add_wide_int (ptr->x_flag_jump_tables);
  hstate.add_wide_int (ptr->x_flag_keep_gc_roots_live);
  hstate.add_wide_int (ptr->x_flag_lifetime_dse);
  hstate.add_wide_int (ptr->x_flag_limit_function_alignment);
  hstate.add_wide_int (ptr->x_flag_live_range_shrinkage);
  hstate.add_wide_int (ptr->x_flag_loop_nest_optimize);
  hstate.add_wide_int (ptr->x_flag_loop_parallelize_all);
  hstate.add_wide_int (ptr->x_flag_lra_remat);
  hstate.add_wide_int (ptr->x_flag_errno_math);
  hstate.add_wide_int (ptr->x_flag_modulo_sched);
  hstate.add_wide_int (ptr->x_flag_modulo_sched_allow_regmoves);
  hstate.add_wide_int (ptr->x_flag_move_loop_invariants);
  hstate.add_wide_int (ptr->x_flag_non_call_exceptions);
  hstate.add_wide_int (ptr->x_flag_nothrow_opt);
  hstate.add_wide_int (ptr->x_flag_omit_frame_pointer);
  hstate.add_wide_int (ptr->x_flag_opt_info);
  hstate.add_wide_int (ptr->x_flag_optimize_sibling_calls);
  hstate.add_wide_int (ptr->x_flag_optimize_strlen);
  hstate.add_wide_int (ptr->x_flag_pack_struct);
  hstate.add_wide_int (ptr->x_flag_partial_inlining);
  hstate.add_wide_int (ptr->x_flag_peel_loops);
  hstate.add_wide_int (ptr->x_flag_no_peephole);
  hstate.add_wide_int (ptr->x_flag_peephole2);
  hstate.add_wide_int (ptr->x_flag_plt);
  hstate.add_wide_int (ptr->x_flag_predictive_commoning);
  hstate.add_wide_int (ptr->x_flag_prefetch_loop_arrays);
  hstate.add_wide_int (ptr->x_flag_printf_return_value);
  hstate.add_wide_int (ptr->x_flag_reciprocal_math);
  hstate.add_wide_int (ptr->x_flag_pcc_struct_return);
  hstate.add_wide_int (ptr->x_flag_rename_registers);
  hstate.add_wide_int (ptr->x_flag_reorder_blocks);
  hstate.add_wide_int (ptr->x_flag_reorder_blocks_algorithm);
  hstate.add_wide_int (ptr->x_flag_reorder_blocks_and_partition);
  hstate.add_wide_int (ptr->x_flag_reorder_functions);
  hstate.add_wide_int (ptr->x_flag_rerun_cse_after_loop);
  hstate.add_wide_int (ptr->x_flag_resched_modulo_sched);
  hstate.add_wide_int (ptr->x_flag_rounding_math);
  hstate.add_wide_int (ptr->x_flag_rtti);
  hstate.add_wide_int (ptr->x_flag_sched_critical_path_heuristic);
  hstate.add_wide_int (ptr->x_flag_sched_dep_count_heuristic);
  hstate.add_wide_int (ptr->x_flag_sched_group_heuristic);
  hstate.add_wide_int (ptr->x_flag_schedule_interblock);
  hstate.add_wide_int (ptr->x_flag_sched_last_insn_heuristic);
  hstate.add_wide_int (ptr->x_flag_sched_pressure);
  hstate.add_wide_int (ptr->x_flag_sched_rank_heuristic);
  hstate.add_wide_int (ptr->x_flag_schedule_speculative);
  hstate.add_wide_int (ptr->x_flag_sched_spec_insn_heuristic);
  hstate.add_wide_int (ptr->x_flag_schedule_speculative_load);
  hstate.add_wide_int (ptr->x_flag_schedule_speculative_load_dangerous);
  hstate.add_wide_int (ptr->x_flag_sched_stalled_insns);
  hstate.add_wide_int (ptr->x_flag_sched_stalled_insns_dep);
  hstate.add_wide_int (ptr->x_flag_sched2_use_superblocks);
  hstate.add_wide_int (ptr->x_flag_schedule_fusion);
  hstate.add_wide_int (ptr->x_flag_schedule_insns);
  hstate.add_wide_int (ptr->x_flag_schedule_insns_after_reload);
  hstate.add_wide_int (ptr->x_flag_section_anchors);
  hstate.add_wide_int (ptr->x_flag_sel_sched_pipelining);
  hstate.add_wide_int (ptr->x_flag_sel_sched_pipelining_outer_loops);
  hstate.add_wide_int (ptr->x_flag_sel_sched_reschedule_pipelined);
  hstate.add_wide_int (ptr->x_flag_selective_scheduling);
  hstate.add_wide_int (ptr->x_flag_selective_scheduling2);
  hstate.add_wide_int (ptr->x_flag_setstackexecutable);
  hstate.add_wide_int (ptr->x_flag_short_enums);
  hstate.add_wide_int (ptr->x_flag_short_wchar);
  hstate.add_wide_int (ptr->x_flag_shrink_wrap);
  hstate.add_wide_int (ptr->x_flag_shrink_wrap_separate);
  hstate.add_wide_int (ptr->x_flag_signaling_nans);
  hstate.add_wide_int (ptr->x_flag_signed_zeros);
  hstate.add_wide_int (ptr->x_flag_simd_cost_model);
  hstate.add_wide_int (ptr->x_flag_single_precision_constant);
  hstate.add_wide_int (ptr->x_flag_split_ivs_in_unroller);
  hstate.add_wide_int (ptr->x_flag_split_loops);
  hstate.add_wide_int (ptr->x_flag_split_paths);
  hstate.add_wide_int (ptr->x_flag_split_wide_types);
  hstate.add_wide_int (ptr->x_flag_ssa_backprop);
  hstate.add_wide_int (ptr->x_flag_ssa_phiopt);
  hstate.add_wide_int (ptr->x_flag_stack_protect);
  hstate.add_wide_int (ptr->x_flag_stack_reuse);
  hstate.add_wide_int (ptr->x_flag_stdarg_opt);
  hstate.add_wide_int (ptr->x_flag_store_merging);
  hstate.add_wide_int (ptr->x_flag_strict_aliasing);
  hstate.add_wide_int (ptr->x_flag_strict_enums);
  hstate.add_wide_int (ptr->x_flag_strict_overflow);
  hstate.add_wide_int (ptr->x_flag_strict_volatile_bitfields);
  hstate.add_wide_int (ptr->x_flag_thread_jumps);
  hstate.add_wide_int (ptr->x_flag_threadsafe_statics);
  hstate.add_wide_int (ptr->x_flag_tracer);
  hstate.add_wide_int (ptr->x_flag_trapping_math);
  hstate.add_wide_int (ptr->x_flag_trapv);
  hstate.add_wide_int (ptr->x_flag_tree_bit_ccp);
  hstate.add_wide_int (ptr->x_flag_tree_builtin_call_dce);
  hstate.add_wide_int (ptr->x_flag_tree_ccp);
  hstate.add_wide_int (ptr->x_flag_tree_ch);
  hstate.add_wide_int (ptr->x_flag_tree_coalesce_vars);
  hstate.add_wide_int (ptr->x_flag_tree_copy_prop);
  hstate.add_wide_int (ptr->x_flag_tree_cselim);
  hstate.add_wide_int (ptr->x_flag_tree_dce);
  hstate.add_wide_int (ptr->x_flag_tree_dom);
  hstate.add_wide_int (ptr->x_flag_tree_dse);
  hstate.add_wide_int (ptr->x_flag_tree_forwprop);
  hstate.add_wide_int (ptr->x_flag_tree_fre);
  hstate.add_wide_int (ptr->x_flag_tree_loop_distribute_patterns);
  hstate.add_wide_int (ptr->x_flag_tree_loop_distribution);
  hstate.add_wide_int (ptr->x_flag_tree_loop_if_convert);
  hstate.add_wide_int (ptr->x_flag_tree_loop_im);
  hstate.add_wide_int (ptr->x_flag_tree_loop_ivcanon);
  hstate.add_wide_int (ptr->x_flag_tree_loop_optimize);
  hstate.add_wide_int (ptr->x_flag_tree_loop_vectorize);
  hstate.add_wide_int (ptr->x_flag_tree_live_range_split);
  hstate.add_wide_int (ptr->x_flag_tree_parallelize_loops);
  hstate.add_wide_int (ptr->x_flag_tree_partial_pre);
  hstate.add_wide_int (ptr->x_flag_tree_phiprop);
  hstate.add_wide_int (ptr->x_flag_tree_pre);
  hstate.add_wide_int (ptr->x_flag_tree_pta);
  hstate.add_wide_int (ptr->x_flag_tree_reassoc);
  hstate.add_wide_int (ptr->x_flag_tree_scev_cprop);
  hstate.add_wide_int (ptr->x_flag_tree_sink);
  hstate.add_wide_int (ptr->x_flag_tree_slp_vectorize);
  hstate.add_wide_int (ptr->x_flag_tree_slsr);
  hstate.add_wide_int (ptr->x_flag_tree_sra);
  hstate.add_wide_int (ptr->x_flag_tree_switch_conversion);
  hstate.add_wide_int (ptr->x_flag_tree_tail_merge);
  hstate.add_wide_int (ptr->x_flag_tree_ter);
  hstate.add_wide_int (ptr->x_flag_tree_vectorize);
  hstate.add_wide_int (ptr->x_flag_tree_vrp);
  hstate.add_wide_int (ptr->x_flag_unconstrained_commons);
  hstate.add_wide_int (ptr->x_flag_unroll_all_loops);
  hstate.add_wide_int (ptr->x_flag_unroll_loops);
  hstate.add_wide_int (ptr->x_flag_unsafe_math_optimizations);
  hstate.add_wide_int (ptr->x_flag_unswitch_loops);
  hstate.add_wide_int (ptr->x_flag_unwind_tables);
  hstate.add_wide_int (ptr->x_flag_var_tracking);
  hstate.add_wide_int (ptr->x_flag_vect_cost_model);
  hstate.add_wide_int (ptr->x_flag_value_profile_transformations);
  hstate.add_wide_int (ptr->x_flag_web);
  hstate.add_wide_int (ptr->x_flag_wrapv);
  return hstate.end ();
}

/* Stream out optimization options  */
void
cl_optimization_stream_out (struct bitpack_d *bp,
                            struct cl_optimization *ptr)
{
  bp_pack_value (bp, ptr->x_optimize, 64);
  bp_pack_value (bp, ptr->x_optimize_size, 64);
  bp_pack_value (bp, ptr->x_optimize_debug, 64);
  bp_pack_value (bp, ptr->x_flag_aggressive_loop_optimizations, 64);
  bp_pack_value (bp, ptr->x_align_functions, 64);
  bp_pack_value (bp, ptr->x_align_jumps, 64);
  bp_pack_value (bp, ptr->x_align_labels, 64);
  bp_pack_value (bp, ptr->x_align_loops, 64);
  bp_pack_value (bp, ptr->x_flag_associative_math, 64);
  bp_pack_value (bp, ptr->x_flag_asynchronous_unwind_tables, 64);
  bp_pack_value (bp, ptr->x_flag_auto_inc_dec, 64);
  bp_pack_value (bp, ptr->x_flag_branch_on_count_reg, 64);
  bp_pack_value (bp, ptr->x_flag_branch_probabilities, 64);
  bp_pack_value (bp, ptr->x_flag_branch_target_load_optimize, 64);
  bp_pack_value (bp, ptr->x_flag_branch_target_load_optimize2, 64);
  bp_pack_value (bp, ptr->x_flag_btr_bb_exclusive, 64);
  bp_pack_value (bp, ptr->x_flag_caller_saves, 64);
  bp_pack_value (bp, ptr->x_flag_code_hoisting, 64);
  bp_pack_value (bp, ptr->x_flag_combine_stack_adjustments, 64);
  bp_pack_value (bp, ptr->x_flag_compare_elim_after_reload, 64);
  bp_pack_value (bp, ptr->x_flag_conserve_stack, 64);
  bp_pack_value (bp, ptr->x_flag_cprop_registers, 64);
  bp_pack_value (bp, ptr->x_flag_crossjumping, 64);
  bp_pack_value (bp, ptr->x_flag_cse_follow_jumps, 64);
  bp_pack_value (bp, ptr->x_flag_cx_fortran_rules, 64);
  bp_pack_value (bp, ptr->x_flag_cx_limited_range, 64);
  bp_pack_value (bp, ptr->x_flag_dce, 64);
  bp_pack_value (bp, ptr->x_flag_defer_pop, 64);
  bp_pack_value (bp, ptr->x_flag_delayed_branch, 64);
  bp_pack_value (bp, ptr->x_flag_delete_dead_exceptions, 64);
  bp_pack_value (bp, ptr->x_flag_delete_null_pointer_checks, 64);
  bp_pack_value (bp, ptr->x_flag_devirtualize, 64);
  bp_pack_value (bp, ptr->x_flag_devirtualize_speculatively, 64);
  bp_pack_value (bp, ptr->x_flag_dse, 64);
  bp_pack_value (bp, ptr->x_flag_early_inlining, 64);
  bp_pack_value (bp, ptr->x_flag_exceptions, 64);
  bp_pack_value (bp, ptr->x_flag_expensive_optimizations, 64);
  bp_pack_value (bp, ptr->x_flag_finite_math_only, 64);
  bp_pack_value (bp, ptr->x_flag_float_store, 64);
  bp_pack_value (bp, ptr->x_flag_forward_propagate, 64);
  bp_pack_value (bp, ptr->x_flag_fp_contract_mode, 64);
  bp_pack_value (bp, ptr->x_flag_fp_int_builtin_inexact, 64);
  bp_pack_value (bp, ptr->x_flag_no_function_cse, 64);
  bp_pack_value (bp, ptr->x_flag_gcse, 64);
  bp_pack_value (bp, ptr->x_flag_gcse_after_reload, 64);
  bp_pack_value (bp, ptr->x_flag_gcse_las, 64);
  bp_pack_value (bp, ptr->x_flag_gcse_lm, 64);
  bp_pack_value (bp, ptr->x_flag_gcse_sm, 64);
  bp_pack_value (bp, ptr->x_flag_graphite, 64);
  bp_pack_value (bp, ptr->x_flag_graphite_identity, 64);
  bp_pack_value (bp, ptr->x_flag_guess_branch_prob, 64);
  bp_pack_value (bp, ptr->x_flag_hoist_adjacent_loads, 64);
  bp_pack_value (bp, ptr->x_flag_if_conversion, 64);
  bp_pack_value (bp, ptr->x_flag_if_conversion2, 64);
  bp_pack_value (bp, ptr->x_flag_indirect_inlining, 64);
  bp_pack_value (bp, ptr->x_flag_no_inline, 64);
  bp_pack_value (bp, ptr->x_flag_inline_atomics, 64);
  bp_pack_value (bp, ptr->x_flag_inline_functions, 64);
  bp_pack_value (bp, ptr->x_flag_inline_functions_called_once, 64);
  bp_pack_value (bp, ptr->x_flag_inline_small_functions, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_bit_cp, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_cp, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_cp_clone, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_icf, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_icf_functions, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_icf_variables, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_profile, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_pta, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_pure_const, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_ra, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_reference, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_sra, 64);
  bp_pack_value (bp, ptr->x_flag_ipa_vrp, 64);
  bp_pack_value (bp, ptr->x_flag_ira_algorithm, 64);
  bp_pack_value (bp, ptr->x_flag_ira_hoist_pressure, 64);
  bp_pack_value (bp, ptr->x_flag_ira_loop_pressure, 64);
  bp_pack_value (bp, ptr->x_flag_ira_region, 64);
  bp_pack_value (bp, ptr->x_flag_ira_share_save_slots, 64);
  bp_pack_value (bp, ptr->x_flag_ira_share_spill_slots, 64);
  bp_pack_value (bp, ptr->x_flag_isolate_erroneous_paths_attribute, 64);
  bp_pack_value (bp, ptr->x_flag_isolate_erroneous_paths_dereference, 64);
  bp_pack_value (bp, ptr->x_flag_ivopts, 64);
  bp_pack_value (bp, ptr->x_flag_jump_tables, 64);
  bp_pack_value (bp, ptr->x_flag_keep_gc_roots_live, 64);
  bp_pack_value (bp, ptr->x_flag_lifetime_dse, 64);
  bp_pack_value (bp, ptr->x_flag_limit_function_alignment, 64);
  bp_pack_value (bp, ptr->x_flag_live_range_shrinkage, 64);
  bp_pack_value (bp, ptr->x_flag_loop_nest_optimize, 64);
  bp_pack_value (bp, ptr->x_flag_loop_parallelize_all, 64);
  bp_pack_value (bp, ptr->x_flag_lra_remat, 64);
  bp_pack_value (bp, ptr->x_flag_errno_math, 64);
  bp_pack_value (bp, ptr->x_flag_modulo_sched, 64);
  bp_pack_value (bp, ptr->x_flag_modulo_sched_allow_regmoves, 64);
  bp_pack_value (bp, ptr->x_flag_move_loop_invariants, 64);
  bp_pack_value (bp, ptr->x_flag_non_call_exceptions, 64);
  bp_pack_value (bp, ptr->x_flag_nothrow_opt, 64);
  bp_pack_value (bp, ptr->x_flag_omit_frame_pointer, 64);
  bp_pack_value (bp, ptr->x_flag_opt_info, 64);
  bp_pack_value (bp, ptr->x_flag_optimize_sibling_calls, 64);
  bp_pack_value (bp, ptr->x_flag_optimize_strlen, 64);
  bp_pack_value (bp, ptr->x_flag_pack_struct, 64);
  bp_pack_value (bp, ptr->x_flag_partial_inlining, 64);
  bp_pack_value (bp, ptr->x_flag_peel_loops, 64);
  bp_pack_value (bp, ptr->x_flag_no_peephole, 64);
  bp_pack_value (bp, ptr->x_flag_peephole2, 64);
  bp_pack_value (bp, ptr->x_flag_plt, 64);
  bp_pack_value (bp, ptr->x_flag_predictive_commoning, 64);
  bp_pack_value (bp, ptr->x_flag_prefetch_loop_arrays, 64);
  bp_pack_value (bp, ptr->x_flag_printf_return_value, 64);
  bp_pack_value (bp, ptr->x_flag_reciprocal_math, 64);
  bp_pack_value (bp, ptr->x_flag_pcc_struct_return, 64);
  bp_pack_value (bp, ptr->x_flag_rename_registers, 64);
  bp_pack_value (bp, ptr->x_flag_reorder_blocks, 64);
  bp_pack_value (bp, ptr->x_flag_reorder_blocks_algorithm, 64);
  bp_pack_value (bp, ptr->x_flag_reorder_blocks_and_partition, 64);
  bp_pack_value (bp, ptr->x_flag_reorder_functions, 64);
  bp_pack_value (bp, ptr->x_flag_rerun_cse_after_loop, 64);
  bp_pack_value (bp, ptr->x_flag_resched_modulo_sched, 64);
  bp_pack_value (bp, ptr->x_flag_rounding_math, 64);
  bp_pack_value (bp, ptr->x_flag_rtti, 64);
  bp_pack_value (bp, ptr->x_flag_sched_critical_path_heuristic, 64);
  bp_pack_value (bp, ptr->x_flag_sched_dep_count_heuristic, 64);
  bp_pack_value (bp, ptr->x_flag_sched_group_heuristic, 64);
  bp_pack_value (bp, ptr->x_flag_schedule_interblock, 64);
  bp_pack_value (bp, ptr->x_flag_sched_last_insn_heuristic, 64);
  bp_pack_value (bp, ptr->x_flag_sched_pressure, 64);
  bp_pack_value (bp, ptr->x_flag_sched_rank_heuristic, 64);
  bp_pack_value (bp, ptr->x_flag_schedule_speculative, 64);
  bp_pack_value (bp, ptr->x_flag_sched_spec_insn_heuristic, 64);
  bp_pack_value (bp, ptr->x_flag_schedule_speculative_load, 64);
  bp_pack_value (bp, ptr->x_flag_schedule_speculative_load_dangerous, 64);
  bp_pack_value (bp, ptr->x_flag_sched_stalled_insns, 64);
  bp_pack_value (bp, ptr->x_flag_sched_stalled_insns_dep, 64);
  bp_pack_value (bp, ptr->x_flag_sched2_use_superblocks, 64);
  bp_pack_value (bp, ptr->x_flag_schedule_fusion, 64);
  bp_pack_value (bp, ptr->x_flag_schedule_insns, 64);
  bp_pack_value (bp, ptr->x_flag_schedule_insns_after_reload, 64);
  bp_pack_value (bp, ptr->x_flag_section_anchors, 64);
  bp_pack_value (bp, ptr->x_flag_sel_sched_pipelining, 64);
  bp_pack_value (bp, ptr->x_flag_sel_sched_pipelining_outer_loops, 64);
  bp_pack_value (bp, ptr->x_flag_sel_sched_reschedule_pipelined, 64);
  bp_pack_value (bp, ptr->x_flag_selective_scheduling, 64);
  bp_pack_value (bp, ptr->x_flag_selective_scheduling2, 64);
  bp_pack_value (bp, ptr->x_flag_setstackexecutable, 64);
  bp_pack_value (bp, ptr->x_flag_short_enums, 64);
  bp_pack_value (bp, ptr->x_flag_short_wchar, 64);
  bp_pack_value (bp, ptr->x_flag_shrink_wrap, 64);
  bp_pack_value (bp, ptr->x_flag_shrink_wrap_separate, 64);
  bp_pack_value (bp, ptr->x_flag_signaling_nans, 64);
  bp_pack_value (bp, ptr->x_flag_signed_zeros, 64);
  bp_pack_value (bp, ptr->x_flag_simd_cost_model, 64);
  bp_pack_value (bp, ptr->x_flag_single_precision_constant, 64);
  bp_pack_value (bp, ptr->x_flag_split_ivs_in_unroller, 64);
  bp_pack_value (bp, ptr->x_flag_split_loops, 64);
  bp_pack_value (bp, ptr->x_flag_split_paths, 64);
  bp_pack_value (bp, ptr->x_flag_split_wide_types, 64);
  bp_pack_value (bp, ptr->x_flag_ssa_backprop, 64);
  bp_pack_value (bp, ptr->x_flag_ssa_phiopt, 64);
  bp_pack_value (bp, ptr->x_flag_stack_protect, 64);
  bp_pack_value (bp, ptr->x_flag_stack_reuse, 64);
  bp_pack_value (bp, ptr->x_flag_stdarg_opt, 64);
  bp_pack_value (bp, ptr->x_flag_store_merging, 64);
  bp_pack_value (bp, ptr->x_flag_strict_aliasing, 64);
  bp_pack_value (bp, ptr->x_flag_strict_enums, 64);
  bp_pack_value (bp, ptr->x_flag_strict_overflow, 64);
  bp_pack_value (bp, ptr->x_flag_strict_volatile_bitfields, 64);
  bp_pack_value (bp, ptr->x_flag_thread_jumps, 64);
  bp_pack_value (bp, ptr->x_flag_threadsafe_statics, 64);
  bp_pack_value (bp, ptr->x_flag_tracer, 64);
  bp_pack_value (bp, ptr->x_flag_trapping_math, 64);
  bp_pack_value (bp, ptr->x_flag_trapv, 64);
  bp_pack_value (bp, ptr->x_flag_tree_bit_ccp, 64);
  bp_pack_value (bp, ptr->x_flag_tree_builtin_call_dce, 64);
  bp_pack_value (bp, ptr->x_flag_tree_ccp, 64);
  bp_pack_value (bp, ptr->x_flag_tree_ch, 64);
  bp_pack_value (bp, ptr->x_flag_tree_coalesce_vars, 64);
  bp_pack_value (bp, ptr->x_flag_tree_copy_prop, 64);
  bp_pack_value (bp, ptr->x_flag_tree_cselim, 64);
  bp_pack_value (bp, ptr->x_flag_tree_dce, 64);
  bp_pack_value (bp, ptr->x_flag_tree_dom, 64);
  bp_pack_value (bp, ptr->x_flag_tree_dse, 64);
  bp_pack_value (bp, ptr->x_flag_tree_forwprop, 64);
  bp_pack_value (bp, ptr->x_flag_tree_fre, 64);
  bp_pack_value (bp, ptr->x_flag_tree_loop_distribute_patterns, 64);
  bp_pack_value (bp, ptr->x_flag_tree_loop_distribution, 64);
  bp_pack_value (bp, ptr->x_flag_tree_loop_if_convert, 64);
  bp_pack_value (bp, ptr->x_flag_tree_loop_im, 64);
  bp_pack_value (bp, ptr->x_flag_tree_loop_ivcanon, 64);
  bp_pack_value (bp, ptr->x_flag_tree_loop_optimize, 64);
  bp_pack_value (bp, ptr->x_flag_tree_loop_vectorize, 64);
  bp_pack_value (bp, ptr->x_flag_tree_live_range_split, 64);
  bp_pack_value (bp, ptr->x_flag_tree_parallelize_loops, 64);
  bp_pack_value (bp, ptr->x_flag_tree_partial_pre, 64);
  bp_pack_value (bp, ptr->x_flag_tree_phiprop, 64);
  bp_pack_value (bp, ptr->x_flag_tree_pre, 64);
  bp_pack_value (bp, ptr->x_flag_tree_pta, 64);
  bp_pack_value (bp, ptr->x_flag_tree_reassoc, 64);
  bp_pack_value (bp, ptr->x_flag_tree_scev_cprop, 64);
  bp_pack_value (bp, ptr->x_flag_tree_sink, 64);
  bp_pack_value (bp, ptr->x_flag_tree_slp_vectorize, 64);
  bp_pack_value (bp, ptr->x_flag_tree_slsr, 64);
  bp_pack_value (bp, ptr->x_flag_tree_sra, 64);
  bp_pack_value (bp, ptr->x_flag_tree_switch_conversion, 64);
  bp_pack_value (bp, ptr->x_flag_tree_tail_merge, 64);
  bp_pack_value (bp, ptr->x_flag_tree_ter, 64);
  bp_pack_value (bp, ptr->x_flag_tree_vectorize, 64);
  bp_pack_value (bp, ptr->x_flag_tree_vrp, 64);
  bp_pack_value (bp, ptr->x_flag_unconstrained_commons, 64);
  bp_pack_value (bp, ptr->x_flag_unroll_all_loops, 64);
  bp_pack_value (bp, ptr->x_flag_unroll_loops, 64);
  bp_pack_value (bp, ptr->x_flag_unsafe_math_optimizations, 64);
  bp_pack_value (bp, ptr->x_flag_unswitch_loops, 64);
  bp_pack_value (bp, ptr->x_flag_unwind_tables, 64);
  bp_pack_value (bp, ptr->x_flag_var_tracking, 64);
  bp_pack_value (bp, ptr->x_flag_var_tracking_assignments, 64);
  bp_pack_value (bp, ptr->x_flag_var_tracking_assignments_toggle, 64);
  bp_pack_value (bp, ptr->x_flag_var_tracking_uninit, 64);
  bp_pack_value (bp, ptr->x_flag_variable_expansion_in_unroller, 64);
  bp_pack_value (bp, ptr->x_flag_vect_cost_model, 64);
  bp_pack_value (bp, ptr->x_flag_value_profile_transformations, 64);
  bp_pack_value (bp, ptr->x_flag_web, 64);
  bp_pack_value (bp, ptr->x_flag_wrapv, 64);
}

/* Stream in optimization options  */
void
cl_optimization_stream_in (struct bitpack_d *bp,
                           struct cl_optimization *ptr)
{
  ptr->x_optimize = (char ) bp_unpack_value (bp, 64);
  ptr->x_optimize_size = (char ) bp_unpack_value (bp, 64);
  ptr->x_optimize_debug = (char ) bp_unpack_value (bp, 64);
  ptr->x_flag_aggressive_loop_optimizations = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_align_functions = (int ) bp_unpack_value (bp, 64);
  ptr->x_align_jumps = (int ) bp_unpack_value (bp, 64);
  ptr->x_align_labels = (int ) bp_unpack_value (bp, 64);
  ptr->x_align_loops = (int ) bp_unpack_value (bp, 64);
  ptr->x_flag_associative_math = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_asynchronous_unwind_tables = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_auto_inc_dec = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_branch_on_count_reg = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_branch_probabilities = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_branch_target_load_optimize = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_branch_target_load_optimize2 = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_btr_bb_exclusive = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_caller_saves = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_code_hoisting = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_combine_stack_adjustments = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_compare_elim_after_reload = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_conserve_stack = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_cprop_registers = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_crossjumping = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_cse_follow_jumps = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_cx_fortran_rules = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_cx_limited_range = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_dce = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_defer_pop = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_delayed_branch = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_delete_dead_exceptions = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_delete_null_pointer_checks = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_devirtualize = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_devirtualize_speculatively = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_dse = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_early_inlining = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_exceptions = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_expensive_optimizations = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_finite_math_only = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_float_store = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_forward_propagate = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_fp_contract_mode = (enum fp_contract_mode ) bp_unpack_value (bp, 64);
  ptr->x_flag_fp_int_builtin_inexact = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_no_function_cse = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_gcse = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_gcse_after_reload = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_gcse_las = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_gcse_lm = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_gcse_sm = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_graphite = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_graphite_identity = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_guess_branch_prob = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_hoist_adjacent_loads = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_if_conversion = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_if_conversion2 = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_indirect_inlining = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_no_inline = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_inline_atomics = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_inline_functions = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_inline_functions_called_once = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_inline_small_functions = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_bit_cp = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_cp = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_cp_clone = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_icf = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_icf_functions = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_icf_variables = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_profile = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_pta = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_pure_const = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_ra = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_reference = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_sra = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ipa_vrp = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ira_algorithm = (enum ira_algorithm ) bp_unpack_value (bp, 64);
  ptr->x_flag_ira_hoist_pressure = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ira_loop_pressure = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ira_region = (enum ira_region ) bp_unpack_value (bp, 64);
  ptr->x_flag_ira_share_save_slots = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ira_share_spill_slots = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_isolate_erroneous_paths_attribute = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_isolate_erroneous_paths_dereference = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ivopts = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_jump_tables = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_keep_gc_roots_live = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_lifetime_dse = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_limit_function_alignment = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_live_range_shrinkage = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_loop_nest_optimize = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_loop_parallelize_all = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_lra_remat = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_errno_math = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_modulo_sched = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_modulo_sched_allow_regmoves = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_move_loop_invariants = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_non_call_exceptions = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_nothrow_opt = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_omit_frame_pointer = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_opt_info = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_optimize_sibling_calls = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_optimize_strlen = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_pack_struct = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_partial_inlining = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_peel_loops = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_no_peephole = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_peephole2 = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_plt = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_predictive_commoning = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_prefetch_loop_arrays = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_printf_return_value = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_reciprocal_math = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_pcc_struct_return = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_rename_registers = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_reorder_blocks = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_reorder_blocks_algorithm = (enum reorder_blocks_algorithm ) bp_unpack_value (bp, 64);
  ptr->x_flag_reorder_blocks_and_partition = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_reorder_functions = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_rerun_cse_after_loop = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_resched_modulo_sched = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_rounding_math = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_rtti = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_sched_critical_path_heuristic = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_sched_dep_count_heuristic = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_sched_group_heuristic = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_schedule_interblock = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_sched_last_insn_heuristic = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_sched_pressure = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_sched_rank_heuristic = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_schedule_speculative = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_sched_spec_insn_heuristic = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_schedule_speculative_load = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_schedule_speculative_load_dangerous = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_sched_stalled_insns = (int ) bp_unpack_value (bp, 64);
  ptr->x_flag_sched_stalled_insns_dep = (int ) bp_unpack_value (bp, 64);
  ptr->x_flag_sched2_use_superblocks = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_schedule_fusion = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_schedule_insns = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_schedule_insns_after_reload = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_section_anchors = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_sel_sched_pipelining = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_sel_sched_pipelining_outer_loops = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_sel_sched_reschedule_pipelined = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_selective_scheduling = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_selective_scheduling2 = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_setstackexecutable = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_short_enums = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_short_wchar = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_shrink_wrap = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_shrink_wrap_separate = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_signaling_nans = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_signed_zeros = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_simd_cost_model = (enum vect_cost_model ) bp_unpack_value (bp, 64);
  ptr->x_flag_single_precision_constant = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_split_ivs_in_unroller = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_split_loops = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_split_paths = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_split_wide_types = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ssa_backprop = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_ssa_phiopt = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_stack_protect = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_stack_reuse = (enum stack_reuse_level ) bp_unpack_value (bp, 64);
  ptr->x_flag_stdarg_opt = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_store_merging = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_strict_aliasing = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_strict_enums = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_strict_overflow = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_strict_volatile_bitfields = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_thread_jumps = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_threadsafe_statics = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tracer = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_trapping_math = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_trapv = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_bit_ccp = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_builtin_call_dce = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_ccp = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_ch = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_coalesce_vars = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_copy_prop = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_cselim = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_dce = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_dom = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_dse = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_forwprop = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_fre = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_loop_distribute_patterns = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_loop_distribution = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_loop_if_convert = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_loop_im = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_loop_ivcanon = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_loop_optimize = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_loop_vectorize = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_live_range_split = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_parallelize_loops = (int ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_partial_pre = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_phiprop = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_pre = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_pta = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_reassoc = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_scev_cprop = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_sink = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_slp_vectorize = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_slsr = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_sra = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_switch_conversion = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_tail_merge = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_ter = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_vectorize = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_tree_vrp = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_unconstrained_commons = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_unroll_all_loops = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_unroll_loops = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_unsafe_math_optimizations = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_unswitch_loops = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_unwind_tables = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_var_tracking = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_var_tracking_assignments = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_var_tracking_assignments_toggle = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_var_tracking_uninit = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_variable_expansion_in_unroller = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_vect_cost_model = (enum vect_cost_model ) bp_unpack_value (bp, 64);
  ptr->x_flag_value_profile_transformations = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_web = (signed char ) bp_unpack_value (bp, 64);
  ptr->x_flag_wrapv = (signed char ) bp_unpack_value (bp, 64);
}
