Open64: osprey/common/com/config

00001 /*
00002  * Copyright (C) 2007. QLogic Corporation. All Rights Reserved.
00003  */
00004 
00005 /*
00006  * Copyright 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00007  */
00008 
00009 /*
00010 
00011   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00012 
00013   This program is free software; you can redistribute it and/or modify it
00014   under the terms of version 2 of the GNU General Public License as
00015   published by the Free Software Foundation.
00016 
00017   This program is distributed in the hope that it would be useful, but
00018   WITHOUT ANY WARRANTY; without even the implied warranty of
00019   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00020 
00021   Further, this software is distributed without any warranty that it is
00022   free of the rightful claim of any third person regarding infringement 
00023   or the like.  Any license provided herein, whether implied or 
00024   otherwise, applies only to this software file.  Patent licenses, if 
00025   any, provided herein do not apply to combinations of this program with 
00026   other software, or any other product whatsoever.  
00027 
00028   You should have received a copy of the GNU General Public License along
00029   with this program; if not, write the Free Software Foundation, Inc., 59
00030   Temple Place - Suite 330, Boston MA 02111-1307, USA.
00031 
00032   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00033   Mountain View, CA 94043, or:
00034 
00035   http://www.sgi.com
00036 
00037   For further information regarding this notice, see:
00038 
00039   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00040 
00041 */
00042 
00043 
00044 /* ====================================================================
00045  * ====================================================================
00046  *
00047  * $Source: /proj/osprey/CVS/open64/osprey1.0/common/com/config_ipa.cxx,v $
00048  *
00049  * Revision history:
00050  *  11-Apr-96 - Original Version, extracted from ipa_option.c.
00051  *
00052  * Description:
00053  *
00054  * Configure the -IPA and -INLINE groups (included in config.c).
00055  * Used from ipl, inline, and ipa (ld).
00056  *
00057  * ====================================================================
00058  * ====================================================================
00059  */
00060 
00061 /* This file is included in config.c, so it doesn't need its own set of
00062  * standard includes -- only the following:
00063  */
00064 #include "config_ipa.h"
00065 
00066 /* IPA file variables declared in glob.h: */
00067 char *Ipa_File_Name = NULL; /* IPAA summary file name */
00068 char *Feedback_Filename = NULL;
00069 char *Annotation_Filename = NULL;
00070 FILE *Ipa_File = NULL;    /* IPAA summary file (if open) */
00071 
00072 /* Skiplist support from config.h: */
00073 typedef struct skiplist SKIPLIST;
00074 SKIPLIST *Build_Skiplist ( OPTION_LIST *olist );
00075 
00076 /* ====================================================================
00077  * List of global variables that are set by the -IPA option group
00078  * ====================================================================
00079  */
00080 
00081 #ifdef KEY
00082 const float DEFAULT_MIN_PROBABILITY = 0.20;
00083 #endif
00084 
00085 #define DEFAULT_BLOAT_FACTOR  100
00086 #define DEFAULT_PU_LIMIT  2500
00087 #define DEFAULT_HARD_LIMIT  (2500 + (2500 >> 2))
00088 #define DEFAULT_SMALL_PU  30
00089 #define DEFAULT_SMALL_CALLEE  500
00090 #define DEFAULT_MIN_FREQ  100
00091 #define DEFAULT_MIN_HOTNESS 10
00092 #define DEFAULT_RELA_FREQ 50
00093 #define DEFAULT_INLINE_Max_Pu_Size 5000
00094 #define DEFAULT_CLONE_BLOAT_FACTOR 100
00095 #define DEFAULT_EXTGOT_FACTOR   200     /* 2 times the estimated EXTGOT entries */
00096 #define DEFAULT_NUM_FORTRAN_INTR 100    /* Arbitary estimate */
00097 #define DEFAULT_MAP_LIMIT 0x1fff0000   /* total size in bytes we
00098             allow input objects to be
00099             mapped in at the same time
00100             without turning into the
00101             SAVE_SPACE option  
00102                 */
00103 #define DEFAULT_OUTPUT_FILE_SIZE  10000
00104 
00105 #define DEFAULT_MAX_DENSITY   11 // INLINING_TUNINING
00106 
00107 #ifdef KEY
00108 #define DEFAULT_ICALL_MIN_FREQ    200
00109 #endif
00110 
00111 
00112 /* #define DEFAULT_GSPACE 65535 -- from config.c */
00113 
00114 /* Feature enable flags: */
00115 BOOL IPA_Enable_DFE = TRUE;   /* Dead Function Elimination */
00116 BOOL IPA_Enable_DFE_Set = FALSE;  /* ... explicitly set? */
00117 BOOL IPA_Enable_Inline = TRUE;    /* Inlining */
00118 BOOL IPA_Enable_Picopt = TRUE;    /* PIC optimization */
00119 BOOL IPA_Enable_AutoGnum = TRUE;  /* AutoGnum optimization */
00120 BOOL IPA_Enable_Opt_Alias =FALSE; /* WOPT uses alias/mod/ref */
00121 BOOL IPA_Enable_Simple_Alias = TRUE;  /* Simple alias/mod/ref */
00122 BOOL IPA_Enable_Addressing = TRUE;  /* Addr_taken analysis */
00123 BOOL IPA_Enable_BarrierFarg = FALSE;  /* Barrier for aliased Fortran actual */
00124 BOOL IPA_Enable_Alias_Class = TRUE;     /* Alias classification */
00125 BOOL IPA_Debug_AC_Temp_Files = FALSE;   /* save alias class temps til done? */
00126 BOOL IPA_Enable_Readonly_Ref = TRUE;  /* find out readonly ref parameter */
00127 BOOL IPA_Enable_Cprop = TRUE;   /* Constant Propagation */
00128 BOOL IPA_Enable_Cprop2 = TRUE;    /* Aggressive constant propagation */
00129 BOOL IPA_Enable_Assert = FALSE;   // generate assert statement for
00130           // cprop debugging
00131 BOOL IPA_Enable_daVinci = FALSE;  /* Graphical display of call graph */
00132 BOOL IPA_Enable_ipacom = TRUE;    /* Call ipacom after IPA */
00133 BOOL IPA_Enable_final_link = TRUE;  /* Final link step */
00134 BOOL IPA_Enable_Memtrace = FALSE; /* Memory trace */
00135 BOOL IPA_Enable_DST = TRUE;   /* Generate DST */
00136 BOOL IPA_Enable_DCE = TRUE;   /* Enable Dead Call Elimination */
00137 BOOL IPA_Enable_Exc = TRUE;   /* Enable exception handling */
00138 BOOL IPA_Enable_Recycle = TRUE;   /* Enable recycling of variables */
00139 BOOL IPA_Enable_DVE = TRUE;   /* Enable Dead Variable Elimination */
00140 BOOL IPA_Enable_CGI = TRUE;   /* Enable Constant Global Variable
00141            * Identification */
00142 BOOL IPA_Enable_Copy_Prop = TRUE; /* Copy propagation during inlining */
00143 BOOL IPA_Enable_Padding = TRUE;   /* Intra-Dimension padding 
00144            * of common block variables */
00145 UINT32 IPA_Common_Pad_Size = 0;         /* Amount by which to pad commons */
00146 
00147 BOOL IPA_Enable_Cloning = TRUE;         /* Enable Cloning in conjunction */
00148                                         /* with constant propagation     */
00149 BOOL IPA_Enable_Lang = FALSE;           /* support inlining across language */
00150 BOOL IPA_Enable_Relocatable_Opt = FALSE;/* support -call_shared optimizations of relocatable objects */
00151 BOOL IPA_Enable_Split_Common = TRUE;    /* Enable split common inside IPA */
00152 BOOL IPA_Enable_Array_Sections = TRUE;  /* Array section analysis in IPA */
00153 BOOL IPA_Enable_Array_Summary = FALSE;  /* Array section summary in IPL */
00154 
00155 BOOL IPA_Enable_Scalar_Euse = FALSE;   /* enable scalar euse  */
00156 BOOL IPA_Enable_Scalar_Kill = FALSE;   /* enable scalar kill   */
00157 BOOL IPA_Enable_Common_Const = TRUE; /* enable cprop of common block vars */
00158 BOOL IPA_Enable_Feedback = FALSE;       /* create pragma files, etc.      */
00159 
00160 /* Echo back end command lines: */
00161 BOOL  IPA_Echo_Commands = FALSE;
00162 
00163 /* max. bloat % of the entire program */
00164 UINT32  IPA_Bloat_Factor = DEFAULT_BLOAT_FACTOR;
00165 BOOL  IPA_Bloat_Factor_Set = FALSE;
00166 
00167 #ifdef KEY
00168 float IPA_Min_Branch_Prob = DEFAULT_MIN_PROBABILITY;
00169 #endif
00170 UINT32  IPA_PU_Limit = DEFAULT_PU_LIMIT;/* Max nodes per PU after inlining */
00171 BOOL  IPA_PU_Limit_Set = FALSE; /* if IPA_PU_Limit is set by user */
00172 
00173 /* absolute max. # of nodes per PU after inlining (1.25 * IPA_PU_Limit) */
00174 UINT32  IPA_PU_Hard_Limit = DEFAULT_HARD_LIMIT;
00175 BOOL  IPA_PU_Hard_Limit_Set = FALSE;
00176 
00177 /* Size of small PU that's always inlined */
00178 UINT32  IPA_PU_Minimum_Size = DEFAULT_SMALL_PU;
00179 
00180 /* Callees larger than this size are not inlined, except ...  */
00181 UINT32  IPA_Small_Callee_Limit = DEFAULT_SMALL_CALLEE; 
00182 
00183 UINT32  IPA_Max_Depth = UINT32_MAX; /* maximum depth to inline */
00184 UINT32  IPA_Force_Depth = 0;    /* force inlining to depth n
00185            * regardless of size */
00186 BOOL  IPA_Force_Depth_Set = FALSE;
00187 BOOL  IPA_Enable_Merge_ty = TRUE; /* merge types across files */
00188 
00189 #ifdef KEY
00190 UINT32  IPA_Max_Jobs = 1; /* disable concurrent backend compilations */
00191 #else
00192 UINT32  IPA_Max_Jobs = 0; /* concurrent backend compilations */
00193 #endif
00194 BOOL  IPA_Max_Jobs_Set = FALSE;
00195 
00196 /* 100th% of call freq lower than which will not inlined */
00197 UINT32  IPA_Min_Freq = DEFAULT_MIN_FREQ;  
00198 
00199 
00200 /* For those infrequently invoked PU which however contains hot loops*/
00201 UINT32  IPA_Max_Density = DEFAULT_MAX_DENSITY;// INLINING_TUNINING
00202 
00203 /* % of time that an inlined callee is called by its caller */
00204 UINT32  IPA_Rela_Freq = DEFAULT_RELA_FREQ;  
00205 
00206 /* only routines "hotter" than this will be inlined */
00207 UINT32  IPA_Min_Hotness = DEFAULT_MIN_HOTNESS;
00208 
00209 /* ignore zero-freq. statements when estimating size of a PU */
00210 BOOL IPA_Use_Effective_Size = TRUE;
00211 
00212 /* max. gp-relative space available for auto Gnum */
00213 UINT32  IPA_Gspace = DEFAULT_GSPACE - 72;// Kluge to get around gcc problem
00214 
00215 /* % of estimtated external got size used for estimating the whole .got size */
00216 UINT32  IPA_Extgot_Factor = 0;
00217 
00218 /* number of FORTRAN instrinsics functions existed in this executable,
00219    used for estimating the number of GOTs */
00220 UINT32  IPA_Num_Fortran_Intrinsics = DEFAULT_NUM_FORTRAN_INTR;
00221 BOOL  IPA_Has_Fortran = FALSE;
00222 
00223 /* user specified -G num */
00224 UINT32  IPA_user_gnum = 0;  
00225 
00226 OPTION_LIST *IPA_Skip = NULL;   /* List of skip options */
00227 BOOL  IPA_Skip_Report = FALSE;  /* Report skip count */
00228 
00229 BOOL IPA_Enable_Preempt = FALSE;  /* allow the user to specify that
00230              functions are not preemptible */
00231 
00232 BOOL IPA_Enable_Flow_Analysis = TRUE; /* flow-sensitive analysis */
00233 
00234 /* Maximum limit IPA allows the whole program input to be mapped into
00235  * the address space without converting into the SAVE_SPACE mode
00236  */
00237 UINT32  IPA_Map_Limit = DEFAULT_MAP_LIMIT;
00238 
00239 BOOL IPA_Enable_SP_Partition = FALSE; /* Enable IPA to partition its
00240            * call-graph so as to allow
00241            * address space conversation
00242            */
00243 BOOL IPA_Enable_GP_Partition = FALSE; /* Enable IPA to partition its
00244            * call-graph so as to allow
00245            * picopt even if multigot
00246            */
00247 BOOL IPA_Space_Access_Mode = DEFAULT_ACCESS_MODE;
00248 
00249 BOOL IPA_Enable_Keeplight = TRUE;  /* allow the user to ONLY keep the .I
00250              * and .o in the .ipakeep directory
00251              */
00252 
00253 #ifdef KEY
00254 BOOL IPA_Enable_Icall_Opt = TRUE;   /* allow ipa change icall to call */
00255 BOOL IPA_Enable_EH_Region_Removal = FALSE; // remove useless exception regions
00256 BOOL IPA_Enable_Branch_Heuristic = FALSE; // use branch prob. for inlining
00257 BOOL IPA_Check_Options = TRUE; // check for inconsistent options
00258 BOOL IPA_Clone_List_Actions = FALSE; // report function cloner actions
00259 BOOL IPA_Enable_Pure_Call_Opt = FALSE; // optimize callsites w/o side-effects
00260 INT32 IPA_Pure_Call_skip_before = 0;
00261 
00262 BOOL IPA_Enable_Cord = FALSE;   /* will bring up for x86-64 */
00263 // In the absence of feedback, -IPA:pu_reorder defaults to REORDER_DISABLE
00264 PU_REORDER_SCHEME IPA_Enable_PU_Reorder = REORDER_DISABLE; /* Procedure reordering: PathScale version */
00265 BOOL IPA_Enable_PU_Reorder_Set = FALSE;
00266 BOOL IPA_Enable_Ctype = FALSE;    /* Insert array for use by ctype.h. */
00267 BOOL IPA_Consult_Inliner_For_Icall_Opt = TRUE; // Check inlining heuristics
00268                                                // during icall-opt?
00269 UINT32 IPA_Icall_Min_Freq = DEFAULT_ICALL_MIN_FREQ; // Min freq for icall opt
00270                                                     // used in IPL.
00271 BOOL IPA_Enable_Source_PU_Order = FALSE;
00272 #ifdef TARG_X8664
00273 UINT32 IPA_Enable_Struct_Opt = 1;
00274 #else
00275 UINT32 IPA_Enable_Struct_Opt = 0;
00276 #endif
00277 UINT32 IPA_Update_Struct = 0;   /* temporary, should be removed */
00278 #else
00279 BOOL IPA_Enable_Cord = TRUE;    /* Enable procedure reordering. */
00280 #endif
00281 BOOL IPA_Enable_Linearization = FALSE;  /* Enable linearization of array */
00282 BOOL IPA_Use_Intrinsic = FALSE;   /* load intrinsic libraries */
00283 
00284 BOOL IPA_Enable_Inline_Nested_PU = TRUE;  /* enable inlining of nested PU, for f90 */
00285 
00286 BOOL IPA_Enable_Reshape = TRUE;   // reshape analysis for arrays 
00287 BOOL IPA_Enable_Inline_Struct = TRUE;  /* enable inlining of STRUCT for f90 */
00288 BOOL IPA_Enable_Inline_Char_Array = TRUE;  /* enable inlining of Character Array for f90 */
00289 BOOL IPA_Enable_Inline_Optional_Arg = TRUE;  /* enable inlining of functions with optional arguments */
00290 BOOL IPA_Enable_Inline_Struct_Array_Actual = TRUE;  /* enable inlining of STRUCT for f90 when the actual is an array type */
00291 BOOL IPA_Enable_Inline_Var_Dim_Array = TRUE;  /* enable inlining of variable-dimensioned array */
00292 BOOL IPA_Enable_Reorder=FALSE; /*enable field reordering*/
00293 
00294 // call preopt during IPA
00295 BOOL IPA_Enable_Preopt = FALSE;          
00296 BOOL IPA_Enable_Preopt_Set = FALSE;
00297 
00298 // maximum number of clones for a call graph node
00299 UINT32 IPA_Max_Node_Clones = 0;
00300 BOOL   IPA_Max_Node_Clones_Set = FALSE;
00301 
00302 // maximum % increase of the call graph size through node cloning
00303 UINT32 IPA_Max_Clone_Bloat = DEFAULT_CLONE_BLOAT_FACTOR;
00304 
00305 /* Max. "size" of each output file */
00306 UINT32 IPA_Max_Output_File_Size = DEFAULT_OUTPUT_FILE_SIZE;
00307 
00308 /* percentage change of the max. output file size */
00309 INT32 IPA_Output_File_Size = 0;
00310 
00311 /* This flag is to use the old type merge phase. It should be removed when the old type merge is removed. */
00312 #if !defined(TARG_SL)
00313 BOOL IPA_Enable_Old_Type_Merge = FALSE;  
00314 #else
00315 BOOL IPA_Enable_Old_Type_Merge = TRUE;  //jczhang: Not enabled in SL
00316 #endif
00317 
00318 /* enable devirtualization */
00319 BOOL IPA_Enable_Devirtualization = FALSE;
00320 
00321 static OPTION_DESC Options_IPA[] = {
00322     { OVK_BOOL, OV_VISIBLE, FALSE, "addressing",  "",
00323     0, 0, 0,    &IPA_Enable_Addressing, NULL,
00324     "Enable address-taken analysis" },
00325     { OVK_BOOL, OV_VISIBLE, FALSE, "readonly_parameter",  "",
00326     0, 0, 0,    &IPA_Enable_Readonly_Ref, NULL,
00327     "Enable identification of read-only reference parameters" }, 
00328     { OVK_BOOL, OV_VISIBLE, FALSE, "aggr_cprop",    "",
00329     0, 0, 0,    &IPA_Enable_Cprop2, NULL,
00330     "Enable aggressive constant propagation" },
00331     { OVK_BOOL, OV_VISIBLE, FALSE, "alias", "",
00332     0, 0, 0,    &IPA_Enable_Simple_Alias,NULL,
00333     "Enable variable mod, use, and alias analysis" },
00334     { OVK_BOOL, OV_INTERNAL,  FALSE, "array_section", "",
00335     0, 0, 0,    &IPA_Enable_Array_Sections, NULL,
00336     "Enable interprocedural array section analysis " },
00337     { OVK_BOOL, OV_INTERNAL,  FALSE, "array_summary", "",
00338     0, 0, 0,    &IPA_Enable_Array_Summary, NULL,
00339     "Enable local array section summary" },
00340     { OVK_BOOL, OV_INTERNAL,  FALSE, "scalar_kill", "",
00341     0, 0, 0,    &IPA_Enable_Scalar_Kill, NULL,
00342     "Enable scalar kill analysis" },
00343     { OVK_BOOL, OV_INTERNAL,  FALSE, "scalar_euse", "",
00344     0, 0, 0,    &IPA_Enable_Scalar_Euse, NULL,
00345     "Enable scalar euse analysis" },
00346     { OVK_BOOL, OV_VISIBLE, FALSE, "common_cprop",  "",
00347     0, 0, 0,    &IPA_Enable_Common_Const, NULL,
00348     "Enable common constant propagation" },
00349     { OVK_BOOL, OV_VISIBLE, FALSE, "autognum",  "",
00350     0, 0, 0,    &IPA_Enable_AutoGnum, NULL,
00351     "Enable automatic gp-relative data allocation" },
00352     { OVK_BOOL, OV_INTERNAL,  FALSE, "barrier_aliasfarg", "",
00353     0, 0, 0,    &IPA_Enable_BarrierFarg,  NULL,
00354 /*
00355     "Enable barrier generation for inlined Fortran aliased actual arg." ,
00356     "Enable barrier gen. for inlined aliased Fortran actual" ,
00357 */
00358     "Enable barrier gen. " },
00359     { OVK_BOOL, OV_VISIBLE, FALSE, "cgi",   "",
00360     0, 0, 0,    &IPA_Enable_CGI,  NULL,
00361     "Enable constant global variable identification" },
00362     { OVK_BOOL, OV_SHY,   FALSE, "compile", "",
00363     0, 0, 0,    &IPA_Enable_ipacom, NULL,
00364     "Enable final back-end compilation" }, 
00365     { OVK_BOOL, OV_SHY,   FALSE, "link",    "",
00366     0, 0, 0,    &IPA_Enable_final_link, NULL,
00367     "Enable final link step" },
00368     { OVK_BOOL, OV_VISIBLE, FALSE, "copy_prop", "",
00369     0, 0, 0,    &IPA_Enable_Copy_Prop,  NULL,
00370     "Enable interprocedural copy propagation" },
00371     { OVK_BOOL, OV_VISIBLE, FALSE, "cprop", "",
00372     0, 0, 0,    &IPA_Enable_Cprop,  NULL,
00373     "Enable constant propagation" },
00374     { OVK_BOOL, OV_INTERNAL,  FALSE, "assert", "",
00375     0, 0, 0,    &IPA_Enable_Assert, NULL,
00376           "Enable assertion for constant propagation" },
00377     { OVK_BOOL, OV_VISIBLE, FALSE, "clone", "",
00378     0, 0, 0,    &IPA_Enable_Cloning,  NULL,
00379     "Enable subprogram cloning" },
00380     { OVK_UINT32, OV_INTERNAL,  FALSE, "multi_clone",   "",
00381            0, 0, UINT32_MAX, &IPA_Max_Node_Clones, &IPA_Max_Node_Clones_Set,
00382     "Maximum clones per call graph node" },
00383     { OVK_UINT32, OV_INTERNAL,  FALSE, "node_bloat",   "",
00384           DEFAULT_CLONE_BLOAT_FACTOR, 0, UINT32_MAX, &IPA_Max_Clone_Bloat,NULL,
00385     "Maximum call graph bloat with cloning" },
00386     { OVK_BOOL, OV_VISIBLE, FALSE, "dce",         "",
00387     0, 0, 0,    &IPA_Enable_DCE,  NULL,
00388     "Enable dead code elimination" },
00389     { OVK_BOOL, OV_VISIBLE, FALSE, "dve",   "",
00390     0, 0, 0,    &IPA_Enable_DVE,  NULL,
00391     "Enable dead variable elimination" },
00392     { OVK_UINT32,OV_VISIBLE,  FALSE, "depth", "",
00393     UINT32_MAX, 0, UINT32_MAX,&IPA_Max_Depth, NULL,
00394     "Limit inlining depth" },
00395     { OVK_UINT32,OV_VISIBLE,  FALSE, "maxdepth",  "",
00396     UINT32_MAX, 0, UINT32_MAX,&IPA_Max_Depth, NULL,
00397     "Limit inlining depth" },
00398     { OVK_UINT32,OV_VISIBLE,  FALSE, "forcedepth",  "",
00399     UINT32_MAX, 0, UINT32_MAX, &IPA_Force_Depth,  &IPA_Force_Depth_Set,
00400     "Inline to at least this depth" },
00401     { OVK_BOOL, OV_VISIBLE, FALSE, "dfe",   "",
00402     0, 0, 0,    &IPA_Enable_DFE,  &IPA_Enable_DFE_Set,
00403     "Enable dead function elimination" },
00404     { OVK_BOOL, OV_INTERNAL,  FALSE, "dst",   "",
00405     0, 0, 0,    &IPA_Enable_DST,  NULL},
00406     { OVK_BOOL, OV_VISIBLE, FALSE, "echo_commands", "",
00407     0, 0, 0,    &IPA_Echo_Commands, NULL,
00408     "Echo back end compilation commands" },
00409     { OVK_BOOL, OV_INTERNAL,  FALSE, "exc",   "",
00410     0, 0, 0,    &IPA_Enable_Exc,  NULL},
00411     { OVK_BOOL, OV_INTERNAL,  FALSE, "flow_analysis", "",
00412     0, 0, 0,    &IPA_Enable_Flow_Analysis,  NULL},
00413     { OVK_BOOL, OV_INTERNAL,  FALSE, "gp_partition",  "",
00414     0, 0, 0,    &IPA_Enable_GP_Partition, NULL},
00415     { OVK_BOOL, OV_INTERNAL,  FALSE, "graph", "",
00416     0, 0, 0,    &IPA_Enable_daVinci,  NULL,
00417     "Generate call-graph display" },
00418     { OVK_UINT32,OV_VISIBLE,  FALSE, "Gspace",  "",
00419     DEFAULT_GSPACE, 0, DEFAULT_GSPACE, &IPA_Gspace, NULL},
00420     { OVK_UINT32,OV_VISIBLE,  FALSE, "Gnum",  "",
00421     DEFAULT_GSPACE, 0, DEFAULT_GSPACE, &IPA_user_gnum, NULL,
00422     "Specific size limit for data in gp-relative space" },
00423     { OVK_UINT32,OV_INTERNAL, FALSE, "Gfactor",   "",
00424           DEFAULT_EXTGOT_FACTOR, 0, UINT32_MAX, &IPA_Extgot_Factor, NULL,
00425     "Percentage used to multiply the number of External GOTs, for AutoGnum purpose" },
00426     { OVK_UINT32,OV_VISIBLE,  FALSE, "hard_plimit", "",
00427     DEFAULT_HARD_LIMIT, 0, UINT32_MAX,
00428     &IPA_PU_Hard_Limit, &IPA_PU_Hard_Limit_Set }, 
00429     { OVK_BOOL, OV_SHY,   FALSE, "ignore_lang", "",
00430     0, 0, 0,    &IPA_Enable_Lang, NULL},
00431     { OVK_BOOL, OV_VISIBLE, FALSE, "inline",  "",
00432     0, 0, 0,    &IPA_Enable_Inline, NULL,
00433     "Enable subprogram inlining" },
00434     { OVK_NAME, OV_INTERNAL,  FALSE, "ipaa_summary_file", "",
00435     0, 0, 0,    &Ipa_File_Name,   NULL,
00436     "File name for IP alias analysis summary" },
00437     { OVK_UINT32,OV_INTERNAL, FALSE, "intrinsics",   "intr",
00438           DEFAULT_NUM_FORTRAN_INTR, 0, UINT32_MAX,
00439           &IPA_Num_Fortran_Intrinsics, NULL,
00440     "Number of FORTRAN intrinsics used" },
00441     { OVK_BOOL, OV_INTERNAL,  FALSE, "keeplight", "",
00442     0, 0, 0,    &IPA_Enable_Keeplight,  NULL},
00443     { OVK_UINT32,OV_INTERNAL, FALSE, "map_limit",   "",
00444           DEFAULT_MAP_LIMIT, 0, UINT32_MAX, &IPA_Map_Limit, NULL},
00445     { OVK_UINT32,OV_VISIBLE,  FALSE, "max_jobs",  "",
00446     1, 0, UINT32_MAX, &IPA_Max_Jobs,    &IPA_Max_Jobs_Set,
00447     "Maximum number of concurrent back-end jobs" },
00448     { OVK_BOOL, OV_INTERNAL,  FALSE, "merge_ty",  "",
00449     0, 0, 0,    &IPA_Enable_Merge_ty, NULL},
00450     { OVK_BOOL, OV_INTERNAL,  FALSE, "use_effective_size", "",
00451     0, 0, 0,    &IPA_Use_Effective_Size, NULL},
00452     { OVK_OBSOLETE,OV_INTERNAL, FALSE, "min_freq",  "",
00453     DEFAULT_MIN_FREQ, 0, 10000, &IPA_Min_Freq,  NULL},
00454     { OVK_UINT32,OV_SHY,  FALSE, "min_hotness", "",
00455     DEFAULT_MIN_HOTNESS, 0, UINT32_MAX, &IPA_Min_Hotness, NULL},
00456     { OVK_UINT32,OV_SHY,  FALSE, "max_density", "",
00457     DEFAULT_MAX_DENSITY, 0, UINT32_MAX, &IPA_Max_Density, NULL},
00458     { OVK_BOOL, OV_INTERNAL,  FALSE, "reshape", "",
00459     0, 0, 0,    &IPA_Enable_Reshape,  NULL,
00460     "Reshape analysis for IPA" },
00461     { OVK_BOOL, OV_INTERNAL,  FALSE, "opt_alias", "",
00462     0, 0, 0,    &IPA_Enable_Opt_Alias,  NULL,
00463     "Use IPA alias information in WOPT" },
00464     { OVK_BOOL, OV_INTERNAL,  FALSE,  "pad",          "",
00465     0, 0, 0,    &IPA_Enable_Padding,  NULL,
00466           "Enable padding of common block arrays"},
00467     { OVK_UINT32, OV_INTERNAL,  FALSE, "common_pad_size",       "",
00468           0, 1, 1000,           &IPA_Common_Pad_Size,   NULL,
00469     "Amount by which to pad common block array dimensions" },
00470     { OVK_LIST, OV_SHY,   FALSE, "partition_group", "",
00471     0, 0, 0,    &IPA_Group_Names, NULL },
00472     { OVK_LIST, OV_VISIBLE, FALSE, "specfile",  "spec",
00473     0, 0, 0,    &IPA_Spec_Files,  NULL,
00474     "Identify IPA specification filename" },
00475     { OVK_BOOL, OV_SHY,   FALSE, "sp_partition",  "",
00476     0, 0, 0,    &IPA_Enable_SP_Partition, NULL},
00477     { OVK_BOOL, OV_VISIBLE, FALSE, "picopt",  "",
00478     0, 0, 0,    &IPA_Enable_Picopt, NULL,
00479     "Enable shared code optimizations" },
00480     { OVK_BOOL, OV_VISIBLE, FALSE, "preempt", "",
00481     0, 0, 0,    &IPA_Enable_Preempt,  NULL},
00482     { OVK_UINT32, OV_VISIBLE, FALSE, "plimit",  "",
00483     DEFAULT_PU_LIMIT, 0, UINT32_MAX, &IPA_PU_Limit, &IPA_PU_Limit_Set},
00484     { OVK_UINT32, OV_SHY, FALSE, "callee_limit", "",
00485     DEFAULT_SMALL_CALLEE, 0, UINT32_MAX, &IPA_Small_Callee_Limit, NULL},
00486     { OVK_BOOL, OV_INTERNAL,  FALSE, "recycle", "",
00487     0, 0, 0,    &IPA_Enable_Recycle,  NULL},
00488     { OVK_BOOL, OV_SHY,   FALSE, "relopt",  "",
00489     0, 0, 0,    &IPA_Enable_Relocatable_Opt,  NULL},
00490     { OVK_OBSOLETE, OV_VISIBLE, FALSE, "rela_freq", "",
00491     DEFAULT_RELA_FREQ, 0, 100, &IPA_Rela_Freq,  NULL},
00492     { OVK_LIST, OV_VISIBLE,   FALSE, "skip_after",  "",
00493     0, 0, 0,    &IPA_Skip,    NULL},
00494     { OVK_LIST, OV_VISIBLE, FALSE, "skip_before", "",
00495     0, 0, 0,    &IPA_Skip,    NULL},
00496     { OVK_LIST, OV_VISIBLE, FALSE, "skip_equal",  "",
00497     0, 0, 0,    &IPA_Skip,    NULL},
00498     { OVK_BOOL, OV_INTERNAL,  FALSE, "skip_report", "",
00499     0, 0, 0,    &IPA_Skip_Report, NULL,
00500     "Report PU numbers for skip control" },
00501     { OVK_UINT32, OV_VISIBLE, FALSE, "small_pu",  "",
00502     DEFAULT_SMALL_PU, 1, UINT32_MAX, &IPA_PU_Minimum_Size, NULL },
00503     { OVK_UINT32, OV_VISIBLE, FALSE, "space", "",
00504     DEFAULT_BLOAT_FACTOR, 0, UINT32_MAX, &IPA_Bloat_Factor,
00505     &IPA_Bloat_Factor_Set}, 
00506     { OVK_BOOL, OV_INTERNAL,  FALSE, "split", "",
00507     0, 0, 0,    &IPA_Enable_Split_Common, NULL,
00508     "Enable IPA split common optimization" },
00509     { OVK_BOOL, OV_INTERNAL,  FALSE, "cord",    "",
00510     0, 0, 0,    &IPA_Enable_Cord, NULL,
00511     "Enable procedure reordering" },
00512     { OVK_BOOL, OV_VISIBLE, FALSE, "linear",    "",
00513     0, 0, 0,    &IPA_Enable_Linearization,  NULL,
00514     "Enable linearization of array subscripts" },
00515     { OVK_BOOL, OV_VISIBLE, FALSE, "use_intrinsic", "",
00516     0, 0, 0,    &IPA_Use_Intrinsic, NULL,
00517     "Load Intrinsic Libraries" },
00518     { OVK_BOOL, OV_VISIBLE,     FALSE, "feedback",             "",
00519           0, 0, 0,              &IPA_Enable_Feedback,   NULL,
00520           "Create .pragma, .dfe, .dve  files, " },
00521     { OVK_BOOL, OV_VISIBLE,     FALSE, "class", "",
00522           0, 0, 0,              &IPA_Enable_Alias_Class, NULL,
00523          "Enable interprocedural alias classification" },
00524     { OVK_BOOL, OV_VISIBLE,     FALSE, "ac_temp", "",
00525           0, 0, 0,              &IPA_Debug_AC_Temp_Files, NULL,
00526          "Save files from before alias classification" },
00527     { OVK_BOOL, OV_INTERNAL,    FALSE, "nested",             "",
00528           0, 0, 0,              &IPA_Enable_Inline_Nested_PU,   NULL,
00529           "Enable inlining of nested PU " },
00530     { OVK_BOOL, OV_INTERNAL,    FALSE, "preopt",             "",
00531           0, 0, 0,              &IPA_Enable_Preopt, &IPA_Enable_Preopt_Set,
00532           "Enable calling the preopt" },
00533     { OVK_BOOL, OV_INTERNAL,    FALSE, "struct",             "",
00534           0, 0, 0,              &IPA_Enable_Inline_Struct,   NULL,
00535           "Enable inlining of PU with F90 structures " },
00536     { OVK_BOOL, OV_INTERNAL,    FALSE, "char",             "",
00537           0, 0, 0,              &IPA_Enable_Inline_Char_Array,   NULL,
00538           "Enable inlining of PU with char arrays " },
00539     { OVK_BOOL, OV_INTERNAL,    FALSE, "optional",             "",
00540           0, 0, 0,              &IPA_Enable_Inline_Optional_Arg,   NULL,
00541           "Enable inlining of PU with optional arguments " },
00542     { OVK_BOOL, OV_INTERNAL,    FALSE, "array_struct",             "",
00543           0, 0, 0,              &IPA_Enable_Inline_Struct_Array_Actual,   NULL,
00544           "Enable inlining of PU with F90 structures when actuals are of ARRAY type " },
00545     { OVK_INT32, OV_INTERNAL, FALSE, "output_file_size", "",
00546     0, -100, INT32_MAX, &IPA_Output_File_Size, NULL},
00547     { OVK_BOOL, OV_INTERNAL,    FALSE, "var_dim_array",             "",
00548           0, 0, 0,              &IPA_Enable_Inline_Var_Dim_Array,   NULL,
00549           "Enable inlining of PU with param that is variable-dim array " },
00550     { OVK_NAME, OV_INTERNAL,  FALSE, "propagate_feedback_file", "",
00551     0, 0, 0,    &Feedback_Filename,   NULL,
00552     "Feedback file name which IPA will propagate to next phase" },
00553     { OVK_NAME, OV_INTERNAL,  FALSE, "propagate_annotation_file", "",
00554     0, 0, 0,    &Annotation_Filename,   NULL,
00555     "Annotation file name which IPA will propagate to next phase" },
00556     { OVK_BOOL, OV_INTERNAL,  FALSE, "field_reorder", "",
00557     0, 0, 0,    &IPA_Enable_Reorder,  NULL,
00558     "Enable field reordering"},
00559 #ifdef KEY
00560     { OVK_BOOL, OV_INTERNAL,  FALSE, "icall_opt", "",
00561     0, 0, 0,    &IPA_Enable_Icall_Opt,  NULL,
00562     "Enable conversion of icall to call"},
00563     { OVK_BOOL, OV_INTERNAL,  FALSE, "eh_opt",  "",
00564     0, 0, 0,    &IPA_Enable_EH_Region_Removal,  NULL,
00565     "Enable removal of exception regions"},
00566     { OVK_BOOL, OV_INTERNAL,  FALSE, "branch",  "",
00567     0, 0, 0,    &IPA_Enable_Branch_Heuristic, NULL,
00568     "Enable use of branch probabilities for inlining"},
00569     { OVK_BOOL, OV_INTERNAL,  FALSE, "check_opt", "",
00570     0, 0, 0,    &IPA_Check_Options, NULL,
00571     "Enable handling of any inconsistent optimization options"},
00572     { OVK_BOOL, OV_VISIBLE, FALSE, "clone_list",  "",
00573     0, 0, 0,  &IPA_Clone_List_Actions,  NULL,
00574     "Report function cloner actions" },
00575     { OVK_BOOL, OV_VISIBLE, FALSE, "pure_call", "",
00576     0, 0, 0,  &IPA_Enable_Pure_Call_Opt,  NULL,
00577     "Optimize calls to functions without side-effects" },
00578     { OVK_INT32, OV_INTERNAL, FALSE, "call_op_skip_b",  "",
00579     0, 0, INT32_MAX,  &IPA_Pure_Call_skip_before, NULL,
00580     "For debugging" },
00581     { OVK_INT32, OV_INTERNAL, FALSE, "pu_reorder",  "",
00582     REORDER_DISABLE, REORDER_DISABLE, REORDER_BY_EDGE_FREQ,
00583     &IPA_Enable_PU_Reorder, &IPA_Enable_PU_Reorder_Set,
00584     "Enable procedure reordering" },
00585     { OVK_BOOL, OV_INTERNAL,  FALSE, "ctype", "",
00586     0, 0, 0,    &IPA_Enable_Ctype,  NULL,
00587     "Enable insertion of ctype.h array"},
00588     { OVK_BOOL, OV_INTERNAL,  FALSE, "icallopt_needs_inline",  "",
00589     0, 0, 0,    &IPA_Consult_Inliner_For_Icall_Opt, NULL,
00590     "Check inlining heuristics during icall opt"},
00591     { OVK_UINT32, OV_INTERNAL,  FALSE, "icall_min_freq",  "",
00592     DEFAULT_ICALL_MIN_FREQ, 1, UINT32_MAX, &IPA_Icall_Min_Freq, NULL,
00593     "Min freq of icall for icall optimization"},
00594     { OVK_BOOL, OV_INTERNAL,    FALSE, "source_pu_order",  "",
00595       0, 0, 0,              &IPA_Enable_Source_PU_Order, NULL,
00596       "Maintain source-code PU ordering in IPA output"},
00597     { OVK_BOOL, OV_INTERNAL,    FALSE, "ipa_enable_old_type_merge", "",
00598       0, 0, 0,              &IPA_Enable_Old_Type_Merge, NULL,
00599       "Use the old type merge phase in IPA"},
00600     { OVK_BOOL, OV_INTERNAL,    FALSE, "devirtualization", "",
00601       0, 0, 0,              &IPA_Enable_Devirtualization, NULL,
00602       "Use devirtualization phase"},
00603 #ifdef TARG_X8664
00604     { OVK_UINT32, OV_INTERNAL,  FALSE, "optimize_struct", "",
00605     1, 0, UINT32_MAX, &IPA_Enable_Struct_Opt, NULL,
00606 #else
00607     { OVK_UINT32, OV_INTERNAL,  FALSE, "optimize_struct", "",
00608     0, 0, UINT32_MAX, &IPA_Enable_Struct_Opt, NULL,
00609 #endif
00610     "Enable IPA struct optimizations"},
00611     /* The following option is temporary, and should be removed soon */
00612     { OVK_UINT32, OV_INTERNAL,  FALSE, "update_struct", "",
00613     0, 0, UINT32_MAX, &IPA_Update_Struct, NULL,
00614     "Struct update"},
00615 #endif // KEY
00616     { OVK_COUNT }     /* List terminator -- must be last */
00617 };
00618 
00619 /* ====================================================================
00620  * List of global variables that are set by the -INLINE option group.
00621  * ====================================================================
00622  */
00623 
00624 /* What is the default inlining behavior? */
00625 BOOL  INLINE_Enable = TRUE; /* If FALSE, disable inliner? */
00626 BOOL  INLINE_All = FALSE; /* Inline everything possible? */
00627 BOOL    INLINE_Optimize_Alloca = TRUE; /* when inlining calls with alloca fix the stack and pop */
00628 BOOL  INLINE_Enable_Copy_Prop = TRUE; /* Copy Propogation during stand-alone inlining? */
00629 BOOL  INLINE_Enable_Subst_Copy_Prop = FALSE; /* Aggressive substitution of actual for formal and hence copy propogation during stand-alone inlining */
00630 BOOL    INLINE_F90 = TRUE;  /* Enable recognition of F90 in parameter type compatibility */
00631 BOOL  INLINE_None = FALSE;  /* Inline nothing? */
00632 BOOL  INLINE_Exceptions = TRUE; /* Inline exception code? */
00633 BOOL  INLINE_Keep_PU_Order = FALSE; /* Retain input PU order? */
00634 BOOL  INLINE_List_Actions = FALSE;  /* List inline actions? */
00635 UINT32  INLINE_Max_Pu_Size = DEFAULT_INLINE_Max_Pu_Size;
00636                                         /* Max size of pu : default 5000 */
00637 BOOL  INLINE_Preemptible = FALSE; /* Inline preemptible PUs? */
00638 BOOL  INLINE_Static = FALSE;          /* Inline static fns? */
00639 BOOL    INLINE_Static_Set = FALSE;  /* ... explicitly set? */
00640 BOOL  INLINE_Aggressive = FALSE; /* inline even non-leaf, out-of-loop calls */
00641 BOOL    INLINE_Enable_Split_Common = TRUE;  /* Enable split common: inliner */
00642 BOOL    INLINE_Enable_Auto_Inlining = TRUE; /* Enable automatic inlining analysis */
00643 BOOL  INLINE_Enable_Restrict_Pointers = FALSE; // Allow restrict pointers
00644           // as formal parameter
00645 #ifdef KEY
00646 BOOL  INLINE_Recursive = TRUE;  // Do recursive inlining
00647 BOOL  INLINE_Param_Mismatch = TRUE; // Inline even if # of actuals < # of formals
00648 BOOL  INLINE_Type_Mismatch = FALSE;   // Inline even if actuals' type != formals' type
00649 // check parameter compatibility during inlining
00650 CHECK_PARAM_COMPATIBILITY INLINE_Check_Compatibility = RELAXED_CHECK;
00651 BOOL    INLINE_Ignore_Bloat = TRUE;    // Ignore code bloat (-IPA:space)
00652 UINT32   INLINE_Callee_Limit = 0;      // Callee size limit for functions
00653                                        // marked inline by user
00654 #endif
00655 
00656 OPTION_LIST *INLINE_List_Names = NULL;  /* Must/never/file options */
00657 OPTION_LIST *INLINE_Spec_Files = NULL;  /* Specification files */
00658 OPTION_LIST *IPA_Group_Names = NULL;  /* groupings, e.g. partition groupings */
00659 OPTION_LIST *IPA_Spec_Files = NULL; /* Specification files for IPA options, particularly used for partition groupings */
00660 UINT32  INLINE_Skip_After = UINT32_MAX;
00661 UINT32  INLINE_Skip_Before = 0;
00662 BOOL    INLINE_Array_Bounds = FALSE;    /* "conforming" array bounds */
00663 BOOL    INLINE_Use_Malloc_Mempool = FALSE;    /* Use the malloc mempool for */
00664 BOOL    INLINE_Free_Malloc_Mempool = FALSE;   /* Use the malloc mempool for
00665              cloning tree */
00666 BOOL    INLINE_Inlined_Pu_Call_Graph = FALSE; /* impl. 2 of lightweight inliner -- build a call graph with only the PU tagged inline */
00667 BOOL    INLINE_Inlined_Pu_Call_Graph2 = FALSE; /* impl. 3 of lightweight inliner -- build a call graph with only the PU tagged inline and its callers */
00668 BOOL    INLINE_Get_Time_Info = FALSE;          /* Generate timing info for different phases of the inliner */
00669 
00670 char    *INLINE_Script_Name = NULL;
00671 BOOL   INLINE_Enable_Script = FALSE;;
00672   
00673 static OPTION_DESC Options_INLINE[] = {
00674     { OVK_BOOL, OV_VISIBLE, FALSE, "",  NULL,
00675     0, 0, 0,  &INLINE_Enable, NULL,
00676     "Enable subprogram inlining" },
00677     { OVK_BOOL, OV_SHY,   FALSE, "aggressive",  "",
00678     0, 0, 0,  &INLINE_Aggressive, NULL },
00679     { OVK_BOOL, OV_VISIBLE, FALSE, "all", "a",
00680     0, 0, 0,  &INLINE_All,  NULL,
00681     "Attempt to inline all subprograms" },
00682     { OVK_BOOL, OV_SHY,   FALSE, "alloca",  "alloca",
00683     0, 0, 0,  &INLINE_Optimize_Alloca,  NULL,
00684     "Enable save/restore of stack when inlining calls with alloca" },
00685     {OVK_BOOL, OV_VISIBLE,  FALSE, "copy_prop_inline",  "copy", 
00686     0, 0, 0,      &INLINE_Enable_Copy_Prop, NULL,
00687     "Enable inliner copy propagation" },
00688     { OVK_BOOL, OV_VISIBLE, FALSE, "dfe", "df",
00689     0, 0, 0,  &IPA_Enable_DFE,  &IPA_Enable_DFE_Set,
00690     "Enable dead function elimination" },
00691     { OVK_BOOL, OV_INTERNAL,  FALSE, "exceptions",  "exc",
00692     0, 0, 0,  &INLINE_Exceptions, NULL },
00693     { OVK_LIST, OV_VISIBLE, FALSE, "file",  "f",
00694     0, 0, 0,  &INLINE_List_Names, NULL,
00695     "Identify files where inliner should search for subprograms" },
00696     { OVK_BOOL, OV_VISIBLE, FALSE, "keep_pu_order", "keep_pu",
00697     0, 0, 0,  &INLINE_Keep_PU_Order,  NULL,
00698     "Preserve source subprogram ordering" },
00699     { OVK_LIST, OV_VISIBLE,     FALSE, "library", "lib",
00700           0, 0, 0,      &INLINE_List_Names,     NULL,
00701          "Identify archive libraries where inliner should search for subprograms" },
00702     { OVK_BOOL, OV_VISIBLE, FALSE, "list",  "l",
00703     0, 0, 0,  &INLINE_List_Actions, NULL,
00704     "Report inliner actions" },
00705     { OVK_UINT32, OV_VISIBLE, FALSE, "max_pu_size_inline", "max_pu_size",
00706     DEFAULT_INLINE_Max_Pu_Size, 0, UINT32_MAX,
00707     &INLINE_Max_Pu_Size, NULL,
00708     "Limit size of inlined subprograms" },
00709     { OVK_LIST, OV_VISIBLE, FALSE, "must",  "m",
00710     0, 0, 0,  &INLINE_List_Names, NULL,
00711     "Identify subprograms to be inlined" },
00712     { OVK_LIST, OV_VISIBLE, FALSE, "never", "ne",
00713     0, 0, 0,  &INLINE_List_Names, NULL,
00714     "Identify subprograms not to inline" },
00715     { OVK_BOOL, OV_VISIBLE, FALSE, "none",  "no",
00716     0, 0, 0,  &INLINE_None, NULL,
00717     "Disable default inlining" },
00718     { OVK_BOOL, OV_SHY,   FALSE, "preemptible", "preempt",
00719     0, 0, 0,  &INLINE_Preemptible,  NULL },
00720     { OVK_BOOL, OV_INTERNAL,  FALSE, "recycle_symbols", "recycle",
00721     0, 0, 0,  &IPA_Enable_Recycle,  NULL },
00722     { OVK_LIST, OV_VISIBLE, FALSE, "specfile",  "sp",
00723     0, 0, 0,  &INLINE_Spec_Files, NULL,
00724     "Identify IPA specification filename" },
00725     { OVK_BOOL, OV_INTERNAL,  FALSE, "split", "",
00726     0, 0, 0,    &INLINE_Enable_Split_Common,  NULL,
00727     "Enable inliner split common optimization" },
00728     { OVK_BOOL, OV_SHY,   FALSE, "static",  "",
00729     0, 0, 0,    &INLINE_Static, &INLINE_Static_Set,
00730     "Enable inlining of static functions" },
00731     { OVK_BOOL, OV_INTERNAL,  FALSE, "subst_copy_prop_inline",  "subst", 
00732     0, 0, 0,      &INLINE_Enable_Subst_Copy_Prop, NULL,
00733     "Enable inliner copy propagation" },
00734     { OVK_BOOL, OV_INTERNAL,  FALSE, "f90param",  "", 
00735    0, 0, 0,      &INLINE_F90, NULL,
00736    "Enable parameter type checking for F90" },
00737     { OVK_BOOL, OV_INTERNAL,  FALSE, "auto",  "",
00738     0, 0, 0,    &INLINE_Enable_Auto_Inlining, NULL,
00739     "Enable inliner automatic inline analysis" },
00740     { OVK_BOOL, OV_INTERNAL,  FALSE,  "restrict", "",
00741     0, 0, 0,    &INLINE_Enable_Restrict_Pointers, NULL,
00742     "Allow inlining of PUs with restrict pointer as formal parameters" },
00743 #ifdef KEY
00744     { OVK_BOOL, OV_INTERNAL,  FALSE,  "recurse",  "",
00745     0, 0, 0,    &INLINE_Recursive, NULL,
00746     "Allow recursive inlining of PUs" },
00747     { OVK_BOOL, OV_INTERNAL,  FALSE,  "num_mismatch", "",
00748     0, 0, 0,    &INLINE_Param_Mismatch, NULL,
00749     "Allow inlining even if # of parameters does not match between call and callee" },
00750     { OVK_BOOL, OV_INTERNAL,  FALSE,  "type_mismatch",  "",
00751     0, 0, 0,    &INLINE_Type_Mismatch, NULL,
00752     "Allow inlining even if actuals don't exactly match formals" },
00753     { OVK_INT32, OV_INTERNAL, FALSE, "check_types", "",
00754     RELAXED_CHECK, STRICT_CHECK, AGGRESSIVE,
00755     &INLINE_Check_Compatibility, NULL, "Check parameter type compatibility during inlining"},
00756     { OVK_BOOL, OV_INTERNAL,  FALSE,  "ignore_bloat", "",
00757     0, 0, 0,    &INLINE_Ignore_Bloat, NULL,
00758     "Ignore code bloat controlled by -IPA:space" },
00759     { OVK_UINT32, OV_INTERNAL,  FALSE, "callee_size", "",
00760     0, 0, UINT32_MAX, &INLINE_Callee_Limit, NULL,
00761     "Callee size limit for functions marked inline by user"},
00762 #endif
00763     { OVK_LIST, OV_VISIBLE, FALSE, "skip",  "s",
00764     0, 0, 0,  &INLINE_List_Names, NULL,
00765     "Skip requested CG edges to avoid doing inlining" },
00766     { OVK_BOOL, OV_INTERNAL,    FALSE, "nested",             "",
00767           0, 0, 0,              &IPA_Enable_Inline_Nested_PU,   NULL,
00768           "Enable inlining of nested PU " },
00769     { OVK_BOOL, OV_INTERNAL,    FALSE, "struct",             "",
00770           0, 0, 0,              &IPA_Enable_Inline_Struct,   NULL,
00771           "Enable inlining of PU with F90 structures " },
00772     { OVK_BOOL, OV_INTERNAL,    FALSE, "char",             "",
00773           0, 0, 0,              &IPA_Enable_Inline_Char_Array,   NULL,
00774           "Enable inlining of PU with char arrays " },
00775     { OVK_BOOL, OV_INTERNAL,    FALSE, "optional",             "opt",
00776           0, 0, 0,              &IPA_Enable_Inline_Optional_Arg,   NULL,
00777           "Enable inlining of PU with optional arguments " },
00778     { OVK_LIST, OV_VISIBLE, FALSE, "edge",  "e",
00779     0, 0, 0,  &INLINE_List_Names, NULL,
00780     "Inline requested CG edges ONLY" },
00781     { OVK_BOOL, OV_INTERNAL,    FALSE, "array_struct",             "",
00782           0, 0, 0,              &IPA_Enable_Inline_Struct_Array_Actual,   NULL,
00783           "Enable inlining of PU with F90 structures when actuals are of ARRAY type" },
00784     { OVK_UINT32, OV_VISIBLE, FALSE, "skip_after", "",
00785     UINT32_MAX, 0, UINT32_MAX, &INLINE_Skip_After, NULL,
00786     "Edge number to skip if larger than the specified" },
00787     { OVK_UINT32, OV_VISIBLE, FALSE, "skip_before", "",
00788     0, 0, UINT32_MAX, &INLINE_Skip_Before, NULL,
00789     "Edge number to skip if smaller than the specified" },
00790     { OVK_BOOL, OV_INTERNAL,    FALSE, "var_dim_array",             "",
00791           0, 0, 0,              &IPA_Enable_Inline_Var_Dim_Array,   NULL,
00792           "Enable inlining of PU with param that is variable-dim array " },
00793     { OVK_LIST, OV_VISIBLE, FALSE, "in_edge", "",
00794     0, 0, 0,  &INLINE_List_Names, NULL,
00795     "Inline requested CG edges " },
00796     { OVK_BOOL, OV_INTERNAL,    FALSE, "array_bounds",             "",
00797           0, 0, 0,              &INLINE_Array_Bounds,   NULL,
00798           "Is it safe to inline a PU with an array parameter whose outermost dimension size is unknown" },
00799     { OVK_BOOL, OV_INTERNAL,    FALSE, "malloc",             "",
00800           0, 0, 0,              &INLINE_Use_Malloc_Mempool,   NULL,
00801           "Use malloc mempool instead of private mempool to clone trees" },
00802     { OVK_BOOL, OV_INTERNAL,    FALSE, "free",             "",
00803           0, 0, 0,              &INLINE_Free_Malloc_Mempool,   NULL,
00804           "Free memory malloc'ed by the malloc mempool used in clone trees" },
00805     { OVK_BOOL, OV_INTERNAL,    FALSE, "inlined_pu",             "",
00806           0, 0, 0,              &INLINE_Inlined_Pu_Call_Graph,   NULL,
00807           "Lightweight inliner impl 2 -- build a call graph with only PU tagged inline" },
00808     { OVK_BOOL, OV_INTERNAL,    FALSE, "pu_need_inline",          "",
00809           0, 0, 0,              &INLINE_Inlined_Pu_Call_Graph2,   NULL,
00810           "Lightweight inliner impl 2 -- build a call graph with only PU tagged inline and callers that call these PUs" },
00811     { OVK_BOOL, OV_INTERNAL,    FALSE, "time",          "",
00812           0, 0, 0,              &INLINE_Get_Time_Info,   NULL,
00813           "Generate timing info for different phase of the inliner" },
00814     { OVK_NAME, OV_VISIBLE, TRUE, "inline_script", "", 
00815           0, 0, 0,  &INLINE_Script_Name, &INLINE_Enable_Script, 
00816           "Enable call-site specific inlining based on inline description file" },
00817     { OVK_COUNT }     /* List terminator -- must be last */
00818 };
osprey/common/com/config_ipa.cxx
