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 * 69 newael(void) 70 { 71 return (calloc(sizeof (struct aelist), 1)); 72 } 73 74 static void 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 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 ** 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 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 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 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 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 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 default: 289 return (pid); 290 } 291 292 in = fdopen(0, "r"); 293 out = fdopen(1, "w"); 294 295 /* 296 * Key off the CODEMGR_WS environment variable to detect 297 * if we're in an activated workspace, and to get the 298 * path to the workspace. 299 */ 300 wspace = getenv("CODEMGR_WS"); 301 if (wspace != NULL) 302 wspace_len = strlen(wspace); 303 304 while (!feof(in)) { 305 int c, num; 306 307 switch (c = fgetc(in)) { 308 case '#': 309 switch (fscanf(in, " %d", &num)) { 310 case 0: 311 /* 312 * discard comment lines completely 313 * discard ident strings completely too. 314 * (GNU as politely ignores them..) 315 */ 316 copyuntil(in, NULL, '\n'); 317 break; 318 default: 319 (void) fprintf(stderr, "fscanf botch?"); 320 /*FALLTHROUGH*/ 321 case EOF: 322 exit(1); 323 /*NOTREACHED*/ 324 case 1: 325 /* 326 * This line has a number at the beginning; 327 * if it has a string after the number, then 328 * it's a filename. 329 * 330 * If this is an activated workspace, use 331 * copyuntil_path() to do path rewriting 332 * that will prevent workspace paths from 333 * being burned into the resulting object. 334 * If not in an activated workspace, then 335 * copy the existing path straight through 336 * without interpretation. 337 */ 338 if (fgetc(in) == ' ' && fgetc(in) == '"') { 339 (void) fprintf(out, "\t.file \""); 340 if (wspace != NULL) 341 copyuntil_path(in, out, '"', 342 wspace, wspace_len); 343 else 344 copyuntil(in, out, '"'); 345 (void) fputc('\n', out); 346 } 347 (void) fprintf(out, "\t.line %d\n", num - 1); 348 /* 349 * discard the rest of the line 350 */ 351 copyuntil(in, NULL, '\n'); 352 break; 353 } 354 break; 355 case '\n': 356 /* 357 * preserve newlines 358 */ 359 (void) fputc(c, out); 360 break; 361 case EOF: 362 /* 363 * don't write EOF! 364 */ 365 break; 366 default: 367 /* 368 * lines that don't begin with '#' are copied 369 */ 370 (void) fputc(c, out); 371 copyuntil(in, out, '\n'); 372 break; 373 } 374 375 if (ferror(out)) 376 exit(1); 377 } 378 379 exit(0); 380 /*NOTREACHED*/ 381 } 382 383 static pid_t 384 invoke(char **argv, int pipein, int pipeout) 385 { 386 pid_t pid; 387 388 if (verbose) { 389 char **dargv = argv; 390 391 while (*dargv) 392 (void) fprintf(stderr, "%s ", *dargv++); 393 } 394 395 switch (pid = fork()) { 396 case 0: 397 if (pipein >= 0 && dup2(pipein, 0) == -1) { 398 perror("dup2"); 399 exit(1); 400 } 401 if (pipeout >= 0 && dup2(pipeout, 1) == -1) { 402 perror("dup2"); 403 exit(1); 404 } 405 closefrom(3); 406 (void) execvp(argv[0], argv); 407 perror("execvp"); 408 (void) fprintf(stderr, "%s: couldn't run %s\n", 409 progname, argv[0]); 410 break; 411 case -1: 412 perror("fork"); 413 default: 414 return (pid); 415 } 416 exit(2); 417 /*NOTREACHED*/ 418 } 419 420 static int 421 pipeline(char **ppargv, char **asargv) 422 { 423 int pipedes[4]; 424 int active = 0; 425 int rval = 0; 426 pid_t pid_pp, pid_f, pid_as; 427 428 if (pipe(pipedes) == -1 || pipe(pipedes + 2) == -1) { 429 perror("pipe"); 430 return (4); 431 } 432 433 if ((pid_pp = invoke(ppargv, -1, pipedes[0])) > 0) 434 active++; 435 436 if (verbose) 437 (void) fprintf(stderr, "| "); 438 439 if ((pid_f = filter(pipedes[1], pipedes[2])) > 0) 440 active++; 441 442 if (verbose) 443 (void) fprintf(stderr, "| "); 444 445 if ((pid_as = invoke(asargv, pipedes[3], -1)) > 0) 446 active++; 447 448 if (verbose) { 449 (void) fprintf(stderr, "\n"); 450 (void) fflush(stderr); 451 } 452 453 closefrom(3); 454 455 if (active != 3) 456 return (5); 457 458 while (active != 0) { 459 pid_t pid; 460 int stat; 461 462 if ((pid = wait(&stat)) == -1) { 463 rval++; 464 break; 465 } 466 467 if (!WIFEXITED(stat)) 468 continue; 469 470 if (pid == pid_pp || pid == pid_f || pid == pid_as) { 471 active--; 472 if (WEXITSTATUS(stat) != 0) 473 rval++; 474 } 475 } 476 477 return (rval); 478 } 479 480 int 481 main(int argc, char *argv[]) 482 { 483 struct aelist *cpp = NULL; 484 struct aelist *m4 = NULL; 485 struct aelist *as = newael(); 486 char **asargv; 487 char *outfile = NULL; 488 char *srcfile = NULL; 489 const char *dir, *cmd; 490 static char as_pgm[MAXPATHLEN]; 491 static char as64_pgm[MAXPATHLEN]; 492 static char m4_pgm[MAXPATHLEN]; 493 static char m4_cmdefs[MAXPATHLEN]; 494 static char cpp_pgm[MAXPATHLEN]; 495 int as64 = 0; 496 int code; 497 498 if ((progname = strrchr(argv[0], '/')) == NULL) 499 progname = argv[0]; 500 else 501 progname++; 502 503 /* 504 * Helpful when debugging, or when changing tool versions.. 505 */ 506 if ((cmd = getenv("AW_AS")) != NULL) 507 strlcpy(as_pgm, cmd, sizeof (as_pgm)); 508 else { 509 if ((dir = getenv("AW_AS_DIR")) == NULL) 510 dir = DEFAULT_AS_DIR; /* /usr/sfw/bin */ 511 (void) snprintf(as_pgm, sizeof (as_pgm), "%s/gas", dir); 512 } 513 514 if ((cmd = getenv("AW_AS64")) != NULL) 515 strlcpy(as64_pgm, cmd, sizeof (as64_pgm)); 516 else { 517 if ((dir = getenv("AW_AS64_DIR")) == NULL) 518 dir = DEFAULT_AS64_DIR; /* /usr/sfw/bin */ 519 (void) snprintf(as64_pgm, sizeof (as_pgm), "%s/gas", dir); 520 } 521 522 if ((cmd = getenv("AW_M4")) != NULL) 523 strlcpy(m4_pgm, cmd, sizeof (m4_pgm)); 524 else { 525 if ((dir = getenv("AW_M4_DIR")) == NULL) 526 dir = DEFAULT_M4_DIR; /* /usr/ccs/bin */ 527 (void) snprintf(m4_pgm, sizeof (m4_pgm), "%s/m4", dir); 528 } 529 530 if ((cmd = getenv("AW_M4LIB")) != NULL) 531 strlcpy(m4_cmdefs, cmd, sizeof (m4_cmdefs)); 532 else { 533 if ((dir = getenv("AW_M4LIB_DIR")) == NULL) 534 dir = DEFAULT_M4LIB_DIR; /* /usr/ccs/lib */ 535 (void) snprintf(m4_cmdefs, sizeof (m4_cmdefs), 536 "%s/cm4defs", dir); 537 } 538 539 if ((cmd = getenv("AW_CPP")) != NULL) 540 strlcpy(cpp_pgm, cmd, sizeof (cpp_pgm)); 541 else { 542 if ((dir = getenv("AW_CPP_DIR")) == NULL) 543 dir = DEFAULT_CPP_DIR; /* /usr/ccs/lib */ 544 (void) snprintf(cpp_pgm, sizeof (cpp_pgm), "%s/cpp", dir); 545 } 546 547 newae(as, as_pgm); 548 newae(as, "--warn"); 549 newae(as, "--fatal-warnings"); 550 newae(as, "--traditional-format"); 551 552 /* 553 * Walk the argument list, translating as we go .. 554 */ 555 while (--argc > 0) { 556 char *arg; 557 int arglen; 558 559 arg = *++argv; 560 arglen = strlen(arg); 561 562 if (*arg != '-') { 563 char *filename; 564 565 /* 566 * filenames ending in '.s' are taken to be 567 * assembler files, and provide the default 568 * basename of the output file. 569 * 570 * other files are passed through to the 571 * preprocessor, if present, or to gas if not. 572 */ 573 filename = arg; 574 if ((arglen > 2) && 575 ((strcmp(arg + arglen - 2, ".s") == 0) || 576 (strcmp(arg + arglen - 2, ".S") == 0))) { 577 /* 578 * Though 'as' allows multiple assembler 579 * files to be processed in one invocation 580 * of the assembler, ON only processes one 581 * file at a time, which makes things a lot 582 * simpler! 583 */ 584 if (srcfile == NULL) 585 srcfile = arg; 586 else 587 return (usage( 588 "one assembler file at a time")); 589 590 /* 591 * If we haven't seen a -o option yet, 592 * default the output to the basename 593 * of the input, substituting a .o on the end 594 */ 595 if (outfile == NULL) { 596 char *argcopy; 597 598 argcopy = strdup(arg); 599 argcopy[arglen - 1] = 'o'; 600 601 if ((outfile = strrchr( 602 argcopy, '/')) == NULL) 603 outfile = argcopy; 604 else 605 outfile++; 606 } 607 } 608 if (cpp) 609 newae(cpp, filename); 610 else if (m4) 611 newae(m4, filename); 612 else 613 newae(as, filename); 614 continue; 615 } else 616 arglen--; 617 618 switch (arg[1]) { 619 case 'K': 620 /* 621 * -K pic 622 * -K PIC 623 */ 624 if (arglen == 1) { 625 if ((arg = *++argv) == NULL || *arg == '\0') 626 return (usage("malformed -K")); 627 argc--; 628 } else { 629 arg += 2; 630 } 631 if (strcmp(arg, "PIC") != 0 && strcmp(arg, "pic") != 0) 632 return (usage("malformed -K")); 633 break; /* just ignore -Kpic for gcc */ 634 case 'Q': 635 if (strcmp(arg, "-Qn") == 0) 636 break; 637 /*FALLTHROUGH*/ 638 case 'b': 639 case 's': 640 case 'T': 641 /* 642 * -b Extra symbol table for source browser .. 643 * not relevant to gas, thus should error. 644 * -s Put stabs in .stabs section not stabs.excl 645 * not clear if there's an equivalent 646 * -T 4.x migration option 647 */ 648 default: 649 return (error(arg)); 650 case 'x': 651 /* 652 * Accept -xarch special case to invoke alternate 653 * assemblers or assembler flags for different 654 * architectures. 655 */ 656 if (strcmp(arg, "-xarch=amd64") == 0 || 657 strcmp(arg, "-xarch=generic64") == 0) { 658 as64++; 659 fixae_arg(as->ael_head, as64_pgm); 660 break; 661 } 662 /* 663 * XX64: Is this useful to gas? 664 */ 665 if (strcmp(arg, "-xmodel=kernel") == 0) 666 break; 667 668 /* 669 * -xF Generates performance analysis data 670 * no equivalent 671 */ 672 return (error(arg)); 673 case 'V': 674 newae(as, arg); 675 break; 676 case '#': 677 verbose++; 678 break; 679 case 'L': 680 newae(as, "--keep-locals"); 681 break; 682 case 'n': 683 newae(as, "--no-warn"); 684 break; 685 case 'o': 686 if (arglen != 1) 687 return (usage("bad -o flag")); 688 if ((arg = *++argv) == NULL || *arg == '\0') 689 return (usage("bad -o flag")); 690 outfile = arg; 691 argc--; 692 arglen = strlen(arg + 1); 693 break; 694 case 'm': 695 if (cpp) 696 return (usage("-m conflicts with -P")); 697 if (m4 == NULL) { 698 m4 = newael(); 699 newae(m4, m4_pgm); 700 newae(m4, m4_cmdefs); 701 } 702 break; 703 case 'P': 704 if (m4) 705 return (usage("-P conflicts with -m")); 706 if (cpp == NULL) { 707 cpp = newael(); 708 newae(cpp, cpp_pgm); 709 newae(cpp, "-D__GNUC_AS__"); 710 } 711 break; 712 case 'D': 713 case 'U': 714 if (cpp) 715 newae(cpp, arg); 716 else if (m4) 717 newae(m4, arg); 718 else 719 newae(as, arg); 720 break; 721 case 'I': 722 if (cpp) 723 newae(cpp, arg); 724 else 725 newae(as, arg); 726 break; 727 case '-': /* a gas-specific option */ 728 newae(as, arg); 729 break; 730 } 731 } 732 733 #if defined(__i386) 734 if (as64) 735 newae(as, "--64"); 736 else 737 newae(as, "--32"); 738 #endif 739 740 if (srcfile == NULL) 741 return (usage("no source file(s) specified")); 742 if (outfile == NULL) 743 outfile = "a.out"; 744 newae(as, "-o"); 745 newae(as, outfile); 746 747 asargv = aeltoargv(as); 748 if (cpp) { 749 #if defined(__sparc) 750 newae(cpp, "-Dsparc"); 751 newae(cpp, "-D__sparc"); 752 if (as64) 753 newae(cpp, "-D__sparcv9"); 754 else 755 newae(cpp, "-D__sparcv8"); 756 #elif defined(__i386) || defined(__x86) 757 if (as64) { 758 newae(cpp, "-D__x86_64"); 759 newae(cpp, "-D__amd64"); 760 } else { 761 newae(cpp, "-Di386"); 762 newae(cpp, "-D__i386"); 763 } 764 #else 765 #error "need isa-dependent defines" 766 #endif 767 code = pipeline(aeltoargv(cpp), asargv); 768 } else if (m4) 769 code = pipeline(aeltoargv(m4), asargv); 770 else { 771 /* 772 * XXX should arrange to fork/exec so that we 773 * can unlink the output file if errors are 774 * detected.. 775 */ 776 (void) execvp(asargv[0], asargv); 777 perror("execvp"); 778 (void) fprintf(stderr, "%s: couldn't run %s\n", 779 progname, asargv[0]); 780 code = 7; 781 } 782 if (code != 0) 783 (void) unlink(outfile); 784 return (code); 785 } 786