%
%
%  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.

% There are two section types, which can be interspersed:
% Each option in the OPTIONS section 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 %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 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.

% 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.

% Lines in the COMBINATIONS section give 
% an option combination, 
% whether the combination is OKAY, a WARNING, or an ERROR,
% and what implied behavior comes from that option.
% The implied behavior of combinations overrides the implied behavior
% of the individual options.

% 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
#define cc	c
#define CC	C
#define Cc	cc,CC
#define f77	f
#define UPC     u
#define upc     u
% 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
#define cpp	p
#define cfe	C
#define ffe	F
#define FE	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	FE,ipl,be
% ALLX: ALL except pca & pfa which don't accept the usual compilation args
#define ALLX	cpp,CMP,ld


%%% OPTIONS
% <option name>	<action> <default> <languages> <phases> <implies>
%	<help message>
-help	;		ALL	NONE	""
	"print list of possible options"
-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 don't invoke anything"
-showt	{time_flag = TRUE; }	ALL	NONE	""
	"show time taken by each phase"
-showm	{memory_flag ++ ; }	ALL	NONE	""
	"show memory usage by each phase"
-Q 	{quiet_flag = FALSE; }	ALL	NONE	""
	"suppress timing information (g++) "
-version {show_version = TRUE; execute_flag = FALSE;} ALL	NONE	""
	"Show the version of the compiler being used"
% -showd turns on internal driver debugging 
-showd	{show_flag = debug = TRUE; execute_flag = FALSE;} ALL NONE ""
	""
-show_defaults	execute_flag=FALSE; 	ALL NONE ""
	"show default values"
% gcc has -v show version as well as phases, so take that meaning
-v	{show_flag = TRUE; show_version = TRUE;} ALL	cpp,ld	self "-show"
	"show phases and version as they are being invoked"
-fullwarn toggle(&msglevel,2);		Cc,FTN,as  cpp	self "-m2"
	"give more warnings, especially about missing prototypes"
-w	toggle(&msglevel,0);		ALL	cfe,as,PFA	self "-m0"
	""
-w0	warn_no_longer_supported2(option_name,"-fullwarn");		ALL	as,ld,FE ""
	""
-w1	warn_no_longer_needed(option_name);		ALL	NONE	""
	""
-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"
-diag_suppress%s	;		Cc	cpp,cfe	"-diag_suppress%s"
	"turn off named diagnostics"
-diag_remark%s		;		Cc	cpp,cfe	"-diag_remark%s"
	"make named diagnostics into remarks"
-diag_warning%s		;		Cc	cpp,cfe	"-diag_warning%s"
	"make named diagnostics into warnings"
-diag_error%s		;		Cc	cpp,cfe	"-diag_error%s"
	"make named diagnostics into errors"

-brief_diagnostics	;		CC	cpp	self
	"issue one-line diagnostic messages"

% -V is an svr4 option, currently ignored
-V	warn_ignored("-V");		cc	ALLX	""
	""
-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"
-x%s		;		F90	ffe	"-x%s"
	"Disable various directives in F90"

I-include=%D  ;		FTN     ffe,PFA     "-include=%D"
	""
-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"
#ifdef linux
-nostdlib	;	LINK	ld	"-nostartfiles -nodefaultlibs"
	"no predefined libraries or startfiles"
#else
-nostdlib	;	LINK	ld	"-L"
	"no predefined library search path list"
#endif
-objectlist%s	source_kind=S_o;		LINK	ld	"-objectlist %s"
	"Read the following file to get a list of files to be linked"
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
	""

-G		;		cc	ld	self
	""
-G%d	toggle(&gnum,optargd);		ALL	ffe,be	"-G%d"
	""
-Gspace%d	;		ALL	be	"-TENV:Gspace=%d"
	""
% encourage people to replace -K with -keep
-keep	keep_flag=TRUE;		ALL	ipap	self
	"keep intermediate files"
-save-temps	keep_flag=TRUE;	ALL	NONE	""
	""
-K	keep_flag=TRUE;		ALL	NONE	""
	""
-K*		;		ALL	NONE	""
	""
% even though -K* will parse the following K options, 
% we have to list them so the driver knows what to do with them:
-KPIC		;		ALL	NONE	""
	""
% these svr4 options are accepted but ignored by the driver
-Kminabi 	;		cc	NONE	"-abi"
	""
-Ksd	toggle(&speed,TRUE);		cc	NONE	""
	""
-Ksz	toggle(&speed,FALSE);		cc	NONE	""
	""
-Kfpe	toggle(&fpe,TRUE);warn_ignored("-Kfpe"); 	cc	NONE	""
	""
-Kmau	toggle(&fpe,FALSE);warn_ignored("-Kmau"); 	cc	NONE	""
	""
% 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 don't need init and fini
#ifdef linux
#define PIC_FLAGS_1    "-TENV:PIC -pic2"
#define PIC_FLAGS_2    "-TENV:PIC -pic2 -shared"
#else
#define PIC_FLAGS_1    "-TENV:PIC -pic2 -init _main -fini _fini"
#define PIC_FLAGS_2    "-TENV:PIC -pic2 -init _main -fini _fini -shared"
#endif
I-cpp_pic	;		ALL	NONE	"-D_PIC -D__DSO__"
	""
-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"
-non_shared	toggle(&shared,NON_SHARED); 	ALL	NONE	""
	"compile non-shared (no DSO's)"
-pic1		;		ALL	NONE	-TENV:CPIC
	""
-pic2		;		ALL	NONE	-TENV:PIC
	""
-xgot		;		ALL	NONE	"-TENV:large_GOT"
	""
-multigot	;		ALL	NONE	""
	""

% This option turns on everything of interest to SPEC:
-Ofast  Process_Ofast("");		ALL	NONE	""
	"default fast option configuration"
-Ofast=%s Process_Ofast(optargs);		ALL	NONE	""
	"processor-specific fast option configuration"

-bigp_off toggle(&big_pages,FALSE);  ALL NONE ""
    "Disable large pages"

-bigp_on toggle(&big_pages,TRUE);  ALL NONE ""
    "Enable large pages"

-fbgen	Gen_feedback=TRUE;		ALL	N	""
	"Option needed for generating feedback files for spec"

-fbuse%s Process_fbuse(optargs);		ALL	N	""
	"Option needed to use feedback files for spec"

-fbexe%s Process_fbexe(optargs);        ALL     N       ""
	"Option needed to specify the name of the pixified binary to prof"

-fb_xdir%D Process_fb_xdir(optargs);		ALL	N	""
	"Option needed to tell pixie where to emit the pixified dso's "

-fb_cdir%D Process_fb_cdir(optargs);		ALL	N	""
	"Option needed to tell pixie where to emit the Count Files"

-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       ""
        "Option needed for using SPEC feedback files"

% 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"
-DEBUG:%s	;		ALL	GRP	"-DEBUG:%s"
	"option group to debugging options"
-TENV:%s	;		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"
	"option group to control software pipelining"
-GRA:%s		;		ALL	be	"-GRA:%s"
	"option group to control global register allocation"
-GCM:%s		{warning("-GCM group no longer supported");}	N NONE	""
	""
-CG:%s		;		ALL	be	"-CG:%s"
	"option group to control code generation"
-PHASE:%s	;		ALL	be,ipl	"-PHASE:%s"
	""
-WOPT:%s	;		ALL	be,ipl	"-WOPT:%s"
	"option group internal-use WOPT options"
-LNO:%s		;		ALL	be,ld	"-LNO:%s"
	"option group to control loop nest optimization"
-MP:%s		Process_Mp_Group(optargs);		ALL	NONE	""
	"option group to control distributed shared memory optimization"
-VHO:%s		;		ALL	ffe,be	"-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"
	"specify the loop id used by ProMP annotation"
-PROMP:%s	;		FTN,Cc	be	"-PHASE:prompf -PROMP:%s"
	"option group to generate ProMP analysis file"

-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	""
	"default options (abi,isa,proc)"
-fverify-tree ;           CC     FE  "-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 is also a define, so trick cpp
-F/**/E:%s		;		ALL	ffe	"-FE:%s"
	""
I-init%s		;		CC	ld	"-init %s"
	""
I-fini%s		;		CC	ld	"-fini %s"
	""
-B*dynamic	warn_no_longer_supported(option_name);	cc	NONE	""
	""
-B*static	warn_no_longer_supported(option_name);	cc	NONE	""
	""
-B*symbolic	warn_no_longer_supported(option_name);	cc	NONE	""
	""
% -C can have two different meanings, so escape to hand-code
-C*		;		ALL	NONE	""
	"C/C++: keep C comments after cpp; f77: runtime subscript checking"
-check_bounds	;		FTN	ffe	"-DEBUG:subscript_check"
	"check bounds"
-d*y	toggle(&dynamic,TRUE);		cc	ld	"-dy"
	""
-d*n	toggle(&dynamic,FALSE);		cc	ld	"-dn"
	""
-abi		;		ALL	as,ld	self "-D_ABI_SOURCE -TARG:pure"
	"generate strict-abi-compliant object files"
% 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	cpp	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"
	""
% first_phase is P_cpp by default, so set it to anything different
-nocpp	nocpp_flag=TRUE;first_phase=P_any_fe; 	FTN	FE	self
	"don't do cpp processing"
% cpp is also a define, so trick the preprocessor
-c/**/pp  toggle(&use_ftpp,0);first_phase=P_any_cpp; 	ALL	NONE	""
	""
-J*sfm	warn_ignored(option_name);		cc	NONE	""
	""
% -o is now handled elsewhere because of complications introduced by cord
-o%s	save_name(&outfile,optargs);check_output_name(optargs);cancel_saved_arg(2);  ALL NONE ""
	"put output in following file name rather than a.out"
-onetrip	;		f77	ffe	"-1"
	"One trip DO loops"
-1		;		f77	ffe	self
	"One trip DO loops"
-p0	warn_no_longer_supported2(option_name,"speedshop(1)");		ALL	NONE	""
	""
-p1	warn_no_longer_supported2(option_name,"speedshop(1)");		ALL	NONE	""
	""
-p	;		ALL	ld	self "-TENV:call_mcount"
	""
-pg	;		ALL	ld	self "-TENV:call_mcount"
	""
-q*p	warn_no_longer_supported2(option_name,"speedshop(1)");		cc	NONE	""
	""
-q*l	warn_no_longer_supported2(option_name,"speedshop(1)");	 cc	NONE	""
	""
-Q*y	toggle(&ident,TRUE);warn_ignored(option_name);  cc	NONE	""
	""
-Q*n	toggle(&ident,FALSE);warn_ignored(option_name);  cc	NONE	""
	""
-purple	warn_no_longer_supported2(option_name,"-PURPLE:=ON");		ALL	NONE	""
	""

I-cpp_lp32	;		ALL	NONE	"-D_MIPS_SZINT=32 -D_MIPS_SZLONG=32 -D_MIPS_SZPTR=32 -D_SIZE_INT=32 -D_SIZE_LONG=32 -D_SIZE_PTR=32"
	""
I-cpp_lp64	;		ALL	NONE	"-D_MIPS_SZINT=32 -D_MIPS_SZLONG=64 -D_MIPS_SZPTR=64 -D_SIZE_INT=32 -D_SIZE_LONG=64 -D_SIZE_PTR=64"
	""
I-cpp_i64	;		ALL	NONE	"-D_ABI_I64 -D_IA64_ARCH=0"
	""
I-cpp_i32	;		ALL	NONE	"-D_ABI_I32 -D_IA64_ARCH=0"
	""
#ifdef TARG_MIPS
#define MIPS1_DEFS	"-D__mips=1 -D_MIPS_ISA=1"
#define MIPS2_DEFS	"-D__mips=2 -D_MIPS_ISA=2"
#define MIPS3_DEFS	"-D__mips=3 -D_MIPS_ISA=3"
#define MIPS4_DEFS	"-D__mips=4 -D_MIPS_ISA=4"
% The _MIPS_SIM values must match the values defined in sgidefs.h
#define ABI32_DEFS 	"-D_ABIO32=1 -D_MIPS_SIM=_ABIO32 -D_MIPS_FPSET=16 -D_ILP32 -Amodel(ilp32)"
#define NEWABI32_DEFS 	"-D_ABIN32=2 -D_MIPS_SIM=_ABIN32 -D_MIPS_FPSET=32 -D_ILP32 -Amodel(ilp32)"
#define ABI64_DEFS 	"-D_ABI64=3 -D_MIPS_SIM=_ABI64 -D_MIPS_FPSET=32 -D_LP64 -Amodel(lp64)"
-mips1	toggle(&isa,ISA_MIPS1);		ALL	NONE	"-mips1" MIPS1_DEFS "-TARG:isa=mips1"
	"compile for mips1 instruction set"
-mips2	toggle(&isa,ISA_MIPS2);		ALL	as,ld	"-mips2" MIPS2_DEFS "-TARG:isa=mips2"
	"compile for mips2 instruction set"
-mips3	toggle(&isa,ISA_MIPS3); 	ALL	as,ld	"-mips3" MIPS3_DEFS "-TARG:isa=mips3"
	"compile for mips3 instruction set"
-mips4	toggle(&isa,ISA_MIPS4); 	ALL	as,ld	"-mips4" MIPS4_DEFS "-TARG:isa=mips4"
	"compile for mips4 instruction set"
-n32	toggle(&abi,ABI_N32); 	ALL	as,ld,PFA	"-n32" NEWABI32_DEFS "-TARG:abi=n32"
	""
-64     toggle(&abi,ABI_64);       ALL     pwrc,PFA,mpc,as,ld      "-64" ABI64_DEFS "-TARG:abi=64"
        "compile for 64-bit ABI"
#endif

#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"
        "compile for Intel IA64 32-bit ABI"
-i64     toggle(&abi,ABI_I64);       ALL     pwrc,PFA,mpc	"-i64" ABII64_DEFS "-TARG:abi=i64 -D__ia64=1"
        "compile for Intel 64-bit ABI"
-ia32   toggle(&abi,ABI_IA32);       ALL     pwrc,PFA,mpc	"-ia32" ABIIA32_DEFS "-TARG:abi=ia32 -D__ia32=1"
        "compile for Intel 32-bit ABI"
-itanium toggle(&isa,ISA_IA641);	ALL	NONE	"-i64"
	""

%%% COMBINATIONS
% <combo>	<error>		<implies>
#ifdef TARG_MIPS
"-mips1 -n32"		ERROR	""
"-mips2 -n32"		ERROR	""
"-mips3 -n32"		OKAY	"-mips3 -n32" MIPS3_DEFS NEWABI32_DEFS "-TARG:abi=n32:isa=mips3"
"-mips4 -n32"		OKAY	"-mips4 -n32" MIPS4_DEFS NEWABI32_DEFS "-TARG:abi=n32:isa=mips4"
"-mips1 -64"		ERROR	""
"-mips2 -64"		ERROR	""
"-mips3 -64"		OKAY	"-mips3 -64" MIPS3_DEFS ABI64_DEFS "-TARG:abi=64:isa=mips3"
"-mips4 -64"		OKAY	"-mips4 -64" MIPS4_DEFS ABI64_DEFS "-TARG:abi=64:isa=mips4"
#endif

%%% OPTIONS
% 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 XTENDEFS "-D__INLINE_INTRINSICS"
#define NONANSI_svr4	"-D_LONGLONG -D_SGI_SOURCE -D_SVR4_SOURCE"
#define XANSI	""
#define ANSI	"-Xansi -D__STRICT_ANSI__"
#define CCKR	"-OPT:alias=cckr_default -Xcckr"
% 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_nonansi_svr4	;		ALL	NONE	NONANSI_svr4
	""
I-cpp_extensions	;		ALL	NONE	"-D__EXTENSIONS__ -D__MATH_HAS_NO_SIDE_EFFECTS"
	""
I-cpp_krdefs		;		cc	NONE	KRDEFS
	""
I-cpp_krdefs_linux	;		Cc	NONE	KRDEFS_linux
	""
-xansi	toggle(&ansi,EXTENDED_ANSI);		cc	NONE	XANSI XTENDEFS  
	"extended ansi C"
-X*a	toggle(&ansi,EXTENDED_ANSI);		cc	NONE	XANSI XTENDEFS 
	"extended ansi C"
-ansi	toggle(&ansi,STRICT_ANSI);		cc,FTN	cpp,FE	self ANSI
	"strict ansi"
-ansiE		;		FTN,Cc	FE	self
	"issue error message for non standard features"
-ansiW		;		FTN,Cc	FE	self
	"issue warning messages for non standard features"
-X*c	toggle(&ansi,STRICT_ANSI);		cc	NONE	ANSI
	"strict ansi C"
-cckr	toggle(&ansi,KR_ANSI);		cc	NONE	CCKR XTENDEFS KRDEFS
	"K&R compatible C"
-X*t	toggle(&ansi,KR_ANSI);		cc	NONE	CCKR XTENDEFS  KRDEFS
	"K&R compatible C"
-ansiposix	warn_no_longer_supported(option_name); 	cc	NONE	""
	""
% these options are only set for cc:
I-lang-c		;		cc	cpp	self
	""
I-lang-c89		;		cc	cpp	self
	""
I-lang-c++		;		CC	cpp	self
	""
I-lang-asm		;		as	cpp	self
	""
I-Xansi                 ;       cc      mpc     self
        ""
I-Xcckr                 ;       cc      mpc     self
        ""
I-D_LANGUAGE_C		;	cc	cpp	self
	""
I-DLANGUAGE_C		;	cc	cpp	self
	""
I-D__EXTENSIONS__ 	;	CC,cc	cpp	self
	""
I-D__INLINE_INTRINSICS	;	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-cpp_cplus 		;	CC	NONE	 CXX_DEFS NONANSI_svr4
	""
I-cpp_cplus_linux	;	CC	NONE	CXX_DEFS_LINUX
	""
I-D_LANGUAGE_C_PLUS_PLUS=1 ;	CC	cpp	self
	""
%
% XTENDEFS is added to CC compiles in add_special_option
I-xtendefs		;	CC	cpp,cfe XTENDEFS "-D__EXTENSIONS__ -D__MATH_HAS_NO_SIDE_EFFECTS"
	""
I-xtendefs_linux	;	CC	cpp,cfe XTENDEFS
	""

% 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
	""
I-DLANGUAGE_ASSEMBLY	;		as	cpp	self
	""
I-Xdo_linesplice	;		ALL	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
	""
I-DLANGUAGE_FORTRAN	;		FTN	cpp	self
	""
% f77 and as use cpp, but require k&r processing for things like # comments
I-cpp_nonansi_f77	;		f77	cpp	KRDEFS NONANSI_svr4 
	""
-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"
% want to pass whole -Wl,* arg to gcc link
-Wl,%s			;		LINK	ld	"-Wl,%s"
	""
-Wp,%s			;		ALL	cpp	"-Wp,%s"
	""
-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=include,S=startup,L=libraries}"

% XPG requires ability to do -O 0 as well as -O0
-O*0	toggle(&olevel,0);		ALL	CMP	"-O0"
	"no optimization"
-O*1	toggle(&olevel,1);		ALL	CMP	"-O1 -D__OPTIMIZE__"
	"minimal optimization"
-O	toggle(&olevel,2);		ALL	CMP	"-O2 -D__OPTIMIZE__"
	"same as -O2"
-O*2	toggle(&olevel,2);		ALL	CMP	"-O2 -D__OPTIMIZE__"
	"global optimization"
-O*3	O3_flag=TRUE;toggle(&olevel,3);	ALL	CMP	"-O3 -D__OPTIMIZE__"
	"full optimization"
-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
	""
-g2	toggle(&glevel,2);		ALL	CMP	self
	""
-g3	toggle(&glevel,3);		ALL	CMP	self
	"add some debugging to optimized code"
-gslim	toggle(&glevel,2);		Cc	CMP	self
	"put out slim class debug info"
-gslim0	toggle(&glevel,2);		Cc	CMP	self
	"put out slim class debug info"
-gslim2	toggle(&glevel,2);		Cc	CMP	self
	"put out slim class debug info"
-gdwarf-2	;		ALL	cpp	self "-DEBUG:format=dwarf2"
	""
-gdwarf-20	toggle(&glevel,0);	ALL	cpp	self "-DEBUG:format=dwarf2 -g0"
	""
-gdwarf-21	toggle(&glevel,1);	ALL	cpp	self "-DEBUG:format=dwarf2 -g1"
	""
-gdwarf-22	toggle(&glevel,2);	ALL	cpp	self "-DEBUG:format=dwarf2 -g2"
	""
-gdwarf-23	toggle(&glevel,3);	ALL	cpp	self "-DEBUG:format=dwarf2 -g3"
	""
-gstabs		;		ALL	cpp	self "-DEBUG:format=stabs"
	""
-gstabs0	toggle(&glevel,0);	ALL	cpp	self "-DEBUG:format=stabs -g0"
	""
-gstabs1	toggle(&glevel,1);	ALL	cpp	self "-DEBUG:format=stabs -g1"
	""
-gstabs2	toggle(&glevel,2);	ALL	cpp	self "-DEBUG:format=stabs -g2"
	""
-gstabs3	toggle(&glevel,3);	ALL	cpp	self "-DEBUG:format=stabs -g3"
	""

%%% COMBINATIONS
% !-non_shared means "-non_shared not specified"
%"-O3 !-non_shared"	WARNING		"-non_shared"
"-KPIC -non_shared"	WARNING		"-non_shared"
"-abi -non_shared"	WARNING		"-abi"

%%% OPTIONS
-EB	toggle(&endian,ENDIAN_BIG);		ALL	NONE	""
	""
-EL	toggle(&endian,ENDIAN_LITTLE);		ALL	NONE	""
	""
-meb		;		ALL	cfe	self
	""	
-mel		;		ALL	cfe	self
	""	
I-m0		;		ALL	GRP	self
	""
I-m1		;		ALL	GRP	self
	""
I-m2		;		ALL	GRP	self
	""
-medusa	add_library_dir("/usr/ia64-sgi-linux/lib/medusa"); ALL	NONE	""
	""
-signed		toggle(&signed_char,TRUE);		Cc	cfe	self
	"characters are signed by default"
-unsigned	toggle(&signed_char,FALSE);		Cc	cfe	self
	"character are unsigned by default"
-float		;		cc	cfe	self
	"don't automatically promote floats to doubles"
-float_const	;		cc	cfe	self
	"treat floating point constants as floats rather than doubles"
-common		;		cc	NONE	""
	"default:  use relaxed ref/def model"
% can be argument to cc, CC, or a cpp flag for fortran.
% the cpp lang will match cpp use but not fortran ffe use.
-dollar		;		Cc,cpp,as	cpp,cfe		self
	""

% default defines:
% will later fixup version XXX with value from stamp.h:
I-cpp_version	;		ALL	cpp	"-D_SGI_COMPILER_VERSION=XXX"
	""
I-cpp_sgi	;		ALL	cpp	"-D__sgi"
	""
I-cpp_mips	;		ALL	cpp	"-Amachine(mips) -Acpu(mips)"
	""
I-cpp_ia64	;		ALL	cpp	"-Amachine(ia64) -Acpu(ia64)"
	""
I-cpp_ia32	;		ALL	cpp	"-Amachine(ia32) -Acpu(ia32)"
	""
I-cpp_unix	;		ALL	cpp	"-D__unix -D__unix__"
	""
I-cpp_svr3	;		ALL	cpp	"-D__SVR3 -D_SYSTYPE_SYSV"
	""
I-cpp_svr4	;		ALL	cpp	"-D_SYSTYPE_SVR4"
	""
I-cpp_irix	;		ALL	cpp	"-Asystem(unix)"
	""
I-cpp_linux	;		ALL	cpp	"-D__linux -D__linux__ -Asystem(linux)"
	""
I-cpp_cfe	;		cc	cpp	"-D_MODERN_C"
	""

I-object		;	ALL	ld	""
	""
-elf			;	ALL	NONE	"-D__ELF__"
	""
I-_SYSTYPE_SVR4		;	ALL	ld	self
	""
-no_unresolved 		warn_ignored(option_name); 	ALL	NONE	""
	""
-ignore_unresolved 	warn_ignored(option_name); 	ALL	NONE	""
	""
-transitive_link 	warn_ignored(option_name); 	ALL	NONE	""
	""
-full_transitive_link 	warn_ignored(option_name); 	ALL	NONE	""
	""
-no_transitive_link 	warn_ignored(option_name); 	ALL	NONE	""
	""

% -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	"-INTERNAL:return_val=on -INTERNAL:mldid_mstid=on -INTERNAL:return_info=on"
	""
-usef90		;		F90	NONE	"-INTERNAL:return_val=on -INTERNAL:mldid_mstid=on -INTERNAL:return_info=on"
	""

-ddopt	warn_no_longer_supported(option_name);  FTN	NONE ""
	""
-ZG	warn_no_longer_supported(option_name);  FTN	NONE ""
	""
-Nq%d	warn_no_longer_needed(option_name);  FTN	NONE self
	""
-Nx%d	warn_no_longer_needed(option_name);  FTN	NONE self
	""
-Ns%d	warn_no_longer_needed(option_name);  FTN	NONE self
	""
-Nc%d	warn_no_longer_needed(option_name);  FTN	NONE self
	""
-Ne%d	warn_no_longer_needed(option_name);  FTN	NONE self
	""
-Nl%d	warn_no_longer_needed(option_name);  FTN	NONE self
	""
-NC%d	;  FTN	ffe "-NC%d"
	"set max # of continuation lines"
-Nn%d	warn_no_longer_needed(option_name);  FTN	NONE self
	""
% use exact name as param rather than option_name for combined options 
-j	warn_no_longer_supported("-j");  ALL	NONE ""
	""

% smart build: use -pch and -pch_dir instead..
-smart%s	warn_no_longer_supported2("-smart","-pch");	 CC NONE ""
	""
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"
	"Act as if a USE statement is specified in every PU"

-ftpp		toggle(&use_ftpp,1); 	F90	NONE	""
	""
-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
	"treat locals as static but not shared among multiple threads"

-backslash	first_phase=P_any_fe;		f77	ffe	self
	"treat backslash as normal character rather than an escape"
-noexpopt	;		FTN	be	"-OPT:fast_exp=no"
	"Don't optimize exponentiation operations"
-keepdollar	;		f77	ffe	self
	"Treat $ as a normal last character in symbol names"  
-chararg1	;		f77	ffe	self
	""
-nof77	;		f77	ffe	self
	""
-noappend 		;		FTN	ffe	self
	""
-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	""
	""

-cray_mp    toggle(&mpkind,CRAY_MP);	 FTN ffe self 
    "enable Cray micro-tasking directives"

-dsm			;		FTN,Cc	GRP	self
	"enable the DSM directives"

-mp		toggle(&mpkind,NORMAL_MP);		FTN,Cc	ffe	self 
	"enable the multiprocessing directives"

-dsm_clone		;		ALL	ipl,be,d	self
	"run dsm prelinker with cloning for distributed reshaped arrays"

-dsm_check		;		ALL	be	self
	"generate code to do reshape consistency check for args at run-time"

-dsm_recompile		;		ALL	ffe,cfe,be,ipl	self
	"tell the fe and be to not touch rii files"

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

-memctr			;		ALL	be	"-memctr"
	"instrument for Origin memory counters"

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

-mpio			;		FTN	be	self
	"enable Fortran I/O statements to be executed in parallel"

-mp_schedtype=%s	;		FTN	PFA,ffe 	"-mp_schedtype=%s"
	"Set the MP schedule algorithm: simple,dynamic,runtime,interleave,gss"
-chunk=%d		;		FTN	PFA,ffe	"-chunk=%d"
	"Set the MP chunksize"
-mp_chunk=%d		;		FTN	ffe	"-mp_chunk=%d"
	"Set the MP chunksize"

-mp_use_locks	warn_no_longer_needed(option_name);  FTN NONE ""
	""
-mp_use_copy	warn_no_longer_needed(option_name);  FTN NONE ""
	""

-listing	keep_listing=TRUE;		FTN	ffe,PFA	""
	"keep the listing file"
% invoke apo  - which discovers parallelism (synonym for -pfa, -pca)
-apo		auto_parallelize=TRUE;		Cc,FTN	be	"-pfa"
	"run Auto Parallel Optimizer"
-apo*list	auto_parallelize=TRUE;keep_list=TRUE;		Cc,FTN	be	"-pfa -LNO:prompl"
	"run Auto Parallel Optimizer and keep listing"
-apo*keep	auto_parallelize=TRUE;keep_list=keep_mp=TRUE;Process_Promp();		Cc,FTN	be	"-pfa -LNO:prompl"
	"run Auto Parallel Optimizer and keep listing and pfa output"
% invoke pfa  - which discovers parallelism
-pfa		auto_parallelize=TRUE;		Cc,FTN	be	"-pfa"
	"run Power Fortran Analyzer"
-pfa*list	auto_parallelize=TRUE;keep_list=TRUE; 	Cc,FTN	be	"-pfa -LNO:prompl"
	"run Power Fortran Analyzer and keep listing"
-pfa*keep	auto_parallelize=TRUE;keep_list=keep_mp=TRUE;Process_Promp();		Cc,FTN	be	"-pfa -LNO:prompl"
	"run Power Fortran Analyzer and keep listing and pfa output"
% 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"

-d16	toggle(&dflag,2);		FTN	ffe	self
	"use double=16 and dcomplex=32"

-d16const 		;		f77	ffe	self
	""

-dump_input 		;		f77	ffe	self
	""

-extend_source fortran_line_length=132;		FTN	ffe	self "-scan=132"
	"make each source line 132 bytes long"

-d_lines		;		FTN	ffe	self
	"compile lines with a D in column 1"
-pad_char_literals		;		F90	ffe	self
	"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"
	"sets the source statement length to 72 columns"
-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"

% handle with special routine which reads option groups
% after all switches read, pass switch to ld if ipa run, or to inline if
% stand-alone inliner run
-INLINE:%s	Process_Inline();	       ALL     ipap	"-INLINE:%s"
	"specify inline processing option group"

% handle with special routine which reads option groups
-INLINE		Process_Inline();	       ALL     NONE    ""
	"request inline processing"

-inline		Process_Inline();		Cc	NONE	"-INLINE"
	"request inline processing"

-noinline	Process_Inline();		Cc	NONE	"-INLINE:=OFF"
	"suppress inline processing"
-nobool	;		CC 	cfe	self
	"disallow bool keyword"
-exceptions	;	CC	cfe,be	"-LANG:exc"
	"turn on support for exception-handling"
-no_exceptions	;	CC	cfe,be	"-LANG:exc=OFF"
	"turn off support for exception-handling (default)"
-noisam		warn_no_longer_supported(option_name);  FTN NONE ""
	""

% warn about old flag no longer supported; new driver will split this
% flag, which may cause confusion
-Olimit%d	warn_no_longer_supported2(option_name,"-OPT:Olimit=n");  ALL NONE self
	""
-bestGnum	warn_no_longer_supported(option_name);  ALL NONE ""
	""
-volatile	warn_no_longer_supported(option_name);  Cc NONE ""
	""
-acpp		warn_no_longer_needed(option_name);  Cc NONE ""
	""
-oldcpp		warn_no_longer_supported(option_name);  Cc NONE ""
	""
-pch		;		Cc	cfe	self
	""
-pch_dir%s		;		Cc	cfe	"-pch_dir%s"
	""
-prototypes	warn_no_longer_supported2(option_name,"-fullwarn");  Cc NONE ""
	""
-noprototypes	warn_no_longer_supported(option_name);  Cc NONE ""
	""
-pedantic		;		Cc	cfe	self
	""
-use_readonly_const	;		Cc,FTN	cfe	self
	""
-use_readwrite_const	;		Cc,FTN	cfe	self
	""
-change_const		;		FTN	NONE	""
	""
-noalias	warn_no_longer_supported2(option_name,"-OPT:alias=restrict");  cc NONE ""
	""
-strictIEEE	warn_no_longer_supported2(option_name,"-OPT:IEEE_comparisons");  f77 NONE ""
	""
%I-tt%s		;		ALL	be	self
%	""
-wlint,%s	warn_nyi("-wlint");		cc	cfe	""
	""
-wlint		warn_nyi("-wlint");		cc	cfe	""
	""

% sopt is no longer supported
-sopt,%s warn_no_longer_supported(option_name);	 cc,FTN	NONE	""
	""
-sopt	warn_no_longer_supported(option_name);	 cc,FTN	NONE	""
	""

% invoke pca  - which discovers parallelism
-pca		auto_parallelize=TRUE;		Cc,FTN	be	"-pfa"
	"run Power C Analyzer"
-pca*list	auto_parallelize=TRUE;keep_list=TRUE; 	Cc,FTN be "-pfa -LNO:prompl"
	"run Power C Analyzer and keep listing"
-pca*keep	auto_parallelize=TRUE;keep_list=keep_mp=TRUE;Process_Promp();	 cc,FTN be	"-pfa -LNO:prompl"
	"run Power C Analyzer and keep listing and pca output"
-pca,%s		{auto_parallelize=TRUE; warning("options after -pca, are ignored; should just use -pca");}	Cc,FTN	be	"-pfa"
	""

% for kernel folks
-jalr		;		ALL	NONE	"-TARG:force_jalr"
	""
-align8		;		Cc,f77	FE,be	self
	"align data in common blocks to 8-bit boundaries"
-align16	;		Cc,f77	FE,be	self
	"align data in common blocks to 16-bit boundaries"
-align32	;		Cc,FTN	FE,be	self
	"align data in common blocks to 32-bit boundaries"
-align64	;		Cc,FTN	FE,be	self
	"align data in common blocks to 64-bit boundaries"
-align128	;		Cc,f77	FE,be	self
	"align data in common blocks to 128-bit boundaries"
% -u can have two different meanings, so escape to hand-code
-u*		;		ALL	NONE	""
	""
I-u%s		;		Cc	ld	"-u %s"
	""
-ignore_minor	;		LINK	ld	self
	""
-require_minor	;		LINK	ld	self
	""
-aoutkeep	;		LINK	ld	self
	""
-exact_version	;		LINK	ld	self
	""
-set_version%s	;		LINK	ld	"-set_version %s"
	""
-soname%s	;		LINK	ld	"-soname %s"
	""
-update_registry%s	; 	LINK	ld	"-update_registry %s"
	""
-check_registry%s	; 	LINK	ld	"-check_registry %s"
	""
-guarantee_init	;		LINK	ld	self
	""
-guarantee_start_init	; 	LINK	ld	self
	""
-ignore_version	;		LINK	ld	self
	""
-jmpopt		;		LINK	ld	self
	""
-no_library_replacement	; 	LINK	ld	self
	""
-rdata_writable	; 	LINK	ld	self
	""
-rdata_shared	; 	LINK	ld	self
	""
-no_rqs	; 	LINK	ld	self
	""
-force_load	; 	LINK	ld	self
	""
-delay_load	; 	LINK	ld	self
	""
-default_delay_load	; 	LINK	ld	self
	""
-exclude%s	;		LINK	ld	"-exclude %s"
	""
-no_archive	; 	LINK	ld	self
	""
-quickstart_info	; 	LINK	ld	self
	""
-no_quickstart_info	; 	LINK	ld	self
	""
-info	; 	LINK	ld	self
	""
-no_info	; 	LINK	ld	self
	""
-s		;		LINK	ld	self
	""
-e%s		;		LINK	ld	"-e %s"
	""
-y%s		;		LINK	ld	"-y %s"
	""
% the truth is, we use %x so this will be seen before %s;
% in other respects %x is the same as %d.
-D%x		;		LINK	ld	"-D %d"
	""
-T%x		;		LINK	ld	"-T %d"
	""
-Xnobsschange	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xnosortbss	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xsortbss	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xndblock%s	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xblock%s	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xblockrange%s	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xlocaldata%s	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xndlocaldata%s	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xalignbss%s	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xnoalignbss%s	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xcachemisalign	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xcachesize%s	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xcachelinesize%s warn_no_longer_supported(option_name);  ALL	NONE self
	""
-Xdefmovemax%s	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xsetalign%s	warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-Xdebug		warn_no_longer_supported(option_name);	 ALL	NONE self
	""
-n		;		LINK	ld	self
	""
-all		;		LINK	ld	--whole-archive
	""
-none		;		LINK	ld	self
	""
-notall		;		LINK	ld	--no-whole-archive
	""
-exports	;		LINK	ld	self
	""
-exported_symbol%s	;		LINK	ld	"-exported_symbol %s"
	""
-exports_file%s	;		LINK	ld	"-exports_file %s"
	""
-hides		;		LINK	ld	self
	""
-hidden_symbol%s	;		LINK	ld	"-hidden_symbol %s"
	""
-hides_file%s	;		LINK	ld	"-hides_file %s"
	""
-warn_unused	;		LINK	ld	self
	""
-dont_warn_unused	;		LINK	ld	self
	""
-rpath%s	;		LINK	ld	"-rpath %s"
	""
--whole-archive		;	LINK	ld	self
	""
--no-whole-archive	;	LINK	ld	self
	""
-avoid_gp_overflow	;		ALL	NONE	"-G0 -xgot -TENV:large_GOT"
	""

% CC options:
-cfront		;		CC	cfe	self
	"cfront-compatible"
-anach		;		CC	cfe	self
	"allow anachronisms"
-nofilt	warn_ignored(option_name);	 	CC	NONE	""
	""
-demangle	;		CC	ld	self
	""
-auto_include 	;		CC	NONE	""
	""
-no_auto_include ;		CC	cfe	"-no_implicit_template_inclusion"
	""
I-no_implicit_template_inclusion	;		CC	cfe	self
	""
-prelink	;		CC	NONE	""
	"use prelinker (default)"
-no_prelink	prelink_flag=FALSE;		CC	cfe	self
	"do not use prelinker (i.e. instantiate all templates immediately)"
-pta		;		CC	NONE	"-template_all"
	""
-ptall		;		CC	NONE	"-template_all"
	""
-pte		;		CC	NONE	""
	""
-ptnone		;		CC	NONE	""
	""
-ptused		;		CC	NONE	"-template_used"
	""
I-template_all		;		CC	cfe	self
	""
I-template_used		;		CC	cfe	self
	""

% IPA-related options:
-ipa	toggle(&ipa,TRUE);		ALL	ipap	self
	"Perform interprocedural analysis and optimization"

-IPA	toggle(&ipa,TRUE);		ALL	NONE	"-ipa"
	"Perform interprocedural analysis and optimization"

-R*		;		ALL	NONE	""
	"pass flags to RATFOR"
-m	run_m4=TRUE;		f77	NONE	""
	"run m4 on each RATFOR source"
-framepointer	warn_no_longer_supported2(option_name,"-TENV:large_stack");  ALL	NONE ""
	""
-trapuv 		;		Cc,FTN	be	"-DEBUG:trap_uninitialized"
	"trap uninitialized variables"
#ifdef linux
-H	;		Cc,as	cpp	self
	"print name of each header file used"
#else
-H%s	change_last_phase(optargs); 	ALL	NONE	""
	"-H<phase> Halt after phase {p=cpp,f=fe,b=be,a=as,l=ld}"
#endif
% obsolete ucode internal flags
-t%s	warn_no_longer_supported2(option_name,"-Y");		ALL	NONE	self
	""
-h%s	warn_no_longer_supported2(option_name,"-Y");		ALL	NONE	self
	""
-B%s	warn_no_longer_supported2(option_name,"-Y");		ALL	NONE	self
	""
-ko%s	warn_no_longer_supported(option_name);		ALL	NONE	self
	""
-nokpicopt	warn_no_longer_supported(option_name);		ALL	NONE	""
	""
-kpicopt	warn_no_longer_supported(option_name);		ALL	NONE	""
	""
-k%s	warn_no_longer_supported(option_name);		ALL	NONE	self
	""
% cord
-cord	toggle(&cordflag,TRUE);		ALL	NONE	""
	"Run cord"
-feedback*%s	add_string(feedback_files,optargs);		ALL	NONE	""
	"Specify feedback file for cord"
-fb%s	save_name(&fb_file,optargs);		ALL	NONE	""
	"Specify feedback file for be"
-nodeflib	;			ALL	NONE	""
	""
-r4000          toggle(&proc,4);  ALL     NONE    "-TARG:proc=r4000"
        ""
-r5000          toggle(&proc,5);  ALL     NONE    "-TARG:proc=r5000"
        ""
-r7000          toggle(&proc,5);  ALL     NONE    "-TARG:proc=r5000"
        ""
-r8000          toggle(&proc,8);  ALL     NONE    "-TARG:proc=r8000"
        ""
-r10000         toggle(&proc,10);        ALL     NONE    "-TARG:proc=r10000"
        ""
-r12000         toggle(&proc,10);        ALL     NONE    "-TARG:proc=r10000"
        ""
-r14000         toggle(&proc,10);        ALL     NONE    "-TARG:proc=r10000"
        ""
-r16000         toggle(&proc,10);        ALL     NONE    "-TARG:proc=r10000"
        ""
% r31k is arbitrary for experimental processors:
I-exp1		toggle(&proc,31);        ALL     NONE    "-TARG:proc=exp1"
        ""
I-exp2		toggle(&proc,31);        ALL     NONE    "-TARG:proc=exp2"
        ""
I-exp3		toggle(&proc,31);        ALL     NONE    "-TARG:proc=exp3"
        ""
-		read_stdin=TRUE;	ALL	cpp	""
	""
--		check_dashdash();	ALL	NONE	""
	""
-ignore_suffix	ignore_suffix=TRUE;	ALL	NONE	""
	"ignore source suffix when determining compiler language"

-cif    keep_cif=TRUE;       F90,Cc	FE      self
        ""

-cif=%d 	;	Cc	cfe	"-cif=%d"
        ""

-ar	;		ALL	NONE	""
	"create an archive (instead of a shared object or executable) using ar"

-experimental warn_no_longer_supported(option_name); 	CC	NONE
	"Experimental C++ frontend that was supported in 7.1 release"

-promp	;	 	FTN,Cc	 be	"-PHASE:prompf -PROMP:=on"
	"Activate promp generation of .anl and .m files"

-generate_instantiation_info ;  CC	cfe    self
	"Internal option - Used by the C++ prelinker to the frontend"
%%% gcc compiler options
-pipe	;		ALL	NONE	""
	""
% -x%s	warn_ignored(option_name);		ALL	NONE	self
%	""
--help	;		ALL	NONE	""
	"print list of possible options"
%%% C language options
-flang-isoc9x	;		Cc	f	self
	""
-fallow-single-precision	;		Cc	f	self
	"Do not promote floats to double if using -traditional"
-fcond-mismatch	;		Cc	f	self
	"Allow different types as args of ? operator"
-fno-cond-mismatch	;		Cc	f	self
	""
-fasm	;		Cc	f	self
	""
-fno-asm	;		Cc	f	self
	"Do not recognise the 'asm' keyword"
-fbuiltin	;		Cc	f	self
	""
-fno-builtin	;		Cc	f	self
	"Do not recognise any built in functions"
-ffreestanding	;		Cc	f	self
	"Assume that standard libraries & main might not exist"
-fno-freestanding	;		Cc	f	self
	""
-fhosted	;		Cc	f	self
	"Assume normal C execution environment"
-fno-hosted	;		Cc	f	self
	""
-fsigned-bitfields	;		Cc	f	self
	""
-fno-signed-bitfields	;		Cc	f	self
	""
-fsigned-char	;		Cc	f	self 
	"Make 'char' be signed by default"
-fno-signed-char	;	Cc	f	self "-D__CHAR_UNSIGNED__"
	""
-funsigned-bitfields	;		Cc	f	self
	"Make bitfields by unsigned by default"
-fno-unsigned-bitfields	;		Cc	f	self
	""
-funsigned-char	;		Cc	f	self "-D__CHAR_UNSIGNED__"
	"Make 'char' be unsigned by default"
-fno-unsigned-char	;	Cc	f	self
	""
-fwritable-strings	;		Cc	f	self
	"Attempt to support writable-strings K&R style C"
-fno-writable-strings	;		Cc	f	self
	""
-ftraditional	;		Cc	f	self
	""
-fno-traditional ;		Cc	f	self
	""
-fnotraditional	;		Cc	f	self
	""
-traditional	;		Cc	cpp	self
	"Attempt to support traditional K&R style C"
-no-traditional	;		Cc	f	self
	""
% cpp is also a define, so trick cpp
-traditional-c/**/pp	;		Cc	NONE	"-traditional"
	""
#ifdef linux
-trigraphs	;		Cc	cpp	self
#else
-trigraphs	;		Cc	f,cpp	self
#endif
	""
%%% Warning Options
-syntax-only	;		Cc	f	self
	""
% -pedantic	;		Cc	f	self
%	"Issue warnings needed by strict compliance to ANSI C"
-pedantic-errors	;		Cc	f	self
	"Issue warnings needed by strict compliance to ANSI C"
% -w	;		Cc	f	self
%	"Suppress warnings"
-W	;		Cc	f	self
	"Enable extra warnings"
-Wall	;		Cc	f	self
	"Enable most warning messages"
-Waggregate-return	;		Cc	f	self
	"Warn about returning structures, unions or arrays"
-Wno-aggregate-return	;		Cc	f	self
	""
-Wbad-function-cast	;		Cc	f	self
	"Attempt to support writable-strings K&R style C"
-Wno-bad-function-cast	;		Cc	f	self
	""
-Wcast-align	;		Cc	f	self
	"Warn about pointer casts which increase alignment"
-Wno-cast-align	;		Cc	f	self
	""
-Wcast-qual	;		Cc	f	self
	"Warn about casts which discard qualifiers"
-Wno-cast-qual	;		Cc	f	self
	""
-Wchar-subscripts	;		Cc	f	self
	"Warn about subscripts whose type is 'char'"
-Wno-char-subscripts	;		Cc	f	self
	""
-Wcomment	;		Cc	f	self
	"Warn if nested comments are detected"
-Wno-comment	;		Cc	f	self
	""
-Wconversion	;		Cc	f	self
	"Warn about possibly confusing type conversions"
-Wno-conversion	;		Cc	f	self
	""
-Werror		;		Cc	f	self
	""
-Wno-error	;		Cc	f	self
	""
-Wformat	;		Cc	f	self
	"Warn about printf format anomalies"
-Wno-format	;		Cc	f	self
	""
-Wid-clash%d	;		Cc	f	self
	"Warn if 2 identifiers have the same first <num> chars"
-Wimplicit	;		Cc	f	self
	""
-Wno-implicit	;		Cc	f	self
 	""
-Wimplicit-int	;		Cc	f	self
	"Warn when a declaration does not specify a type"
-Wno-implicit-int	;		Cc	f	self
	""
-Wimplicit-function-declaration	;		Cc	f	self
	""
-Wno-implicit-function-declaration	;		Cc	f	self
	""
-Werror-implicit-function-declaration	;		Cc	f	self
	""
%-Wno-error-implicit-function-declaration	;		Cc	f	self
%	""
-Wimport	;		Cc	f	self
	"Warn about the use of the #import directive"
-Wno-import	;		Cc	f	self
	""
-Winline	;		Cc	f	self
	""
-Wno-inline	;		Cc	f	self
	""
-Wlarger-than%d	;		Cc	f	self
	"Warn if an object is larger than <number> bytes"
-Wlong-long	;		Cc	f	self
	""
-Wno-long-long	;		Cc	f	self
	""
-Wmain	;		Cc	f	self
	"Warn about suspicious declarations of main"
-Wno-main	;		Cc	f	self
	""
-Wmissing-braces	;	Cc	f	self
	"Warn about possibly missing braces around initialisers"
-Wno-missing-braces	;	Cc	f	self
	"Warn about possibly missing braces around initialisers"
-Wmissing-declarations	;		Cc	f	self
	"Warn about global funcs without previous declarations"
-Wno-missing-declarations	;		Cc	f	self
	""
-Wmissing-noreturn	;		Cc	f	self
	"Warn about global funcs without previous declarations"
-Wno-missing-noreturn	;		Cc	f	self
	""
-Wmissing-prototypes	;		Cc	f	self
	"Warn about global funcs without prototypes"
-Wno-missing-prototypes	;		Cc	f	self
	""
-Wmultichar	;		Cc	f	self
	""
-Wno-multichar	;		Cc	f	self
	""
-Wnested-externs	;		Cc	f	self
	"Warn about externs not at file scope level"
-Wno-nested-externs	;		Cc	f	self
	""
-Wparentheses	;		Cc	f	self
	"Warn about possible missing parentheses"
-Wno-parentheses	;		Cc	f	self
	""
-Wpointer-arith	;		Cc	f	self
	"Warn about function pointer arithmetic"
-Wno-pointer-arith	;		Cc	f	self
	""
-Wredundant-decls	;		Cc	f	self
	"Warn about multiple declarations of the same object"
-Wno-redundant-decls	;		Cc	f	self
	""
-Wreturn-type	;		Cc	f	self
	""
-Wshadow	;		Cc	f	self
	"Warn when one local variable shadows another"
-Wno-shadow	;		Cc	f	self
	""
-Wsign-compare	;		Cc	f	self
	"Warn about signed/unsigned comparisons"
-Wno-sign-compare	;		Cc	f	self
	""
-Wstrict-prototypes	;		Cc	f	self
	"Warn about non-prototyped function decls"
-Wno-strict-prototypes	;		Cc	f	self
	""
-Wswitch	;		Cc	f	self
	""
-Wno-switch	;		Cc	f	self
	""
-Wtraditional	;		Cc	f	self
	"Warn about constructs whoes meaning change in ANSI C"
-Wno-traditional	;		Cc	f	self
	""
-Wtrigraphs	;		Cc	f	self
	"Warn when trigraphs are encountered"
-Wno-trigraphs	;		Cc	f	self
	""
-Wundef	;		Cc	f	self
	""
-Wno-undef	;		Cc	f	self
	""
-Wuninitialized	;		Cc	f	self
	"Warn about unitialized automatic variables"
-Wno-uninitialized	;		Cc	f	self
	""
-Wunknown-pragmas	;		Cc	f	self
	""
-Wno-unknown-pragmas	;		Cc	f	self
	""
-Wunused	;		Cc	f	self
	"Warn when a variable is unused"
-Wno-unused	;		Cc	f	self
	""
-Wwrite-strings	;		Cc	f	self
	"Mark strings as 'const char *'"
-Wno-write-strings	;		Cc	f	self
	""
%%% Optimization Options
-fbranch-probabilities	;		Cc	f	self
	"Use profiling information for branch probabilities"
-foptimize-register-moves	;		Cc	f	self
	""
-fcaller-saves	;		Cc	f	self
	"Enable saving registers around function calls"
-fcse-follow-jumps	;		Cc	f	self
	"When running CSE, follow jumps to their targets"
-fcse-skip-blocks	;		Cc	f	self
	"When running CSE, follow conditional jumps"
-fdelayed-branch	;		Cc	f	self
	"Attempt to fill delay slots of branch instructions"
-fexpensive-optimizations	;		Cc	f	self
	"Perform a number of minor, expensive optimisations"
-ffast-math	;		Cc	f	"-OPT:IEEE_arithmetic=2"
	"Improve FP speed by violating ANSI & IEEE rules"
-ffloat-store	;		Cc	f	"-OPT:IEEE_arithmetic=1"
	"Do not store floats in registers"
-fforce-addr	;		Cc	f	self
	"Copy memory address constants into regs before using"
-fforce-mem	;		Cc	f	self
	"Copy memory operands into registers before using"
-fdata-sections	;		Cc	f	self
	""
-ffunction-sections	;		Cc	f	self
	"place each function into its own section"
-fgcse		;		Cc	f	self
	""
-finline-functions	;		Cc	f	self
	"Integrate simple functions into their callers"
-fno-inline-functions	;		Cc	f	self "-INLINE:=off"
	""
-finline-limit-%d	;		Cc	f	self
	""
-fkeep-inline-functions	;		Cc	f	self
	"Generate code for funcs even if they are fully inlined"
-fno-default-inline	;		Cc	f	self
	""
-fno-defer-pop		;		Cc	f	self
	""
-fno-function-cse	;		Cc	f	self
	""
-fno-inline		;		Cc	f	self "-INLINE:=off"
	""
-fno-peephole		;		Cc	f	self
	""
-fomit-frame-pointer	;		Cc	f	self
	"When possible do not generate stack frames"
-fno-omit-frame-pointer	;		Cc	f	self
	""
-fregmove	;		Cc	f	self
	""
-frerun-cse-after-loop	;		Cc	f	self
	"Run CSE pass after loop optimisations"
-frerun-loop-opt	;		Cc	f	self
	""
-fschedule-insns	;		Cc	f	self
	"Reschedule instructions to avoid pipeline stalls"
-fschedule-insns2	;		Cc	f	self
	"Run two passes of the instruction scheduler"
-fstrength-reduce	;		Cc	f	self
	"Perform strength reduction optimisations"
-fno-strength-reduce	;		Cc	f	self
	""
-fthread-jumps	;		Cc	f	self
	"Perform jump threading optimisations"
-funroll-all-loops	;		Cc	f	self
	"Peform loop onrolling for all loops"
-funroll-loops	;		Cc	f	self
	"unroll-loops"
-fmove-all-movables	;		Cc	f	self
	""
-freduce-all-givs	;		Cc	f	self
	""
-fstrict-aliasing	;		Cc	f	self
	""
-fno-strict-aliasing	;		Cc	f	self
	""
%%% Preprocessor options
-dD	;		Cc,as	cpp	self
	""
-dM	;		Cc,as	cpp	self
	""
-dN	;		Cc,as	cpp	self
	""
-idirafter%D	;		Cc,as	cpp	"-idirafter %D"
	""
-include%s	;		Cc,as	cpp	"-include %s"
	""
-imacros%s	;		Cc,as	cpp	"-imacros %s"
	""
-iprefix%s	;		Cc,as	cpp	"-iprefix %s"
	""
-iwithprefix%D	;		Cc,as	cpp	"-iwithprefix %D"
	""
-iwithprefixbefore%D	;		Cc,as	cpp	"-iwithprefixbefore %D"
	""
-isystem%D	;		Cc,as	cpp	"-isystem %D"
	""
-MD	;		Cc,as	cpp	self
	""
-MMD	;		Cc,as	cpp	self
	""
-MM	;		Cc,as	cpp	self
	""
-MG	;		Cc,as	cpp	self
	""
-undef	;		Cc,as	cpp	self
	""
%%% Code Generation Options
-fcall-saved-%s	;		Cc	NONE	""
	""
-fcall-used-%s	;		Cc	NONE	""
	""
-fexceptions	;		Cc	NONE	""
	"Enable exception handling"
-ffixed-%s	;		Cc	NONE	"-TENV:registers_not_allocatable=%s"
	""
-mfixed-range=%s	;	Cc	NONE	"-TENV:registers_not_allocatable=%s"
	""
-funwind-tables	;		Cc	NONE	"-CG:emit_unwind_info=on"
	""
-fno-unwind-tables	;	Cc	NONE	"-CG:emit_unwind_info=off"
	""
-mconstant-gp	;		Cc	NONE	"-TENV:constant_gp=on"
	""
-mno-sdata	;		Cc	NONE	"-G0"
	""
-finhibit-size-directive	;		Cc	NONE	""
	"Do not generate .size directives"
-fcheck-memory-usage	;		Cc	NONE	""
	"Generate code to check every memory access"
-fprefix-function-name	;		Cc	NONE	""
	"Add a prefix to all function names"
-fno-common	;		Cc	cfe	self
	"use strict ref/def initialization model"
-fno-ident	;		Cc	cfe	self
	"Ignore #ident directives"
-fno-gnu-linker	;		Cc	NONE	""
	""
-fpcc-struct-return	;		Cc	NONE	""
	""
-fpic	;		Cc	NONE	""
	"Generate position independent code, if possible"
-fPIC	;		Cc	NONE	""
 	""
-freg-struct-return	;		Cc	NONE	""
	"Return 'short' aggregates in registers"
-fshared-data	;		Cc	NONE	""
	"Mark data as shared rather than private"
-fshort-enums	;		Cc	NONE	""
	"Use the smallest fitting integer to hold enums"
-fshort-double	;		Cc	NONE	""
	"Use the same size for double as for float"
-fvolatile	;		Cc	NONE	""
	"Consider all mem refs through pointers as volatile"
-fvolatile-global	;		Cc	NONE	""
	"Consider all mem refs to global data to be volatile"
-fvolatile-static	;		Cc	NONE	""
	""
-fverbose-asm	;		Cc	NONE	""
	""
-fpack-struct	;		Cc	NONE	""
	"Pack structure members together without holes"
-fstack-check	;		Cc	NONE	""
	"Insert stack checking code into the program"
-fargument-alias	;		Cc	NONE	""
	""
-fargument-noalias	;		Cc	NONE	""
	""
-fargument-noalias-global	;		Cc	NONE	""
	""
-fleading-underscore	;		Cc	NONE	""
	""
%%% Linker Options
-nostartfiles	;		LINK	NONE	""
	""
-nodefaultlibs	;		LINK	NONE	""
	""
-Xlinker%s	warn_no_longer_supported2(option_name,"-Wl,");		LINK	ld	self
	""
-symbolic	;		LINK	ld	self
	""
%%% Directory Options
-I-		;		ALL	cpp	self
 	""
-specs=%s	warn_ignored(option_name);		ALL	NONE	self
	""
%%% Target Options
-b%s	warn_ignored(option_name);		ALL	NONE	self
	""
%%% 386-specific options
-m386	warn_ignored(option_name);		ALL	NONE	self
	""
-malign-loops=%d	warn_ignored(option_name); 	ALL	NONE	self
	""
-malign-jumps=%d	warn_ignored(option_name); 	ALL	NONE	self
	""
-malign-functions=%d	warn_ignored(option_name); 	ALL	NONE	self
	""
%%% ia-64 workaround
-ma-step	;	ALL	NONE	"-TARG:ma0_step=on -mb-step"
	""
-mb-step	;	ALL	NONE	""
	""
-mvolatile-asm-stop	;	ALL	NONE	"-CG:volatile_asm_stop=on"
	""
-print-file-name=%s	{execute_flag=FALSE; print_file_path(optargs);}	ALL	NONE	""
	""
-print-libgcc-file-name	;	ALL	NONE	"-print-file-name=libgcc.a"
	""
-print-prog-name=%s	{execute_flag=FALSE; print_file_path(optargs);}	ALL	NONE	""
	""
-print-search-dirs	{execute_flag=FALSE; warn_ignored(option_name);}	ALL	NONE	""
	""
-x*c	ignore_suffix=TRUE;default_source_kind=S_c;	ALL	cpp "-xc"
	""
-x*c++	ignore_suffix=TRUE;default_source_kind=S_C;	ALL	cpp "-xc++"
	""
-x*c/**/pp-output	ignore_suffix=TRUE;default_source_kind=S_i;	ALL NONE ""
	""
-x*c++-c/**/pp-output	ignore_suffix=TRUE;default_source_kind=S_ii;	ALL NONE ""
	""
-x*assembler	ignore_suffix=TRUE;default_source_kind=S_s;	ALL NONE ""
	""
-x*assembler-with-c/**/pp	ignore_suffix=TRUE;default_source_kind=S_S;	ALL cpp "-xassembler-with-cpp"
	""
-x*f	ignore_suffix=TRUE;default_source_kind=S_f;	ALL NONE ""
	""
-x*none		ignore_suffix=FALSE;default_source_kind=S_NONE;	ALL	cpp "-xnone"
	""
%%% gcc long option aliases
--all-warnings	;	ALL	NONE	"-Wall"
	""
--ansi		;	ALL	NONE	"-ansi"
	""
--assemble	;	ALL	NONE	"-S"
	""
--assert%s	;	ALL	NONE	"-A%s"
	""
--comments	;	ALL	NONE	"-C"
	""
--compile	;	ALL	NONE	"-c"
	""
--debug		;	ALL	NONE	"-g"
	""
% --debug%d	;	ALL	NONE	"-g%d"
--define-macro%s	;	ALL	NONE	"-D%s"
	""
--dependencies	;	ALL	NONE	"-M"
	""
--extra-warnings	;	ALL	NONE	"-W"
	""
--force-link%s	;	ALL	NONE	"-u %s"
	""
--imacros%s	;	ALL	NONE	"-imacros %s"
	""
--include%s	;	ALL	NONE	"-include %s"
	""
--include-barrier	;	ALL	NONE	"-I-"
	""
--include-directory%D	;	ALL	NONE	"-I%D"
	""
--include-directory-after%D	;	ALL	NONE	"-idirafter %D"
	""
--include-prefix%s	;	ALL	NONE	"-iprefix %s"
	""
--include-with-prefix%D	;	ALL	NONE	"-iwithprefix %D"
	""
--include-with-prefix-before%D	;	ALL	NONE	"-iwithprefixbefore %D"
	""
--library-directory%D	;	ALL	NONE	"-L%D"
	""
--no-line-commands	;	ALL	NONE	"-P"
	""
--no-standard-includes	;	ALL	NONE	"-nostdinc"
	""
--no-standard-libraries	;	ALL	NONE	"-nostdlib"
	""
--no-warnings	;	ALL	NONE	"-w"
	""
--optimize	;	ALL	NONE	"-O"
	""
--output%s	;	ALL	NONE	"-o %s"
	""
--pedantic	;	ALL	NONE	"-pedantic"
	""
--pedantic-errors	;	ALL	NONE	"-pedantic-errors"
	""
--pipe	;	ALL	NONE	"-pipe"
	""
--preprocess	;	ALL	NONE	"-E"
	""
% need to handle either <space>name or =name
--print-file-name%s	;	ALL	NONE	"-print-file-name=%s"
	""
--print-file-name=%s	;	ALL	NONE	"-print-file-name=%s"
	""
--print-libgcc-file-name	;	ALL	NONE	"-print-file-name=libgcc.a"
	""
--print-search-dirs	;	ALL	NONE	"-print-search-dirs"
	""
--print-missing-file-dependencies	;	ALL	NONE	"-MG"
	""
--print-prog-name%s	;	ALL	NONE	"-print-prog-name=%s"
	""
--print-prog-name=%s	;	ALL	NONE	"-print-prog-name=%s"
	""
--profile	;	ALL	NONE	"-p"
	""
--save-temps	;	ALL	NONE	"-save-temps"
	""
--shared	;	ALL	NONE	"-shared"
	""
--specs%s	;	ALL	NONE	"-specs=%s"
	""
--specs=%s	;	ALL	NONE	"-specs=%s"
	""
--static	;	LINK	ld	self
	""
--symbolic	;	ALL	NONE	"-symbolic"
	""
--target%s	;	ALL	NONE	"-b%s"
	""
#ifdef linux
--trace-includes	;	ALL	NONE	"-H"
	""
#endif
--traditional	;	ALL	NONE	"-traditional"
	""
--traditional-cpp	;	ALL	NONE	"-traditional-cpp"
	""
--trigraphs	;	ALL	NONE	"-trigraphs"
	""
--undefine-macro%s	;	ALL	NONE	"-U%s"
	""
--user-dependencies	;	ALL	NONE	"-MM"
	""
--verbose	;	ALL	NONE	"-v"
	""
--write-dependencies	;	ALL	NONE	"-MD"
	""
--write-user-dependencies	;	ALL	NONE	"-MMD"
	""
-fupc-threads-%d  set_upc_no_threads(optargd,optargs); u 	cfe "-fupc-threads-%d"
	""
%special flag for the upc configuration file
-fconfig-%s	set_config_file(optargs);	u	cfe 	"-fconfig-%s"
	""
