xref: /illumos-gate/usr/src/tools/aw/aw.c (revision 4ac5eacf)
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 2010 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * Wrapper for the GNU assembler to make it accept the Sun assembler
29  * arguments where possible.
30  *
31  * There are several limitations; the Sun assembler takes multiple
32  * source files, we only take one.
33  *
34  * -b, -s, -xF, -T plain not supported.
35  * -S isn't supported either, because while GNU as does generate
36  * listings with -a, there's no obvious mapping between sub-options.
37  * -K pic, -K PIC not supported either, though it's not clear what
38  * these actually do ..
39  * -Qy (not supported) adds a string to the .comment section
40  * describing the assembler version, while
41  * -Qn (supported) suppresses the string (also the default).
42  *
43  * We also add '-#' support to see invocation lines..
44  * We also add '-xarch=amd64' in case we need to feed the assembler
45  * something different (or in case we need to invoke a different binary
46  * altogether!)
47  */
48 
49 #include <sys/types.h>
50 #include <sys/wait.h>
51 #include <stdio.h>
52 #include <unistd.h>
53 #include <string.h>
54 #include <stdlib.h>
55 #include <sys/param.h>
56 
57 static const char *progname;
58 static int verbose;
59 
60 struct aelist {
61 	int ael_argc;
62 	struct ae {
63 		struct ae *ae_next;
64 		char *ae_arg;
65 	} *ael_head, *ael_tail;
66 };
67 
68 static struct aelist *
newael(void)69 newael(void)
70 {
71 	return (calloc(sizeof (struct aelist), 1));
72 }
73 
74 static void
newae(struct aelist * ael,const char * arg)75 newae(struct aelist *ael, const char *arg)
76 {
77 	struct ae *ae;
78 
79 	ae = calloc(sizeof (*ae), 1);
80 	ae->ae_arg = strdup(arg);
81 	if (ael->ael_tail == NULL)
82 		ael->ael_head = ae;
83 	else
84 		ael->ael_tail->ae_next = ae;
85 	ael->ael_tail = ae;
86 	ael->ael_argc++;
87 }
88 
89 static void
fixae_arg(struct ae * ae,const char * newarg)90 fixae_arg(struct ae *ae, const char *newarg)
91 {
92 	free(ae->ae_arg);
93 	ae->ae_arg = strdup(newarg);
94 }
95 
96 static char **
aeltoargv(struct aelist * ael)97 aeltoargv(struct aelist *ael)
98 {
99 	struct ae *ae;
100 	char **argv;
101 	int argc;
102 
103 	argv = calloc(sizeof (*argv), ael->ael_argc + 1);
104 
105 	for (argc = 0, ae = ael->ael_head; ae; ae = ae->ae_next, argc++) {
106 		argv[argc] = ae->ae_arg;
107 		if (ae == ael->ael_tail)
108 			break;
109 	}
110 
111 	return (argv);
112 }
113 
114 static int
error(const char * arg)115 error(const char *arg)
116 {
117 	(void) fprintf(stderr,
118 	    "%s: as->gas mapping failed at or near arg '%s'\n", progname, arg);
119 	return (2);
120 }
121 
122 static int
usage(const char * arg)123 usage(const char *arg)
124 {
125 	if (arg != NULL)
126 		(void) fprintf(stderr, "error: %s\n", arg);
127 	(void) fprintf(stderr, "Usage: %s [-V] [-#]\n"
128 	    "\t[-xarch=architecture]\n"
129 	    "\t[-o objfile] [-L]\n"
130 	    "\t[-P [[-Ipath] [-Dname] [-Dname=def] [-Uname]]...]\n"
131 	    "\t[-m] [-n] file.s ...\n", progname);
132 	return (3);
133 }
134 
135 static void
copyuntil(FILE * in,FILE * out,int termchar)136 copyuntil(FILE *in, FILE *out, int termchar)
137 {
138 	int c;
139 
140 	while ((c = fgetc(in)) != EOF) {
141 		if (out && fputc(c, out) == EOF)
142 			exit(1);
143 		if (c == termchar)
144 			break;
145 	}
146 }
147 
148 /*
149  * Variant of copyuntil(), used for copying the path used
150  * for .file directives. This version removes the workspace
151  * from the head of the path, or failing that, attempts to remove
152  * /usr/include. This is a workaround for the way gas handles
153  * these directives. The objects produced by gas contain STT_FILE
154  * symbols for every .file directive. These FILE symbols contain our
155  * workspace paths, leading to wsdiff incorrectly flagging them as
156  * having changed. By clipping off the workspace from these paths,
157  * we eliminate these false positives.
158  */
159 static void
copyuntil_path(FILE * in,FILE * out,int termchar,const char * wspace,size_t wspace_len)160 copyuntil_path(FILE *in, FILE *out, int termchar,
161     const char *wspace, size_t wspace_len)
162 {
163 #define	PROTO_INC "/proto/root_i386/usr/include/"
164 #define	SYS_INC "/usr/include/"
165 
166 	static const size_t proto_inc_len = sizeof (PROTO_INC) - 1;
167 	static const size_t sys_inc_len = sizeof (SYS_INC) - 1;
168 
169 	/*
170 	 * Dynamically sized buffer for reading paths. Retained
171 	 * and reused between calls.
172 	 */
173 	static char	*buf = NULL;
174 	static size_t	bufsize = 0;
175 
176 	size_t	bufcnt = 0;
177 	char	*bufptr;
178 	int	c;
179 
180 	/* Read the path into the buffer */
181 	while ((c = fgetc(in)) != EOF) {
182 		/*
183 		 * If we need a buffer, or need a larger buffer,
184 		 * fix that here.
185 		 */
186 		if (bufcnt >= bufsize) {
187 			bufsize = (bufsize == 0) ? MAXPATHLEN : (bufsize * 2);
188 			buf = realloc(buf, bufsize + 1); /* + room for NULL */
189 			if (buf == NULL) {
190 				perror("realloc");
191 				exit(1);
192 			}
193 		}
194 
195 		buf[bufcnt++] = c;
196 		if (c == termchar)
197 			break;
198 	}
199 	if (bufcnt == 0)
200 		return;
201 
202 	/*
203 	 * We have a non-empty buffer, and thus the opportunity
204 	 * to do some surgery on it before passing it to the output.
205 	 */
206 	buf[bufcnt] = '\0';
207 	bufptr = buf;
208 
209 	/*
210 	 * If our workspace is at the start, remove it.
211 	 * If not, then look for the system /usr/include instead.
212 	 */
213 	if ((wspace_len > 0) && (wspace_len < bufcnt) &&
214 	    (strncmp(bufptr, wspace, wspace_len) == 0)) {
215 		bufptr += wspace_len;
216 		bufcnt -= wspace_len;
217 
218 		/*
219 		 * Further opportunity: Also clip the prefix
220 		 * that leads to /usr/include in the proto.
221 		 */
222 		if ((proto_inc_len < bufcnt) &&
223 		    (strncmp(bufptr, PROTO_INC, proto_inc_len) == 0)) {
224 			bufptr += proto_inc_len;
225 			bufcnt -= proto_inc_len;
226 		}
227 	} else if ((sys_inc_len < bufcnt) &&
228 	    (strncmp(bufptr, SYS_INC, sys_inc_len) == 0)) {
229 		bufptr += sys_inc_len;
230 		bufcnt -= sys_inc_len;
231 	}
232 
233 	/* Output whatever is left */
234 	if (out && (fwrite(bufptr, 1, bufcnt, out) != bufcnt)) {
235 		perror("fwrite");
236 		exit(1);
237 	}
238 
239 #undef PROTO_INC
240 #undef SYS_INC
241 }
242 
243 /*
244  * The idea here is to take directives like this emitted
245  * by cpp:
246  *
247  *	# num
248  *
249  * and convert them to directives like this that are
250  * understood by the GNU assembler:
251  *
252  *	.line num
253  *
254  * and similarly:
255  *
256  *	# num "string" optional stuff
257  *
258  * is converted to
259  *
260  *	.line num
261  *	.file "string"
262  *
263  * While this could be done with a sequence of sed
264  * commands, this is simpler and faster..
265  */
266 static pid_t
filter(int pipein,int pipeout)267 filter(int pipein, int pipeout)
268 {
269 	pid_t pid;
270 	FILE *in, *out;
271 	char *wspace;
272 	size_t wspace_len;
273 
274 	if (verbose)
275 		(void) fprintf(stderr, "{#line filter} ");
276 
277 	switch (pid = fork()) {
278 	case 0:
279 		if (dup2(pipein, 0) == -1 ||
280 		    dup2(pipeout, 1) == -1) {
281 			perror("dup2");
282 			exit(1);
283 		}
284 		closefrom(3);
285 		break;
286 	case -1:
287 		perror("fork");
288 		exit(1);
289 	default:
290 		return (pid);
291 	}
292 
293 	in = fdopen(0, "r");
294 	out = fdopen(1, "w");
295 
296 	/*
297 	 * Key off the CODEMGR_WS environment variable to detect
298 	 * if we're in an activated workspace, and to get the
299 	 * path to the workspace.
300 	 */
301 	wspace = getenv("CODEMGR_WS");
302 	if (wspace != NULL)
303 		wspace_len = strlen(wspace);
304 
305 	while (!feof(in)) {
306 		int c, num;
307 
308 		switch (c = fgetc(in)) {
309 		case '#':
310 			switch (fscanf(in, " %d", &num)) {
311 			case 0:
312 				/*
313 				 * discard comment lines completely
314 				 * discard ident strings completely too.
315 				 * (GNU as politely ignores them..)
316 				 */
317 				copyuntil(in, NULL, '\n');
318 				break;
319 			default:
320 				(void) fprintf(stderr, "fscanf botch?");
321 				/*FALLTHROUGH*/
322 			case EOF:
323 				exit(1);
324 				/*NOTREACHED*/
325 			case 1:
326 				/*
327 				 * This line has a number at the beginning;
328 				 * if it has a string after the number, then
329 				 * it's a filename.
330 				 *
331 				 * If this is an activated workspace, use
332 				 * copyuntil_path() to do path rewriting
333 				 * that will prevent workspace paths from
334 				 * being burned into the resulting object.
335 				 * If not in an activated workspace, then
336 				 * copy the existing path straight through
337 				 * without interpretation.
338 				 */
339 				if (fgetc(in) == ' ' && fgetc(in) == '"') {
340 					(void) fprintf(out, "\t.file \"");
341 					if (wspace != NULL)
342 						copyuntil_path(in, out, '"',
343 						    wspace, wspace_len);
344 					else
345 						copyuntil(in, out, '"');
346 					(void) fputc('\n', out);
347 				}
348 				(void) fprintf(out, "\t.line %d\n", num - 1);
349 				/*
350 				 * discard the rest of the line
351 				 */
352 				copyuntil(in, NULL, '\n');
353 				break;
354 			}
355 			break;
356 		case '\n':
357 			/*
358 			 * preserve newlines
359 			 */
360 			(void) fputc(c, out);
361 			break;
362 		case EOF:
363 			/*
364 			 * don't write EOF!
365 			 */
366 			break;
367 		default:
368 			/*
369 			 * lines that don't begin with '#' are copied
370 			 */
371 			(void) fputc(c, out);
372 			copyuntil(in, out, '\n');
373 			break;
374 		}
375 
376 		if (ferror(out))
377 			exit(1);
378 	}
379 
380 	exit(0);
381 	/*NOTREACHED*/
382 }
383 
384 static pid_t
invoke(char ** argv,int pipein,int pipeout)385 invoke(char **argv, int pipein, int pipeout)
386 {
387 	pid_t pid;
388 
389 	if (verbose) {
390 		char **dargv = argv;
391 
392 		while (*dargv)
393 			(void) fprintf(stderr, "%s ", *dargv++);
394 	}
395 
396 	switch (pid = fork()) {
397 	case 0:
398 		if (pipein >= 0 && dup2(pipein, 0) == -1) {
399 			perror("dup2");
400 			exit(1);
401 		}
402 		if (pipeout >= 0 && dup2(pipeout, 1) == -1) {
403 			perror("dup2");
404 			exit(1);
405 		}
406 		closefrom(3);
407 		(void) execvp(argv[0], argv);
408 		perror("execvp");
409 		(void) fprintf(stderr, "%s: couldn't run %s\n",
410 		    progname, argv[0]);
411 		break;
412 	case -1:
413 		perror("fork");
414 		exit(1);
415 	default:
416 		return (pid);
417 	}
418 	exit(2);
419 	/*NOTREACHED*/
420 }
421 
422 static int
pipeline(char ** ppargv,char ** asargv)423 pipeline(char **ppargv, char **asargv)
424 {
425 	int pipedes[4];
426 	int active = 0;
427 	int rval = 0;
428 	pid_t pid_pp, pid_f, pid_as;
429 
430 	if (pipe(pipedes) == -1 || pipe(pipedes + 2) == -1) {
431 		perror("pipe");
432 		return (4);
433 	}
434 
435 	if ((pid_pp = invoke(ppargv, -1, pipedes[0])) > 0)
436 		active++;
437 
438 	if (verbose)
439 		(void) fprintf(stderr, "| ");
440 
441 	if ((pid_f = filter(pipedes[1], pipedes[2])) > 0)
442 		active++;
443 
444 	if (verbose)
445 		(void) fprintf(stderr, "| ");
446 
447 	if ((pid_as = invoke(asargv, pipedes[3], -1)) > 0)
448 		active++;
449 
450 	if (verbose) {
451 		(void) fprintf(stderr, "\n");
452 		(void) fflush(stderr);
453 	}
454 
455 	closefrom(3);
456 
457 	if (active != 3)
458 		return (5);
459 
460 	while (active != 0) {
461 		pid_t pid;
462 		int stat;
463 
464 		if ((pid = wait(&stat)) == -1) {
465 			rval++;
466 			break;
467 		}
468 
469 		if (!WIFEXITED(stat))
470 			continue;
471 
472 		if (pid == pid_pp || pid == pid_f || pid == pid_as) {
473 			active--;
474 			if (WEXITSTATUS(stat) != 0)
475 				rval++;
476 		}
477 	}
478 
479 	return (rval);
480 }
481 
482 int
main(int argc,char * argv[])483 main(int argc, char *argv[])
484 {
485 	struct aelist *cpp = NULL;
486 	struct aelist *m4 = NULL;
487 	struct aelist *as = newael();
488 	char **asargv;
489 	char *outfile = NULL;
490 	char *srcfile = NULL;
491 	const char *dir, *cmd;
492 	static char as_pgm[MAXPATHLEN];
493 	static char as64_pgm[MAXPATHLEN];
494 	static char m4_pgm[MAXPATHLEN];
495 	static char m4_cmdefs[MAXPATHLEN];
496 	static char cpp_pgm[MAXPATHLEN];
497 	int as64 = 0;
498 	int code;
499 
500 	if ((progname = strrchr(argv[0], '/')) == NULL)
501 		progname = argv[0];
502 	else
503 		progname++;
504 
505 	/*
506 	 * Helpful when debugging, or when changing tool versions..
507 	 */
508 	if ((cmd = getenv("AW_AS")) != NULL)
509 		strlcpy(as_pgm, cmd, sizeof (as_pgm));
510 	else {
511 		if ((dir = getenv("AW_AS_DIR")) == NULL)
512 			dir = DEFAULT_AS_DIR;	/* /usr/sfw/bin */
513 		(void) snprintf(as_pgm, sizeof (as_pgm), "%s/gas", dir);
514 	}
515 
516 	if ((cmd = getenv("AW_AS64")) != NULL)
517 		strlcpy(as64_pgm, cmd, sizeof (as64_pgm));
518 	else {
519 		if ((dir = getenv("AW_AS64_DIR")) == NULL)
520 			dir = DEFAULT_AS64_DIR;	/* /usr/sfw/bin */
521 		(void) snprintf(as64_pgm, sizeof (as_pgm), "%s/gas", dir);
522 	}
523 
524 	if ((cmd = getenv("AW_M4")) != NULL)
525 		strlcpy(m4_pgm, cmd, sizeof (m4_pgm));
526 	else {
527 		if ((dir = getenv("AW_M4_DIR")) == NULL)
528 			dir = DEFAULT_M4_DIR;	/* /usr/ccs/bin */
529 		(void) snprintf(m4_pgm, sizeof (m4_pgm), "%s/m4", dir);
530 	}
531 
532 	if ((cmd = getenv("AW_M4LIB")) != NULL)
533 		strlcpy(m4_cmdefs, cmd, sizeof (m4_cmdefs));
534 	else {
535 		if ((dir = getenv("AW_M4LIB_DIR")) == NULL)
536 			dir = DEFAULT_M4LIB_DIR;	/* /usr/ccs/lib */
537 		(void) snprintf(m4_cmdefs, sizeof (m4_cmdefs),
538 		    "%s/cm4defs", dir);
539 	}
540 
541 	if ((cmd = getenv("AW_CPP")) != NULL)
542 		strlcpy(cpp_pgm, cmd, sizeof (cpp_pgm));
543 	else {
544 		if ((dir = getenv("AW_CPP_DIR")) == NULL)
545 			dir = DEFAULT_CPP_DIR;	/* /usr/ccs/lib */
546 		(void) snprintf(cpp_pgm, sizeof (cpp_pgm), "%s/cpp", dir);
547 	}
548 
549 	newae(as, as_pgm);
550 	newae(as, "--warn");
551 	newae(as, "--fatal-warnings");
552 	newae(as, "--traditional-format");
553 
554 	/*
555 	 * Walk the argument list, translating as we go ..
556 	 */
557 	while (--argc > 0) {
558 		char *arg;
559 		int arglen;
560 
561 		arg = *++argv;
562 		arglen = strlen(arg);
563 
564 		if (*arg != '-') {
565 			char *filename;
566 
567 			/*
568 			 * filenames ending in '.s' are taken to be
569 			 * assembler files, and provide the default
570 			 * basename of the output file.
571 			 *
572 			 * other files are passed through to the
573 			 * preprocessor, if present, or to gas if not.
574 			 */
575 			filename = arg;
576 			if ((arglen > 2) &&
577 			    ((strcmp(arg + arglen - 2, ".s") == 0) ||
578 			    (strcmp(arg + arglen - 2, ".S") == 0))) {
579 				/*
580 				 * Though 'as' allows multiple assembler
581 				 * files to be processed in one invocation
582 				 * of the assembler, ON only processes one
583 				 * file at a time, which makes things a lot
584 				 * simpler!
585 				 */
586 				if (srcfile == NULL)
587 					srcfile = arg;
588 				else
589 					return (usage(
590 					    "one assembler file at a time"));
591 
592 				/*
593 				 * If we haven't seen a -o option yet,
594 				 * default the output to the basename
595 				 * of the input, substituting a .o on the end
596 				 */
597 				if (outfile == NULL) {
598 					char *argcopy;
599 
600 					argcopy = strdup(arg);
601 					argcopy[arglen - 1] = 'o';
602 
603 					if ((outfile = strrchr(
604 					    argcopy, '/')) == NULL)
605 						outfile = argcopy;
606 					else
607 						outfile++;
608 				}
609 			}
610 			if (cpp)
611 				newae(cpp, filename);
612 			else if (m4)
613 				newae(m4, filename);
614 			else
615 				newae(as, filename);
616 			continue;
617 		} else
618 			arglen--;
619 
620 		switch (arg[1]) {
621 		case 'K':
622 			/*
623 			 * -K pic
624 			 * -K PIC
625 			 */
626 			if (arglen == 1) {
627 				if ((arg = *++argv) == NULL || *arg == '\0')
628 					return (usage("malformed -K"));
629 				argc--;
630 			} else {
631 				arg += 2;
632 			}
633 			if (strcmp(arg, "PIC") != 0 && strcmp(arg, "pic") != 0)
634 				return (usage("malformed -K"));
635 			break;		/* just ignore -Kpic for gcc */
636 		case 'Q':
637 			if (strcmp(arg, "-Qn") == 0)
638 				break;
639 			/*FALLTHROUGH*/
640 		case 'b':
641 		case 's':
642 		case 'T':
643 			/*
644 			 * -b	Extra symbol table for source browser ..
645 			 *	not relevant to gas, thus should error.
646 			 * -s	Put stabs in .stabs section not stabs.excl
647 			 *	not clear if there's an equivalent
648 			 * -T	4.x migration option
649 			 */
650 		default:
651 			return (error(arg));
652 		case 'x':
653 			/*
654 			 * Accept -xarch special case to invoke alternate
655 			 * assemblers or assembler flags for different
656 			 * architectures.
657 			 */
658 			if (strcmp(arg, "-xarch=amd64") == 0 ||
659 			    strcmp(arg, "-xarch=generic64") == 0) {
660 				as64++;
661 				fixae_arg(as->ael_head, as64_pgm);
662 				break;
663 			}
664 			/*
665 			 * XX64: Is this useful to gas?
666 			 */
667 			if (strcmp(arg, "-xmodel=kernel") == 0)
668 				break;
669 
670 			/*
671 			 * -xF	Generates performance analysis data
672 			 *	no equivalent
673 			 */
674 			return (error(arg));
675 		case 'V':
676 			newae(as, arg);
677 			break;
678 		case '#':
679 			verbose++;
680 			break;
681 		case 'L':
682 			newae(as, "--keep-locals");
683 			break;
684 		case 'n':
685 			newae(as, "--no-warn");
686 			break;
687 		case 'o':
688 			if (arglen != 1)
689 				return (usage("bad -o flag"));
690 			if ((arg = *++argv) == NULL || *arg == '\0')
691 				return (usage("bad -o flag"));
692 			outfile = arg;
693 			argc--;
694 			arglen = strlen(arg + 1);
695 			break;
696 		case 'm':
697 			if (cpp)
698 				return (usage("-m conflicts with -P"));
699 			if (m4 == NULL) {
700 				m4 = newael();
701 				newae(m4, m4_pgm);
702 				newae(m4, m4_cmdefs);
703 			}
704 			break;
705 		case 'P':
706 			if (m4)
707 				return (usage("-P conflicts with -m"));
708 			if (cpp == NULL) {
709 				cpp = newael();
710 				newae(cpp, cpp_pgm);
711 				newae(cpp, "-D__GNUC_AS__");
712 			}
713 			break;
714 		case 'D':
715 		case 'U':
716 			if (cpp)
717 				newae(cpp, arg);
718 			else if (m4)
719 				newae(m4, arg);
720 			else
721 				newae(as, arg);
722 			break;
723 		case 'I':
724 			if (cpp)
725 				newae(cpp, arg);
726 			else
727 				newae(as, arg);
728 			break;
729 		case '-':	/* a gas-specific option */
730 			newae(as, arg);
731 			break;
732 		}
733 	}
734 
735 #if defined(__i386)
736 	if (as64)
737 		newae(as, "--64");
738 	else
739 		newae(as, "--32");
740 #endif
741 
742 	if (srcfile == NULL)
743 		return (usage("no source file(s) specified"));
744 	if (outfile == NULL)
745 		outfile = "a.out";
746 	newae(as, "-o");
747 	newae(as, outfile);
748 
749 	asargv = aeltoargv(as);
750 	if (cpp) {
751 #if defined(__sparc)
752 		newae(cpp, "-Dsparc");
753 		newae(cpp, "-D__sparc");
754 		if (as64)
755 			newae(cpp, "-D__sparcv9");
756 		else
757 			newae(cpp, "-D__sparcv8");
758 #elif defined(__i386) || defined(__x86)
759 		if (as64) {
760 			newae(cpp, "-D__x86_64");
761 			newae(cpp, "-D__amd64");
762 		} else {
763 			newae(cpp, "-Di386");
764 			newae(cpp, "-D__i386");
765 		}
766 #else
767 #error	"need isa-dependent defines"
768 #endif
769 		code = pipeline(aeltoargv(cpp), asargv);
770 	} else if (m4)
771 		code = pipeline(aeltoargv(m4), asargv);
772 	else {
773 		/*
774 		 * XXX	should arrange to fork/exec so that we
775 		 *	can unlink the output file if errors are
776 		 *	detected..
777 		 */
778 		(void) execvp(asargv[0], asargv);
779 		perror("execvp");
780 		(void) fprintf(stderr, "%s: couldn't run %s\n",
781 		    progname, asargv[0]);
782 		code = 7;
783 	}
784 	if (code != 0)
785 		(void) unlink(outfile);
786 	return (code);
787 }
788