Subversion Repositories Open64

%

% Copyright 2005-2008 NVIDIA Corporation.  All rights reserved.

%

% -*- fundamental -*-

%

%  Copyright (C) 2008-2009 Advanced Micro Devices, Inc.  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

%

%

% Lines beginning with % are comment lines,

% lines beginning with %%% denote new sections.

% Each option has two lines.

% The first line contains:

% the option name,

% an action to be done upon reading the option,

% what languages accept it,

% what phases accept it,

% and what other options it implies.

% The second line contains the help message for that option.

% There must be no spaces in any of the fields except the last one,

% or you can have spaces in an action if you surround it with braces.

% There are several special syntax rules for option names that are used:

% Option names that start with I, e.g. I-foo, are internal names

% that the user cannot access.  Internal names are used for phase options

% (e.g. -pic2), and for implicit defaults like -D__sgi.

% A %s after an option name means to use the next string as an argument;

% a %- after an option name means to use the next string or '-' as an argument;

% a %d or %x after an option name means to use the next number as an argument;

% a %D after an option name means to use the next directory as an argument;

% the %{s,x,d,D} formats accept an optional space before the argument;

% if there is no number or directory for a corresponding %{x,d,D},

% then the option is not matched.

% A * in the middle of an argument means there can be an optional space here;

% a * at the end of the argument means the syntax is too complicated and a

% call to a hand-written routine called parse_<prefix>_option will be generated.

% A ? at the end of %D means the option will be ignored if the directory

% argument is missing (KEY).

% A special action is toggle(&<var>,<val>) which stores the value in the

% variable, and gives an error if the variable has already been set.

% This is useful for catching conflicts like -mips1 -mips2.

#ifdef KEY

% Toggle is also used in support of options from compiler.defaults.  When the

% driver starts, <var> is initially set to UNDEFINED.  <var> is toggled to

% other values according to command line options.  When parsing

% compiler.defaults, toggle will silently drop an option if its <var> is not

% UNDEFINED, meaning it is already set by a command line option.  All options

% in compiler.defaults must have a <var>.

#endif

% The implies field should include the option name if that name is to be

% passed to phases.  The special word "self" for the implies field means

% to repeat the option name.

% Repeating a %{d,D,s} in the implies field shows the format to use

% when passing to phases, i.e. whether to have a blank space.

% A simple alias is recognized when you have an option that has

% no action, language=all, phases=none, and 1 implies option.

% This is directly translated to the implies option when processing.

% The file is first preprocessed by cpp to expand macros, and then sorted

% by option names.

% the letter keys for languages and phases must match what is in lang_defs.c

% ALL and NONE can be used for both languages and phases.

#define ALL A

#define NONE  N

% languages

% use CPP not cpp to avoid conflict with -cpp option

#define CPP   p

#define cc  c

#define CC  C

#define Cc  cc,CC

#define f77 f

% f90 used in option name, so use F90 for define

#define F90 F

#define FTN f77,F90

#define as  a

#define LINK  Cc,FTN

% phases

% CPP is a phase as well as a language, but the definition is the same

#define cfe C

#define ffe F

#define anyfe f

#define ipl i

#define be  b

#define as  a

#define ld  l

#define ipap  j

#define pwrc  K

% pfa used in option name, so use PFA for define

#define PFA K

#define mpc M

% GRP: All the pieces that swallow regular group options

#define GRP ffe,b,i

#define CMP anyfe,ipl,be

% ALLX: ALL except pca & pfa which do not accept the usual compilation args

#define ALLX  CPP,CMP,ld

% <option name> <action> <languages> <phases> <implies>

% <help message>

-help {print_help = TRUE;}  ALL NONE  ""

  "print list of possible options"

-h  {print_help = TRUE;}  ALL NONE  ""

  ""

-realO  ;   ALL NONE  ""

  "override the turning down of optimization levels"

-help:%s  save_name(&help_pattern,optargs);   ALL NONE  ""

  "print list of possible options that contain given string"

%

-show {show_flag = TRUE; }  ALL GRP self

  "show phases as they are being invoked"

-show1  {show_flag = TRUE; }  ALL NONE  ""

  ""

-show0  {show_flag = TRUE; execute_flag = FALSE;} ALL NONE  ""

  "show what phases would be called, but do not invoke anything"

-showt  {time_flag = TRUE; }  ALL NONE  ""

  "show time taken by each phase"

-Q  {quiet_flag = FALSE; }  ALL NONE  ""

  "suppress timing information (g++) "

-version {show_version++; show_copyright = TRUE; execute_flag = FALSE;} ALL NONE  ""

  "Show the version of the compiler being used"

%-copyright {show_copyright = TRUE; execute_flag = FALSE;} ALL  NONE  ""

% "Show the copyright for the compiler being used"

% Fix for bug 492

-dumpversion {dump_version = TRUE; execute_flag = FALSE;} ALL NONE  ""

  "Show the version of the compiler being used, and nothing else"

% -showd turns on internal driver debugging

-showd  {show_flag = debug = TRUE; execute_flag = FALSE;} ALL NONE ""

  ""

-show-defaults  {show_defaults = TRUE; execute_flag = FALSE;} ALL NONE  ""

  "Show the default compiler options being used"

% gcc has -v show version as well as phases, so take that meaning

-v  {show_flag = TRUE; show_version++;} ALL CPP,as,ld self "-show"

  "show phases and version as they are being invoked"

-fullwarn toggle(&msglevel,2);    FTN  CPP  "-m2"

  "give more warnings, especially about missing prototypes"

-w  toggle(&msglevel,0);    ALL CPP,cfe,as,PFA  self "-m0"

  ""

-w2     ;   f77 ffe self

  "warnings count as errors"

-w3     ;   f77 ffe self

  "supress warnings but exit with error status"

-w66      ;   f ffe self

  "turn off F66 incompatibility warnings"

-66     ;   f ffe self

  "issue errors when non-F66 feature used"

-woff*all toggle(&msglevel,0);    ALL NONE  "-w -m0"

  "turn off all warnings"

-woff*options   ;   ALL NONE  ""

  "turn off warnings about options"

-woff%d     ;   FTN ffe,be  "-woff%d"

  "turn off named warnings"

% -V is an svr4 option, currently ignored

-V  {show_version++; show_copyright=TRUE; execute_flag=FALSE;} ALL NONE ""

  "Show the version of the compiler being used"

-V%d  {warn_ignored("-V <version>");} cc  ALLX  ""

  ""

% last_phase gives the last phase to run, phase names from lang_defs.h

% If the user gives conflicting last phases, e.g. -c -P,

% then we use the earliest phase given.

-c  last_phase=(((ipa==TRUE)&&(shared==RELOCATABLE))?P_any_ld:earliest_phase(P_any_as,last_phase));  ALL  NONE  ""

  "produce a .o and stop"

-r  toggle(&shared,RELOCATABLE);last_phase=P_any_ld;  ALL  ld self

  "produce a relocatable .o and stop"

-S  last_phase=earliest_phase(P_be,last_phase);  Cc,FTN NONE  ""

  "produce a .s and stop"

-fe last_phase=earliest_phase(P_any_fe,last_phase);  Cc,FTN NONE  ""

  "stop after the front end is run"

-F  dash_F_option();   f77  NONE  ""

  "stop after RATFOR (f77 only)"

% just parse and then stop

-parse  last_phase=earliest_phase(P_any_fe,last_phase);  Cc cfe self

  ""

-I%D    ;   ALL CPP "-I%D -include=%D"

  "add following directory to the include search path list"

-iquote%D ;   ALL CPP "-iquote=%D"

  "add following directory to the include search path list"

-x%-    set_explicit_lang(option_name,optargs);   ALL NONE  ""

  "Specify explicit language for input files"

I-include=%D  ;   FTN     ffe,PFA     "-include=%D"

  ""

% KEY Make -I to always mean an include search path.  -I without a

% directory argument does nothing.

%-I ;   ALL NONE  "-nostdinc"

% ""

%I-ivpad  ;   LINK  ld  "-ivpad"

% "inter-variable padding of common blocks"

-nostdinc nostdinc=TRUE;    ALL CPP self

  "no predefined include search path list"

-stdinc   nostdinc=FALSE;   ALL CPP ""

  "predefined include search path list"

-nostdinc++ nostdinc=TRUE;    CC,CPP  CPP self

  "Do not search for header files in the standard directories specific to C++"

-nostdlib ; LINK  ld  self

  "Do not use standard system startup files or libraries when linking"

-ffast-stdlib ; A anyfe,ld  "-OPT:fast_stdlib=on"

  "Use faster versions of some standard library functions, when available"

-fno-fast-stdlib  ; A anyfe,ld  "-OPT:fast_stdlib=off"

  "Do not use faster versions of standard library functions"

-nolibopen64rt  ; LINK  ld  ""

  "Do not link with libopen64rt"

%I-split_common ;   LINK  ld  "-split_common"

% "check split COMMON for inconsistencies and fix them"

-LIST:%s  ;   ALL be,ipl  "-LIST:%s"

  "option group to control listing file and contents"

-LD_%s    ;   ALL ld  "-LD_%s"

  ""

-L%D  add_library_dir(optargs);   LINK  ld  "-L%D"

  "add following directory to the library search path list"

-L    ;   LINK  ld  self

  ""

-s    ;   LINK  ld  self

  "Strip symbol table and relocation information"

#ifdef SL

-G8     toggle(&gnum,optargd);    ALL ffe,be  "-G8"

  ""

-Gspace8  ;   ALL be  "-TENV:Gspace=8"

  ""

#else

-G%d  toggle(&gnum,optargd);    ALL ffe,be  "-G%d"

  ""

-Gspace%d ;   ALL be  "-TENV:Gspace=%d"

  ""

#endif

% encourage people to replace -K with -keep

-keep keep_flag=TRUE;   ALL ipap  self

  "keep intermediate files"

-save-temps keep_flag=TRUE; ALL NONE  ""

  ""

-pass-exit-codes  pass_exit_codes=TRUE; ALL NONE  ""

  "Return the highest error code encountered by any phase"

% there are three shared modes:  non, dso, call; call-shared is the default.

% -KPIC can mean either dso or call, so it is only used to say "not non-shared".

% on linux, use g++ driver so do not need init and fini

#define PIC_FLAGS_1    "-TENV:PIC -pic2"

#define PIC_FLAGS_2    "-TENV:PIC -pic2 -shared"

I-cpp_pic ;   ALL NONE  "-D_PIC -D__DSO__"

  ""

% KEY support only -fpic, -fno-pic, -static, -shared, -pic1

-call_shared  toggle(&shared,CALL_SHARED);  ALL NONE  PIC_FLAGS_1

  "call-shared PIC code"

%-shared  toggle(&shared,DSO_SHARED); ALL l PIC_FLAGS_2

% "dso-shared PIC code"

-shared   toggle(&shared,DSO_SHARED); ALL l -TENV:PIC -shared

  "dso-shared PIC code"

%-non_shared  toggle(&shared,NON_SHARED);   ALL NONE  ""

% "compile non-shared (no DSOs)"

-pic1   ;   ALL NONE  -TENV:CPIC

  ""

-pic2   ;   ALL NONE  -TENV:PIC

  ""

% This option turns on everything of interest to SPEC:

-Ofast  Process_Ofast("");    ALL NONE  ""

  "default fast option configuration"

-fb_phase=%s Process_fb_phase(optargs);        ALL     N       ""

        ""

-fb-phase=%s Process_fb_phase(optargs);        ALL     N       ""

        "Option needed to tell compile feedback phase"

-fbgen  Gen_feedback=TRUE;    ALL N ""

  ""

-fbuse%s Process_fbuse(optargs);    ALL N ""

  ""

-fbexe%s Process_fbexe(optargs);        ALL     N       ""

  ""

-fb_xdir%D Process_fb_xdir(optargs);    ALL N ""

  ""

-fb_cdir%D Process_fb_cdir(optargs);    ALL N ""

  ""

-fb_create%s Process_fb_create(optargs);        ALL     N       ""

        ""

-fb-create%s Process_fb_create(optargs);        ALL     N       ""

        "Option needed for SPEC feedback file generation"

-fb_opt%s Process_fb_opt(optargs);      ALL     N       ""

        ""

-fb-opt%s Process_fb_opt(optargs);      ALL     N       ""

        "Option needed for using SPEC feedback files"

-fb_type=%s Process_fb_type(optargs);   ALL    N     ""

        ""

-fb-type=%s Process_fb_type(optargs);   ALL    N     ""

        "Option need for the type of profiles"

-frandom-seed%s ; ALL N "-frandom-seed=%s"

  "specify random seed (string) for internal random number generator"

-fivopts  ; ALL NONE  ""

  "Perform induction variable optimizations (for options compatibility only, performed by default by Open64)"

-fno-ivopts ; ALL NONE  ""

  "Do not perform induction variable optimizations (for options compatibility only, ignored by Open64)"

-frename-registers  ;           ALL     NONE    ""

             "for options compatibility only, ignored by Open64"

-ftree-vectorize ;    ALL NONE  ""

       "Perform 'tree' specific vectorization; for options compatibility only, ignored by Open64"

-fno-tree-vectorize ;   ALL NONE  ""

       "Don't perform 'tree' specific vectorization; for options compatibility only, ignored by Open64"

-directives-only ; ALL NONE ""

             "ignored by open64"

% Basic option groups:

% See opt_actions.c::Process_Ofast if you change the -OPT: item.

-OPT:%s   Process_Opt_Group(optargs);   ALL CMP,ipap "-OPT:%s"

  "option group to control optimization"

-OPT:unroll_level=n ;   ALL be  ""

  "where n=1,2 controls unrolling, default=1, aggressive=2"

-OPT:keep_ext=on,off ;  ALL be  ""

  "where default is off, on means external syms are preserved"

-DEBUG:%s ;   ALL GRP "-DEBUG:%s"

  "option group to debugging options"

-TENV:%s  Process_Tenv_Group(optargs);  ALL GRP "-TENV:%s"

  "option group to control target environment"

-TARG:%s  Process_Targ_Group(optargs);  ALL GRP "-TARG:%s"

  "option group to control compilation target"

-SWP:%s   ;   ALL be  "-SWP:%s"

  ""

-GRA:%s   ;   ALL be  "-GRA:%s"

  "option group to control global register allocation"

#ifdef X8664

-GRA:unspill=on,off ;   ALL be  ""

  "when on enables optimal GRA/LRA boundary condition allocations"

#endif

-GCM:%s   {warning("-GCM group no longer supported");}  N NONE  ""

  ""

-CG:%s    ;   ALL be  "-CG:%s"

  "option group to control code generation"

-CG:unroll_level=n ;    ALL be  ""

  "where n=0,1,2 controls unrolling, none=0, default=1, aggressive=2"

-CG:unroll_fb_req=on,off ;    ALL be  ""

  "when on with FDO disables cold code layout for unrolled loops"

#ifdef X8664

-CG:cmp_peep=on,off ;   ALL be  ""

  "when on load-exec opts include compare instructions"

-CG:compute_to=on,off ;   ALL be  ""

  "when on, enables SSE based scheduling/local code motion optimizations"

#endif

-PHASE:%s ;   ALL be,ipl  "-PHASE:%s"

  ""

-WOPT:%s  ;   ALL be,ipl  "-WOPT:%s"

  "option group internal-use WOPT options"

-LNO:%s   ;   ALL be  "-LNO:%s"

  "option group to control loop nest optimization"

-HP:%s    Process_Hugepage_Group(optargs);  ALL be  ""

  "option group to specify huge page usage, e.g., -HP:bdt=2m:heap=2m,limit=150"

-HP   Process_Hugepage_Default();   ALL be  ""

  "equivalent to -HP:heap=2m"

-HUGEPAGE:%s  Process_Hugepage_Group(optargs);  ALL be  ""

  "equivalent to -HP:"

-HUGEPAGE Process_Hugepage_Default();   ALL be  ""

  "equivalent to -HP"

#ifndef KEY

-MP:%s    Process_Mp_Group(optargs);    ALL NONE  ""

  ""

#endif

-VHO:%s   ;   ALL ffe,be,ipl  "-VHO:%s"

  "option group to control vho lowering"

% C and Fortran listing related options:

-CLIST:%s ;   cc  be  "-PHASE:clist -CLIST:%s"

  "option group to control C source listing of compiler intermediate"

-FLIST:%s ;   FTN be  "-PHASE:flist -FLIST:%s"

  "option group to control Fortran source listing of compiler intermediate"

-clist  ;   cc  be  "-PHASE:clist -CLIST:=ON"

  ""

-flist  ;   FTN be  "-PHASE:flist -FLIST:=ON"

  ""

-mplist   ;   FTN,cc  be  "-mplist"

  ""

-PURPLE:%s  ;   f77 be  "-PHASE:purple -PURPLE:%s"

  "option group to control problem isolation slicing tool"

-PROMP:next_id=%d ;   FTN,Cc  be  "-PROMP:next_id=%d"

  ""

-PROMP:%s ;   FTN,Cc  be  "-PHASE:prompf -PROMP:%s"

  ""

-IPA:%s toggle(&ipa,TRUE);    ALL ipl,ipap  "-IPA:%s"

  "option group to control interprocedural optimizations"

-LANG:std toggle(&standard_cplusplus,TRUE);  CC    GRP  "-LANG:std"

        "Use ISO/ANSI standard-conforming C++ language and library"

-LANG:%s  ;   LINK  GRP "-LANG:%s"

  "option group to control language features"

-INTERNAL:%s  ;   LINK  GRP,ipap  "-INTERNAL:%s"

  "option group to control features while testing"

-DEFAULT:%s Process_Default_Group(optargs);   ALL N ""

  ""

-fverify-tree ;           CC     anyfe  "-fverify-tree"

        "Run verification routine before tree-to-whirl conversion"

% Linker Option Group(s)

-LMSG:%s  ;   ALL ld  "-LMSG:%s"

  "option group to control error/warning messages in ld"

-FE:%s    ;   ALL ffe "-FE:%s"

  ""

I-init%s    ;   CC  ld  "-init %s"

  ""

I-fini%s    ;   CC  ld  "-fini %s"

  ""

% -C can have two different meanings, so escape to hand-code

-C*   ;   ALL NONE  ""

  "C/C++: keep C comments after cpp; Fortran: runtime subscript checking"

-ffortran-bounds-check  ; FTN ffe "-DEBUG:subscript_check"

  "check bounds"

-ffortran2003 ; FTN ffe self

  "Fortran 2003 behavior for BOZ constants in intrinsics"

% we can safely assume that P_cpp will be the earliest phase

% P_any_cpp is the generic union of all cpp phases

-E  last_phase=P_any_cpp;   ALL NONE  self

  "run cpp and send result to standard output"

-P    ;   ALL CPP self

  ""

-M  last_phase=P_any_cpp;   ALL CPP self

  "run cpp and print list of make dependencies"

-MDupdate%s ;   ALL CPP,ld  "-MDupdate %s"

  "update the following file with make dependencies"

-MDtarget%s ;   ALL CPP "-MDtarget %s"

  "use the following as the target for make dependencies"

-MDignore%s ;   ALL ld  "-MDignore %s"

  ""

-fdollars-in-identifiers   ;    ALL     CPP     self

        "Accept `$' in identifiers"

% first_phase is P_cpp by default, so set it to anything different

-nocpp nocpp_flag=TRUE;first_phase=P_any_fe;  FTN anyfe self

  "do not do cpp processing"

-cpp  toggle(&use_ftpp,0);first_phase=P_any_cpp;  ALL NONE  ""

  ""

% -o is now handled elsewhere because of complications introduced by cord

-o%-  save_name(&outfile,optargs);check_output_name(optargs);cancel_saved_arg(2);  ALL NONE ""

  "put output in following file name rather than a.out"

-fonetrip ;   f77 ffe "-1"

  "One trip DO loops"

-onetrip  ;   f77 ffe "-1"

  "One trip DO loops"

-1    ;   f77 ffe self

  "One trip DO loops"

-p  ;   ALL ld  self "-TENV:call_mcount"

  ""

-pg ;   ALL ld  self "-lm" "-TENV:call_mcount"

  ""

-profile  ; ALL ld  self "-lm" "-TENV:call_mcount"

  ""

#ifdef SL

% sl specific flags

-march=%s ;  ALL     as      ""

        "Set CPU type"

-n32    toggle(&abi,ABI_N32);   ALL     PFA     "-n32" "-TARG:abi=n32"

        "Compile for 32-bit ABI"

-mips4  toggle(&isa,ISA_MIPS4);         ALL     as      "-mips4" "-TARG:isa=mips4"

        "compile for mips4 instruction set"

-sl1_dsp   toggle(&use_sl1_dsp,TRUE);   ALL  NONE "-CG:dsp_thread=on -TARG:processor=sl1_dsp -march=sl1"

  ""

-sl1_pcore toggle(&use_sl1_pcore,TRUE); ALL  NONE   "-TARG:processor=sl1_pcore -march=sl1"

  ""

-sl5       toggle(&use_sl5,TRUE); ALL  NONE   "-TARG:processor=sl5 -march=sl5"

  ""

-mlong-long      Long_Long_Support=TRUE;   Cc,cpp f self

  "Supporting 64bit Long Long for SL"

-msoft-float    Float_Point_Support=TRUE;  Cc,cpp f self

  "Supporting Float Point Emulation for SL"

-ldscript ldscript_file=TRUE; ALL ld  ""

  "Using appointed link file"

#endif

#ifdef X8664 /* Bug #381, here the MACRO is X8664/IA64, no 'TARG_' prefix */

-m32  toggle(&abi,ABI_N32); ALL be  "-TARG:abi=n32"

        "Compile for 32-bit ABI"

-m64  toggle(&abi,ABI_64);  ALL be  "-TARG:abi=n64"

  "Compile for 64-bit ABI"

#endif

#ifdef TARG_NVISA

-m32    toggle(&abi,ABI_N32);   ALL     be      "-TARG:abi=n32"

        "Compile for 32-bit ABI"

-m64    toggle(&abi,ABI_64);    ALL     be      "-TARG:abi=n64"

        "Compile for 64-bit ABI"

-w64  toggle(&abi,ABI_W64); ALL NONE  "-TARG:abi=w64"

  "Compile for Windows 64-bit ABI"

#endif

#ifdef KEY /* Bug 4210 */

-module%s Process_module(optargs);  F90 NONE  ""

  "Directory in which to create .mod file"

#endif /* KEY Bug 4210 */

% KRDEFS are used by K&R compiles; ONANSI by any non-strict-ansi compile

#define KRDEFS "-Dunix -Dsgi -DLANGUAGE_C"

#define KRDEFS_linux "-Dunix -Dlinux"

#define ANSI  "-Xansi -D__STRICT_ANSI__"

% One kludge that we do is to add -DMIPSE{L,B} by hand in the driver,

% by checking if ansi==KR_ANSI and then checking the endian value.

I-cpp_nonansi   ;   ALL NONE  "-D_LONGLONG"

  ""

I-cpp_extensions  ;   ALL NONE  "-D__EXTENSIONS__ -D__MATH_HAS_NO_SIDE_EFFECTS"

  ""

% KEY: Do not list FTN here because while FTN fe and FTN cpp take -ansi, gcc for

%      FTN preprocessing does not.  Handle FTN -ansi when calling individual

%      phases.

-ansi toggle(&ansi,STRICT_ANSI);  cc  CPP,anyfe self ANSI

  "strict ansi and standard intrinsics only"

-std=c89    ;   Cc,CPP  CPP,cfe self

  "Support ISO C from 1990"

-std=iso9899:1990 ;   Cc,CPP  CPP,cfe self

  "Support ISO C from 1990"

-std=iso9899:199409 ;   Cc,CPP  CPP,cfe self

  "Support ISO C from 1990, with 1994 amendments"

-std=c99    ;   Cc,CPP  CPP,cfe self

  "Support revised ISO C, from 1999"

-std=c9x    ;   Cc,CPP  CPP,cfe self

  "Support revised ISO C, from 1999"

-std=iso9899:1999 ;   Cc,CPP  CPP,cfe self

  "Support revised ISO C, from 1999"

-std=iso9899:199x ;   Cc,CPP  CPP,cfe self

  "Support revised ISO C, from 1999"

-std=gnu89    ;   Cc,CPP  CPP,cfe self

  "Support ISO C from 1990, with GNU extensions"

-std=gnu99    ;   Cc,CPP  CPP,cfe self

  "Support ISO C from 1999, with GNU extensions"

-std=gnu9x    ;   Cc,CPP  CPP,cfe self

  "Support ISO C from 1999, with GNU extensions"

-std=c++98    ;   CC,CPP  CPP,cfe self

  "Support 1998 ISO C++ standard plus amendments"

-std=gnu++98    ;   CC,CPP  CPP,cfe self

  "The same as '-std=c++98' plus GNU extensions.  This is the default for C++ code."

% these options are only set for cc:

I-Xansi                 ;       cc      mpc     self

        ""

I-D_LANGUAGE_C    ; cc  CPP self

  ""

I-D__EXTENSIONS__   ; CC,cc CPP self

  ""

I-D__GNUC__ ; CC,cc CPP self

  ""

% these options are only set for CC:

#define CXX_DEFS "-D_LANGUAGE_C_PLUS_PLUS=1 -D_MODERN_C"

#define CXX_DEFS_LINUX "-D_LANGUAGE_C_PLUS_PLUS=1"

% the -Xcpluscomm is needed in case we use CPP

I-D_LANGUAGE_C_PLUS_PLUS=1 ;  CC  CPP self

  ""

% these options are only set for as:

#define AS_DEFS "-D_LANGUAGE_ASSEMBLY -DLANGUAGE_ASSEMBLY"

I-cpp_assembly    ;   as  CPP AS_DEFS

  ""

I-D_LANGUAGE_ASSEMBLY ;   as  CPP self

  ""

% these options are only set for fortran:

% these options are only set for fortran:

#define FTN_DEFS "-D_LANGUAGE_FORTRAN -DLANGUAGE_FORTRAN"

#define FTN77_DEFS "-D_LANGUAGE_FORTRAN77 -DLANGUAGE_FORTRAN77"

#define FTN90_DEFS "-D_LANGUAGE_FORTRAN90 -DLANGUAGE_FORTRAN90"

I-cpp_fortran   ;   FTN CPP FTN_DEFS

  ""

I-cpp_fortran90   ;   F90 CPP FTN90_DEFS

  ""

I-cpp_fortran77   ;   f77 CPP FTN77_DEFS

  ""

I-D_LANGUAGE_FORTRAN  ;   FTN CPP self

  ""

% f77 and as use cpp, but require k&r processing for things like # comments

-A%s      ;   ALL CPP "-A%s"

  "add following cpp assertions"

-D%s      ;   ALL CPP "-D%s"

  "add following macro define"

% -U can have two different meanings, so escape to hand-code

-U*   ;   ALL NONE  ""

  ""

-U%s      ;   ALL CPP "-U%s"

  "undefine the following macro"

-l%s      ;   LINK  ld  "-l%s"

  "-l<arg> adds library lib<arg> to link list"

-WB,%s      ;   LINK  ld  "-WB,%s"

  "-WB,<arg> passes <arg> to the back-end via ipacom"

%the next 2 entries are allegedly handled by the W* entry -- gbl

%Bug#551

%-Wa,%s     ;   LINK  as  "-Wa,%s"

% "pass comma-separated opts to assembler as individual opts"

-Wl,%s      ;   LINK  ld  "-Wl,%s"

  "pass comma-separated opts to linker as individual opts"

-Wp,%s      ;   ALL CPP "-Wp,%s"

  "pass comma-separated opts to preprocessor as individual opts"

-W*     ;   ALL NONE  ""

  "-W<phase>,<arg> sends arg to phase {p=cpp,f=fe,b=be,a=as,l=ld}"

-Y%s  change_phase_path(optargs);   ALL ipap  "-Y%s"

  "-Y<phase>,<path> uses path to find phase {p=cpp,f=fe,b=be,a=as,l=ld,i=inline,I=include,S=startup,L=libraries}"

% XPG requires ability to do -O 0 as well as -O0

-O*0  toggle(&olevel,0);    ALL CMP,CPP "-O0"

  "no optimization"

-O*1  toggle(&olevel,1);    ALL CMP,CPP "-O1 -D__OPTIMIZE__"

  "minimal optimization"

-O  toggle(&olevel,2);    ALL CMP,CPP "-O2 -D__OPTIMIZE__"

  "same as -O2"

-O*2  toggle(&olevel,2);    ALL CMP,CPP "-O2 -D__OPTIMIZE__"

  "global optimization"

-O*3  O3_flag=TRUE;toggle(&olevel,3); ALL CMP,CPP "-O3 -D__OPTIMIZE__"

  "full optimization"

-O*%d ;       ALL CMP,CPP "-O3"

  "full optimization"

-Os toggle(&ospace,TRUE); ALL CMP "-OPT:space"

  "Optimize for space"

-mspace toggle(&ospace,TRUE); ALL CMP "-OPT:space"

  ""

-g  toggle(&glevel,2);    ALL CMP "-g2"

  "full debug info"

-g0 toggle(&glevel,0);    ALL CMP self

  "no debug info"

-g1 toggle(&glevel,1);    ALL CMP self "-Wl,--export-dynamic"

  ""

-g2 toggle(&glevel,2);    ALL CMP self

  ""

-g3 toggle(&glevel,3);    ALL CMP,CPP self

  "Add debugging information for C preprocessor macros"

-gdwarf warn_ignored(option_name);  ALL NONE  ""

  ""

-gdwarf-1 warn_ignored(option_name);  ALL NONE  ""

  ""

-gdwarf-1+  warn_ignored(option_name);  ALL NONE  ""

  ""

-gdwarf-2 toggle(&glevel,2);  ALL CMP "-g2"

  "Produce debugging information in DWARF version 2 format"

-gdwarf-20  toggle(&glevel,0);  ALL CMP "-g0"

  "Produce DWARF 2 debugging information at debug level 0"

-gdwarf-21  toggle(&glevel,1);  ALL CMP "-g1"

  "Produce DWARF 2 debugging information at debug level 1"

-gdwarf-22  toggle(&glevel,2);  ALL CMP "-g2"

  "Produce DWARF 2 debugging information at debug level 2"

-gdwarf-23  toggle(&glevel,3);  ALL CMP "-g3"

  "Produce DWARF 2 debugging information at debug level 3"

-ggdb toggle(&glevel,2);    ALL CMP "-g2"

  "Produce debugging information for use by GDB"

-ggdb3  toggle(&glevel,3);    ALL CMP "-g3"

  "Produce debugging information for use by GDB"

#ifdef KEY

-gnu3 toggle(&gnu_major_version,3);toggle(&gnu_minor_version,3);  Cc  NONE  ""

  "Use GCC 3.3 C/C++ front-end."

-gnu4 toggle(&gnu_major_version,4);toggle(&gnu_minor_version,2);  Cc  NONE  ""

  "Use GCC 4.2 C/C++ front-end."

-gnu40  toggle(&gnu_major_version,4);toggle(&gnu_minor_version,0);  Cc  NONE  ""

  "Use GCC 4.0 C/C++ front-end."

-gnu42  toggle(&gnu_major_version,4);toggle(&gnu_minor_version,2);  Cc  NONE  ""

  "Use GCC 4.2 C/C++ front-end."

#endif

-gstabs   warn_ignored(option_name);  ALL NONE  ""

  ""

-gstabs+  warn_ignored(option_name);  ALL NONE  ""

  ""

-gstabs0  warn_ignored(option_name);  ALL NONE  ""

  ""

-gstabs1  warn_ignored(option_name);  ALL NONE  ""

  ""

-gstabs2  warn_ignored(option_name);  ALL NONE  ""

  ""

-gstabs3  warn_ignored(option_name);  ALL NONE  ""

  ""

#define ABII32_DEFS     "-D_ILP32 -Amodel(ilp32)"

#define ABII64_DEFS     "-D_LP64"

#define ABIIA32_DEFS    "-D_ILP32 -Amodel(ilp32)"

-i32    toggle(&abi,ABI_I32);       ALL     pwrc,PFA,mpc        "-i32" ABII32_DEFS "-TARG:abi=i32 -D__ia64=1"

        ""

-i64     toggle(&abi,ABI_I64);       ALL     pwrc,PFA,mpc       "-i64" ABII64_DEFS "-TARG:abi=i64 -D__ia64=1"

        ""

-ia32   toggle(&abi,ABI_IA32);       ALL     pwrc,PFA,mpc       "-ia32" ABIIA32_DEFS "-TARG:abi=ia32 -D__ia32=1"

        ""

-itanium toggle(&isa,ISA_IA641);        ALL     NONE    "-i64"

        ""

% See the comments associated with -mlittle/big-endian

I-m0    ;   ALL GRP self

  ""

I-m1    ;   ALL GRP self

  ""

I-m2    ;   ALL GRP self

  ""

I-object    ; ALL ld  ""

  ""

% -useas says to go through the assembler phase

-useas  toggle(&skip_as,FALSE);   ALL NONE  ""

  ""

% -noas says to skip the assembler phase

-noas toggle(&skip_as,TRUE);    ALL NONE  ""

  ""

-usegfe   ;   Cc  NONE  ""

  ""

-usef90   ;   F90 NONE  ""

  ""

-NC%d ;  FTN  ffe "-NC%d"

  "set max # of continuation lines"

I-cvs   ;   FTN F self

  ""

I-cvs,%D  ;   FTN F "-cvs,%D"

  ""

I-cvs_nosrc ;   FTN F self

  ""

I-cvs_nosrc,%D  ;   FTN F "-cvs_nosrc,%D"

  ""

-automatic  toggle(&isstatic,1);    FTN NONE  ""

  ""

-auto_use%s ;     F90 ffe "-auto_use=%s"

  ""

-auto-use%s ;     F90 ffe "-auto_use=%s"

  "Act as if a USE statement is specified in every PU"

#ifdef KEY  /* bug 9058 */

-fcoco    toggle(&use_coco,TRUE); FTN NONE  ""

  "use coco Fortran preprocessor"

-fcoco=%s toggle(&use_coco,TRUE);save_name(&coco_setfile,optargs);  FTN NONE  ""

  "use coco Fortran preprocessor"

#endif

-ftpp   toggle(&use_ftpp,1);  F90 NONE  ""

  ""

-macro_expand expand_ftpp_macros=TRUE;  F90 N ""

  ""

-macro-expand expand_ftpp_macros=TRUE;  F90 N ""

  "expand macros everywhere in ftpp"

-static-data    ;   FTN ffe self

  "treat local data as static"

-static   ;   LINK  ld  self

  ""

-static_threadprivate   ;   FTN ffe self

  ""

-static-threadprivate   ;   FTN ffe self

  "treat locals as static but not shared among multiple threads"

-dumpspecs  warn_ignored(option_name);  ALL anyfe self

  ""

-backslash  first_phase=P_any_fe;   f77 ffe self

  "treat backslash as normal character rather than an escape"

#ifdef KEY /* Bug 4260 */

-byteswapio toggle(&io_byteswap,1);   F90 ffe self

  "Swap bytes during file I/O"

-convert%s  toggle(&io_byteswap,2);check_convert_name(optargs); F90 ffe "-convert %s"

  "Convert files by swapping bytes during I/O"

#endif /* KEY Bug 4260 */

-noexpopt ;   FTN be  "-OPT:fast_exp=no"

  "Do not optimize exponentiation operations"

-keepdollar ;   f77 ffe self

  "Treat $ as a normal last character in symbol names"

-chararg1 ;   f77 ffe self

  ""

-nof77  ;   f77 ffe self

  ""

-ff77 warn_ignored(option_name);  FTN NONE  ""

  "Use idiomatic UNIX FORTRAN 77"

-ff90 ;   FTN NONE  ""

  "Allow Fortran 90 constructs"

-fdirectives  ; FTN ffe ""

  "Recognize Fortran compiler directives inside comments"

-fno-directives ; FTN ffe "-xall"

  "Ignore Fortran compiler directives inside comments"

I-xall    ; FTN ffe self

  ""

-fsecond-underscore ;   FTN ffe self

  "Append a second underscore to symbols that already contain an underscore"

-fno-second-underscore  ;   FTN ffe self

  "Do not append a second underscore to symbols that already contain an underscore"

-funderscoring  ;   FTN ffe self

  "Append underscores to symbols"

-fno-underscoring ;   FTN ffe self

  "Do not append underscores to symbols"

-fcheck-new ; CC  cfe self

  "Check result of operator new for NULL"

-fno-check-new  ; CC  cfe self

  "Do not check result of operator new for NULL"

-fvisibility-inlines-hidden ;   CC      cfe     self

        "for options compatibility only, ignored by Open64"

-frepo          ;       CC      cfe     self

        "Enable automatic template instantiation at link time, for options compatibility only, ignored by Open64"

-fconserve-space        ;       CC      cfe     self

        "Put uninitialized or runtime-initialized global variables into the common segment, for options compatibility only, ignored by Open64"

-felide-constructors    ;       CC      cfe     self

        "for options compatibility only, ignored by Open64"

-fno-elide-constructors ; CC  cfe self

  "Do not perform an optimization that can avoid calling the copy constructor"

-fno-implement-inlines  ;       CC      cfe     self

        "Do not emit out-of-line copies of inline functions controlled by `#pragma implementation', for options compatibility only, ignored by Open64"

-ffor-scope ; CC  cfe self

  "Variables declared in a for-init loop are constrained to that scope"

-fno-for-scope  ; CC  cfe self

  "Variables declared in a for-init loop extend to the enclosing scope"

-fuse-cxa-atexit  ; CC  cfe self

  "Register static destructors with __cxa_atexit instead of atexit"

-fno-use-cxa-atexit ; CC  cfe self

  "Register static destructors with atexit instead of __cxa_atexit"

-frtti  ; CC  cfe self

  "Generate runtime type information"

-fno-rtti ; CC  cfe self

  "Do not generate runtime type information"

-fimplicit-templates  ; CC  cfe self

  "Emit code for non-inline templates instantiated implicitly"

-fno-implicit-templates ; CC  cfe self

  "Never emit code for non-inline templates instantiated implicitly"

-fimplicit-inline-templates ; CC  cfe self

  "Emit code for inline templates instantiated implicitly"

-fno-implicit-inline-templates  ; CC  cfe self

  "Never emit code for inline templates instantiated implicitly"

-fweak  warn_ignored(option_name);  ALL NONE  ""

  ""

-fno-weak warn_ignored(option_name);  ALL NONE  ""

  ""

-fssa warn_ignored(option_name);  ALL NONE  ""

  ""

-fno-ssa  warn_ignored(option_name);  ALL NONE  ""

  ""

-fssa-ccp warn_ignored(option_name);  ALL NONE  ""

  ""

-fno-ssa-ccp  warn_ignored(option_name);  ALL NONE  ""

  ""

-fssa-dce warn_ignored(option_name);  ALL NONE  ""

  ""

-fno-ssa-dce  warn_ignored(option_name);  ALL NONE  ""

  ""

-foptimize-register-move  warn_ignored(option_name);  ALL NONE  ""

  ""

-fno-optimize-register-move warn_ignored(option_name);  ALL NONE  ""

  ""

-foptimize-sibling-calls  warn_ignored(option_name);  ALL NONE  ""

  ""

-fno-optimize-sibling-calls warn_ignored(option_name);  ALL NONE  ""

  ""

-femit-class-debug-always warn_ignored(option_name);  ALL NONE  ""

  ""

-fno-emit-class-debug-always  warn_ignored(option_name);  ALL NONE  ""

  ""

-ftree-vrp  warn_ignored(option_name);  ALL NONE  ""

  "Perform Value Range Propagation on trees"

-fno-tree-vrp warn_ignored(option_name);  ALL NONE  ""

  ""

-Wframe-larger-than-100000000   warn_ignored(option_name);      ALL     NONE    ""

        "help noticing functions with larger than usual frame sizes"

-Wno-vla   warn_ignored(option_name);      ALL     NONE    ""

        "prevent the -pedantic warning of the variable length array"

-Wno-error=%s   warn_ignored(option_name);      ALL     NONE    ""

        "makes -Ws warnings not be error"

-ftls-model=%s  check_opt_tls_model(optargs);   Cc  cfe "-ftls-model=%s"

  "Thread-Local Storage model. \n\t\tShould be one of `global-dynamic', `local-dynamic', `initial-exec' or `local-exec'.\n\t\tThe default without -fpic is `initial-exec'; with -fpic the default is `global-dynamic`."

-varargs  ;   f77 ffe self

  "MATRA varargs"

%-nocode last_phase=earliest_phase(P_any_fe,last_phase);  FTN ffe   self

%        "do not generate any intermediate code from front-end"

-vms  warn_no_longer_supported2(option_name,"-vms_cc");   FTN NONE  self

  ""

-vms_cc   ;   f77 ffe self

  ""

-old_rl   ;   f77 ffe self

  ""

-bytereclen ;   f77 ffe "-old_rl"

  ""

-vms_stdin    ;   f77 ffe self

  ""

-vms_endfile    ;   f77 ffe self

  ""

-vms_library    ;   f77 ffe self

  ""

-usefpidx   ;   f ffe self

  ""

% this should be on by default unless -mp, but off now until freeze over

-cray_directives  ;   FTN N self

  ""

-mipslibs      toggle(&use_mipslibs,TRUE);toggle(&use_craylibs,FALSE);         f77     NONE    ""

       ""

-craylibs      toggle(&use_craylibs,TRUE);toggle(&use_mipslibs,FALSE);         f77     NONE    ""

       ""

#ifndef KEY

-cray_mp    toggle(&mpkind,CRAY_MP);   FTN ffe self

    "enable Cray micro-tasking directives"

-dsm      ;   FTN,Cc  GRP self

  ""

#endif

-mp     toggle(&mpkind,NORMAL_MP);      FTN,Cc  ffe,cfe     self

        "enable the multiprocessing directives"

-openmp     ;   FTN,Cc  ffe -mp

        "enable the multiprocessing directives (same as -mp)"

#ifdef KEY

-fopenmp    ;   Cc  cfe self

        ""

#endif

#ifndef KEY

-dsm_clone    ;   ALL ipl,be,d  self

  ""

-dsm_check    ;   ALL be  self

  ""

-dsm_recompile    ;   ALL ffe,cfe,be,ipl  self

  ""

#endif

-memsim     ;   ALL N "-LNO:mem_sim=TRUE -lmemsim"

  ""

-memctr     ;   ALL be  "-memctr"

  ""

-mieee-fp ;   ALL be  "-OPT:IEEE_NaN_Inf=on"

  "Use IEEE floating point comparisons"

-mno-ieee-fp  ; ALL be  "-OPT:IEEE_NaN_Inf=off"

  "IEEE floating point comparisons not required"

-mp_keep warn_no_longer_supported2(option_name,"-CLIST/-FLIST");  FTN,cc  NONE  ""

  ""

-mpio     ;   FTN be  self

  ""

-mp_schedtype=%s  ;   FTN PFA,ffe   "-mp_schedtype=%s"

  ""

-chunk=%d   ;   FTN PFA,ffe "-chunk=%d"

  "Set the MP chunksize"

-mp_chunk=%d    ;   FTN ffe "-mp_chunk=%d"

  ""

-mp_use_locks warn_no_longer_needed(option_name);  FTN NONE ""

  ""

-mp_use_copy  warn_no_longer_needed(option_name);  FTN NONE ""

  ""

% invoke apo  - which discovers parallelism (synonym for -pfa, -pca)

-apo    auto_parallelize=TRUE;    Cc,FTN  be  "-pfa"

  ""

-apo*list auto_parallelize=TRUE;keep_list=TRUE;   Cc,FTN  be  "-pfa -LNO:prompl"

  ""

-apo*keep auto_parallelize=TRUE;keep_list=keep_mp=TRUE;Process_Promp();   Cc,FTN  be  "-pfa -LNO:prompl"

  ""

% invoke pfa  - which discovers parallelism

-pfa    auto_parallelize=TRUE;    Cc,FTN  be  "-pfa"

  ""

-pfa*list auto_parallelize=TRUE;keep_list=TRUE;   Cc,FTN  be  "-pfa -LNO:prompl"

  ""

-pfa*keep auto_parallelize=TRUE;keep_list=keep_mp=TRUE;Process_Promp();   Cc,FTN  be  "-pfa -LNO:prompl"

  ""

% Because of limitation on derived flags, we repeat the -pfa,%s in the

% implied list.  This is to find the parent flag so action is done.

-pfa,%s   {auto_parallelize=TRUE; warning("options after -pfa, are ignored; should just use -pfa");}    Cc,FTN  be  "-pfa"

  ""

-pfa2 warn_no_longer_supported2(option_name,"-pfa");  ALL NONE ""

  ""

I-lo=ocktl  ;   FTN PFA self

  ""

-i2 toggle(&iflag,1);   f77 ffe self

  "make integer and logical quantities short (2 bytes)"

-noi4 toggle(&iflag,1);   f77 ffe self

  "make integer and logical quantities short (2 bytes)"

-i4 toggle(&iflag,2);   FTN ffe self

  "make integer and logical quantities long (4 bytes)"

-i8 toggle(&iflag,3);   FTN ffe self

  "make integer and logical quantities long long (8 bytes)"

-r4 toggle(&rflag,1);   FTN ffe self

  "use REAL*4 and COMPLEX*8 as the defaults for real and complex"

-r8 toggle(&rflag,2);   FTN ffe self

  "use REAL*8 and COMPLEX*16 as the defaults for real and complex"

-r8const    ;   f77 ffe self

  ""

-d8 toggle(&dflag,1);   FTN ffe self

  "use double=8 and dcomplex=16"

-dump_input     ;   f77 ffe self

  ""

-extend_source fortran_line_length=132;   FTN ffe self "-scan=132"

  ""

-extend-source fortran_line_length=132;   FTN ffe "-extend_source -scan=132"

  "make each source line 132 bytes long"

-e*     ;   LINK  ld  ""

  ""

-d_lines    ;   FTN ffe self

  ""

-d-lines    ;   FTN ffe self

  "compile lines with a D in column 1"

-pad_char_literals    ;   F90 ffe self

  ""

-pad-char-literals    ;   F90 ffe "-pad_char_literals"

  "blank pad character literal actual arguments to word boundary"

-expand_include   ;   FTN ffe self

  ""

-noextend_source fortran_line_length=72;  FTN ffe self "-scan=72"

  ""

-noextend-source fortran_line_length=72;  FTN ffe "-noextend_source -scan=72"

  ""

-col72  fortran_line_length=72;   FTN ffe self "-scan=72"

  "sets the source statement length to 72 columns"

-col80  fortran_line_length=80;   F90 ffe self "-scan=80"

  "sets the source statement length to 80 columns"

-col120 fortran_line_length=120;  FTN ffe self "-scan=120"

  "sets the source statement length to 120 columns"

I-scan%s    ;   FTN PFA self

  ""

-freeform toggle(&fortran_form,2);  F90 ffe ""

  "sets Fortran 90 free form source statement formatting"

-fixedform  toggle(&fortran_form,1);  F90 ffe ""

  "sets Fortran 90 fixed form source statement formatting"

-default64    ;   F90  ffe  self

  "Cray compatibility mode for F90"