xref: /titanic_44/usr/src/tools/cw/cw.c (revision 87308b749adb04ab3f564c765b089962af3edb4d) 
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2011, Richard Lowe.
24  */
25 /*
26  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
27  * Use is subject to license terms.
28  */
29 
30 /*
31  * Wrapper for the GNU C compiler to make it accept the Sun C compiler
32  * arguments where possible.
33  *
34  * Since the translation is inexact, this is something of a work-in-progress.
35  *
36  */
37 
38 /* If you modify this file, you must increment CW_VERSION */
39 #define	CW_VERSION	"1.30"
40 
41 /*
42  * -#		Verbose mode
43  * -###		Show compiler commands built by driver, no compilation
44  * -A<name[(tokens)]>	Preprocessor predicate assertion
45  * -B<[static|dynamic]>	Specify dynamic or static binding
46  * -C		Prevent preprocessor from removing comments
47  * -c		Compile only - produce .o files, suppress linking
48  * -cg92	Alias for -xtarget=ss1000
49  * -D<name[=token]>	Associate name with token as if by #define
50  * -d[y|n]	dynamic [-dy] or static [-dn] option to linker
51  * -E		Compile source through preprocessor only, output to stdout
52  * -erroff=<t>	Suppress warnings specified by tags t(%none, %all, <tag list>)
53  * -errtags=<a>	Display messages with tags a(no, yes)
54  * -errwarn=<t>	Treats warnings specified by tags t(%none, %all, <tag list>)
55  *		as errors
56  * -fast	Optimize using a selection of options
57  * -fd		Report old-style function definitions and declarations
58  * -features=zla	Allow zero-length arrays
59  * -flags	Show this summary of compiler options
60  * -fnonstd	Initialize floating-point hardware to non-standard preferences
61  * -fns[=<yes|no>] Select non-standard floating point mode
62  * -fprecision=<p> Set FP rounding precision mode p(single, double, extended)
63  * -fround=<r>	Select the IEEE rounding mode in effect at startup
64  * -fsimple[=<n>] Select floating-point optimization preferences <n>
65  * -fsingle	Use single-precision arithmetic (-Xt and -Xs modes only)
66  * -ftrap=<t>	Select floating-point trapping mode in effect at startup
67  * -fstore	force floating pt. values to target precision on assignment
68  * -G		Build a dynamic shared library
69  * -g		Compile for debugging
70  * -H		Print path name of each file included during compilation
71  * -h <name>	Assign <name> to generated dynamic shared library
72  * -I<dir>	Add <dir> to preprocessor #include file search path
73  * -i		Passed to linker to ignore any LD_LIBRARY_PATH setting
74  * -keeptmp	Keep temporary files created during compilation
75  * -KPIC	Compile position independent code with 32-bit addresses
76  * -Kpic	Compile position independent code
77  * -L<dir>	Pass to linker to add <dir> to the library search path
78  * -l<name>	Link with library lib<name>.a or lib<name>.so
79  * -mc		Remove duplicate strings from .comment section of output files
80  * -mr		Remove all strings from .comment section of output files
81  * -mr,"string"	Remove all strings and append "string" to .comment section
82  * -mt		Specify options needed when compiling multi-threaded code
83  * -native	Find available processor, generate code accordingly
84  * -nofstore	Do not force floating pt. values to target precision
85  *		on assignment
86  * -nolib	Same as -xnolib
87  * -noqueue	Disable queuing of compiler license requests
88  * -norunpath	Do not build in a runtime path for shared libraries
89  * -O		Use default optimization level (-xO2 or -xO3. Check man page.)
90  * -o <outputfile> Set name of output file to <outputfile>
91  * -P		Compile source through preprocessor only, output to .i  file
92  * -PIC		Alias for -KPIC or -xcode=pic32
93  * -p		Compile for profiling with prof
94  * -pic		Alias for -Kpic or -xcode=pic13
95  * -Q[y|n]	Emit/don't emit identification info to output file
96  * -qp		Compile for profiling with prof
97  * -R<dir[:dir]> Build runtime search path list into executable
98  * -S		Compile and only generate assembly code (.s)
99  * -s		Strip symbol table from the executable file
100  * -t		Turn off duplicate symbol warnings when linking
101  * -U<name>	Delete initial definition of preprocessor symbol <name>
102  * -V		Report version number of each compilation phase
103  * -v		Do stricter semantic checking
104  * -W<c>,<arg>	Pass <arg> to specified component <c> (a,l,m,p,0,2,h,i,u)
105  * -w		Suppress compiler warning messages
106  * -Xa		Compile assuming ANSI C conformance, allow K & R extensions
107  *		(default mode)
108  * -Xc		Compile assuming strict ANSI C conformance
109  * -Xs		Compile assuming (pre-ANSI) K & R C style code
110  * -Xt		Compile assuming K & R conformance, allow ANSI C
111  * -x386	Generate code for the 80386 processor
112  * -x486	Generate code for the 80486 processor
113  * -xarch=<a>	Specify target architecture instruction set
114  * -xbuiltin[=<b>] When profitable inline, or substitute intrinisic functions
115  *		for system functions, b={%all,%none}
116  * -xCC		Accept C++ style comments
117  * -xchar_byte_order=<o> Specify multi-char byte order <o> (default, high, low)
118  * -xchip=<c>	Specify the target processor for use by the optimizer
119  * -xcode=<c>	Generate different code for forming addresses
120  * -xcrossfile[=<n>] Enable optimization and inlining across source files,
121  *		n={0|1}
122  * -xe		Perform only syntax/semantic checking, no code generation
123  * -xF		Compile for later mapfile reordering or unused section
124  *		elimination
125  * -xhelp=<f>	Display on-line help information f(flags, readme, errors)
126  * -xildoff	Cancel -xildon
127  * -xildon	Enable use of the incremental linker, ild
128  * -xinline=[<a>,...,<a>]  Attempt inlining of specified user routines,
129  *		<a>={%auto,func,no%func}
130  * -xlibmieee	Force IEEE 754 return values for math routines in
131  *		exceptional cases
132  * -xlibmil	Inline selected libm math routines for optimization
133  * -xlic_lib=sunperf	Link in the Sun supplied performance libraries
134  * -xlicinfo	Show license server information
135  * -xM		Generate makefile dependencies
136  * -xM1		Generate makefile dependencies, but exclude /usr/include
137  * -xmaxopt=[off,1,2,3,4,5] maximum optimization level allowed on #pragma opt
138  * -xnolib	Do not link with default system libraries
139  * -xnolibmil	Cancel -xlibmil on command line
140  * -xO<n>	Generate optimized code (n={1|2|3|4|5})
141  * -xP		Print prototypes for function definitions
142  * -xpentium	Generate code for the pentium processor
143  * -xpg		Compile for profiling with gprof
144  * -xprofile=<p> Collect data for a profile or use a profile to optimize
145  *		<p>={{collect,use}[:<path>],tcov}
146  * -xregs=<r>	Control register allocation
147  * -xs		Allow debugging without object (.o) files
148  * -xsb		Compile for use with the WorkShop source browser
149  * -xsbfast	Generate only WorkShop source browser info, no compilation
150  * -xsfpconst	Represent unsuffixed floating point constants as single
151  *		precision
152  * -xspace	Do not do optimizations that increase code size
153  * -xstrconst	Place string literals into read-only data segment
154  * -xtarget=<t>	Specify target system for optimization
155  * -xtemp=<dir>	Set directory for temporary files to <dir>
156  * -xtime	Report the execution time for each compilation phase
157  * -xtransition	Emit warnings for differences between K&R C and ANSI C
158  * -xtrigraphs[=<yes|no>] Enable|disable trigraph translation
159  * -xunroll=n	Enable unrolling loops n times where possible
160  * -Y<c>,<dir>	Specify <dir> for location of component <c> (a,l,m,p,0,h,i,u)
161  * -YA,<dir>	Change default directory searched for components
162  * -YI,<dir>	Change default directory searched for include files
163  * -YP,<dir>	Change default directory for finding libraries files
164  * -YS,<dir>	Change default directory for startup object files
165  */
166 
167 /*
168  * Translation table:
169  */
170 /*
171  * -#				-v
172  * -###				error
173  * -A<name[(tokens)]>		pass-thru
174  * -B<[static|dynamic]>		pass-thru (syntax error for anything else)
175  * -C				pass-thru
176  * -c				pass-thru
177  * -cg92			-m32 -mcpu=v8 -mtune=supersparc (SPARC only)
178  * -D<name[=token]>		pass-thru
179  * -dy or -dn			-Wl,-dy or -Wl,-dn
180  * -E				pass-thru
181  * -erroff=E_EMPTY_TRANSLATION_UNIT ignore
182  * -errtags=%all		-Wall
183  * -errwarn=%all		-Werror else -Wno-error
184  * -fast			error
185  * -fd				error
186  * -features=zla		ignore
187  * -flags			--help
188  * -fnonstd			error
189  * -fns[=<yes|no>]		error
190  * -fprecision=<p>		error
191  * -fround=<r>			error
192  * -fsimple[=<n>]		error
193  * -fsingle[=<n>]		error
194  * -ftrap=<t>			error
195  * -fstore			error
196  * -G				pass-thru
197  * -g				pass-thru
198  * -H				pass-thru
199  * -h <name>			pass-thru
200  * -I<dir>			pass-thru
201  * -i				pass-thru
202  * -keeptmp			-save-temps
203  * -KPIC			-fPIC
204  * -Kpic			-fpic
205  * -L<dir>			pass-thru
206  * -l<name>			pass-thru
207  * -mc				error
208  * -mr				error
209  * -mr,"string"			error
210  * -mt				-D_REENTRANT
211  * -native			error
212  * -nofstore			error
213  * -nolib			-nodefaultlibs
214  * -noqueue			ignore
215  * -norunpath			ignore
216  * -O				-O1 (Check the man page to be certain)
217  * -o <outputfile>		pass-thru
218  * -P				-E -o filename.i (or error)
219  * -PIC				-fPIC (C++ only)
220  * -p				pass-thru
221  * -pic				-fpic (C++ only)
222  * -Q[y|n]			error
223  * -qp				-p
224  * -R<dir[:dir]>		pass-thru
225  * -S				pass-thru
226  * -s				-Wl,-s
227  * -t				-Wl,-t
228  * -U<name>			pass-thru
229  * -V				--version
230  * -v				-Wall
231  * -Wa,<arg>			pass-thru
232  * -Wp,<arg>			pass-thru except -xc99=<a>
233  * -Wl,<arg>			pass-thru
234  * -W{m,0,2,h,i,u>		error/ignore
235  * -Wu,-xmodel=kernel		-ffreestanding -mcmodel=kernel -mno-red-zone
236  * -xmodel=kernel		-ffreestanding -mcmodel=kernel -mno-red-zone
237  * -Wu,-save_args		-msave-args
238  * -w				pass-thru
239  * -Xa				-std=iso9899:199409 or -ansi
240  * -Xc				-ansi -pedantic
241  * -Xt				error
242  * -Xs				-traditional -std=c89
243  * -x386			-march=i386 (x86 only)
244  * -x486			-march=i486 (x86 only)
245  * -xarch=<a>			table
246  * -xbuiltin[=<b>]		-fbuiltin (-fno-builtin otherwise)
247  * -xCC				ignore
248  * -xchar_byte_order=<o>	error
249  * -xchip=<c>			table
250  * -xcode=<c>			table
251  * -xdebugformat=<format>	ignore (always use dwarf-2 for gcc)
252  * -xcrossfile[=<n>]		ignore
253  * -xe				error
254  * -xF				error
255  * -xhelp=<f>			error
256  * -xildoff			ignore
257  * -xildon			ignore
258  * -xinline			ignore
259  * -xlibmieee			error
260  * -xlibmil			error
261  * -xlic_lib=sunperf		error
262  * -xM				-M
263  * -xM1				-MM
264  * -xmaxopt=[...]		error
265  * -xnolib			-nodefaultlibs
266  * -xnolibmil			error
267  * -xO<n>			-O<n>
268  * -xP				error
269  * -xpentium			-march=pentium (x86 only)
270  * -xpg				error
271  * -xprofile=<p>		error
272  * -xregs=<r>			table
273  * -xs				error
274  * -xsb				error
275  * -xsbfast			error
276  * -xsfpconst			error
277  * -xspace			ignore (-not -Os)
278  * -xstrconst			ignore
279  * -xtarget=<t>			table
280  * -xtemp=<dir>			error
281  * -xtime			error
282  * -xtransition			-Wtransition
283  * -xtrigraphs=<yes|no>		-trigraphs -notrigraphs
284  * -xunroll=n			error
285  * -W0,-xdbggen=no%usedonly	-fno-eliminate-unused-debug-symbols
286  *				-fno-eliminate-unused-debug-types
287  * -Y<c>,<dir>			error
288  * -YA,<dir>			error
289  * -YI,<dir>			-nostdinc -I<dir>
290  * -YP,<dir>			error
291  * -YS,<dir>			error
292  */
293 
294 #include <stdio.h>
295 #include <sys/types.h>
296 #include <unistd.h>
297 #include <string.h>
298 #include <stdlib.h>
299 #include <ctype.h>
300 #include <fcntl.h>
301 #include <errno.h>
302 #include <stdarg.h>
303 #include <sys/utsname.h>
304 #include <sys/param.h>
305 #include <sys/isa_defs.h>
306 #include <sys/wait.h>
307 #include <sys/stat.h>
308 
309 #define	CW_F_CXX	0x01
310 #define	CW_F_SHADOW	0x02
311 #define	CW_F_EXEC	0x04
312 #define	CW_F_ECHO	0x08
313 #define	CW_F_XLATE	0x10
314 #define	CW_F_PROG	0x20
315 
316 typedef enum cw_compiler {
317 	CW_C_CC = 0,
318 	CW_C_GCC
319 } cw_compiler_t;
320 
321 static const char *cmds[] = {
322 	"cc", "CC",
323 	"gcc", "g++"
324 };
325 
326 static char default_dir[2][MAXPATHLEN] = {
327 	DEFAULT_CC_DIR,
328 	DEFAULT_GCC_DIR,
329 };
330 
331 #define	CC(ctx) \
332 	(((ctx)->i_flags & CW_F_SHADOW) ? \
333 	    ((ctx)->i_compiler == CW_C_CC ? CW_C_GCC : CW_C_CC) : \
334 	    (ctx)->i_compiler)
335 
336 #define	CIDX(compiler, flags)	\
337 	((int)(compiler) << 1) + ((flags) & CW_F_CXX ? 1 : 0)
338 
339 typedef enum cw_op {
340 	CW_O_NONE = 0,
341 	CW_O_PREPROCESS,
342 	CW_O_COMPILE,
343 	CW_O_LINK
344 } cw_op_t;
345 
346 struct aelist {
347 	struct ae {
348 		struct ae *ae_next;
349 		char *ae_arg;
350 	} *ael_head, *ael_tail;
351 	int ael_argc;
352 };
353 
354 typedef struct cw_ictx {
355 	cw_compiler_t	i_compiler;
356 	struct aelist	*i_ae;
357 	uint32_t	i_flags;
358 	int		i_oldargc;
359 	char		**i_oldargv;
360 	pid_t		i_pid;
361 	char		i_discard[MAXPATHLEN];
362 	char		*i_stderr;
363 } cw_ictx_t;
364 
365 /*
366  * Status values to indicate which Studio compiler and associated
367  * flags are being used.
368  */
369 #define	M32		0x01	/* -m32 - only on Studio 12 */
370 #define	M64		0x02	/* -m64 - only on Studio 12 */
371 #define	SS11		0x100	/* Studio 11 */
372 #define	SS12		0x200	/* Studio 12 */
373 
374 #define	TRANS_ENTRY	5
375 /*
376  * Translation table definition for the -xarch= flag. The "x_arg"
377  * value is translated into the appropriate gcc flags according
378  * to the values in x_trans[n]. The x_flags indicates what compiler
379  * is being used and what flags have been set via the use of
380  * "x_arg".
381  */
382 typedef struct xarch_table {
383 	char	*x_arg;
384 	int	x_flags;
385 	char	*x_trans[TRANS_ENTRY];
386 } xarch_table_t;
387 
388 /*
389  * The translation table for the -xarch= flag used in the Studio compilers.
390  */
391 static const xarch_table_t xtbl[] = {
392 #if defined(__x86)
393 	{ "generic",	SS11 },
394 	{ "generic64",	(SS11|M64), { "-m64", "-mtune=opteron" } },
395 	{ "amd64",	(SS11|M64), { "-m64", "-mtune=opteron" } },
396 	{ "386",	SS11,	{ "-march=i386" } },
397 	{ "pentium_pro", SS11,	{ "-march=pentiumpro" } },
398 	{ "sse",	SS11, { "-msse", "-mfpmath=sse" } },
399 	{ "sse2",	SS11, { "-msse2", "-mfpmath=sse" } },
400 #elif defined(__sparc)
401 	{ "generic",	(SS11|M32), { "-m32", "-mcpu=v8" } },
402 	{ "generic64",	(SS11|M64), { "-m64", "-mcpu=v9" } },
403 	{ "v8",		(SS11|M32), { "-m32", "-mcpu=v8", "-mno-v8plus" } },
404 	{ "v8plus",	(SS11|M32), { "-m32", "-mcpu=v9", "-mv8plus" } },
405 	{ "v8plusa",	(SS11|M32), { "-m32", "-mcpu=ultrasparc", "-mv8plus",
406 			"-mvis" } },
407 	{ "v8plusb",	(SS11|M32), { "-m32", "-mcpu=ultrasparc3", "-mv8plus",
408 			"-mvis" } },
409 	{ "v9",		(SS11|M64), { "-m64", "-mcpu=v9" } },
410 	{ "v9a",	(SS11|M64), { "-m64", "-mcpu=ultrasparc", "-mvis" } },
411 	{ "v9b",	(SS11|M64), { "-m64", "-mcpu=ultrasparc3", "-mvis" } },
412 	{ "sparc",	SS12, { "-mcpu=v9", "-mv8plus" } },
413 	{ "sparcvis",	SS12, { "-mcpu=ultrasparc", "-mvis" } },
414 	{ "sparcvis2",	SS12, { "-mcpu=ultrasparc3", "-mvis" } }
415 #endif
416 };
417 
418 static int xtbl_size = sizeof (xtbl) / sizeof (xarch_table_t);
419 
420 static const char *progname;
421 
422 static const char *xchip_tbl[] = {
423 #if defined(__x86)
424 	"386",		"-mtune=i386", NULL,
425 	"486",		"-mtune=i486", NULL,
426 	"pentium",	"-mtune=pentium", NULL,
427 	"pentium_pro",  "-mtune=pentiumpro", NULL,
428 #elif defined(__sparc)
429 	"super",	"-mtune=supersparc", NULL,
430 	"ultra",	"-mtune=ultrasparc", NULL,
431 	"ultra3",	"-mtune=ultrasparc3", NULL,
432 #endif
433 	NULL,		NULL
434 };
435 
436 static const char *xcode_tbl[] = {
437 #if defined(__sparc)
438 	"abs32",	"-fno-pic", "-mcmodel=medlow", NULL,
439 	"abs44",	"-fno-pic", "-mcmodel=medmid", NULL,
440 	"abs64",	"-fno-pic", "-mcmodel=medany", NULL,
441 	"pic13",	"-fpic", NULL,
442 	"pic32",	"-fPIC", NULL,
443 #endif
444 	NULL,		NULL
445 };
446 
447 static const char *xtarget_tbl[] = {
448 #if defined(__x86)
449 	"pentium_pro",	"-march=pentiumpro", NULL,
450 #endif	/* __x86 */
451 	NULL,		NULL
452 };
453 
454 static const char *xregs_tbl[] = {
455 #if defined(__sparc)
456 	"appl",		"-mapp-regs", NULL,
457 	"no%appl",	"-mno-app-regs", NULL,
458 	"float",	"-mfpu", NULL,
459 	"no%float",	"-mno-fpu", NULL,
460 #endif	/* __sparc */
461 	NULL,		NULL
462 };
463 
464 static void
465 nomem(void)
466 {
467 	(void) fprintf(stderr, "%s: error: out of memory\n", progname);
468 	exit(1);
469 }
470 
471 static void
472 cw_perror(const char *fmt, ...)
473 {
474 	va_list ap;
475 	int saved_errno = errno;
476 
477 	(void) fprintf(stderr, "%s: error: ", progname);
478 
479 	va_start(ap, fmt);
480 	(void) vfprintf(stderr, fmt, ap);
481 	va_end(ap);
482 
483 	(void) fprintf(stderr, " (%s)\n", strerror(saved_errno));
484 }
485 
486 static void
487 newae(struct aelist *ael, const char *arg)
488 {
489 	struct ae *ae;
490 
491 	if ((ae = calloc(sizeof (*ae), 1)) == NULL)
492 		nomem();
493 	ae->ae_arg = strdup(arg);
494 	if (ael->ael_tail == NULL)
495 		ael->ael_head = ae;
496 	else
497 		ael->ael_tail->ae_next = ae;
498 	ael->ael_tail = ae;
499 	ael->ael_argc++;
500 }
501 
502 static cw_ictx_t *
503 newictx(void)
504 {
505 	cw_ictx_t *ctx = calloc(sizeof (cw_ictx_t), 1);
506 	if (ctx)
507 		if ((ctx->i_ae = calloc(sizeof (struct aelist), 1)) == NULL) {
508 			free(ctx);
509 			return (NULL);
510 		}
511 
512 	return (ctx);
513 }
514 
515 static void
516 error(const char *arg)
517 {
518 	(void) fprintf(stderr,
519 	    "%s: error: mapping failed at or near arg '%s'\n", progname, arg);
520 	exit(2);
521 }
522 
523 /*
524  * Add the current favourite set of warnings to the gcc invocation.
525  */
526 static void
527 warnings(struct aelist *h)
528 {
529 	static int warningsonce;
530 
531 	if (warningsonce++)
532 		return;
533 
534 	/*
535 	 * Enable as many warnings as exist, then disable those that we never
536 	 * ever want.
537 	 */
538 	newae(h, "-Wall");
539 	newae(h, "-Wextra");
540 }
541 
542 static void
543 optim_disable(struct aelist *h, int level)
544 {
545 	if (level >= 2) {
546 		newae(h, "-fno-strict-aliasing");
547 		newae(h, "-fno-unit-at-a-time");
548 		newae(h, "-fno-optimize-sibling-calls");
549 	}
550 }
551 
552 /* ARGSUSED */
553 static void
554 Xamode(struct aelist *h)
555 {
556 }
557 
558 static void
559 Xcmode(struct aelist *h)
560 {
561 	static int xconce;
562 
563 	if (xconce++)
564 		return;
565 
566 	newae(h, "-ansi");
567 	newae(h, "-pedantic-errors");
568 }
569 
570 static void
571 Xsmode(struct aelist *h)
572 {
573 	static int xsonce;
574 
575 	if (xsonce++)
576 		return;
577 
578 	newae(h, "-traditional");
579 	newae(h, "-traditional-cpp");
580 }
581 
582 static void
583 usage()
584 {
585 	(void) fprintf(stderr,
586 	    "usage: %s { -_cc | -_gcc | -_CC | -_g++ } [ -_compiler | ... ]\n",
587 	    progname);
588 	exit(2);
589 }
590 
591 static int
592 xlate_xtb(struct aelist *h, const char *xarg)
593 {
594 	int	i, j;
595 
596 	for (i = 0; i < xtbl_size; i++) {
597 		if (strcmp(xtbl[i].x_arg, xarg) == 0)
598 			break;
599 	}
600 
601 	/*
602 	 * At the end of the table and so no matching "arg" entry
603 	 * found and so this must be a bad -xarch= flag.
604 	 */
605 	if (i == xtbl_size)
606 		error(xarg);
607 
608 	for (j = 0; j < TRANS_ENTRY; j++) {
609 		if (xtbl[i].x_trans[j] != NULL)
610 			newae(h, xtbl[i].x_trans[j]);
611 		else
612 			break;
613 	}
614 	return (xtbl[i].x_flags);
615 
616 }
617 
618 static void
619 xlate(struct aelist *h, const char *xarg, const char **table)
620 {
621 	while (*table != NULL && strcmp(xarg, *table) != 0) {
622 		while (*table != NULL)
623 			table++;
624 		table++;
625 	}
626 
627 	if (*table == NULL)
628 		error(xarg);
629 
630 	table++;
631 
632 	while (*table != NULL) {
633 		newae(h, *table);
634 		table++;
635 	}
636 }
637 
638 static void
639 do_gcc(cw_ictx_t *ctx)
640 {
641 	int c;
642 	int pic = 0, nolibc = 0;
643 	int in_output = 0, seen_o = 0, c_files = 0;
644 	cw_op_t op = CW_O_LINK;
645 	char *model = NULL;
646 	int	mflag = 0;
647 
648 	if (ctx->i_flags & CW_F_PROG) {
649 		newae(ctx->i_ae, "--version");
650 		return;
651 	}
652 
653 	newae(ctx->i_ae, "-fident");
654 	newae(ctx->i_ae, "-finline");
655 	newae(ctx->i_ae, "-fno-inline-functions");
656 	newae(ctx->i_ae, "-fno-builtin");
657 	newae(ctx->i_ae, "-fno-asm");
658 	newae(ctx->i_ae, "-fdiagnostics-show-option");
659 	newae(ctx->i_ae, "-nodefaultlibs");
660 
661 #if defined(__sparc)
662 	/*
663 	 * The SPARC ldd and std instructions require 8-byte alignment of
664 	 * their address operand.  gcc correctly uses them only when the
665 	 * ABI requires 8-byte alignment; unfortunately we have a number of
666 	 * pieces of buggy code that doesn't conform to the ABI.  This
667 	 * flag makes gcc work more like Studio with -xmemalign=4.
668 	 */
669 	newae(ctx->i_ae, "-mno-integer-ldd-std");
670 #endif
671 
672 	/*
673 	 * This is needed because 'u' is defined
674 	 * under a conditional on 'sun'.  Should
675 	 * probably just remove the conditional,
676 	 * or make it be dependent on '__sun'.
677 	 *
678 	 * -Dunix is also missing in enhanced ANSI mode
679 	 */
680 	newae(ctx->i_ae, "-D__sun");
681 
682 	/*
683 	 * Walk the argument list, translating as we go ..
684 	 */
685 
686 	while (--ctx->i_oldargc > 0) {
687 		char *arg = *++ctx->i_oldargv;
688 		size_t arglen = strlen(arg);
689 
690 		if (*arg == '-') {
691 			arglen--;
692 		} else {
693 			/*
694 			 * Discard inline files that gcc doesn't grok
695 			 */
696 			if (!in_output && arglen > 3 &&
697 			    strcmp(arg + arglen - 3, ".il") == 0)
698 				continue;
699 
700 			if (!in_output && arglen > 2 &&
701 			    arg[arglen - 2] == '.' &&
702 			    (arg[arglen - 1] == 'S' || arg[arglen - 1] == 's' ||
703 			    arg[arglen - 1] == 'c' || arg[arglen - 1] == 'i'))
704 				c_files++;
705 
706 			/*
707 			 * Otherwise, filenames and partial arguments
708 			 * are passed through for gcc to chew on.  However,
709 			 * output is always discarded for the secondary
710 			 * compiler.
711 			 */
712 			if ((ctx->i_flags & CW_F_SHADOW) && in_output)
713 				newae(ctx->i_ae, ctx->i_discard);
714 			else
715 				newae(ctx->i_ae, arg);
716 			in_output = 0;
717 			continue;
718 		}
719 
720 		if (ctx->i_flags & CW_F_CXX) {
721 			if (strncmp(arg, "-compat=", 8) == 0) {
722 				/* discard -compat=4 and -compat=5 */
723 				continue;
724 			}
725 			if (strcmp(arg, "-Qoption") == 0) {
726 				/* discard -Qoption and its two arguments */
727 				if (ctx->i_oldargc < 3)
728 					error(arg);
729 				ctx->i_oldargc -= 2;
730 				ctx->i_oldargv += 2;
731 				continue;
732 			}
733 			if (strcmp(arg, "-xwe") == 0) {
734 				/* turn warnings into errors */
735 				newae(ctx->i_ae, "-Werror");
736 				continue;
737 			}
738 			if (strcmp(arg, "-noex") == 0) {
739 				/* no exceptions */
740 				newae(ctx->i_ae, "-fno-exceptions");
741 				/* no run time type descriptor information */
742 				newae(ctx->i_ae, "-fno-rtti");
743 				continue;
744 			}
745 			if (strcmp(arg, "-pic") == 0) {
746 				newae(ctx->i_ae, "-fpic");
747 				pic = 1;
748 				continue;
749 			}
750 			if (strcmp(arg, "-PIC") == 0) {
751 				newae(ctx->i_ae, "-fPIC");
752 				pic = 1;
753 				continue;
754 			}
755 			if (strcmp(arg, "-norunpath") == 0) {
756 				/* gcc has no corresponding option */
757 				continue;
758 			}
759 			if (strcmp(arg, "-nolib") == 0) {
760 				/* -nodefaultlibs is on by default */
761 				nolibc = 1;
762 				continue;
763 			}
764 #if defined(__sparc)
765 			if (strcmp(arg, "-cg92") == 0) {
766 				mflag |= xlate_xtb(ctx->i_ae, "v8");
767 				xlate(ctx->i_ae, "super", xchip_tbl);
768 				continue;
769 			}
770 #endif	/* __sparc */
771 		}
772 
773 		switch ((c = arg[1])) {
774 		case '_':
775 			if (strcmp(arg, "-_noecho") == 0)
776 				ctx->i_flags &= ~CW_F_ECHO;
777 			else if (strncmp(arg, "-_cc=", 5) == 0 ||
778 			    strncmp(arg, "-_CC=", 5) == 0)
779 				/* EMPTY */;
780 			else if (strncmp(arg, "-_gcc=", 6) == 0 ||
781 			    strncmp(arg, "-_g++=", 6) == 0)
782 				newae(ctx->i_ae, arg + 6);
783 			else
784 				error(arg);
785 			break;
786 		case '#':
787 			if (arglen == 1) {
788 				newae(ctx->i_ae, "-v");
789 				break;
790 			}
791 			error(arg);
792 			break;
793 		case 'g':
794 			newae(ctx->i_ae, "-gdwarf-2");
795 			break;
796 		case 'E':
797 			if (arglen == 1) {
798 				newae(ctx->i_ae, "-xc");
799 				newae(ctx->i_ae, arg);
800 				op = CW_O_PREPROCESS;
801 				nolibc = 1;
802 				break;
803 			}
804 			error(arg);
805 			break;
806 		case 'c':
807 		case 'S':
808 			if (arglen == 1) {
809 				op = CW_O_COMPILE;
810 				nolibc = 1;
811 			}
812 			/* FALLTHROUGH */
813 		case 'C':
814 		case 'H':
815 		case 'p':
816 			if (arglen == 1) {
817 				newae(ctx->i_ae, arg);
818 				break;
819 			}
820 			error(arg);
821 			break;
822 		case 'A':
823 		case 'h':
824 		case 'I':
825 		case 'i':
826 		case 'L':
827 		case 'l':
828 		case 'R':
829 		case 'U':
830 		case 'u':
831 		case 'w':
832 			newae(ctx->i_ae, arg);
833 			break;
834 		case 'o':
835 			seen_o = 1;
836 			if (arglen == 1) {
837 				in_output = 1;
838 				newae(ctx->i_ae, arg);
839 			} else if (ctx->i_flags & CW_F_SHADOW) {
840 				newae(ctx->i_ae, "-o");
841 				newae(ctx->i_ae, ctx->i_discard);
842 			} else {
843 				newae(ctx->i_ae, arg);
844 			}
845 			break;
846 		case 'D':
847 			newae(ctx->i_ae, arg);
848 			/*
849 			 * XXX	Clearly a hack ... do we need _KADB too?
850 			 */
851 			if (strcmp(arg, "-D_KERNEL") == 0 ||
852 			    strcmp(arg, "-D_BOOT") == 0)
853 				newae(ctx->i_ae, "-ffreestanding");
854 			break;
855 		case 'd':
856 			if (arglen == 2) {
857 				if (strcmp(arg, "-dy") == 0) {
858 					newae(ctx->i_ae, "-Wl,-dy");
859 					break;
860 				}
861 				if (strcmp(arg, "-dn") == 0) {
862 					newae(ctx->i_ae, "-Wl,-dn");
863 					break;
864 				}
865 			}
866 			if (strcmp(arg, "-dalign") == 0) {
867 				/*
868 				 * -dalign forces alignment in some cases;
869 				 * gcc does not need any flag to do this.
870 				 */
871 				break;
872 			}
873 			error(arg);
874 			break;
875 		case 'e':
876 			if (strcmp(arg,
877 			    "-erroff=E_EMPTY_TRANSLATION_UNIT") == 0) {
878 				/*
879 				 * Accept but ignore this -- gcc doesn't
880 				 * seem to complain about empty translation
881 				 * units
882 				 */
883 				break;
884 			}
885 			/* XX64 -- ignore all -erroff= options, for now */
886 			if (strncmp(arg, "-erroff=", 8) == 0)
887 				break;
888 			if (strcmp(arg, "-errtags=yes") == 0) {
889 				warnings(ctx->i_ae);
890 				break;
891 			}
892 			if (strcmp(arg, "-errwarn=%all") == 0) {
893 				newae(ctx->i_ae, "-Werror");
894 				break;
895 			}
896 			error(arg);
897 			break;
898 		case 'f':
899 			if (strcmp(arg, "-flags") == 0) {
900 				newae(ctx->i_ae, "--help");
901 				break;
902 			}
903 			if (strncmp(arg, "-features=zla", 13) == 0) {
904 				/*
905 				 * Accept but ignore this -- gcc allows
906 				 * zero length arrays.
907 				 */
908 				break;
909 			}
910 			error(arg);
911 			break;
912 		case 'G':
913 			newae(ctx->i_ae, "-shared");
914 			nolibc = 1;
915 			break;
916 		case 'k':
917 			if (strcmp(arg, "-keeptmp") == 0) {
918 				newae(ctx->i_ae, "-save-temps");
919 				break;
920 			}
921 			error(arg);
922 			break;
923 		case 'K':
924 			if (arglen == 1) {
925 				if ((arg = *++ctx->i_oldargv) == NULL ||
926 				    *arg == '\0')
927 					error("-K");
928 				ctx->i_oldargc--;
929 			} else {
930 				arg += 2;
931 			}
932 			if (strcmp(arg, "pic") == 0) {
933 				newae(ctx->i_ae, "-fpic");
934 				pic = 1;
935 				break;
936 			}
937 			if (strcmp(arg, "PIC") == 0) {
938 				newae(ctx->i_ae, "-fPIC");
939 				pic = 1;
940 				break;
941 			}
942 			error("-K");
943 			break;
944 		case 'm':
945 			if (strcmp(arg, "-mt") == 0) {
946 				newae(ctx->i_ae, "-D_REENTRANT");
947 				break;
948 			}
949 			if (strcmp(arg, "-m64") == 0) {
950 				newae(ctx->i_ae, "-m64");
951 #if defined(__x86)
952 				newae(ctx->i_ae, "-mtune=opteron");
953 #endif
954 				mflag |= M64;
955 				break;
956 			}
957 			if (strcmp(arg, "-m32") == 0) {
958 				newae(ctx->i_ae, "-m32");
959 				mflag |= M32;
960 				break;
961 			}
962 			error(arg);
963 			break;
964 		case 'B':	/* linker options */
965 		case 'M':
966 		case 'z':
967 			{
968 				char *opt;
969 				size_t len;
970 				char *s;
971 
972 				if (arglen == 1) {
973 					opt = *++ctx->i_oldargv;
974 					if (opt == NULL || *opt == '\0')
975 						error(arg);
976 					ctx->i_oldargc--;
977 				} else {
978 					opt = arg + 2;
979 				}
980 				len = strlen(opt) + 7;
981 				if ((s = malloc(len)) == NULL)
982 					nomem();
983 				(void) snprintf(s, len, "-Wl,-%c%s", c, opt);
984 				newae(ctx->i_ae, s);
985 				free(s);
986 			}
987 			break;
988 		case 'n':
989 			if (strcmp(arg, "-noqueue") == 0) {
990 				/*
991 				 * Horrid license server stuff - n/a
992 				 */
993 				break;
994 			}
995 			error(arg);
996 			break;
997 		case 'O':
998 			if (arglen == 1) {
999 				newae(ctx->i_ae, "-O");
1000 				break;
1001 			}
1002 			error(arg);
1003 			break;
1004 		case 'P':
1005 			/*
1006 			 * We could do '-E -o filename.i', but that's hard,
1007 			 * and we don't need it for the case that's triggering
1008 			 * this addition.  We'll require the user to specify
1009 			 * -o in the Makefile.  If they don't they'll find out
1010 			 * in a hurry.
1011 			 */
1012 			newae(ctx->i_ae, "-E");
1013 			op = CW_O_PREPROCESS;
1014 			nolibc = 1;
1015 			break;
1016 		case 'q':
1017 			if (strcmp(arg, "-qp") == 0) {
1018 				newae(ctx->i_ae, "-p");
1019 				break;
1020 			}
1021 			error(arg);
1022 			break;
1023 		case 's':
1024 			if (arglen == 1) {
1025 				newae(ctx->i_ae, "-Wl,-s");
1026 				break;
1027 			}
1028 			error(arg);
1029 			break;
1030 		case 't':
1031 			if (arglen == 1) {
1032 				newae(ctx->i_ae, "-Wl,-t");
1033 				break;
1034 			}
1035 			error(arg);
1036 			break;
1037 		case 'V':
1038 			if (arglen == 1) {
1039 				ctx->i_flags &= ~CW_F_ECHO;
1040 				newae(ctx->i_ae, "--version");
1041 				break;
1042 			}
1043 			error(arg);
1044 			break;
1045 		case 'v':
1046 			if (arglen == 1) {
1047 				warnings(ctx->i_ae);
1048 				break;
1049 			}
1050 			error(arg);
1051 			break;
1052 		case 'W':
1053 			if (strncmp(arg, "-Wp,-xc99", 9) == 0) {
1054 				/*
1055 				 * gcc's preprocessor will accept c99
1056 				 * regardless, so accept and ignore.
1057 				 */
1058 				break;
1059 			}
1060 			if (strncmp(arg, "-Wa,", 4) == 0 ||
1061 			    strncmp(arg, "-Wp,", 4) == 0 ||
1062 			    strncmp(arg, "-Wl,", 4) == 0) {
1063 				newae(ctx->i_ae, arg);
1064 				break;
1065 			}
1066 			if (strcmp(arg, "-W0,-xc99=pragma") == 0) {
1067 				/* (undocumented) enables _Pragma */
1068 				break;
1069 			}
1070 			if (strcmp(arg, "-W0,-xc99=%none") == 0) {
1071 				/*
1072 				 * This is a polite way of saying
1073 				 * "no c99 constructs allowed!"
1074 				 * For now, just accept and ignore this.
1075 				 */
1076 				break;
1077 			}
1078 			if (strcmp(arg, "-W0,-noglobal") == 0 ||
1079 			    strcmp(arg, "-W0,-xglobalstatic") == 0) {
1080 				/*
1081 				 * gcc doesn't prefix local symbols
1082 				 * in debug mode, so this is not needed.
1083 				 */
1084 				break;
1085 			}
1086 			if (strcmp(arg, "-W0,-Lt") == 0) {
1087 				/*
1088 				 * Generate tests at the top of loops.
1089 				 * There is no direct gcc equivalent, ignore.
1090 				 */
1091 				break;
1092 			}
1093 			if (strcmp(arg, "-W0,-xdbggen=no%usedonly") == 0) {
1094 				newae(ctx->i_ae,
1095 				    "-fno-eliminate-unused-debug-symbols");
1096 				newae(ctx->i_ae,
1097 				    "-fno-eliminate-unused-debug-types");
1098 				break;
1099 			}
1100 			if (strcmp(arg, "-W2,-xwrap_int") == 0) {
1101 				/*
1102 				 * Use the legacy behaviour (pre-SS11)
1103 				 * for integer wrapping.
1104 				 * gcc does not need this.
1105 				 */
1106 				break;
1107 			}
1108 			if (strcmp(arg, "-W2,-Rcond_elim") == 0) {
1109 				/*
1110 				 * Elimination and expansion of conditionals;
1111 				 * gcc has no direct equivalent.
1112 				 */
1113 				break;
1114 			}
1115 			if (strcmp(arg, "-Wd,-xsafe=unboundsym") == 0) {
1116 				/*
1117 				 * Prevents optimizing away checks for
1118 				 * unbound weak symbol addresses.  gcc does
1119 				 * not do this, so it's not needed.
1120 				 */
1121 				break;
1122 			}
1123 			if (strncmp(arg, "-Wc,-xcode=", 11) == 0) {
1124 				xlate(ctx->i_ae, arg + 11, xcode_tbl);
1125 				if (strncmp(arg + 11, "pic", 3) == 0)
1126 					pic = 1;
1127 				break;
1128 			}
1129 			if (strncmp(arg, "-Wc,-Qiselect", 13) == 0) {
1130 				/*
1131 				 * Prevents insertion of register symbols.
1132 				 * gcc doesn't do this, so ignore it.
1133 				 */
1134 				break;
1135 			}
1136 			if (strcmp(arg, "-Wc,-Qassembler-ounrefsym=0") == 0) {
1137 				/*
1138 				 * Prevents optimizing away of static variables.
1139 				 * gcc does not do this, so it's not needed.
1140 				 */
1141 				break;
1142 			}
1143 #if defined(__x86)
1144 			if (strcmp(arg, "-Wu,-xmodel=kernel") == 0) {
1145 				newae(ctx->i_ae, "-ffreestanding");
1146 				newae(ctx->i_ae, "-mno-red-zone");
1147 				model = "-mcmodel=kernel";
1148 				nolibc = 1;
1149 				break;
1150 			}
1151 			if (strcmp(arg, "-Wu,-save_args") == 0) {
1152 				newae(ctx->i_ae, "-msave-args");
1153 				break;
1154 			}
1155 #endif	/* __x86 */
1156 			error(arg);
1157 			break;
1158 		case 'X':
1159 			if (strcmp(arg, "-Xa") == 0 ||
1160 			    strcmp(arg, "-Xt") == 0) {
1161 				Xamode(ctx->i_ae);
1162 				break;
1163 			}
1164 			if (strcmp(arg, "-Xc") == 0) {
1165 				Xcmode(ctx->i_ae);
1166 				break;
1167 			}
1168 			if (strcmp(arg, "-Xs") == 0) {
1169 				Xsmode(ctx->i_ae);
1170 				break;
1171 			}
1172 			error(arg);
1173 			break;
1174 		case 'x':
1175 			if (arglen == 1)
1176 				error(arg);
1177 			switch (arg[2]) {
1178 #if defined(__x86)
1179 			case '3':
1180 				if (strcmp(arg, "-x386") == 0) {
1181 					newae(ctx->i_ae, "-march=i386");
1182 					break;
1183 				}
1184 				error(arg);
1185 				break;
1186 			case '4':
1187 				if (strcmp(arg, "-x486") == 0) {
1188 					newae(ctx->i_ae, "-march=i486");
1189 					break;
1190 				}
1191 				error(arg);
1192 				break;
1193 #endif	/* __x86 */
1194 			case 'a':
1195 				if (strncmp(arg, "-xarch=", 7) == 0) {
1196 					mflag |= xlate_xtb(ctx->i_ae, arg + 7);
1197 					break;
1198 				}
1199 				error(arg);
1200 				break;
1201 			case 'b':
1202 				if (strncmp(arg, "-xbuiltin=", 10) == 0) {
1203 					if (strcmp(arg + 10, "%all"))
1204 						newae(ctx->i_ae, "-fbuiltin");
1205 					break;
1206 				}
1207 				error(arg);
1208 				break;
1209 			case 'C':
1210 				/* Accept C++ style comments -- ignore */
1211 				if (strcmp(arg, "-xCC") == 0)
1212 					break;
1213 				error(arg);
1214 				break;
1215 			case 'c':
1216 				if (strncmp(arg, "-xc99=%all", 10) == 0) {
1217 					newae(ctx->i_ae, "-std=gnu99");
1218 					break;
1219 				}
1220 				if (strncmp(arg, "-xc99=%none", 11) == 0) {
1221 					newae(ctx->i_ae, "-std=gnu89");
1222 					break;
1223 				}
1224 				if (strncmp(arg, "-xchip=", 7) == 0) {
1225 					xlate(ctx->i_ae, arg + 7, xchip_tbl);
1226 					break;
1227 				}
1228 				if (strncmp(arg, "-xcode=", 7) == 0) {
1229 					xlate(ctx->i_ae, arg + 7, xcode_tbl);
1230 					if (strncmp(arg + 7, "pic", 3) == 0)
1231 						pic = 1;
1232 					break;
1233 				}
1234 				if (strncmp(arg, "-xcache=", 8) == 0)
1235 					break;
1236 				if (strncmp(arg, "-xcrossfile", 11) == 0)
1237 					break;
1238 				error(arg);
1239 				break;
1240 			case 'd':
1241 				if (strcmp(arg, "-xdepend") == 0)
1242 					break;
1243 				if (strncmp(arg, "-xdebugformat=", 14) == 0)
1244 					break;
1245 				error(arg);
1246 				break;
1247 			case 'F':
1248 				/*
1249 				 * Compile for mapfile reordering, or unused
1250 				 * section elimination, syntax can be -xF or
1251 				 * more complex, like -xF=%all -- ignore.
1252 				 */
1253 				if (strncmp(arg, "-xF", 3) == 0)
1254 					break;
1255 				error(arg);
1256 				break;
1257 			case 'i':
1258 				if (strncmp(arg, "-xinline", 8) == 0)
1259 					/* No inlining; ignore */
1260 					break;
1261 				if (strcmp(arg, "-xildon") == 0 ||
1262 				    strcmp(arg, "-xildoff") == 0)
1263 					/* No incremental linking; ignore */
1264 					break;
1265 				error(arg);
1266 				break;
1267 #if defined(__x86)
1268 			case 'm':
1269 				if (strcmp(arg, "-xmodel=kernel") == 0) {
1270 					newae(ctx->i_ae, "-ffreestanding");
1271 					newae(ctx->i_ae, "-mno-red-zone");
1272 					model = "-mcmodel=kernel";
1273 					nolibc = 1;
1274 					break;
1275 				}
1276 				error(arg);
1277 				break;
1278 #endif	/* __x86 */
1279 			case 'M':
1280 				if (strcmp(arg, "-xM") == 0) {
1281 					newae(ctx->i_ae, "-M");
1282 					break;
1283 				}
1284 				if (strcmp(arg, "-xM1") == 0) {
1285 					newae(ctx->i_ae, "-MM");
1286 					break;
1287 				}
1288 				error(arg);
1289 				break;
1290 			case 'n':
1291 				if (strcmp(arg, "-xnolib") == 0) {
1292 					nolibc = 1;
1293 					break;
1294 				}
1295 				error(arg);
1296 				break;
1297 			case 'O':
1298 				if (strncmp(arg, "-xO", 3) == 0) {
1299 					size_t len = strlen(arg);
1300 					char *s;
1301 					int c = *(arg + 3);
1302 					int level;
1303 
1304 					if (len != 4 || !isdigit(c))
1305 						error(arg);
1306 
1307 					if ((s = malloc(len)) == NULL)
1308 						nomem();
1309 
1310 					level = atoi(arg + 3);
1311 					if (level > 5)
1312 						error(arg);
1313 					if (level >= 2) {
1314 						/*
1315 						 * For gcc-3.4.x at -O2 we
1316 						 * need to disable optimizations
1317 						 * that break ON.
1318 						 */
1319 						optim_disable(ctx->i_ae, level);
1320 						/*
1321 						 * limit -xO3 to -O2 as well.
1322 						 */
1323 						level = 2;
1324 					}
1325 					(void) snprintf(s, len, "-O%d", level);
1326 					newae(ctx->i_ae, s);
1327 					free(s);
1328 					break;
1329 				}
1330 				error(arg);
1331 				break;
1332 			case 'p':
1333 				if (strcmp(arg, "-xpentium") == 0) {
1334 					newae(ctx->i_ae, "-march=pentium");
1335 					break;
1336 				}
1337 				if (strcmp(arg, "-xpg") == 0) {
1338 					newae(ctx->i_ae, "-pg");
1339 					break;
1340 				}
1341 				error(arg);
1342 				break;
1343 			case 'r':
1344 				if (strncmp(arg, "-xregs=", 7) == 0) {
1345 					xlate(ctx->i_ae, arg + 7, xregs_tbl);
1346 					break;
1347 				}
1348 				error(arg);
1349 				break;
1350 			case 's':
1351 				if (strcmp(arg, "-xs") == 0 ||
1352 				    strcmp(arg, "-xspace") == 0 ||
1353 				    strcmp(arg, "-xstrconst") == 0)
1354 					break;
1355 				error(arg);
1356 				break;
1357 			case 't':
1358 				if (strcmp(arg, "-xtransition") == 0) {
1359 					newae(ctx->i_ae, "-Wtransition");
1360 					break;
1361 				}
1362 				if (strcmp(arg, "-xtrigraphs=yes") == 0) {
1363 					newae(ctx->i_ae, "-trigraphs");
1364 					break;
1365 				}
1366 				if (strcmp(arg, "-xtrigraphs=no") == 0) {
1367 					newae(ctx->i_ae, "-notrigraphs");
1368 					break;
1369 				}
1370 				if (strncmp(arg, "-xtarget=", 9) == 0) {
1371 					xlate(ctx->i_ae, arg + 9, xtarget_tbl);
1372 					break;
1373 				}
1374 				error(arg);
1375 				break;
1376 			case 'e':
1377 			case 'h':
1378 			case 'l':
1379 			default:
1380 				error(arg);
1381 				break;
1382 			}
1383 			break;
1384 		case 'Y':
1385 			if (arglen == 1) {
1386 				if ((arg = *++ctx->i_oldargv) == NULL ||
1387 				    *arg == '\0')
1388 					error("-Y");
1389 				ctx->i_oldargc--;
1390 				arglen = strlen(arg + 1);
1391 			} else {
1392 				arg += 2;
1393 			}
1394 			/* Just ignore -YS,... for now */
1395 			if (strncmp(arg, "S,", 2) == 0)
1396 				break;
1397 			if (strncmp(arg, "l,", 2) == 0) {
1398 				char *s = strdup(arg);
1399 				s[0] = '-';
1400 				s[1] = 'B';
1401 				newae(ctx->i_ae, s);
1402 				free(s);
1403 				break;
1404 			}
1405 			if (strncmp(arg, "I,", 2) == 0) {
1406 				char *s = strdup(arg);
1407 				s[0] = '-';
1408 				s[1] = 'I';
1409 				newae(ctx->i_ae, "-nostdinc");
1410 				newae(ctx->i_ae, s);
1411 				free(s);
1412 				break;
1413 			}
1414 			error(arg);
1415 			break;
1416 		case 'Q':
1417 			/*
1418 			 * We could map -Qy into -Wl,-Qy etc.
1419 			 */
1420 		default:
1421 			error(arg);
1422 			break;
1423 		}
1424 	}
1425 
1426 	if (c_files > 1 && (ctx->i_flags & CW_F_SHADOW) &&
1427 	    op != CW_O_PREPROCESS) {
1428 		(void) fprintf(stderr, "%s: error: multiple source files are "
1429 		    "allowed only with -E or -P\n", progname);
1430 		exit(2);
1431 	}
1432 
1433 	/*
1434 	 * Make sure that we do not have any unintended interactions between
1435 	 * the xarch options passed in and the version of the Studio compiler
1436 	 * used.
1437 	 */
1438 	if ((mflag & (SS11|SS12)) == (SS11|SS12)) {
1439 		(void) fprintf(stderr,
1440 		    "Conflicting \"-xarch=\" flags (both Studio 11 and 12)\n");
1441 		exit(2);
1442 	}
1443 
1444 	switch (mflag) {
1445 	case 0:
1446 		/* FALLTHROUGH */
1447 	case M32:
1448 #if defined(__sparc)
1449 		/*
1450 		 * Only -m32 is defined and so put in the missing xarch
1451 		 * translation.
1452 		 */
1453 		newae(ctx->i_ae, "-mcpu=v8");
1454 		newae(ctx->i_ae, "-mno-v8plus");
1455 #endif
1456 		break;
1457 	case M64:
1458 #if defined(__sparc)
1459 		/*
1460 		 * Only -m64 is defined and so put in the missing xarch
1461 		 * translation.
1462 		 */
1463 		newae(ctx->i_ae, "-mcpu=v9");
1464 #endif
1465 		break;
1466 	case SS12:
1467 #if defined(__sparc)
1468 		/* no -m32/-m64 flag used - this is an error for sparc builds */
1469 		(void) fprintf(stderr, "No -m32/-m64 flag defined\n");
1470 		exit(2);
1471 #endif
1472 		break;
1473 	case SS11:
1474 		/* FALLTHROUGH */
1475 	case (SS11|M32):
1476 	case (SS11|M64):
1477 		break;
1478 	case (SS12|M32):
1479 #if defined(__sparc)
1480 		/*
1481 		 * Need to add in further 32 bit options because with SS12
1482 		 * the xarch=sparcvis option can be applied to 32 or 64
1483 		 * bit, and so the translatation table (xtbl) cannot handle
1484 		 * that.
1485 		 */
1486 		newae(ctx->i_ae, "-mv8plus");
1487 #endif
1488 		break;
1489 	case (SS12|M64):
1490 		break;
1491 	default:
1492 		(void) fprintf(stderr,
1493 		    "Incompatible -xarch= and/or -m32/-m64 options used.\n");
1494 		exit(2);
1495 	}
1496 	if (op == CW_O_LINK && (ctx->i_flags & CW_F_SHADOW))
1497 		exit(0);
1498 
1499 	if (model && !pic)
1500 		newae(ctx->i_ae, model);
1501 	if (!nolibc)
1502 		newae(ctx->i_ae, "-lc");
1503 	if (!seen_o && (ctx->i_flags & CW_F_SHADOW)) {
1504 		newae(ctx->i_ae, "-o");
1505 		newae(ctx->i_ae, ctx->i_discard);
1506 	}
1507 }
1508 
1509 static void
1510 do_cc(cw_ictx_t *ctx)
1511 {
1512 	int in_output = 0, seen_o = 0;
1513 	cw_op_t op = CW_O_LINK;
1514 
1515 	if (ctx->i_flags & CW_F_PROG) {
1516 		newae(ctx->i_ae, "-V");
1517 		return;
1518 	}
1519 
1520 	while (--ctx->i_oldargc > 0) {
1521 		char *arg = *++ctx->i_oldargv;
1522 
1523 		if (*arg != '-') {
1524 			if (in_output == 0 || !(ctx->i_flags & CW_F_SHADOW)) {
1525 				newae(ctx->i_ae, arg);
1526 			} else {
1527 				in_output = 0;
1528 				newae(ctx->i_ae, ctx->i_discard);
1529 			}
1530 			continue;
1531 		}
1532 		switch (*(arg + 1)) {
1533 		case '_':
1534 			if (strcmp(arg, "-_noecho") == 0) {
1535 				ctx->i_flags &= ~CW_F_ECHO;
1536 			} else if (strncmp(arg, "-_cc=", 5) == 0 ||
1537 			    strncmp(arg, "-_CC=", 5) == 0) {
1538 				newae(ctx->i_ae, arg + 5);
1539 			} else if (strncmp(arg, "-_gcc=", 6) != 0 &&
1540 			    strncmp(arg, "-_g++=", 6) != 0) {
1541 				(void) fprintf(stderr,
1542 				    "%s: invalid argument '%s'\n", progname,
1543 				    arg);
1544 				exit(2);
1545 			}
1546 			break;
1547 		case 'V':
1548 			ctx->i_flags &= ~CW_F_ECHO;
1549 			newae(ctx->i_ae, arg);
1550 			break;
1551 		case 'o':
1552 			seen_o = 1;
1553 			if (strlen(arg) == 2) {
1554 				in_output = 1;
1555 				newae(ctx->i_ae, arg);
1556 			} else if (ctx->i_flags & CW_F_SHADOW) {
1557 				newae(ctx->i_ae, "-o");
1558 				newae(ctx->i_ae, ctx->i_discard);
1559 			} else {
1560 				newae(ctx->i_ae, arg);
1561 			}
1562 			break;
1563 		case 'c':
1564 		case 'S':
1565 			if (strlen(arg) == 2)
1566 				op = CW_O_COMPILE;
1567 			newae(ctx->i_ae, arg);
1568 			break;
1569 		case 'E':
1570 		case 'P':
1571 			if (strlen(arg) == 2)
1572 				op = CW_O_PREPROCESS;
1573 		/*FALLTHROUGH*/
1574 		default:
1575 			newae(ctx->i_ae, arg);
1576 		}
1577 	}
1578 
1579 	if ((op == CW_O_LINK || op == CW_O_PREPROCESS) &&
1580 	    (ctx->i_flags & CW_F_SHADOW))
1581 		exit(0);
1582 
1583 	if (!seen_o && (ctx->i_flags & CW_F_SHADOW)) {
1584 		newae(ctx->i_ae, "-o");
1585 		newae(ctx->i_ae, ctx->i_discard);
1586 	}
1587 }
1588 
1589 static void
1590 prepctx(cw_ictx_t *ctx)
1591 {
1592 	const char *dir = NULL, *cmd;
1593 	char *program = NULL;
1594 	size_t len;
1595 
1596 	switch (CIDX(CC(ctx), ctx->i_flags)) {
1597 		case CIDX(CW_C_CC, 0):
1598 			program = getenv("CW_CC");
1599 			dir = getenv("CW_CC_DIR");
1600 			break;
1601 		case CIDX(CW_C_CC, CW_F_CXX):
1602 			program = getenv("CW_CPLUSPLUS");
1603 			dir = getenv("CW_CPLUSPLUS_DIR");
1604 			break;
1605 		case CIDX(CW_C_GCC, 0):
1606 			program = getenv("CW_GCC");
1607 			dir = getenv("CW_GCC_DIR");
1608 			break;
1609 		case CIDX(CW_C_GCC, CW_F_CXX):
1610 			program = getenv("CW_GPLUSPLUS");
1611 			dir = getenv("CW_GPLUSPLUS_DIR");
1612 			break;
1613 	}
1614 
1615 	if (program == NULL) {
1616 		if (dir == NULL)
1617 			dir = default_dir[CC(ctx)];
1618 		cmd = cmds[CIDX(CC(ctx), ctx->i_flags)];
1619 		len = strlen(dir) + strlen(cmd) + 2;
1620 		if ((program = malloc(len)) == NULL)
1621 			nomem();
1622 		(void) snprintf(program, len, "%s/%s", dir, cmd);
1623 	}
1624 
1625 	newae(ctx->i_ae, program);
1626 
1627 	if (ctx->i_flags & CW_F_PROG) {
1628 		(void) printf("%s: %s\n", (ctx->i_flags & CW_F_SHADOW) ?
1629 		    "shadow" : "primary", program);
1630 		(void) fflush(stdout);
1631 	}
1632 
1633 	if (!(ctx->i_flags & CW_F_XLATE))
1634 		return;
1635 
1636 	switch (CC(ctx)) {
1637 	case CW_C_CC:
1638 		do_cc(ctx);
1639 		break;
1640 	case CW_C_GCC:
1641 		do_gcc(ctx);
1642 		break;
1643 	}
1644 }
1645 
1646 static int
1647 invoke(cw_ictx_t *ctx)
1648 {
1649 	char **newargv;
1650 	int ac;
1651 	struct ae *a;
1652 
1653 	if ((newargv = calloc(sizeof (*newargv), ctx->i_ae->ael_argc + 1)) ==
1654 	    NULL)
1655 		nomem();
1656 
1657 	if (ctx->i_flags & CW_F_ECHO)
1658 		(void) fprintf(stderr, "+ ");
1659 
1660 	for (ac = 0, a = ctx->i_ae->ael_head; a; a = a->ae_next, ac++) {
1661 		newargv[ac] = a->ae_arg;
1662 		if (ctx->i_flags & CW_F_ECHO)
1663 			(void) fprintf(stderr, "%s ", a->ae_arg);
1664 		if (a == ctx->i_ae->ael_tail)
1665 			break;
1666 	}
1667 
1668 	if (ctx->i_flags & CW_F_ECHO) {
1669 		(void) fprintf(stderr, "\n");
1670 		(void) fflush(stderr);
1671 	}
1672 
1673 	if (!(ctx->i_flags & CW_F_EXEC))
1674 		return (0);
1675 
1676 	/*
1677 	 * We must fix up the environment here so that the
1678 	 * dependency files are not trampled by the shadow compiler.
1679 	 */
1680 	if ((ctx->i_flags & CW_F_SHADOW) &&
1681 	    (unsetenv("SUNPRO_DEPENDENCIES") != 0 ||
1682 	    unsetenv("DEPENDENCIES_OUTPUT") != 0)) {
1683 		(void) fprintf(stderr, "error: environment setup failed: %s\n",
1684 		    strerror(errno));
1685 		return (-1);
1686 	}
1687 
1688 	(void) execv(newargv[0], newargv);
1689 	cw_perror("couldn't run %s", newargv[0]);
1690 
1691 	return (-1);
1692 }
1693 
1694 static int
1695 reap(cw_ictx_t *ctx)
1696 {
1697 	int status, ret = 0;
1698 	char buf[1024];
1699 	struct stat s;
1700 
1701 	/*
1702 	 * Only wait for one specific child.
1703 	 */
1704 	if (ctx->i_pid <= 0)
1705 		return (-1);
1706 
1707 	do {
1708 		if (waitpid(ctx->i_pid, &status, 0) < 0) {
1709 			cw_perror("cannot reap child");
1710 			return (-1);
1711 		}
1712 		if (status != 0) {
1713 			if (WIFSIGNALED(status)) {
1714 				ret = -WTERMSIG(status);
1715 				break;
1716 			} else if (WIFEXITED(status)) {
1717 				ret = WEXITSTATUS(status);
1718 				break;
1719 			}
1720 		}
1721 	} while (!WIFEXITED(status) && !WIFSIGNALED(status));
1722 
1723 	(void) unlink(ctx->i_discard);
1724 
1725 	if (stat(ctx->i_stderr, &s) < 0) {
1726 		cw_perror("stat failed on child cleanup");
1727 		return (-1);
1728 	}
1729 	if (s.st_size != 0) {
1730 		FILE *f;
1731 
1732 		if ((f = fopen(ctx->i_stderr, "r")) != NULL) {
1733 			while (fgets(buf, sizeof (buf), f))
1734 				(void) fprintf(stderr, "%s", buf);
1735 			(void) fflush(stderr);
1736 			(void) fclose(f);
1737 		}
1738 	}
1739 	(void) unlink(ctx->i_stderr);
1740 	free(ctx->i_stderr);
1741 
1742 	/*
1743 	 * cc returns an error code when given -V; we want that to succeed.
1744 	 */
1745 	if (ctx->i_flags & CW_F_PROG)
1746 		return (0);
1747 
1748 	return (ret);
1749 }
1750 
1751 static int
1752 exec_ctx(cw_ictx_t *ctx, int block)
1753 {
1754 	char *file;
1755 
1756 	/*
1757 	 * To avoid offending cc's sensibilities, the name of its output
1758 	 * file must end in '.o'.
1759 	 */
1760 	if ((file = tempnam(NULL, ".cw")) == NULL) {
1761 		nomem();
1762 		return (-1);
1763 	}
1764 	(void) strlcpy(ctx->i_discard, file, MAXPATHLEN);
1765 	(void) strlcat(ctx->i_discard, ".o", MAXPATHLEN);
1766 	free(file);
1767 
1768 	if ((ctx->i_stderr = tempnam(NULL, ".cw")) == NULL) {
1769 		nomem();
1770 		return (-1);
1771 	}
1772 
1773 	if ((ctx->i_pid = fork()) == 0) {
1774 		int fd;
1775 
1776 		(void) fclose(stderr);
1777 		if ((fd = open(ctx->i_stderr, O_WRONLY | O_CREAT | O_EXCL,
1778 		    0666)) < 0) {
1779 			cw_perror("open failed for standard error");
1780 			exit(1);
1781 		}
1782 		if (dup2(fd, 2) < 0) {
1783 			cw_perror("dup2 failed for standard error");
1784 			exit(1);
1785 		}
1786 		if (fd != 2)
1787 			(void) close(fd);
1788 		if (freopen("/dev/fd/2", "w", stderr) == NULL) {
1789 			cw_perror("freopen failed for /dev/fd/2");
1790 			exit(1);
1791 		}
1792 		prepctx(ctx);
1793 		exit(invoke(ctx));
1794 	}
1795 
1796 	if (ctx->i_pid < 0) {
1797 		cw_perror("fork failed");
1798 		return (1);
1799 	}
1800 
1801 	if (block)
1802 		return (reap(ctx));
1803 
1804 	return (0);
1805 }
1806 
1807 int
1808 main(int argc, char **argv)
1809 {
1810 	cw_ictx_t *ctx = newictx();
1811 	cw_ictx_t *ctx_shadow = newictx();
1812 	const char *dir;
1813 	int do_serial, do_shadow;
1814 	int ret = 0;
1815 
1816 	if ((progname = strrchr(argv[0], '/')) == NULL)
1817 		progname = argv[0];
1818 	else
1819 		progname++;
1820 
1821 	if (ctx == NULL || ctx_shadow == NULL)
1822 		nomem();
1823 
1824 	ctx->i_flags = CW_F_ECHO|CW_F_XLATE;
1825 
1826 	/*
1827 	 * Figure out where to get our tools from.  This depends on
1828 	 * the environment variables set at run time.
1829 	 */
1830 	if ((dir = getenv("SPRO_VROOT")) != NULL) {
1831 		(void) snprintf(default_dir[CW_C_CC], MAXPATHLEN,
1832 		    "%s/bin", dir);
1833 	} else if ((dir = getenv("SPRO_ROOT")) != NULL) {
1834 		(void) snprintf(default_dir[CW_C_CC], MAXPATHLEN,
1835 		    "%s/SS12/bin", dir);
1836 	} else if ((dir = getenv("BUILD_TOOLS")) != NULL) {
1837 		(void) snprintf(default_dir[CW_C_CC], MAXPATHLEN,
1838 		    "%s/SUNWspro/SS12/bin", dir);
1839 	}
1840 
1841 	if ((dir = getenv("GCC_ROOT")) != NULL) {
1842 		(void) snprintf(default_dir[CW_C_GCC], MAXPATHLEN,
1843 		    "%s/bin", dir);
1844 	}
1845 
1846 	do_shadow = (getenv("CW_NO_SHADOW") ? 0 : 1);
1847 	do_serial = (getenv("CW_SHADOW_SERIAL") ? 1 : 0);
1848 
1849 	if (getenv("CW_NO_EXEC") == NULL)
1850 		ctx->i_flags |= CW_F_EXEC;
1851 
1852 	/*
1853 	 * The first argument must be one of "-_cc", "-_gcc", "-_CC", or "-_g++"
1854 	 */
1855 	if (argc == 1)
1856 		usage();
1857 	argc--;
1858 	argv++;
1859 	if (strcmp(argv[0], "-_cc") == 0) {
1860 		ctx->i_compiler = CW_C_CC;
1861 	} else if (strcmp(argv[0], "-_gcc") == 0) {
1862 		ctx->i_compiler = CW_C_GCC;
1863 	} else if (strcmp(argv[0], "-_CC") == 0) {
1864 		ctx->i_compiler = CW_C_CC;
1865 		ctx->i_flags |= CW_F_CXX;
1866 	} else if (strcmp(argv[0], "-_g++") == 0) {
1867 		ctx->i_compiler = CW_C_GCC;
1868 		ctx->i_flags |= CW_F_CXX;
1869 	} else {
1870 		/* assume "-_gcc" by default */
1871 		argc++;
1872 		argv--;
1873 		ctx->i_compiler = CW_C_GCC;
1874 	}
1875 
1876 	/*
1877 	 * -_compiler - tell us the path to the primary compiler only
1878 	 */
1879 	if (argc > 1 && strcmp(argv[1], "-_compiler") == 0) {
1880 		ctx->i_flags &= ~CW_F_XLATE;
1881 		prepctx(ctx);
1882 		(void) printf("%s\n", ctx->i_ae->ael_head->ae_arg);
1883 		return (0);
1884 	}
1885 
1886 	/*
1887 	 * -_versions - tell us the cw version, paths to all compilers, and
1888 	 *		ask each for its version if we know how.
1889 	 */
1890 	if (argc > 1 && strcmp(argv[1], "-_versions") == 0) {
1891 		(void) printf("cw version %s", CW_VERSION);
1892 		if (!do_shadow)
1893 			(void) printf(" (SHADOW MODE DISABLED)");
1894 		(void) printf("\n");
1895 		(void) fflush(stdout);
1896 		ctx->i_flags &= ~CW_F_ECHO;
1897 		ctx->i_flags |= CW_F_PROG|CW_F_EXEC;
1898 		argc--;
1899 		argv++;
1900 		do_serial = 1;
1901 	}
1902 
1903 	ctx->i_oldargc = argc;
1904 	ctx->i_oldargv = argv;
1905 
1906 	ret |= exec_ctx(ctx, do_serial);
1907 
1908 	if (do_shadow) {
1909 		(void) memcpy(ctx_shadow, ctx, sizeof (cw_ictx_t));
1910 		ctx_shadow->i_flags |= CW_F_SHADOW;
1911 		ret |= exec_ctx(ctx_shadow, 1);
1912 	}
1913 
1914 	if (!do_serial)
1915 		ret |= reap(ctx);
1916 
1917 	return (ret);
1918 }
1919