Subversion Repositories Open64

/*

 * Copyright (C) 2008-2011 Advanced Micro Devices, Inc.  All Rights Reserved.

 */

/*

 *  Copyright (C) 2007. Pathscale LLC. All Rights Reserved.

 */

/*

 *  Copyright (C) 2006, 2007. QLogic Corporation. All Rights Reserved.

 */

/*

 * Copyright 2002, 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.

 */

/*

  Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.

  This program is free software; you can redistribute it and/or modify it

  under the terms of version 2 of the GNU General Public License as

  published by the Free Software Foundation.

  This program is distributed in the hope that it would be useful, but

  WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

  Further, this software is distributed without any warranty that it is

  free of the rightful claim of any third person regarding infringement

  or the like.  Any license provided herein, whether implied or

  otherwise, applies only to this software file.  Patent licenses, if

  any, provided herein do not apply to combinations of this program with

  other software, or any other product whatsoever.

  You should have received a copy of the GNU General Public License along

  with this program; if not, write the Free Software Foundation, Inc., 59

  Temple Place - Suite 330, Boston MA 02111-1307, USA.

  Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,

  Mountain View, CA 94043, or:

  http://www.sgi.com

  For further information regarding this notice, see:

  http://oss.sgi.com/projects/GenInfo/NoticeExplan

*/

/* ====================================================================

 * ====================================================================

 *

 * Module: cgdriver.c

 * $Source: /proj/osprey/CVS/open64/osprey1.0/be/cg/cgdriver.cxx,v $

 *

 * Description:

 *

 * Main driver -- command line processing and file name manipulation --

 * for the code generator.

 *

 * ====================================================================

 * ====================================================================

 */

#include <stdint.h>

#include <errno.h>

#include <elf_stuff.h>

#if ! defined(BUILD_OS_DARWIN)

#include <elf.h>

#endif /* ! defined(BUILD_OS_DARWIN) */

#include <sys/elf_whirl.h>      /* for WHIRL_REVISION */

#include <ctype.h>

#include "defs.h"

#include "config.h"

#include "config_debug.h"

#include "config_list.h"

#include "config_targ_opt.h"

#include "config_opt.h"

#include "cg_flags.h"

#include "controls.h"

#include "flags.h"

#include "erglob.h"

#include "erlib.h"

#include "errors.h"

#include "../cg/init.cxx"           /* force include of Cg_Initializer */

#include "ercg.h"

#include "file_util.h"

#include "glob.h"

#include "timing.h"

#include "tracing.h"

#include "util.h"

#include "mempool.h"

#include "wn.h"         /* for WN */

#include "opt_alias_interface.h"    /* for ALIAS_MANAGER stuff */

#include "dwarf_DST_mem.h"

#include "bb.h"         /* for cgemit.h */

#include "cg.h"         /* CG_Initialize(), etc. */

#include "cgemit.h"       /* R_Assemble_File() */

#include "cg_swp_options.h"         /* for SWP_Options */

#include "gra.h"                    /* for GRA_optimize_placement... */

#include "ebo.h"        /* for EBO options */

#include "cgprep.h"       /* for CGPREP knobs */

#include "cg_dep_graph.h"     /* for CG_DEP knobs */

#include "cg_dep_graph_update.h"    /* more CG_DEP knobs */

#include "cio.h"                    /* for rw, cicse etc ...*/

#include "cg_loop.h"                /* for unrolling */

#include "cg_loop_recur.h"      /* recurrence fixing */

#include "cgtarget.h"       /* target-dependent stuff */

#include "gcm.h"        /* for GCM options */

#include "cg_sched_est.h"     /* for CG_SCHED_EST options */

#include "targ_proc_properties.h"

#include "cgdriver_arch.h"

#include "cgdriver.h"

#include "register.h"

#include "pqs_cg.h"

#if defined(TARG_IA64) || defined(TARG_LOONGSON)

#include "ipfec_options.h"

#endif

#ifdef KEY

#include "cg_gcov.h"

#include "flags.h"

#endif

#include "cg_swp.h"

#ifdef TARG_X8664

#include "config_wopt.h"

#endif

extern void Set_File_In_Printsrc(char *); /* defined in printsrc.c */

extern char *WHIRL_File_Name;

/* ====================================================================

 *

 * Back end process-specific global data from glob.h.

 *

 * ====================================================================

 */

/* Output requested: */

BOOL Assembly = FALSE;    /* Assembly code */

BOOL Object_Code = FALSE; /* Object code */

/* Have the OP_REGCOPY operations been translated? */

BOOL Regcopies_Translated = FALSE;

/* ====================================================================

 *

 * Local data.

 *

 * ====================================================================

 */

static char *Argv0;       /* argv[0] from main */

/* Default file extensions: */

#define ASM_FILE_EXTENSION ".s" /* Assembly code file */

#define OBJ_FILE_EXTENSION ".o" /* Relocatable object file */

#define DSTDUMP_FILE_EXTENSION ".be.dst" /* DST dump-file extension */

/* Internal flags: */

static BOOL cg_opt_level_overridden = FALSE;

static BOOL CG_tail_call_overridden = FALSE;

static BOOL CG_enable_prefetch_overridden = FALSE;

static BOOL CG_enable_z_conf_prefetch_overridden  = FALSE;

static BOOL CG_enable_nz_conf_prefetch_overridden = FALSE;

static BOOL CG_enable_pf_L1_ld_overridden = FALSE;

static BOOL CG_enable_pf_L1_st_overridden = FALSE;

static BOOL CG_enable_pf_L2_ld_overridden = FALSE;

static BOOL CG_enable_pf_L2_st_overridden = FALSE;

static BOOL CG_L1_ld_latency_overridden;

static BOOL CG_L2_ld_latency_overridden;

static BOOL CG_L1_pf_latency_overridden;

static BOOL CG_L2_pf_latency_overridden;

static BOOL CG_maxinss_overridden = FALSE;

static BOOL Enable_CG_Peephole_overridden = FALSE;

static BOOL EBO_Opt_Level_overridden = FALSE;

static BOOL Integer_Divide_By_Constant_overridden = FALSE;

static BOOL Integer_Divide_Use_Float_overridden = FALSE;

#ifdef TARG_IA64

static BOOL CGPREP_fold_expanded_daddiu_overridden = FALSE;

static BOOL CG_LOOP_create_loop_prologs_overridden = FALSE;

#endif

#ifdef KEY

static BOOL Integer_Multiply_By_Constant_overridden = FALSE;

#endif

static BOOL CG_DEP_Mem_Arc_Pruning_overridden = FALSE;

static BOOL clone_incr_overridden = FALSE;

static BOOL clone_min_incr_overridden = FALSE;

static BOOL clone_max_incr_overridden = FALSE;

static BOOL CFLOW_Enable_Clone_overridden = FALSE;

#ifdef TARG_X8664

BOOL cg_load_execute_overridden = FALSE;

#endif

#ifdef TARG_NVISA

static BOOL CG_use_16bit_ops_overridden = FALSE;

static BOOL CG_rematerialize_grf_overridden= FALSE;

#endif

/* Keep a copy of the command line options for assembly output: */

static char *option_string;

#ifdef TARG_IA64

extern BOOL SWP_KNOB_fatpoint;

#endif

#if !defined(TARG_NVISA)

/* Software pipelining options: */

static OPTION_DESC Options_CG_SWP[] = {

  /* General software pipelining options */

  { OVK_BOOL, OV_INTERNAL,  TRUE, "", NULL,

    0, 0, 0,  &Enable_SWP, &Enable_SWP_overridden },

  { OVK_INT32,  OV_INTERNAL,  TRUE, "sched_direction", "sched_dir",

    0, 0, INT32_MAX,  &SWP_Options.Sched_Direction, NULL },

  { OVK_INT32,  OV_INTERNAL,  TRUE, "heuristics", "heur",

    0, 0, INT32_MAX,  &SWP_Options.Heuristics, NULL },

  { OVK_INT32,  OV_INTERNAL,  TRUE, "opt", "opt",

    0, 0, INT32_MAX,  &SWP_Options.Opt_Level, NULL },

#ifdef TARG_IA64

  { OVK_BOOL, OV_INTERNAL,  TRUE, "do_loop", NULL,

    0, 0, 0,  &SWP_Options.Enable_Do_Loop, NULL },

#endif

  { OVK_BOOL, OV_INTERNAL,  TRUE, "while_loop", NULL,

    0, 0, 0,  &SWP_Options.Enable_While_Loop, NULL },

#ifdef TARG_IA64

  { OVK_INT32,  OV_INTERNAL,  TRUE, "miss_ratio", "miss_r",

    0, 0, INT32_MAX,  &SWP_Options.Load_Cache_Miss_Ratio, NULL },

  { OVK_INT32,  OV_INTERNAL,  TRUE, "miss_latency", "miss_l",

    0, 0, INT32_MAX,  &SWP_Options.Load_Cache_Miss_Latency, NULL },

#endif

  { OVK_INT32,  OV_INTERNAL,  TRUE, "min_unroll_times", "min_unr",

    0, 0, INT32_MAX,  &SWP_Options.Min_Unroll_Times, &SWP_Options.Max_Unroll_Times_Set },

  { OVK_INT32,  OV_INTERNAL,  TRUE, "max_unroll_times", "max_unr",

    0, 0, INT32_MAX,  &SWP_Options.Max_Unroll_Times, &SWP_Options.Max_Unroll_Times_Set },

  { OVK_BOOL, OV_INTERNAL,  TRUE, "bundle", NULL,

    TRUE, 0, 0, &SWP_Options.Enable_Bundling, NULL },

  { OVK_BOOL, OV_INTERNAL,  TRUE, "postincr", "posti",

    0, 0, 0,  &SWP_Options.Enable_Post_Incr, NULL },

  { OVK_INT32,  OV_INTERNAL,  TRUE, "start_ii", "start",

    0, 0, INT32_MAX,  &SWP_Options.Starting_II, NULL },

  { OVK_BOOL, OV_INTERNAL,  TRUE, "workaround", "work",

    0, 0, 0,  &SWP_Options.Enable_Workaround, NULL },

  { OVK_INT32,  OV_INTERNAL,  TRUE, "critical_threshold", "critical",

    0, 0, INT32_MAX,  &SWP_Options.Critical_Threshold, NULL },

  { OVK_BOOL, OV_INTERNAL,  TRUE, "prep_only", "",

    0, 0, 0,  &SWP_Options.Prep_Only, NULL },

  { OVK_BOOL, OV_INTERNAL,  TRUE, "min_retry", "",

    0, 0, 0,  &SWP_Options.Min_Retry, NULL },

  { OVK_BOOL, OV_INTERNAL,  TRUE, "implicit_prefetch", "",

    0, 0, 0,  &SWP_Options.Implicit_Prefetch, &SWP_Options.Implicit_Prefetch_Set },

  { OVK_BOOL, OV_INTERNAL,  TRUE, "predicate_promotion", "",

    0, 0, 0,  &SWP_Options.Predicate_Promotion, NULL },

  { OVK_BOOL, OV_INTERNAL,  TRUE, "enable_brp", "",

    0, 0, 0,  &SWP_Options.Enable_BRP, NULL },

#ifdef TARG_IA64

  { OVK_INT32,  OV_INTERNAL,    TRUE, "fb_prob1", "",

    0, 0, INT32_MAX,  &SWP_Options.FB_Prob1, NULL },

  { OVK_INT32,  OV_INTERNAL,    TRUE, "fb_prob2", "",

    0, 0, INT32_MAX,  &SWP_Options.FB_Prob2, NULL },

  { OVK_INT32,  OV_INTERNAL,    TRUE, "fb_freq", "",

    0, 0, INT32_MAX,  &SWP_Options.FB_Freq, NULL },

#endif

#ifdef SWP_USE_STL

  { OVK_INT32,  OV_INTERNAL,    TRUE, "ops_limit", NULL,

    SWP_OPS_LIMIT, 0, INT32_MAX,  &SWP_Options.OPS_Limit, NULL },

#else

  { OVK_INT32,  OV_INTERNAL,    TRUE, "ops_limit", NULL,

    SWP_OPS_LIMIT, 0, SWP_OPS_LIMIT,  &SWP_Options.OPS_Limit, NULL },

#endif

  { OVK_COUNT }   /* List terminator -- must be last */

};

/* Global register allocator options */

static OPTION_DESC Options_GRA[] = {

  { OVK_BOOL, OV_INTERNAL, TRUE,  "optimize_placement", "",

    0,0,0,      &GRA_optimize_placement, NULL,

    "Enable/disable movement of spills and restores created during splitting [Default TRUE]."

  },

#ifdef TARG_X8664

  { OVK_INT32,  OV_INTERNAL, TRUE, "local_forced_max", "local_forced_max",

    4, 0, 16, &GRA_local_forced_max, &GRA_local_forced_max_set,

    "How many locals to force allocate (out of the number requested by LRA) [Default 4]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE, "unspill", "",

    0,0,0,  &GRA_unspill_enable, NULL,

    "Enable/disable fusing of GRA spills and restores back to registers [Default FALSE]"

  },

#else

  { OVK_INT32,  OV_INTERNAL, TRUE, "local_forced_max", "",

    4, 0, 32, &GRA_local_forced_max, NULL,

    "How many locals to force allocate (out of the number requested by LRA) [Default 4]"

  },

#endif // TARG_X8664

  { OVK_BOOL, OV_INTERNAL, TRUE,  "avoid_glue_references_for_locals", "",

    0,0,0,      &GRA_avoid_glue_references_for_locals,NULL,

    "If possible grant the forced locals from the set of registers not referenced for glue copies in the same block.  [Default TRUE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE, "split_entry_exit_blocks", "",

    0,0,0,  &GRA_split_entry_exit_blocks,NULL,

    "Enable/Disable splitting of entry/exit blocks for callee saved preferencing [Default TRUE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "split_lranges", "",

    0,0,0,      &GRA_split_lranges, NULL,

    "Turn on/off splitting of live ranges [Default TRUE]"

  },

  { OVK_INT32,  OV_INTERNAL, TRUE, "non_split_tn", "",

    4, 0, INT32_MAX,  &GRA_non_split_tn_id, NULL,

    "Turn off live range splitting for a given TN specified by its tn number (n).  [Default -1]"

  },

  { OVK_INT32,  OV_INTERNAL, TRUE, "non_preference_tn", "",

    4, 0, INT32_MAX,  &GRA_non_preference_tn_id, NULL,

    "Turn off preferencing for a given TN specified by its tn number (n). [Default -1]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "use_old_conflict", "",

    0,0,0,      &GRA_use_old_conflict, NULL,

    "Use old conflict graph algorithm ... not functioning at present."

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "shrink_wrap", "",

    0,0,0,      &GRA_shrink_wrap, NULL,

    "Turn on/off shrink wrapping (currently, only for callee saved regs) [Default TRUE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "loop_splitting", "",

    0,0,0,      &GRA_loop_splitting, NULL,

    "Turn on/off loop directed live range splitting [Default TRUE]",

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "home", "",

    0,0,0,      &GRA_home, NULL,

    "Turn on/off gra homing [Default FALSE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "remove_spills", "",

    0,0,0,      &GRA_remove_spills, NULL,

    "Turn on/off gra removal of spill instructions in Optimize_Placment [Default TRUE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "ensure_spill_proximity", "",

    0,0,0,      &GRA_ensure_spill_proximity, NULL,

    "Turn on/off gra placing spills close to use/def in block [Default TRUE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "choose_best_split", "",

    0,0,0,      &GRA_choose_best_split, NULL,

    "Turn on/off gra choosing best/smallest interim split found [Default TRUE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "use_stacked_regs", "",

    0,0,0,      &GRA_use_stacked_regs, NULL,

    "Turn on/off gra using stacked registers [Default TRUE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "redo_liveness", "",

    0,0,0,      &GRA_redo_liveness, NULL,

    "Turn on/off recalculation of liveness [Default FALSE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "preference_globals", "",

    0,0,0,      &GRA_preference_globals, NULL,

    "Turn on/off gra preferencing of global TNs (other than glue code) [Default TRUE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "preference_dedicated", "",

    0,0,0,      &GRA_preference_dedicated, NULL,

    "Turn on/off gra preferencing with dedicated TNs  [Default TRUE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "preference_glue", "",

    0,0,0,      &GRA_preference_glue, NULL,

    "Turn on/off gra preferencing in glue code [Default TRUE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "preference_all", "",

    0,0,0,      &GRA_preference_all, NULL,

    "Turn on/off all gra preferencing [Default TRUE]"

  },

  { OVK_INT32,  OV_INTERNAL, TRUE, "non_home_low", "",

    4, 0, INT32_MAX,  &GRA_non_home_lo, NULL,

    "Turn off homing for a TN range specified by its tn numbers.  [Default INT32_MAX]"

  },

  { OVK_INT32,  OV_INTERNAL, TRUE, "non_home_hi", "",

    4, 0, INT32_MAX,  &GRA_non_home_hi, NULL,

    "Turn off homing for a TN range specified by its tn numbers.  [Default -1]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "recalc_liveness", "",

    0,0,0,      &GRA_recalc_liveness, NULL,

    "Turn on/off recomputation of global liveness info [Default FALSE]"

  },

  { OVK_NAME,   OV_INTERNAL, TRUE,"call_split_freq", "",

    0, 0, 0,  &GRA_call_split_freq_string, NULL,

    "Threshold frequency of block containing a call below which a caller saved register will be preferred and live ranges spanning it will be split [Default .1]"

  },

  { OVK_NAME,   OV_INTERNAL, TRUE,"spill_count_factor", "",

    0, 0, 0,  &GRA_spill_count_factor_string, NULL,

    "Factor by which count of spills affects the priority of a split.  Only valid under OPT:space [Default 0.5]"

  },

#ifdef KEY

  { OVK_BOOL,   OV_INTERNAL, TRUE,"exclude_saved_regs", "",

    0, 0, 0,  &GRA_exclude_callee_saved_regs, NULL,

    "If true, callee-saved registers are never used to allocate to variables by GRA"

  },

  { OVK_BOOL,   OV_INTERNAL, TRUE,"eh_exclude_saved_regs", "",

    0, 0, 0,  &GRA_eh_exclude_callee_saved_regs, NULL,

    "If true, callee-saved registers are never used to allocate to variables in functions with exception handlers"

  },

  { OVK_BOOL,   OV_INTERNAL, TRUE,"fp_exclude_saved_regs", "",

    0, 0, 0,  &GRA_fp_exclude_callee_saved_regs, NULL,

    "If true, floating-point callee-saved registers are never used to allocate to variables by GRA"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "optimize_boundary", "",

    0,0,0,      &GRA_optimize_boundary, &GRA_optimize_boundary_set,

    "Enable/disable reuse of registers in live range boundary basic blocks [Default FALSE]."

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "prioritize_by_density", "",

    0,0,0,      &GRA_prioritize_by_density, &GRA_prioritize_by_density_set,

    "Enable/disable prioritizing live ranges by reference density [Default FALSE]."

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "reclaim", "",

    0,0,0,      &GRA_reclaim_register, &GRA_reclaim_register_set,

    "Enable/disable reclaiming of registers after they have been allocated [Default FALSE]."

  },

#endif // KEY

#ifdef TARG_X8664

  { OVK_BOOL, OV_INTERNAL, TRUE,  "grant_special_regs", "",

    0,0,0,      &GRA_grant_special_regs, NULL,

    "Force GRA to always grant rax/rcx/rdx, whether LRA needs them or not."

  },

#endif

  { OVK_COUNT }   /* List terminator -- must be last */

};

#endif // ! TARG_NVISA

static OPTION_DESC Options_CG[] = {

  // Generic CG options.

  { OVK_BOOL, OV_INTERNAL, TRUE, "warn_bad_freqs", "",

    0, 0, 0,  &CG_warn_bad_freqs, NULL },

#ifdef TARG_IA64

  { OVK_BOOL, OV_INTERNAL, TRUE, "loop_opt", "loop_opt",

    0, 0, 0,  &CG_enable_loop_optimizations, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "tune_do_loop", "tune_do_loop",

    0, 0, 0,    &CG_tune_do_loop, NULL },

#endif

  { OVK_INT32,  OV_INTERNAL, TRUE, "skip_before", "skip_b",

    0, 0, INT32_MAX, &CG_skip_before, NULL },

  { OVK_INT32,  OV_INTERNAL, TRUE, "skip_after", "skip_a",

    0, 0, INT32_MAX, &CG_skip_after, NULL },

  { OVK_INT32,  OV_INTERNAL, TRUE, "skip_equal", "skip_e",

    0, 0, INT32_MAX, &CG_skip_equal, NULL },

  { OVK_INT32,  OV_INTERNAL, TRUE, "local_skip_before", "local_skip_b",

    0, 0, INT32_MAX, &CG_local_skip_before, NULL },

  { OVK_INT32,  OV_INTERNAL, TRUE, "local_skip_after", "local_skip_a",

    0, 0, INT32_MAX, &CG_local_skip_after, NULL },

  { OVK_INT32,  OV_INTERNAL, TRUE, "local_skip_equal", "local_skip_e",

    0, 0, INT32_MAX, &CG_local_skip_equal, NULL },

#ifdef TARG_NVISA

  { OVK_BOOL, OV_INTERNAL, TRUE, "skip_local_16bit", "",

    0, 0, 0,  &CG_skip_local_16bit, NULL },

#else

  { OVK_BOOL, OV_INTERNAL, TRUE, "skip_local_hbf", "",

    0, 0, 0,  &CG_skip_local_hbf, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "skip_local_loop", "",

    0, 0, 0,  &CG_skip_local_loop, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "skip_local_swp", "",

    0, 0, 0,  &CG_skip_local_swp, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "skip_local_ebo", "",

    0, 0, 0,  &CG_skip_local_ebo, NULL },

#ifdef TARG_X8664

  { OVK_BOOL, OV_VISIBLE, TRUE, "cmp_peep", "",

    0, 0, 0,  &CG_cmp_load_exec, NULL },

  { OVK_BOOL, OV_VISIBLE, TRUE, "fma3_peep", "",

    0, 0, 0,  &CG_fma3_load_exec, NULL },

  { OVK_BOOL, OV_VISIBLE, TRUE, "fma4_peep", "",

    0, 0, 0,  &CG_fma4_load_exec, NULL },

  { OVK_BOOL, OV_VISIBLE, TRUE, "dsched", "",

    0, 0, 0,  &CG_dispatch_schedule, NULL },

  { OVK_BOOL,   OV_VISIBLE, TRUE, "nobest_fit", "",

    0, 0, 0,    &CG_LOOP_nounroll_best_fit_set, NULL },

  { OVK_BOOL, OV_VISIBLE, TRUE, "unalign_st", "",

    0, 0, 0,  &CG_128bitstore, NULL },

  { OVK_BOOL, OV_VISIBLE, TRUE, "brfuse", "",

    0, 0, 0,  &CG_branch_fuse, NULL },

  { OVK_BOOL,   OV_VISIBLE, TRUE, "strcmp_expand", "",

    0, 0, 0,    &CG_strcmp_expand, NULL },

  { OVK_BOOL,   OV_VISIBLE, TRUE, "merge_counters_x86", "",

    0, 0, 0,    &CG_merge_counters_x86, &CG_merge_counters_x86_set },

  { OVK_BOOL,   OV_VISIBLE, TRUE, "interior_ptrs", "",

    0, 0, 0,    &CG_interior_ptrs_x86, NULL },

  { OVK_BOOL,   OV_VISIBLE, TRUE, "noavx_clear", "",

    0, 0, 0,    &CG_NoClear_Avx_Simd, NULL },

#endif

  { OVK_BOOL, OV_INTERNAL, TRUE, "skip_local_sched", "",

    0, 0, 0,  &CG_skip_local_sched, NULL },

#endif //TARG_NVISA

  { OVK_INT32,  OV_INTERNAL, TRUE, "optimization_level", "opt",

    0, 0, MAX_OPT_LEVEL,

                &CG_opt_level, &cg_opt_level_overridden },

#ifdef TARG_NVISA

  { OVK_BOOL,   OV_INTERNAL, TRUE, "optimize_copies", "",

    0, 0, 0,    &CG_optimize_copies, NULL },

  { OVK_BOOL,   OV_INTERNAL, TRUE, "remove_typeconv", "",

    0, 0, 0,    &CG_remove_typeconv, NULL },

  { OVK_BOOL,   OV_INTERNAL, TRUE, "rematerialize_grf", "",

    0, 0, 0,    &CG_rematerialize_grf, &CG_rematerialize_grf_overridden},

  { OVK_BOOL,   OV_INTERNAL, TRUE, "use_16bit_ops", "",

    0, 0, 0,    &CG_use_16bit_ops, &CG_use_16bit_ops_overridden},

  { OVK_BOOL,   OV_INTERNAL, TRUE, "vector_loadstore", "",

    0, 0, 0,    &CG_vector_loadstore, NULL },

  { OVK_BOOL,   OV_INTERNAL, TRUE,"cflow", NULL,

    0, 0, 0, &CFLOW_Enable, NULL },

#endif

#if !defined(TARG_NVISA)

  // EBO options:

  { OVK_BOOL, OV_INTERNAL, TRUE, "peephole_optimize", "",

    0, 0, 0,  &Enable_CG_Peephole, &Enable_CG_Peephole_overridden },

#ifdef TARG_IA64

  { OVK_BOOL, OV_INTERNAL, TRUE, "ebo_post_proc_rgn", "",

    0, 0, 0,  &Enable_EBO_Post_Proc_Rgn , NULL},

#endif

  { OVK_BOOL,   OV_INTERNAL, TRUE, "create_madds", "create_madd",

    0, 0, 0,  &CG_create_madds, NULL },

#ifdef TARG_IA64

  { OVK_BOOL,   OV_INTERNAL, TRUE,  "enable_ipfec_phases", "enable_ipfec",

    0,0,0,      &CG_Enable_Ipfec_Phases, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "enable_cycle_counting", "enable_cycle",

    0,0,0,      &CG_Enable_Cycle_Count, NULL },

#endif

#ifdef KEY

  { OVK_BOOL, OV_INTERNAL, TRUE,  "test_coverage", "",

    0, 0, 0,    &flag_test_coverage, NULL},

  { OVK_LIST, OV_INTERNAL, FALSE, "profile_proc", "",

    0, 0, 0,    &Arc_Profile_Region, NULL},

  { OVK_LIST, OV_INTERNAL, FALSE, "profile_id1",  "",

    0, 0, 0,    &Arc_Profile_Region, NULL},

  { OVK_LIST, OV_INTERNAL, FALSE, "profile_id2", "",

    0, 0, 0,    &Arc_Profile_Region, NULL},

  { OVK_INT32,  OV_INTERNAL, FALSE,  "cse_regs", "",

    0, INT32_MIN, INT32_MAX,    &CG_cse_regs, NULL},

  { OVK_INT32,  OV_INTERNAL, FALSE,  "sse_cse_regs", "",

    0, INT32_MIN, INT32_MAX,    &CG_sse_cse_regs, NULL},

#endif

#ifdef TARG_X8664

  { OVK_INT32,  OV_INTERNAL, TRUE,  "sse_load_execute", "sse_load_exe",

    0, 0, INT32_MAX,    &CG_sse_load_execute, NULL},

  { OVK_INT32,  OV_INTERNAL, TRUE, "load_execute", "load_exe",

    0, 0, INT32_MAX,  &CG_load_execute, &cg_load_execute_overridden },

  { OVK_BOOL, OV_INTERNAL, TRUE, "loadbw_execute", "loadbw_exe",

    0, 0, 0,  &CG_loadbw_execute, NULL },

  { OVK_BOOL,   OV_INTERNAL, TRUE, "valgrind_friendly", "valgrind",

    0, 0, 0,    &CG_valgrind_friendly, NULL },

  { OVK_BOOL,   OV_INTERNAL, TRUE, "movext_icmp", "movext_icmp",

    0, 0, 0,    &CG_Movext_ICMP, NULL },

#endif

  // CG Dependence Graph related options.

  { OVK_BOOL, OV_INTERNAL, TRUE, "ignore_lno", "",

    0, 0, 0,  &CG_DEP_Ignore_LNO, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "ignore_wopt", "",

    0, 0, 0,  &CG_DEP_Ignore_WOPT, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "addr_analysis", "",

    0, 0, 0,  &CG_DEP_Addr_Analysis, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "verify_mem_deps", "",

    0, 0, 0,  &CG_DEP_Verify_Mem_Deps, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "add_alloca_arcs", "",

    0, 0, 0,  &CG_DEP_Add_Alloca_Arcs, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "relax_xfer_depndnce", "",

    0, 0, 0,  &CG_DEP_Relax_Xfer_Dependence, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "adjust_ooo_latency", "adjust_ooo_latency",

    0, 0, 0,  &CG_DEP_Adjust_OOO_Latency, NULL },

  { OVK_INT32,  OV_INTERNAL, TRUE, "prune_mem", "",

    0, 0, INT32_MAX, &CG_DEP_Mem_Arc_Pruning,

    &CG_DEP_Mem_Arc_Pruning_overridden },

  { OVK_BOOL, OV_INTERNAL, TRUE, "prune_depndnce", "",

    0, 0, 0,  &CG_DEP_Prune_Dependence, NULL },

  // Prefetching and load latency options.

#ifdef TARG_IA64

  { OVK_BOOL, OV_INTERNAL, FALSE,"prefetch", "",

#else

  { OVK_BOOL,   OV_INTERNAL, TRUE,"prefetch", "",

#endif

    0, 0, 0, &CG_enable_prefetch, &CG_enable_prefetch_overridden },

  { OVK_BOOL, OV_INTERNAL, TRUE,"z_conf_prefetch", "",

    0, 0, 0, &CG_enable_z_conf_prefetch,

       &CG_enable_z_conf_prefetch_overridden },

  { OVK_BOOL, OV_INTERNAL, TRUE,"nz_conf_prefetch", "",

    0, 0, 0, &CG_enable_nz_conf_prefetch,

       &CG_enable_nz_conf_prefetch_overridden },

  { OVK_BOOL, OV_INTERNAL, TRUE,"pf_L1_ld", "",

    0, 0, 0, &CG_enable_pf_L1_ld, &CG_enable_pf_L1_ld_overridden },

  { OVK_BOOL, OV_INTERNAL, TRUE,"pf_L1_st", "",

    0, 0, 0, &CG_enable_pf_L1_st, &CG_enable_pf_L1_st_overridden },

  { OVK_BOOL, OV_INTERNAL, TRUE,"pf_L2_ld", "",

    0, 0, 0, &CG_enable_pf_L2_ld, &CG_enable_pf_L2_ld_overridden },

  { OVK_BOOL, OV_INTERNAL, TRUE,"pf_L2_st", "",

    0, 0, 0, &CG_enable_pf_L2_st, &CG_enable_pf_L2_st_overridden },

  { OVK_BOOL, OV_INTERNAL, TRUE, "exclusive_prefetch", "",

    0, 0, 0, &CG_exclusive_prefetch, NULL },

  { OVK_INT32,  OV_INTERNAL, TRUE, "L1_pf_latency", "",

    0, 0, INT32_MAX, &CG_L1_pf_latency, &CG_L1_pf_latency_overridden  },

  { OVK_INT32,  OV_INTERNAL, TRUE, "L2_pf_latency", "",

    0, 0, INT32_MAX, &CG_L2_pf_latency, &CG_L2_pf_latency_overridden },

  { OVK_INT32,  OV_INTERNAL, TRUE, "L1_ld_latency", "",

    0, 0, INT32_MAX, &CG_L1_ld_latency, &CG_L1_ld_latency_overridden },

  { OVK_INT32,  OV_INTERNAL, TRUE, "L2_ld_latency", "",

    0, 0, INT32_MAX, &CG_L2_ld_latency, &CG_L2_ld_latency_overridden },

  { OVK_INT32,  OV_INTERNAL, TRUE, "z_conf_L1_ld_latency", "",

    0, 0, INT32_MAX, &CG_z_conf_L1_ld_latency, NULL },

  { OVK_INT32,  OV_INTERNAL, TRUE, "z_conf_L2_ld_latency", "",

    0, 0, INT32_MAX, &CG_z_conf_L2_ld_latency, NULL },

  { OVK_INT32,  OV_INTERNAL, TRUE, "ld_latency", "",

    0, 0, INT32_MAX, &CG_ld_latency, NULL },

  // CGLOOP options.

  { OVK_BOOL, OV_INTERNAL, TRUE, "loop_opt", "loop_opt",

    0, 0, 0,  &CG_enable_loop_optimizations, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "opt_non_trip_countable", "opt_non_trip",

    0, 0, 0,  &CG_LOOP_optimize_non_trip_countable, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "opt_lno_winddown_cache", NULL,

    0, 0, 0,  &CG_LOOP_optimize_lno_winddown_cache, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "opt_lno_winddown_reg", NULL,

    0, 0, 0,  &CG_LOOP_optimize_lno_winddown_reg, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "opt_non_innermost", "opt_non_inner",

    0, 0, 0,  &CG_LOOP_optimize_non_innermost, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "fix_recurrences", "",

    0, 0, 0,    &CG_LOOP_fix_recurrences,

    &CG_LOOP_fix_recurrences_specified },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "back_substitution", "",

    0, 0, 0,    &CG_LOOP_back_substitution,

    &CG_LOOP_back_substitution_specified },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "back_substitution_variant", "",

    0, 0, 0,    &CG_LOOP_back_substitution_variant,

    &CG_LOOP_back_substitution_variant_specified },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "interleave_reductions", "",

    0, 0, 0,    &CG_LOOP_interleave_reductions,

    &CG_LOOP_interleave_reductions_specified },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "interleave_posti", "",

    0, 0, 0,    &CG_LOOP_interleave_posti,

    &CG_LOOP_interleave_posti_specified },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "reassociate", "reassoc",

    0, 0, 0,    &CG_LOOP_reassociate,

    &CG_LOOP_reassociate_specified },

  { OVK_INT32, OV_INTERNAL, TRUE, "recurrence_min_omega", "",

    0, 0, INT32_MAX, &CG_LOOP_recurrence_min_omega, NULL },

#ifdef KEY

  { OVK_INT32, OV_INTERNAL, TRUE, "recurrence_max_omega", "",

    0, 0, 16, &CG_LOOP_recurrence_max_omega, NULL },

  { OVK_INT32, OV_INTERNAL, TRUE, "loop_limit", "",

    INT32_MAX, 0, INT32_MAX, &CG_Enable_Loop_Opt_Limit, NULL },

#endif

#ifdef TARG_X8664

  { OVK_BOOL, OV_INTERNAL, TRUE, "cloop", "",

    0, 0, 0,  &CG_LOOP_cloop, NULL },

#endif

#if defined(TARG_SL)

  { OVK_INT32, OV_INTERNAL, TRUE, "zdl_enabled_level", "",

    INT32_MAX, 0, INT32_MAX, &CG_zdl_enabled_level, NULL },

  { OVK_BOOL,  OV_INTERNAL, TRUE, "opt_condmv", "",

    0, 0, 0,   &CG_enable_opt_condmv, NULL},

  { OVK_BOOL,  OV_INTERNAL, TRUE, "CBUS_workaround", "",

    0, 0, 0,   &CG_enable_CBUS_workaround, NULL},

  { OVK_BOOL,  OV_INTERNAL, TRUE, "LD_NOP_workaround", "",

    0, 0, 0,   &CG_enable_LD_NOP_workaround, NULL},

  { OVK_BOOL,  OV_INTERNAL, TRUE, "C3_AR_dependence_workaround", "",

    0, 0, 0,   &CG_enbale_C3_AR_dependence_workaround, NULL},

  /* For SL2, I need a options to tell what application I'm comping.

   * So I can get the right LUT file

   */

  { OVK_NAME, OV_INTERNAL, TRUE,"app_name", "",

    0, 0, 0, &App_Name, NULL },

  { OVK_NAME, OV_INTERNAL, TRUE,"cand_pattern", "",

    0, 0, 0, &Cand_List_Pattern, NULL },

#endif

  // CG Unrolling options - see also OPT:unroll_times_max:unroll_size.

  { OVK_BOOL, OV_INTERNAL, TRUE,"unroll_non_trip_countable", "unroll_non_trip",

    0, 0, 0, &CG_LOOP_unroll_non_trip_countable, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"unroll_fully", "unroll_full",

    0, 0, 0, &CG_LOOP_unroll_fully, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"unroll_remainder_fully", "unroll_remainder_full",

    0, 0, 0, &CG_LOOP_unroll_remainder_fully, NULL },

  { OVK_BOOL, OV_VISIBLE, TRUE,"unroll_fb_req", "",

    0, 0, 0, &CG_LOOP_unroll_fb_required, NULL },

  // Cross Iteration Loop Optimization options.

  { OVK_BOOL, OV_INTERNAL, TRUE, "cio_copy_removal", "",

    0, 0, 0, &CIO_enable_copy_removal, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "cio_read_removal", "",

    0, 0, 0, &CIO_enable_read_removal, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "cio_write_removal", "",

    0, 0, 0, &CIO_enable_write_removal, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "cio_cse_removal", "",

    0, 0, 0, &CIO_enable_cse_removal, NULL },

  { OVK_INT32, OV_INTERNAL, TRUE, "cio_rw_max_omega", "",

    8, 0, INT32_MAX, &CIO_rw_max_omega, NULL },

  // Control flow optimizations (CFLOW) options.

  { OVK_BOOL, OV_INTERNAL, TRUE, "unique_exit", "",

    0, 0, 0,  &CG_unique_exit, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "tail_call", "",

    0, 0, 0,  &CG_tail_call, &CG_tail_call_overridden },

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow_before_cgprep", NULL,

    0, 0, 0, &CFLOW_opt_before_cgprep, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow_after_cgprep", "cflow_after_cgprep",

    0, 0, 0, &CFLOW_opt_after_cgprep, NULL },

  { OVK_INT32,  OV_INTERNAL, TRUE,"ebo_level", "ebo",

    0, INT32_MIN, INT32_MAX, &EBO_Opt_Level, &EBO_Opt_Level_overridden },

#ifdef KEY

  { OVK_INT32,  OV_INTERNAL, TRUE,"ebo_opt_mask", "",

    0, INT32_MIN, INT32_MAX, &EBO_Opt_Mask, NULL },

#endif

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow", NULL,

    0, 0, 0, &CFLOW_Enable, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow_unreachable", "",

    0, 0, 0, &CFLOW_Enable_Unreachable, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow_branch", "",

    0, 0, 0, &CFLOW_Enable_Branch, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow_merge", "",

    0, 0, 0, &CFLOW_Enable_Merge, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow_reorder", "",

    0, 0, 0, &CFLOW_Enable_Reorder, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow_clone", "",

    0, 0, 0, &CFLOW_Enable_Clone, &CFLOW_Enable_Clone_overridden },

#ifdef KEY

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow_freq_order", "cflow_freq_order",

    0, 0, 0, &CFLOW_Enable_Freq_Order, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow_freq_order_on_heu", "cflow_freq_order_on_heu",

    0, 0, 0, &CFLOW_Enable_Freq_Order_On_Heuristics, NULL },

#else

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow_freq_order", "",

    0, 0, 0, &CFLOW_Enable_Freq_Order, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow_freq_order_on_heu", "",

    0, 0, 0, &CFLOW_Enable_Freq_Order_On_Heuristics, NULL },

#endif // KEY

  { OVK_BOOL, OV_INTERNAL, TRUE,"cflow_opt_all_br_to_bcond", "",

    0, 0, 0, &CFLOW_opt_all_br_to_bcond, NULL },

  { OVK_NAME, OV_INTERNAL, TRUE,"cflow_heuristic_tolerance", "",

    0, 0, 0, &CFLOW_heuristic_tolerance, NULL },

  { OVK_NAME, OV_INTERNAL, TRUE,"cflow_feedback_tolerance", "",

    0, 0, 0, &CFLOW_feedback_tolerance, NULL },

  { OVK_INT32,  OV_INTERNAL, TRUE,"cflow_clone_incr", "cflow_clone_i",

    0, 0, 100, &CFLOW_clone_incr, &clone_incr_overridden },

  { OVK_INT32,  OV_INTERNAL, TRUE,"cflow_clone_min_incr", "cflow_clone_mi",

    0, 0, INT32_MAX, &CFLOW_clone_min_incr, &clone_min_incr_overridden },

  { OVK_INT32,  OV_INTERNAL, TRUE,"cflow_clone_max_incr", "cflow_clone_ma",

    0, 0, INT32_MAX, &CFLOW_clone_max_incr, &clone_max_incr_overridden },

  { OVK_NAME, OV_INTERNAL, TRUE,"cflow_cold_threshold", "",

    0, 0, 0, &CFLOW_cold_threshold, NULL },

  // Frequency heuristic/feedback options.

  { OVK_BOOL, OV_INTERNAL, TRUE,"enable_frequency", "",

    0, 0, 0, &FREQ_enable, NULL },

  { OVK_NAME, OV_INTERNAL, TRUE,"eh_freq", "",

    0, 0, 0, &FREQ_eh_freq, NULL },

#ifdef KEY

  { OVK_NAME, OV_INTERNAL, TRUE,"non_local_targ_freq", "",

    0, 0, 0, &FREQ_non_local_targ_freq, NULL },

#endif

  { OVK_NAME, OV_INTERNAL, TRUE,"freq_frequent_never_ratio", "",

    0, 0, 0, &FREQ_frequent_never_ratio, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE, "freq_view_cfg", "",

    0, 0, 0, &FREQ_view_cfg, NULL },

#endif // ! TARG_NVISA

  // Whirl2ops / Expander options.

  { OVK_BOOL, OV_VISIBLE, TRUE, "divrem_opt", "",

    0, 0, 0,  &CG_divrem_opt, NULL },

  { OVK_NAME, OV_INTERNAL, TRUE,"fdiv_algorithm", "fdiv",

    0, 0, 0, &CGEXP_fdiv_algorithm, NULL },

  { OVK_NAME, OV_INTERNAL, TRUE,"sqrt_algorithm", "sqrt",

    0, 0, 0, &CGEXP_sqrt_algorithm, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"use_copyfcc", "",

    0, 0, 0, &CGEXP_use_copyfcc, NULL },

  { OVK_INT32,  OV_INTERNAL, TRUE,"expconst", "",

    DEFAULT_CGEXP_CONSTANT, 0, INT32_MAX, &CGEXP_expandconstant, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"normalize_logical", "normalize",

    0, 0, 0, &CGEXP_normalize_logical, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"gp_prolog_call_shared", "gp_prolog",

    0, 0, 0, &CGEXP_gp_prolog_call_shared, NULL },

#ifdef KEY

  { OVK_BOOL, OV_INTERNAL, TRUE,"integer_multiply_by_constant", "integer_multiply_by_constant",

    0, 0, 0, &CGEXP_cvrt_int_mult_to_add_shift, &Integer_Multiply_By_Constant_overridden },

#endif

  { OVK_BOOL, OV_INTERNAL, TRUE,"integer_divide_by_constant", "integer_divide_by_constant",

    0, 0, 0, &CGEXP_cvrt_int_div_to_mult, &Integer_Divide_By_Constant_overridden },

  { OVK_BOOL, OV_INTERNAL, TRUE,"integer_divide_use_float", "integer_divide_use_float",

    0, 0, 0, &CGEXP_cvrt_int_div_to_fdiv, &Integer_Divide_Use_Float_overridden },

  { OVK_BOOL, OV_INTERNAL, TRUE,"fast_imul", "",

    0, 0, 0, &CGEXP_fast_imul, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"float_consts_from_ints", "",

    0, 0, 0, &CGEXP_float_consts_from_ints, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"float_div_by_const", "",

    0, 0, 0, &CGEXP_opt_float_div_by_const, NULL },

#ifdef TARG_LOONGSON

  { OVK_BOOL,   OV_VISIBLE, TRUE,"use_loongson2e_multdivmod", "",

    0, 0, 0, &CGEXP_use_Loongson2e_MultDivMod, NULL },

  { OVK_BOOL,   OV_INTERNAL, TRUE,"float_use_madd", "",

    0, 0, 0, &CGEXP_float_use_madd, NULL },

#endif

  { OVK_NAME, OV_INTERNAL, TRUE,"lfhint_L1", "",

    0, 0, 0, &CGEXP_lfhint_L1, NULL },

  { OVK_NAME, OV_INTERNAL, TRUE,"lfhint_L2", "",

    0, 0, 0, &CGEXP_lfhint_L2, NULL },

  { OVK_NAME, OV_INTERNAL, TRUE,"ldhint_L1", "",

    0, 0, 0, &CGEXP_ldhint_L1, NULL },

  { OVK_NAME, OV_INTERNAL, TRUE,"ldhint_L2", "",

    0, 0, 0, &CGEXP_ldhint_L2, NULL },

  { OVK_NAME, OV_INTERNAL, TRUE,"sthint_L1", "",

    0, 0, 0, &CGEXP_sthint_L1, NULL },

  { OVK_NAME, OV_INTERNAL, TRUE,"sthint_L2", "",

    0, 0, 0, &CGEXP_sthint_L2, NULL },

#ifdef TARG_NVISA

  { OVK_BOOL, OV_INTERNAL, TRUE,"auto_as_static", "",

    0, 0, 0, &CGEXP_auto_as_static, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"gen_ccodes", "",

    0, 0, 0, &CGEXP_gen_ccodes, NULL },

#endif

  { OVK_BOOL, OV_INTERNAL, TRUE, "localize", "localize",

    0, 0, 0, &CG_localize_tns, &CG_localize_tns_Set},

#ifdef TARG_X8664

  { OVK_BOOL, OV_INTERNAL, TRUE, "localize_x87", "localize_x87",

    0, 0, 0, &CG_localize_x87_tns, &CG_localize_x87_tns_Set,

    "Localize x87 floating point variables.  Has no effect on integer variables.  Default off."

  },

#endif

#ifdef TARG_IA64

  { OVK_BOOL,   OV_INTERNAL, TRUE,  "ldxmov", "",

    0,0,0,      &CG_Enable_Ldxmov_Support, NULL },

#endif

  { OVK_BOOL, OV_INTERNAL, TRUE, "localize_using_stacked_regs", "localize_using_stack",

    0, 0, 0, &LOCALIZE_using_stacked_regs, NULL },

#if !defined(TARG_NVISA)

  // Local Register Allocation (LRA) options.

  { OVK_BOOL, OV_INTERNAL, TRUE,"rematerialize", "remat",

    0, 0, 0, &CGSPILL_Rematerialize_Constants, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"force_rematerialization", "force_remat",

    0, 0, 0, &CGSPILL_Enable_Force_Rematerialization, NULL },

  { OVK_BOOL, OV_INTERNAL, TRUE,"lra_reorder", "",

    0, 0, 0, &LRA_do_reorder, NULL },

#if defined(TARG_SL)

  { OVK_BOOL, OV_INTERNAL, TRUE,"check_reg_alloc", "",

    0, 0, 0, &Enable_Checking_Register_Allocation, NULL },

#endif

#ifdef TARG_X8664

  { OVK_BOOL, OV_INTERNAL, FALSE, "prefer_legacy_regs", "",

    0, 0, 0, &LRA_prefer_legacy_regs, NULL },

#endif

#ifdef KEY

  { OVK_INT32,  OV_INTERNAL, TRUE, "inflate_reg_request", "inflate_reg",

    0, 0, 100, &LRA_inflate_reg_request, &LRA_inflate_reg_request_Set,

    "Inflate LRA register request by this percentage for innermost loops [Default 0]"},

  { OVK_BOOL, OV_INTERNAL, FALSE, "prefer_lru_reg", "",

    1, 0, 0, &LRA_prefer_lru_reg, &LRA_prefer_lru_reg_Set },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "min_spill_loc_size", "",

    0,0,0,      &CG_min_spill_loc_size, NULL,

    "Turn on/off minimize spill location size [Default FALSE]"

  },

  { OVK_BOOL, OV_INTERNAL, TRUE,  "min_stack_size", "",

    0,0,0,      &CG_min_stack_size, NULL,

    "Turn on/off minimize stack size [Default TRUE]"

  },

#endif

  // Global Code Motion (GCM) options.

  {OVK_BOOL,  OV_INTERNAL, TRUE, "gcm", "gcm",