xref: /illumos-gate/usr/src/tools/cw/cw.c (revision 538ff303)
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 = NULL;
1301 					int c = *(arg + 3);
1302 					int level;
1303 
1304 					if (len != 4 || !isdigit(c))
1305 						error(arg);
1306 
1307 					level = atoi(arg + 3);
1308 					if (level > 5)
1309 						error(arg);
1310 					if (level >= 2) {
1311 						/*
1312 						 * For gcc-3.4.x at -O2 we
1313 						 * need to disable optimizations
1314 						 * that break ON.
1315 						 */
1316 						optim_disable(ctx->i_ae, level);
1317 						/*
1318 						 * limit -xO3 to -O2 as well.
1319 						 */
1320 						level = 2;
1321 					}
1322 					if (asprintf(&s, "-O%d", level) == -1)
1323 						nomem();
1324 					newae(ctx->i_ae, s);
1325 					free(s);
1326 					break;
1327 				}
1328 				error(arg);
1329 				break;
1330 			case 'p':
1331 				if (strcmp(arg, "-xpentium") == 0) {
1332 					newae(ctx->i_ae, "-march=pentium");
1333 					break;
1334 				}
1335 				if (strcmp(arg, "-xpg") == 0) {
1336 					newae(ctx->i_ae, "-pg");
1337 					break;
1338 				}
1339 				error(arg);
1340 				break;
1341 			case 'r':
1342 				if (strncmp(arg, "-xregs=", 7) == 0) {
1343 					xlate(ctx->i_ae, arg + 7, xregs_tbl);
1344 					break;
1345 				}
1346 				error(arg);
1347 				break;
1348 			case 's':
1349 				if (strcmp(arg, "-xs") == 0 ||
1350 				    strcmp(arg, "-xspace") == 0 ||
1351 				    strcmp(arg, "-xstrconst") == 0)
1352 					break;
1353 				error(arg);
1354 				break;
1355 			case 't':
1356 				if (strcmp(arg, "-xtransition") == 0) {
1357 					newae(ctx->i_ae, "-Wtransition");
1358 					break;
1359 				}
1360 				if (strcmp(arg, "-xtrigraphs=yes") == 0) {
1361 					newae(ctx->i_ae, "-trigraphs");
1362 					break;
1363 				}
1364 				if (strcmp(arg, "-xtrigraphs=no") == 0) {
1365 					newae(ctx->i_ae, "-notrigraphs");
1366 					break;
1367 				}
1368 				if (strncmp(arg, "-xtarget=", 9) == 0) {
1369 					xlate(ctx->i_ae, arg + 9, xtarget_tbl);
1370 					break;
1371 				}
1372 				error(arg);
1373 				break;
1374 			case 'e':
1375 			case 'h':
1376 			case 'l':
1377 			default:
1378 				error(arg);
1379 				break;
1380 			}
1381 			break;
1382 		case 'Y':
1383 			if (arglen == 1) {
1384 				if ((arg = *++ctx->i_oldargv) == NULL ||
1385 				    *arg == '\0')
1386 					error("-Y");
1387 				ctx->i_oldargc--;
1388 				arglen = strlen(arg + 1);
1389 			} else {
1390 				arg += 2;
1391 			}
1392 			/* Just ignore -YS,... for now */
1393 			if (strncmp(arg, "S,", 2) == 0)
1394 				break;
1395 			if (strncmp(arg, "l,", 2) == 0) {
1396 				char *s = strdup(arg);
1397 				s[0] = '-';
1398 				s[1] = 'B';
1399 				newae(ctx->i_ae, s);
1400 				free(s);
1401 				break;
1402 			}
1403 			if (strncmp(arg, "I,", 2) == 0) {
1404 				char *s = strdup(arg);
1405 				s[0] = '-';
1406 				s[1] = 'I';
1407 				newae(ctx->i_ae, "-nostdinc");
1408 				newae(ctx->i_ae, s);
1409 				free(s);
1410 				break;
1411 			}
1412 			error(arg);
1413 			break;
1414 		case 'Q':
1415 			/*
1416 			 * We could map -Qy into -Wl,-Qy etc.
1417 			 */
1418 		default:
1419 			error(arg);
1420 			break;
1421 		}
1422 	}
1423 
1424 	if (c_files > 1 && (ctx->i_flags & CW_F_SHADOW) &&
1425 	    op != CW_O_PREPROCESS) {
1426 		(void) fprintf(stderr, "%s: error: multiple source files are "
1427 		    "allowed only with -E or -P\n", progname);
1428 		exit(2);
1429 	}
1430 
1431 	/*
1432 	 * Make sure that we do not have any unintended interactions between
1433 	 * the xarch options passed in and the version of the Studio compiler
1434 	 * used.
1435 	 */
1436 	if ((mflag & (SS11|SS12)) == (SS11|SS12)) {
1437 		(void) fprintf(stderr,
1438 		    "Conflicting \"-xarch=\" flags (both Studio 11 and 12)\n");
1439 		exit(2);
1440 	}
1441 
1442 	switch (mflag) {
1443 	case 0:
1444 		/* FALLTHROUGH */
1445 	case M32:
1446 #if defined(__sparc)
1447 		/*
1448 		 * Only -m32 is defined and so put in the missing xarch
1449 		 * translation.
1450 		 */
1451 		newae(ctx->i_ae, "-mcpu=v8");
1452 		newae(ctx->i_ae, "-mno-v8plus");
1453 #endif
1454 		break;
1455 	case M64:
1456 #if defined(__sparc)
1457 		/*
1458 		 * Only -m64 is defined and so put in the missing xarch
1459 		 * translation.
1460 		 */
1461 		newae(ctx->i_ae, "-mcpu=v9");
1462 #endif
1463 		break;
1464 	case SS12:
1465 #if defined(__sparc)
1466 		/* no -m32/-m64 flag used - this is an error for sparc builds */
1467 		(void) fprintf(stderr, "No -m32/-m64 flag defined\n");
1468 		exit(2);
1469 #endif
1470 		break;
1471 	case SS11:
1472 		/* FALLTHROUGH */
1473 	case (SS11|M32):
1474 	case (SS11|M64):
1475 		break;
1476 	case (SS12|M32):
1477 #if defined(__sparc)
1478 		/*
1479 		 * Need to add in further 32 bit options because with SS12
1480 		 * the xarch=sparcvis option can be applied to 32 or 64
1481 		 * bit, and so the translatation table (xtbl) cannot handle
1482 		 * that.
1483 		 */
1484 		newae(ctx->i_ae, "-mv8plus");
1485 #endif
1486 		break;
1487 	case (SS12|M64):
1488 		break;
1489 	default:
1490 		(void) fprintf(stderr,
1491 		    "Incompatible -xarch= and/or -m32/-m64 options used.\n");
1492 		exit(2);
1493 	}
1494 	if (op == CW_O_LINK && (ctx->i_flags & CW_F_SHADOW))
1495 		exit(0);
1496 
1497 	if (model && !pic)
1498 		newae(ctx->i_ae, model);
1499 	if (!nolibc)
1500 		newae(ctx->i_ae, "-lc");
1501 	if (!seen_o && (ctx->i_flags & CW_F_SHADOW)) {
1502 		newae(ctx->i_ae, "-o");
1503 		newae(ctx->i_ae, ctx->i_discard);
1504 	}
1505 }
1506 
1507 static void
1508 do_cc(cw_ictx_t *ctx)
1509 {
1510 	int in_output = 0, seen_o = 0;
1511 	cw_op_t op = CW_O_LINK;
1512 
1513 	if (ctx->i_flags & CW_F_PROG) {
1514 		newae(ctx->i_ae, "-V");
1515 		return;
1516 	}
1517 
1518 	while (--ctx->i_oldargc > 0) {
1519 		char *arg = *++ctx->i_oldargv;
1520 
1521 		if (*arg != '-') {
1522 			if (in_output == 0 || !(ctx->i_flags & CW_F_SHADOW)) {
1523 				newae(ctx->i_ae, arg);
1524 			} else {
1525 				in_output = 0;
1526 				newae(ctx->i_ae, ctx->i_discard);
1527 			}
1528 			continue;
1529 		}
1530 		switch (*(arg + 1)) {
1531 		case '_':
1532 			if (strcmp(arg, "-_noecho") == 0) {
1533 				ctx->i_flags &= ~CW_F_ECHO;
1534 			} else if (strncmp(arg, "-_cc=", 5) == 0 ||
1535 			    strncmp(arg, "-_CC=", 5) == 0) {
1536 				newae(ctx->i_ae, arg + 5);
1537 			} else if (strncmp(arg, "-_gcc=", 6) != 0 &&
1538 			    strncmp(arg, "-_g++=", 6) != 0) {
1539 				(void) fprintf(stderr,
1540 				    "%s: invalid argument '%s'\n", progname,
1541 				    arg);
1542 				exit(2);
1543 			}
1544 			break;
1545 		case 'V':
1546 			ctx->i_flags &= ~CW_F_ECHO;
1547 			newae(ctx->i_ae, arg);
1548 			break;
1549 		case 'o':
1550 			seen_o = 1;
1551 			if (strlen(arg) == 2) {
1552 				in_output = 1;
1553 				newae(ctx->i_ae, arg);
1554 			} else if (ctx->i_flags & CW_F_SHADOW) {
1555 				newae(ctx->i_ae, "-o");
1556 				newae(ctx->i_ae, ctx->i_discard);
1557 			} else {
1558 				newae(ctx->i_ae, arg);
1559 			}
1560 			break;
1561 		case 'c':
1562 		case 'S':
1563 			if (strlen(arg) == 2)
1564 				op = CW_O_COMPILE;
1565 			newae(ctx->i_ae, arg);
1566 			break;
1567 		case 'E':
1568 		case 'P':
1569 			if (strlen(arg) == 2)
1570 				op = CW_O_PREPROCESS;
1571 		/*FALLTHROUGH*/
1572 		default:
1573 			newae(ctx->i_ae, arg);
1574 		}
1575 	}
1576 
1577 	if ((op == CW_O_LINK || op == CW_O_PREPROCESS) &&
1578 	    (ctx->i_flags & CW_F_SHADOW))
1579 		exit(0);
1580 
1581 	if (!seen_o && (ctx->i_flags & CW_F_SHADOW)) {
1582 		newae(ctx->i_ae, "-o");
1583 		newae(ctx->i_ae, ctx->i_discard);
1584 	}
1585 }
1586 
1587 static void
1588 prepctx(cw_ictx_t *ctx)
1589 {
1590 	const char *dir = NULL, *cmd;
1591 	char *program = NULL;
1592 	size_t len;
1593 
1594 	switch (CIDX(CC(ctx), ctx->i_flags)) {
1595 		case CIDX(CW_C_CC, 0):
1596 			program = getenv("CW_CC");
1597 			dir = getenv("CW_CC_DIR");
1598 			break;
1599 		case CIDX(CW_C_CC, CW_F_CXX):
1600 			program = getenv("CW_CPLUSPLUS");
1601 			dir = getenv("CW_CPLUSPLUS_DIR");
1602 			break;
1603 		case CIDX(CW_C_GCC, 0):
1604 			program = getenv("CW_GCC");
1605 			dir = getenv("CW_GCC_DIR");
1606 			break;
1607 		case CIDX(CW_C_GCC, CW_F_CXX):
1608 			program = getenv("CW_GPLUSPLUS");
1609 			dir = getenv("CW_GPLUSPLUS_DIR");
1610 			break;
1611 	}
1612 
1613 	if (program == NULL) {
1614 		if (dir == NULL)
1615 			dir = default_dir[CC(ctx)];
1616 		cmd = cmds[CIDX(CC(ctx), ctx->i_flags)];
1617 		len = strlen(dir) + strlen(cmd) + 2;
1618 		if ((program = malloc(len)) == NULL)
1619 			nomem();
1620 		(void) snprintf(program, len, "%s/%s", dir, cmd);
1621 	}
1622 
1623 	newae(ctx->i_ae, program);
1624 
1625 	if (ctx->i_flags & CW_F_PROG) {
1626 		(void) printf("%s: %s\n", (ctx->i_flags & CW_F_SHADOW) ?
1627 		    "shadow" : "primary", program);
1628 		(void) fflush(stdout);
1629 	}
1630 
1631 	if (!(ctx->i_flags & CW_F_XLATE))
1632 		return;
1633 
1634 	switch (CC(ctx)) {
1635 	case CW_C_CC:
1636 		do_cc(ctx);
1637 		break;
1638 	case CW_C_GCC:
1639 		do_gcc(ctx);
1640 		break;
1641 	}
1642 }
1643 
1644 static int
1645 invoke(cw_ictx_t *ctx)
1646 {
1647 	char **newargv;
1648 	int ac;
1649 	struct ae *a;
1650 
1651 	if ((newargv = calloc(sizeof (*newargv), ctx->i_ae->ael_argc + 1)) ==
1652 	    NULL)
1653 		nomem();
1654 
1655 	if (ctx->i_flags & CW_F_ECHO)
1656 		(void) fprintf(stderr, "+ ");
1657 
1658 	for (ac = 0, a = ctx->i_ae->ael_head; a; a = a->ae_next, ac++) {
1659 		newargv[ac] = a->ae_arg;
1660 		if (ctx->i_flags & CW_F_ECHO)
1661 			(void) fprintf(stderr, "%s ", a->ae_arg);
1662 		if (a == ctx->i_ae->ael_tail)
1663 			break;
1664 	}
1665 
1666 	if (ctx->i_flags & CW_F_ECHO) {
1667 		(void) fprintf(stderr, "\n");
1668 		(void) fflush(stderr);
1669 	}
1670 
1671 	if (!(ctx->i_flags & CW_F_EXEC))
1672 		return (0);
1673 
1674 	/*
1675 	 * We must fix up the environment here so that the
1676 	 * dependency files are not trampled by the shadow compiler.
1677 	 */
1678 	if ((ctx->i_flags & CW_F_SHADOW) &&
1679 	    (unsetenv("SUNPRO_DEPENDENCIES") != 0 ||
1680 	    unsetenv("DEPENDENCIES_OUTPUT") != 0)) {
1681 		(void) fprintf(stderr, "error: environment setup failed: %s\n",
1682 		    strerror(errno));
1683 		return (-1);
1684 	}
1685 
1686 	(void) execv(newargv[0], newargv);
1687 	cw_perror("couldn't run %s", newargv[0]);
1688 
1689 	return (-1);
1690 }
1691 
1692 static int
1693 reap(cw_ictx_t *ctx)
1694 {
1695 	int status, ret = 0;
1696 	char buf[1024];
1697 	struct stat s;
1698 
1699 	/*
1700 	 * Only wait for one specific child.
1701 	 */
1702 	if (ctx->i_pid <= 0)
1703 		return (-1);
1704 
1705 	do {
1706 		if (waitpid(ctx->i_pid, &status, 0) < 0) {
1707 			cw_perror("cannot reap child");
1708 			return (-1);
1709 		}
1710 		if (status != 0) {
1711 			if (WIFSIGNALED(status)) {
1712 				ret = -WTERMSIG(status);
1713 				break;
1714 			} else if (WIFEXITED(status)) {
1715 				ret = WEXITSTATUS(status);
1716 				break;
1717 			}
1718 		}
1719 	} while (!WIFEXITED(status) && !WIFSIGNALED(status));
1720 
1721 	(void) unlink(ctx->i_discard);
1722 
1723 	if (stat(ctx->i_stderr, &s) < 0) {
1724 		cw_perror("stat failed on child cleanup");
1725 		return (-1);
1726 	}
1727 	if (s.st_size != 0) {
1728 		FILE *f;
1729 
1730 		if ((f = fopen(ctx->i_stderr, "r")) != NULL) {
1731 			while (fgets(buf, sizeof (buf), f))
1732 				(void) fprintf(stderr, "%s", buf);
1733 			(void) fflush(stderr);
1734 			(void) fclose(f);
1735 		}
1736 	}
1737 	(void) unlink(ctx->i_stderr);
1738 	free(ctx->i_stderr);
1739 
1740 	/*
1741 	 * cc returns an error code when given -V; we want that to succeed.
1742 	 */
1743 	if (ctx->i_flags & CW_F_PROG)
1744 		return (0);
1745 
1746 	return (ret);
1747 }
1748 
1749 static int
1750 exec_ctx(cw_ictx_t *ctx, int block)
1751 {
1752 	char *file;
1753 
1754 	/*
1755 	 * To avoid offending cc's sensibilities, the name of its output
1756 	 * file must end in '.o'.
1757 	 */
1758 	if ((file = tempnam(NULL, ".cw")) == NULL) {
1759 		nomem();
1760 		return (-1);
1761 	}
1762 	(void) strlcpy(ctx->i_discard, file, MAXPATHLEN);
1763 	(void) strlcat(ctx->i_discard, ".o", MAXPATHLEN);
1764 	free(file);
1765 
1766 	if ((ctx->i_stderr = tempnam(NULL, ".cw")) == NULL) {
1767 		nomem();
1768 		return (-1);
1769 	}
1770 
1771 	if ((ctx->i_pid = fork()) == 0) {
1772 		int fd;
1773 
1774 		(void) fclose(stderr);
1775 		if ((fd = open(ctx->i_stderr, O_WRONLY | O_CREAT | O_EXCL,
1776 		    0666)) < 0) {
1777 			cw_perror("open failed for standard error");
1778 			exit(1);
1779 		}
1780 		if (dup2(fd, 2) < 0) {
1781 			cw_perror("dup2 failed for standard error");
1782 			exit(1);
1783 		}
1784 		if (fd != 2)
1785 			(void) close(fd);
1786 		if (freopen("/dev/fd/2", "w", stderr) == NULL) {
1787 			cw_perror("freopen failed for /dev/fd/2");
1788 			exit(1);
1789 		}
1790 		prepctx(ctx);
1791 		exit(invoke(ctx));
1792 	}
1793 
1794 	if (ctx->i_pid < 0) {
1795 		cw_perror("fork failed");
1796 		return (1);
1797 	}
1798 
1799 	if (block)
1800 		return (reap(ctx));
1801 
1802 	return (0);
1803 }
1804 
1805 int
1806 main(int argc, char **argv)
1807 {
1808 	cw_ictx_t *ctx = newictx();
1809 	cw_ictx_t *ctx_shadow = newictx();
1810 	const char *dir;
1811 	int do_serial, do_shadow;
1812 	int ret = 0;
1813 
1814 	if ((progname = strrchr(argv[0], '/')) == NULL)
1815 		progname = argv[0];
1816 	else
1817 		progname++;
1818 
1819 	if (ctx == NULL || ctx_shadow == NULL)
1820 		nomem();
1821 
1822 	ctx->i_flags = CW_F_ECHO|CW_F_XLATE;
1823 
1824 	/*
1825 	 * Figure out where to get our tools from.  This depends on
1826 	 * the environment variables set at run time.
1827 	 */
1828 	if ((dir = getenv("SPRO_VROOT")) != NULL) {
1829 		(void) snprintf(default_dir[CW_C_CC], MAXPATHLEN,
1830 		    "%s/bin", dir);
1831 	} else if ((dir = getenv("SPRO_ROOT")) != NULL) {
1832 		(void) snprintf(default_dir[CW_C_CC], MAXPATHLEN,
1833 		    "%s/SS12/bin", dir);
1834 	} else if ((dir = getenv("BUILD_TOOLS")) != NULL) {
1835 		(void) snprintf(default_dir[CW_C_CC], MAXPATHLEN,
1836 		    "%s/SUNWspro/SS12/bin", dir);
1837 	}
1838 
1839 	if ((dir = getenv("GCC_ROOT")) != NULL) {
1840 		(void) snprintf(default_dir[CW_C_GCC], MAXPATHLEN,
1841 		    "%s/bin", dir);
1842 	}
1843 
1844 	do_shadow = (getenv("CW_NO_SHADOW") ? 0 : 1);
1845 	do_serial = (getenv("CW_SHADOW_SERIAL") ? 1 : 0);
1846 
1847 	if (getenv("CW_NO_EXEC") == NULL)
1848 		ctx->i_flags |= CW_F_EXEC;
1849 
1850 	/*
1851 	 * The first argument must be one of "-_cc", "-_gcc", "-_CC", or "-_g++"
1852 	 */
1853 	if (argc == 1)
1854 		usage();
1855 	argc--;
1856 	argv++;
1857 	if (strcmp(argv[0], "-_cc") == 0) {
1858 		ctx->i_compiler = CW_C_CC;
1859 	} else if (strcmp(argv[0], "-_gcc") == 0) {
1860 		ctx->i_compiler = CW_C_GCC;
1861 	} else if (strcmp(argv[0], "-_CC") == 0) {
1862 		ctx->i_compiler = CW_C_CC;
1863 		ctx->i_flags |= CW_F_CXX;
1864 	} else if (strcmp(argv[0], "-_g++") == 0) {
1865 		ctx->i_compiler = CW_C_GCC;
1866 		ctx->i_flags |= CW_F_CXX;
1867 	} else {
1868 		/* assume "-_gcc" by default */
1869 		argc++;
1870 		argv--;
1871 		ctx->i_compiler = CW_C_GCC;
1872 	}
1873 
1874 	/*
1875 	 * -_compiler - tell us the path to the primary compiler only
1876 	 */
1877 	if (argc > 1 && strcmp(argv[1], "-_compiler") == 0) {
1878 		ctx->i_flags &= ~CW_F_XLATE;
1879 		prepctx(ctx);
1880 		(void) printf("%s\n", ctx->i_ae->ael_head->ae_arg);
1881 		return (0);
1882 	}
1883 
1884 	/*
1885 	 * -_versions - tell us the cw version, paths to all compilers, and
1886 	 *		ask each for its version if we know how.
1887 	 */
1888 	if (argc > 1 && strcmp(argv[1], "-_versions") == 0) {
1889 		(void) printf("cw version %s", CW_VERSION);
1890 		if (!do_shadow)
1891 			(void) printf(" (SHADOW MODE DISABLED)");
1892 		(void) printf("\n");
1893 		(void) fflush(stdout);
1894 		ctx->i_flags &= ~CW_F_ECHO;
1895 		ctx->i_flags |= CW_F_PROG|CW_F_EXEC;
1896 		argc--;
1897 		argv++;
1898 		do_serial = 1;
1899 	}
1900 
1901 	ctx->i_oldargc = argc;
1902 	ctx->i_oldargv = argv;
1903 
1904 	ret |= exec_ctx(ctx, do_serial);
1905 
1906 	if (do_shadow) {
1907 		(void) memcpy(ctx_shadow, ctx, sizeof (cw_ictx_t));
1908 		ctx_shadow->i_flags |= CW_F_SHADOW;
1909 		ret |= exec_ctx(ctx_shadow, 1);
1910 	}
1911 
1912 	if (!do_serial)
1913 		ret |= reap(ctx);
1914 
1915 	return (ret);
1916 }
1917