sys/src/cmd/qa/lex.c

   1 #define EXTERN
   2 #include "a.h"
   3 #include "y.tab.h"
   4 #include <ctype.h>
   5
   6 void
   7 main(int argc, char *argv[])
   8 {
   9         char *p;
  10         int nout, nproc, status, i, c;
  11
  12         thechar = 'q';
  13         thestring = "power";
  14         memset(debug, 0, sizeof(debug));
  15         cinit();
  16         outfile = 0;
  17         include[ninclude++] = ".";
  18         ARGBEGIN {
  19         default:
  20                 c = ARGC();
  21                 if(c >= 0 || c < sizeof(debug))
  22                         debug[c] = 1;
  23                 break;
  24
  25         case 'o':
  26                 outfile = ARGF();
  27                 break;
  28
  29         case 'D':
  30                 p = ARGF();
  31                 if(p)
  32                         Dlist[nDlist++] = p;
  33                 break;
  34
  35         case 'I':
  36                 p = ARGF();
  37                 setinclude(p);
  38                 break;
  39         } ARGEND
  40         if(*argv == 0) {
  41                 print("usage: %Ca [-options] file.s\n", thechar);
  42                 errorexit();
  43         }
  44         if(argc > 1 && systemtype(Windows)){
  45                 print("can't assemble multiple files on windows\n");
  46                 errorexit();
  47         }
  48         if(argc > 1) {
  49                 nproc = 1;
  50                 if(p = getenv("NPROC"))
  51                         nproc = atol(p);
  52                 c = 0;
  53                 nout = 0;
  54                 for(;;) {
  55                         while(nout < nproc && argc > 0) {
  56                                 i = myfork();
  57                                 if(i < 0) {
  58                                         i = mywait(&status);
  59                                         if(i < 0)
  60                                                 errorexit();
  61                                         if(status)
  62                                                 c++;
  63                                         nout--;
  64                                         continue;
  65                                 }
  66                                 if(i == 0) {
  67                                         print("%s:\n", *argv);
  68                                         if(assemble(*argv))
  69                                                 errorexit();
  70                                         exits(0);
  71                                 }
  72                                 nout++;
  73                                 argc--;
  74                                 argv++;
  75                         }
  76                         i = mywait(&status);
  77                         if(i < 0) {
  78                                 if(c)
  79                                         errorexit();
  80                                 exits(0);
  81                         }
  82                         if(status)
  83                                 c++;
  84                         nout--;
  85                 }
  86         }
  87         if(assemble(argv[0]))
  88                 errorexit();
  89         exits(0);
  90 }
  91
  92 int
  93 assemble(char *file)
  94 {
  95         char *ofile, *p;
  96         int i, of;
  97
  98         ofile = strdup(file);
  99         p = utfrrune(ofile, pathchar());
 100         if(p) {
 101                 include[0] = ofile;
 102                 *p++ = 0;
 103         } else
 104                 p = ofile;
 105         if(outfile == 0) {
 106                 if(p){
 107                         outfile = p;
 108                         p = utfrrune(outfile, '.');
 109                         if(p)
 110                                 if(p[1] == 's' && p[2] == 0)
 111                                         p[0] = 0;
 112                         outfile = smprint("%s.%C", outfile, thechar);
 113                 } else
 114                         outfile = "/dev/null";
 115         }
 116         p = getenv("INCLUDE");
 117         if(p) {
 118                 setinclude(p);
 119         } else {
 120                 if(systemtype(Plan9))
 121                         setinclude(smprint("/%s/include", thestring));
 122         }
 123
 124         of = mycreat(outfile, 0664);
 125         if(of < 0) {
 126                 yyerror("%Ca: cannot create %s", thechar, outfile);
 127                 errorexit();
 128         }
 129         Binit(&obuf, of, OWRITE);
 130
 131         pass = 1;
 132         nosched = 0;
 133         pinit(file);
 134         for(i=0; i<nDlist; i++)
 135                 dodefine(Dlist[i]);
 136         yyparse();
 137         if(nerrors) {
 138                 cclean();
 139                 return nerrors;
 140         }
 141
 142         pass = 2;
 143         nosched = 0;
 144         outhist();
 145         pinit(file);
 146         for(i=0; i<nDlist; i++)
 147                 dodefine(Dlist[i]);
 148         yyparse();
 149         cclean();
 150         return nerrors;
 151 }
 152
 153 struct
 154 {
 155         char    *name;
 156         ushort  type;
 157         ushort  value;
 158 } itab[] =
 159 {
 160         "SP",           LSP,    D_AUTO,
 161         "SB",           LSB,    D_EXTERN,
 162         "FP",           LFP,    D_PARAM,
 163         "PC",           LPC,    D_BRANCH,
 164
 165         "LR",           LLR,    D_LR,
 166         "CTR",          LCTR,   D_CTR,
 167
 168         "XER",          LSPREG, D_XER,
 169         "MSR",          LMSR,   D_MSR,
 170         "FPSCR",        LFPSCR, D_FPSCR,
 171         "SPR",          LSPR,   D_SPR,
 172         "DCR",          LDCR,   D_DCR,
 173
 174         "SEG",          LSEG,   D_SREG,
 175
 176         "CR",           LCR,    0,
 177         "CR0",          LCREG,  0,
 178         "CR1",          LCREG,  1,
 179         "CR2",          LCREG,  2,
 180         "CR3",          LCREG,  3,
 181         "CR4",          LCREG,  4,
 182         "CR5",          LCREG,  5,
 183         "CR6",          LCREG,  6,
 184         "CR7",          LCREG,  7,
 185
 186         "R",            LR,     0,
 187         "R0",           LREG,   0,
 188         "R1",           LREG,   1,
 189         "R2",           LREG,   2,
 190         "R3",           LREG,   3,
 191         "R4",           LREG,   4,
 192         "R5",           LREG,   5,
 193         "R6",           LREG,   6,
 194         "R7",           LREG,   7,
 195         "R8",           LREG,   8,
 196         "R9",           LREG,   9,
 197         "R10",          LREG,   10,
 198         "R11",          LREG,   11,
 199         "R12",          LREG,   12,
 200         "R13",          LREG,   13,
 201         "R14",          LREG,   14,
 202         "R15",          LREG,   15,
 203         "R16",          LREG,   16,
 204         "R17",          LREG,   17,
 205         "R18",          LREG,   18,
 206         "R19",          LREG,   19,
 207         "R20",          LREG,   20,
 208         "R21",          LREG,   21,
 209         "R22",          LREG,   22,
 210         "R23",          LREG,   23,
 211         "R24",          LREG,   24,
 212         "R25",          LREG,   25,
 213         "R26",          LREG,   26,
 214         "R27",          LREG,   27,
 215         "R28",          LREG,   28,
 216         "R29",          LREG,   29,
 217         "R30",          LREG,   30,
 218         "R31",          LREG,   31,
 219
 220         "F",            LF,     0,
 221         "F0",           LFREG,  0,
 222         "F1",           LFREG,  1,
 223         "F2",           LFREG,  2,
 224         "F3",           LFREG,  3,
 225         "F4",           LFREG,  4,
 226         "F5",           LFREG,  5,
 227         "F6",           LFREG,  6,
 228         "F7",           LFREG,  7,
 229         "F8",           LFREG,  8,
 230         "F9",           LFREG,  9,
 231         "F10",          LFREG,  10,
 232         "F11",          LFREG,  11,
 233         "F12",          LFREG,  12,
 234         "F13",          LFREG,  13,
 235         "F14",          LFREG,  14,
 236         "F15",          LFREG,  15,
 237         "F16",          LFREG,  16,
 238         "F17",          LFREG,  17,
 239         "F18",          LFREG,  18,
 240         "F19",          LFREG,  19,
 241         "F20",          LFREG,  20,
 242         "F21",          LFREG,  21,
 243         "F22",          LFREG,  22,
 244         "F23",          LFREG,  23,
 245         "F24",          LFREG,  24,
 246         "F25",          LFREG,  25,
 247         "F26",          LFREG,  26,
 248         "F27",          LFREG,  27,
 249         "F28",          LFREG,  28,
 250         "F29",          LFREG,  29,
 251         "F30",          LFREG,  30,
 252         "F31",          LFREG,  31,
 253
 254         "CREQV",        LCROP, ACREQV,
 255         "CRXOR",        LCROP, ACRXOR,
 256         "CRAND",        LCROP, ACRAND,
 257         "CROR",         LCROP, ACROR,
 258         "CRANDN",       LCROP, ACRANDN,
 259         "CRORN",        LCROP, ACRORN,
 260         "CRNAND",       LCROP, ACRNAND,
 261         "CRNOR",        LCROP, ACRNOR,
 262
 263         "ADD",          LADDW, AADD,
 264         "ADDV",         LADDW, AADDV,
 265         "ADDCC",        LADDW, AADDCC,
 266         "ADDVCC",       LADDW, AADDVCC,
 267         "ADDC",         LADDW, AADDC,
 268         "ADDCV",        LADDW, AADDCV,
 269         "ADDCCC",       LADDW, AADDCCC,
 270         "ADDCVCC",      LADDW, AADDCVCC,
 271         "ADDE",         LLOGW, AADDE,
 272         "ADDEV",        LLOGW, AADDEV,
 273         "ADDECC",       LLOGW, AADDECC,
 274         "ADDEVCC",      LLOGW, AADDEVCC,
 275
 276         "ADDME",        LABS, AADDME,
 277         "ADDMEV",       LABS, AADDMEV,
 278         "ADDMECC",      LABS, AADDMECC,
 279         "ADDMEVCC",     LABS, AADDMEVCC,
 280         "ADDZE",        LABS, AADDZE,
 281         "ADDZEV",       LABS, AADDZEV,
 282         "ADDZECC",      LABS, AADDZECC,
 283         "ADDZEVCC",     LABS, AADDZEVCC,
 284
 285         "SUB",          LADDW, ASUB,
 286         "SUBV",         LADDW, ASUBV,
 287         "SUBCC",        LADDW, ASUBCC,
 288         "SUBVCC",       LADDW, ASUBVCC,
 289         "SUBE",         LLOGW, ASUBE,
 290         "SUBECC",       LLOGW, ASUBECC,
 291         "SUBEV",        LLOGW, ASUBEV,
 292         "SUBEVCC",      LLOGW, ASUBEVCC,
 293         "SUBC",         LADDW, ASUBC,
 294         "SUBCCC",       LADDW, ASUBCCC,
 295         "SUBCV",        LADDW, ASUBCV,
 296         "SUBCVCC",      LADDW, ASUBCVCC,
 297
 298         "SUBME",        LABS, ASUBME,
 299         "SUBMEV",       LABS, ASUBMEV,
 300         "SUBMECC",      LABS, ASUBMECC,
 301         "SUBMEVCC",     LABS, ASUBMEVCC,
 302         "SUBZE",        LABS, ASUBZE,
 303         "SUBZEV",       LABS, ASUBZEV,
 304         "SUBZECC",      LABS, ASUBZECC,
 305         "SUBZEVCC",     LABS, ASUBZEVCC,
 306
 307         "AND",          LADDW, AAND,
 308         "ANDCC",        LADDW, AANDCC,  /* includes andil & andiu */
 309         "ANDN",         LLOGW, AANDN,
 310         "ANDNCC",       LLOGW, AANDNCC,
 311         "EQV",          LLOGW, AEQV,
 312         "EQVCC",        LLOGW, AEQVCC,
 313         "NAND",         LLOGW, ANAND,
 314         "NANDCC",       LLOGW, ANANDCC,
 315         "NOR",          LLOGW, ANOR,
 316         "NORCC",        LLOGW, ANORCC,
 317         "OR",           LADDW, AOR,     /* includes oril & oriu */
 318         "ORCC",         LADDW, AORCC,
 319         "ORN",          LLOGW, AORN,
 320         "ORNCC",        LLOGW, AORNCC,
 321         "XOR",          LADDW, AXOR,    /* includes xoril & xoriu */
 322         "XORCC",        LLOGW, AXORCC,
 323
 324         "EXTSB",        LABS,   AEXTSB,
 325         "EXTSBCC",      LABS,   AEXTSBCC,
 326         "EXTSH",        LABS, AEXTSH,
 327         "EXTSHCC",      LABS, AEXTSHCC,
 328
 329         "CNTLZW",       LABS, ACNTLZW,
 330         "CNTLZWCC",     LABS, ACNTLZWCC,
 331
 332         "RLWMI",        LRLWM, ARLWMI,
 333         "RLWMICC",      LRLWM, ARLWMICC,
 334         "RLWNM",        LRLWM, ARLWNM,
 335         "RLWNMCC", LRLWM, ARLWNMCC,
 336
 337         "SLW",          LSHW, ASLW,
 338         "SLWCC",        LSHW, ASLWCC,
 339         "SRW",          LSHW, ASRW,
 340         "SRWCC",        LSHW, ASRWCC,
 341         "SRAW",         LSHW, ASRAW,
 342         "SRAWCC",       LSHW, ASRAWCC,
 343
 344         "BR",           LBRA, ABR,
 345         "BC",           LBRA, ABC,
 346         "BCL",          LBRA, ABC,
 347         "BL",           LBRA, ABL,
 348         "BEQ",          LBRA, ABEQ,
 349         "BNE",          LBRA, ABNE,
 350         "BGT",          LBRA, ABGT,
 351         "BGE",          LBRA, ABGE,
 352         "BLT",          LBRA, ABLT,
 353         "BLE",          LBRA, ABLE,
 354         "BVC",          LBRA, ABVC,
 355         "BVS",          LBRA, ABVS,
 356
 357         "CMP",          LCMP, ACMP,
 358         "CMPU",         LCMP, ACMPU,
 359
 360         "DIVW",         LLOGW, ADIVW,
 361         "DIVWV",        LLOGW, ADIVWV,
 362         "DIVWCC",       LLOGW, ADIVWCC,
 363         "DIVWVCC",      LLOGW, ADIVWVCC,
 364         "DIVWU",        LLOGW, ADIVWU,
 365         "DIVWUV",       LLOGW, ADIVWUV,
 366         "DIVWUCC",      LLOGW, ADIVWUCC,
 367         "DIVWUVCC",     LLOGW, ADIVWUVCC,
 368
 369         "FABS",         LFCONV, AFABS,
 370         "FABSCC",       LFCONV, AFABSCC,
 371         "FNEG",         LFCONV, AFNEG,
 372         "FNEGCC",       LFCONV, AFNEGCC,
 373         "FNABS",        LFCONV, AFNABS,
 374         "FNABSCC",      LFCONV, AFNABSCC,
 375
 376         "FADD",         LFADD,  AFADD,
 377         "FADDCC",       LFADD,  AFADDCC,
 378         "FSUB",         LFADD,  AFSUB,
 379         "FSUBCC",       LFADD,  AFSUBCC,
 380         "FMUL",         LFADD,  AFMUL,
 381         "FMULCC",       LFADD,  AFMULCC,
 382         "FDIV",         LFADD,  AFDIV,
 383         "FDIVCC",       LFADD,  AFDIVCC,
 384         "FRSP",         LFCONV, AFRSP,
 385         "FRSPCC",       LFCONV, AFRSPCC,
 386
 387         "FMADD",        LFMA, AFMADD,
 388         "FMADDCC",      LFMA, AFMADDCC,
 389         "FMSUB",        LFMA, AFMSUB,
 390         "FMSUBCC",      LFMA, AFMSUBCC,
 391         "FNMADD",       LFMA, AFNMADD,
 392         "FNMADDCC",     LFMA, AFNMADDCC,
 393         "FNMSUB",       LFMA, AFNMSUB,
 394         "FNMSUBCC",     LFMA, AFNMSUBCC,
 395         "FMADDS",       LFMA, AFMADDS,
 396         "FMADDSCC",     LFMA, AFMADDSCC,
 397         "FMSUBS",       LFMA, AFMSUBS,
 398         "FMSUBSCC",     LFMA, AFMSUBSCC,
 399         "FNMADDS",      LFMA, AFNMADDS,
 400         "FNMADDSCC",    LFMA, AFNMADDSCC,
 401         "FNMSUBS",      LFMA, AFNMSUBS,
 402         "FNMSUBSCC",    LFMA, AFNMSUBSCC,
 403
 404         "FCMPU",        LFCMP, AFCMPU,
 405         "FCMPO",        LFCMP, AFCMPO,
 406         "MTFSB0",       LMTFSB, AMTFSB0,
 407         "MTFSB1",       LMTFSB, AMTFSB1,
 408
 409         "FMOVD",        LFMOV, AFMOVD,
 410         "FMOVS",        LFMOV, AFMOVS,
 411         "FMOVDCC",      LFCONV, AFMOVDCC,       /* fmr. */
 412
 413         "GLOBL",        LTEXT, AGLOBL,
 414
 415         "MOVB",         LMOVB, AMOVB,
 416         "MOVBZ",        LMOVB, AMOVBZ,
 417         "MOVBU",        LMOVB, AMOVBU,
 418         "MOVBZU", LMOVB, AMOVBZU,
 419         "MOVH",         LMOVB, AMOVH,
 420         "MOVHZ",        LMOVB, AMOVHZ,
 421         "MOVHU",        LMOVB, AMOVHU,
 422         "MOVHZU", LMOVB, AMOVHZU,
 423         "MOVHBR",       LXMV, AMOVHBR,
 424         "MOVWBR",       LXMV, AMOVWBR,
 425         "MOVW",         LMOVW, AMOVW,
 426         "MOVWU",        LMOVW, AMOVWU,
 427         "MOVMW",        LMOVMW, AMOVMW,
 428         "MOVFL",        LMOVW,  AMOVFL,
 429
 430         "MULLW",        LADDW, AMULLW,          /* includes multiply immediate 10-139 */
 431         "MULLWV",       LLOGW, AMULLWV,
 432         "MULLWCC",      LLOGW, AMULLWCC,
 433         "MULLWVCC",     LLOGW, AMULLWVCC,
 434
 435         "MULHW",        LLOGW, AMULHW,
 436         "MULHWCC",      LLOGW, AMULHWCC,
 437         "MULHWU",       LLOGW, AMULHWU,
 438         "MULHWUCC",     LLOGW, AMULHWUCC,
 439
 440         "NEG",          LABS, ANEG,
 441         "NEGV",         LABS, ANEGV,
 442         "NEGCC",        LABS, ANEGCC,
 443         "NEGVCC",       LABS, ANEGVCC,
 444
 445         "NOP",          LNOP, ANOP,     /* ori 0,0,0 */
 446         "SYSCALL",      LNOP, ASYSCALL,
 447
 448         "RETURN",       LRETRN, ARETURN,
 449         "RFI",          LRETRN, ARFI,
 450         "RFCI",         LRETRN, ARFCI,
 451
 452         "DATA",         LDATA, ADATA,
 453         "END",          LEND, AEND,
 454         "TEXT",         LTEXT, ATEXT,
 455
 456         /* IBM powerpc embedded  */
 457         "MACCHW", LMA, AMACCHW,
 458         "MACCHWCC", LMA, AMACCHWCC,
 459         "MACCHWS", LMA, AMACCHWS,
 460         "MACCHWSCC", LMA, AMACCHWSCC,
 461         "MACCHWSU", LMA, AMACCHWSU,
 462         "MACCHWSUCC", LMA, AMACCHWSUCC,
 463         "MACCHWSUV", LMA, AMACCHWSUV,
 464         "MACCHWSUVCC", LMA, AMACCHWSUVCC,
 465         "MACCHWSV", LMA, AMACCHWSV,
 466         "MACCHWSVCC", LMA, AMACCHWSVCC,
 467         "MACCHWU", LMA, AMACCHWU,
 468         "MACCHWUCC", LMA, AMACCHWUCC,
 469         "MACCHWUV", LMA, AMACCHWUV,
 470         "MACCHWUVCC", LMA, AMACCHWUVCC,
 471         "MACCHWV", LMA, AMACCHWV,
 472         "MACCHWVCC", LMA, AMACCHWVCC,
 473         "MACHHW", LMA, AMACHHW,
 474         "MACHHWCC", LMA, AMACHHWCC,
 475         "MACHHWS", LMA, AMACHHWS,
 476         "MACHHWSCC", LMA, AMACHHWSCC,
 477         "MACHHWSU", LMA, AMACHHWSU,
 478         "MACHHWSUCC", LMA, AMACHHWSUCC,
 479         "MACHHWSUV", LMA, AMACHHWSUV,
 480         "MACHHWSUVCC", LMA, AMACHHWSUVCC,
 481         "MACHHWSV", LMA, AMACHHWSV,
 482         "MACHHWSVCC", LMA, AMACHHWSVCC,
 483         "MACHHWU", LMA, AMACHHWU,
 484         "MACHHWUCC", LMA, AMACHHWUCC,
 485         "MACHHWUV", LMA, AMACHHWUV,
 486         "MACHHWUVCC", LMA, AMACHHWUVCC,
 487         "MACHHWV", LMA, AMACHHWV,
 488         "MACHHWVCC", LMA, AMACHHWVCC,
 489         "MACLHW", LMA, AMACLHW,
 490         "MACLHWCC", LMA, AMACLHWCC,
 491         "MACLHWS", LMA, AMACLHWS,
 492         "MACLHWSCC", LMA, AMACLHWSCC,
 493         "MACLHWSU", LMA, AMACLHWSU,
 494         "MACLHWSUCC", LMA, AMACLHWSUCC,
 495         "MACLHWSUV", LMA, AMACLHWSUV,
 496         "MACLHWSUVCC", LMA, AMACLHWSUVCC,
 497         "MACLHWSV", LMA, AMACLHWSV,
 498         "MACLHWSVCC", LMA, AMACLHWSVCC,
 499         "MACLHWU", LMA, AMACLHWU,
 500         "MACLHWUCC", LMA, AMACLHWUCC,
 501         "MACLHWUV", LMA, AMACLHWUV,
 502         "MACLHWUVCC", LMA, AMACLHWUVCC,
 503         "MACLHWV", LMA, AMACLHWV,
 504         "MACLHWVCC", LMA, AMACLHWVCC,
 505         "MULCHW",       LLOGW, AMULCHW,
 506         "MULCHWCC",     LLOGW, AMULCHWCC,
 507         "MULCHWU",      LLOGW, AMULCHWU,
 508         "MULCHWUCC",    LLOGW, AMULCHWUCC,
 509         "MULHHW",       LLOGW, AMULHHW,
 510         "MULHHWCC",     LLOGW, AMULHHWCC,
 511         "MULHHWU",      LLOGW, AMULHHWU,
 512         "MULHHWUCC",    LLOGW, AMULHHWUCC,
 513         "MULLHW",       LLOGW, AMULLHW,
 514         "MULLHWCC",     LLOGW, AMULLHWCC,
 515         "MULLHWU",      LLOGW, AMULLHWU,
 516         "MULLHWUCC",    LLOGW, AMULLHWUCC,
 517         "NMACCHW", LMA, ANMACCHW,
 518         "NMACCHWCC", LMA, ANMACCHWCC,
 519         "NMACCHWS", LMA, ANMACCHWS,
 520         "NMACCHWSCC", LMA, ANMACCHWSCC,
 521         "NMACCHWSV", LMA, ANMACCHWSV,
 522         "NMACCHWSVCC", LMA, ANMACCHWSVCC,
 523         "NMACCHWV", LMA, ANMACCHWV,
 524         "NMACCHWVCC", LMA, ANMACCHWVCC,
 525         "NMACHHW", LMA, ANMACHHW,
 526         "NMACHHWCC", LMA, ANMACHHWCC,
 527         "NMACHHWS", LMA, ANMACHHWS,
 528         "NMACHHWSCC", LMA, ANMACHHWSCC,
 529         "NMACHHWSV", LMA, ANMACHHWSV,
 530         "NMACHHWSVCC", LMA, ANMACHHWSVCC,
 531         "NMACHHWV", LMA, ANMACHHWV,
 532         "NMACHHWVCC", LMA, ANMACHHWVCC,
 533         "NMACLHW", LMA, ANMACLHW,
 534         "NMACLHWCC", LMA, ANMACLHWCC,
 535         "NMACLHWS", LMA, ANMACLHWS,
 536         "NMACLHWSCC", LMA, ANMACLHWSCC,
 537         "NMACLHWSV", LMA, ANMACLHWSV,
 538         "NMACLHWSVCC", LMA, ANMACLHWSVCC,
 539         "NMACLHWV", LMA, ANMACLHWV,
 540         "NMACLHWVCC", LMA, ANMACLHWVCC,
 541
 542         /* optional on 32-bit */
 543         "FRES", LFCONV, AFRES,
 544         "FRESCC", LFCONV, AFRESCC,
 545         "FRSQRTE", LFCONV, AFRSQRTE,
 546         "FRSQRTECC", LFCONV, AFRSQRTECC,
 547         "FSEL", LFMA, AFSEL,
 548         "FSELCC", LFMA, AFSELCC,
 549         "FSQRT", LFCONV, AFSQRT,
 550         "FSQRTCC", LFCONV, AFSQRTCC,
 551         "FSQRTS", LFCONV, AFSQRTS,
 552         "FSQRTSCC", LFCONV, AFSQRTSCC,
 553
 554         /* parallel, cross, and secondary (fp2) */
 555         "FPSEL", LFMA, AFPSEL,
 556         "FPMUL", LFADD, AFPMUL,
 557         "FXMUL", LFADD, AFXMUL,
 558         "FXPMUL", LFADD, AFXPMUL,
 559         "FXSMUL", LFADD, AFXSMUL,
 560         "FPADD", LFADD, AFPADD,
 561         "FPSUB", LFADD, AFPSUB,
 562         "FPRE", LFCONV, AFPRE,
 563         "FPRSQRTE", LFCONV, AFPRSQRTE,
 564         "FPMADD", LFMA, AFPMADD,
 565         "FXMADD", LFMA, AFXMADD,
 566         "FXCPMADD", LFMA, AFXCPMADD,
 567         "FXCSMADD", LFMA, AFXCSMADD,
 568         "FPNMADD", LFMA, AFPNMADD,
 569         "FXNMADD", LFMA, AFXNMADD,
 570         "FXCPNMADD", LFMA, AFXCPNMADD,
 571         "FXCSNMADD", LFMA, AFXCSNMADD,
 572         "FPMSUB", LFMA, AFPMSUB,
 573         "FXMSUB", LFMA, AFXMSUB,
 574         "FXCPMSUB", LFMA, AFXCPMSUB,
 575         "FXCSMSUB", LFMA, AFXCSMSUB,
 576         "FPNMSUB", LFMA, AFPNMSUB,
 577         "FXNMSUB", LFMA, AFXNMSUB,
 578         "FXCPNMSUB", LFMA, AFXCPNMSUB,
 579         "FXCSNMSUB", LFMA, AFXCSNMSUB,
 580         "FPABS", LFCONV, AFPABS,
 581         "FPNEG", LFCONV, AFPNEG,
 582         "FPRSP", LFCONV, AFPRSP,
 583         "FPNABS", LFCONV, AFPNABS,
 584         "FSMOVD", LFMOV, AFSMOVD,
 585         "FSCMP", LFCMP, AFSCMP,
 586         "FSABS", LFCONV, AFSABS,
 587         "FSNEG", LFCONV, AFSNEG,
 588         "FSNABS", LFCONV, AFSNABS,
 589         "FPCTIW", LFCONV, AFPCTIW,
 590         "FPCTIWZ", LFCONV, AFPCTIWZ,
 591         "FMOVSPD", LFCONV, AFMOVSPD,
 592         "FMOVPSD", LFCONV, AFMOVPSD,
 593         "FXCPNPMA", LFMA, AFXCPNPMA,
 594         "FXCSNPMA", LFMA, AFXCSNPMA,
 595         "FXCPNSMA", LFMA, AFXCPNSMA,
 596         "FXCSNSMA", LFMA, AFXCSNSMA,
 597         "FXCXNPMA", LFMA, AFXCXNPMA,
 598         "FXCXNSMA", LFMA, AFXCXNSMA,
 599         "FXCXMA", LFMA, AFXCXMA,
 600         "FXCXNMS", LFMA, AFXCXNMS,
 601
 602         /* parallel, cross, and secondary load and store (fp2) */
 603         "FSMOVS", LFMOVX, AFSMOVS,
 604         "FSMOVSU", LFMOVX, AFSMOVSU,
 605         "FSMOVD", LFMOVX, AFSMOVD,
 606         "FSMOVDU", LFMOVX, AFSMOVDU,
 607         "FXMOVS", LFMOVX, AFXMOVS,
 608         "FXMOVSU", LFMOVX, AFXMOVSU,
 609         "FXMOVD", LFMOVX, AFXMOVD,
 610         "FXMOVDU", LFMOVX, AFXMOVDU,
 611         "FPMOVS", LFMOVX, AFPMOVS,
 612         "FPMOVSU", LFMOVX, AFPMOVSU,
 613         "FPMOVD", LFMOVX, AFPMOVD,
 614         "FPMOVDU", LFMOVX, AFPMOVDU,
 615         "FPMOVIW", LFMOVX, AFPMOVIW,
 616
 617         "AFMOVSPD",     LFMOV,  AFMOVSPD,
 618         "AFMOVPSD",     LFMOV,  AFMOVPSD,
 619
 620         /* special instructions */
 621         "DCBF",         LXOP,   ADCBF,
 622         "DCBI",         LXOP,   ADCBI,
 623         "DCBST",        LXOP,   ADCBST,
 624         "DCBT",         LXOP,   ADCBT,
 625         "DCBTST",       LXOP,   ADCBTST,
 626         "DCBZ",         LXOP,   ADCBZ,
 627         "ICBI",         LXOP,   AICBI,
 628
 629         "ECIWX",        LXLD,   AECIWX,
 630         "ECOWX",        LXST,   AECOWX,
 631         "LWAR", LXLD, ALWAR,
 632         "STWCCC", LXST, ASTWCCC,
 633         "EIEIO",        LRETRN, AEIEIO,
 634         "TLBIE",        LNOP,   ATLBIE,
 635         "LSW",  LXLD, ALSW,
 636         "STSW", LXST, ASTSW,
 637
 638         "ISYNC",        LRETRN, AISYNC,
 639         "SYNC",         LRETRN, ASYNC,
 640 /*      "TW",           LADDW,  ATW,*/
 641
 642         "WORD",         LWORD, AWORD,
 643         "SCHED",        LSCHED, 0,
 644         "NOSCHED",      LSCHED, 0x80,
 645
 646         0
 647 };
 648
 649 void
 650 cinit(void)
 651 {
 652         Sym *s;
 653         int i;
 654
 655         nullgen.sym = S;
 656         nullgen.offset = 0;
 657         nullgen.type = D_NONE;
 658         nullgen.name = D_NONE;
 659         nullgen.reg = NREG;
 660         nullgen.xreg = NREG;
 661         if(FPCHIP)
 662                 nullgen.dval = 0;
 663         for(i=0; i<sizeof(nullgen.sval); i++)
 664                 nullgen.sval[i] = 0;
 665
 666         nerrors = 0;
 667         iostack = I;
 668         iofree = I;
 669         peekc = IGN;
 670         for(i=0; i<NHASH; i++)
 671                 hash[i] = S;
 672         for(i=0; itab[i].name; i++) {
 673                 s = slookup(itab[i].name);
 674                 s->type = itab[i].type;
 675                 s->value = itab[i].value;
 676         }
 677         pathname = allocn(pathname, 0, 100);
 678         if(mygetwd(pathname, 99) == 0) {
 679                 pathname = allocn(pathname, 100, 900);
 680                 if(mygetwd(pathname, 999) == 0)
 681                         strcpy(pathname, "/???");
 682         }
 683 }
 684
 685 void
 686 syminit(Sym *s)
 687 {
 688
 689         s->type = LNAME;
 690         s->value = 0;
 691 }
 692
 693 void
 694 cclean(void)
 695 {
 696
 697         outcode(AEND, &nullgen, NREG, &nullgen);
 698         Bflush(&obuf);
 699 }
 700
 701 void
 702 zname(char *n, int t, int s)
 703 {
 704
 705         Bputc(&obuf, ANAME);
 706         Bputc(&obuf, ANAME>>8);
 707         Bputc(&obuf, t);        /* type */
 708         Bputc(&obuf, s);        /* sym */
 709         while(*n) {
 710                 Bputc(&obuf, *n);
 711                 n++;
 712         }
 713         Bputc(&obuf, 0);
 714 }
 715
 716 void
 717 zaddr(Gen *a, int s)
 718 {
 719         long l;
 720         int i;
 721         char *n;
 722         Ieee e;
 723
 724         Bputc(&obuf, a->type);
 725         Bputc(&obuf, a->reg);
 726         Bputc(&obuf, s);
 727         Bputc(&obuf, a->name);
 728         switch(a->type) {
 729         default:
 730                 print("unknown type %d\n", a->type);
 731                 exits("arg");
 732
 733         case D_NONE:
 734         case D_REG:
 735         case D_FREG:
 736         case D_CREG:
 737         case D_FPSCR:
 738         case D_MSR:
 739         case D_SREG:
 740         case D_OPT:
 741                 break;
 742
 743         case D_DCR:
 744         case D_SPR:
 745         case D_OREG:
 746         case D_CONST:
 747         case D_BRANCH:
 748                 l = a->offset;
 749                 Bputc(&obuf, l);
 750                 Bputc(&obuf, l>>8);
 751                 Bputc(&obuf, l>>16);
 752                 Bputc(&obuf, l>>24);
 753                 break;
 754
 755         case D_SCONST:
 756                 n = a->sval;
 757                 for(i=0; i<NSNAME; i++) {
 758                         Bputc(&obuf, *n);
 759                         n++;
 760                 }
 761                 break;
 762
 763         case D_FCONST:
 764                 ieeedtod(&e, a->dval);
 765                 Bputc(&obuf, e.l);
 766                 Bputc(&obuf, e.l>>8);
 767                 Bputc(&obuf, e.l>>16);
 768                 Bputc(&obuf, e.l>>24);
 769                 Bputc(&obuf, e.h);
 770                 Bputc(&obuf, e.h>>8);
 771                 Bputc(&obuf, e.h>>16);
 772                 Bputc(&obuf, e.h>>24);
 773                 break;
 774         }
 775 }
 776
 777 int
 778 outsim(Gen *g)
 779 {
 780         Sym *s;
 781         int sno, t;
 782
 783         s = g->sym;
 784         if(s == S)
 785                 return 0;
 786         sno = s->sym;
 787         if(sno < 0 || sno >= NSYM)
 788                 sno = 0;
 789         t = g->name;
 790         if(h[sno].type == t && h[sno].sym == s)
 791                 return sno;
 792         zname(s->name, t, sym);
 793         s->sym = sym;
 794         h[sym].sym = s;
 795         h[sym].type = t;
 796         sno = sym;
 797         sym++;
 798         if(sym >= NSYM)
 799                 sym = 1;
 800         return sno;
 801 }
 802
 803 void
 804 outcode(int a, Gen *g1, int reg, Gen *g2)
 805 {
 806         int sf, st;
 807
 808         if(a != AGLOBL && a != ADATA)
 809                 pc++;
 810         if(pass == 1)
 811                 return;
 812         if(g1->xreg != NREG) {
 813                 if(reg != NREG || g2->xreg != NREG)
 814                         yyerror("bad addressing modes");
 815                 reg = g1->xreg;
 816         } else
 817         if(g2->xreg != NREG) {
 818                 if(reg != NREG)
 819                         yyerror("bad addressing modes");
 820                 reg = g2->xreg;
 821         }
 822         do {
 823                 sf = outsim(g1);
 824                 st = outsim(g2);
 825         } while(sf != 0 && st == sf);
 826         Bputc(&obuf, a);
 827         Bputc(&obuf, a>>8);
 828         Bputc(&obuf, reg|nosched);
 829         Bputc(&obuf, lineno);
 830         Bputc(&obuf, lineno>>8);
 831         Bputc(&obuf, lineno>>16);
 832         Bputc(&obuf, lineno>>24);
 833         zaddr(g1, sf);
 834         zaddr(g2, st);
 835 }
 836
 837 void
 838 outgcode(int a, Gen *g1, int reg, Gen *g2, Gen *g3)
 839 {
 840         int s1, s2, s3, flag;
 841
 842         if(a != AGLOBL && a != ADATA)
 843                 pc++;
 844         if(pass == 1)
 845                 return;
 846         do {
 847                 s1 = outsim(g1);
 848                 s2 = outsim(g2);
 849                 s3 = outsim(g3);
 850         } while(s1 && (s2 && s1 == s2 || s3 && s1 == s3) || s2 && (s3 && s2 == s3));
 851         flag = 0;
 852         if(g2->type != D_NONE)
 853                 flag = 0x40;    /* flags extra operand */
 854         Bputc(&obuf, a);
 855         Bputc(&obuf, a>>8);
 856         Bputc(&obuf, reg | nosched | flag);
 857         Bputc(&obuf, lineno);
 858         Bputc(&obuf, lineno>>8);
 859         Bputc(&obuf, lineno>>16);
 860         Bputc(&obuf, lineno>>24);
 861         zaddr(g1, s1);
 862         if(flag)
 863                 zaddr(g2, s2);
 864         zaddr(g3, s3);
 865 }
 866
 867 void
 868 outhist(void)
 869 {
 870         Gen g;
 871         Hist *h;
 872         char *p, *q, *op, c;
 873         int n;
 874
 875         g = nullgen;
 876         c = pathchar();
 877         for(h = hist; h != H; h = h->link) {
 878                 p = h->name;
 879                 op = 0;
 880                 /* on windows skip drive specifier in pathname */
 881                 if(systemtype(Windows) && p && p[1] == ':'){
 882                         p += 2;
 883                         c = *p;
 884                 }
 885                 if(p && p[0] != c && h->offset == 0 && pathname){
 886                         /* on windows skip drive specifier in pathname */
 887                         if(systemtype(Windows) && pathname[1] == ':') {
 888                                 op = p;
 889                                 p = pathname+2;
 890                                 c = *p;
 891                         } else if(pathname[0] == c){
 892                                 op = p;
 893                                 p = pathname;
 894                         }
 895                 }
 896                 while(p) {
 897                         q = strchr(p, c);
 898                         if(q) {
 899                                 n = q-p;
 900                                 if(n == 0){
 901                                         n = 1;  /* leading "/" */
 902                                         *p = '/';       /* don't emit "\" on windows */
 903                                 }
 904                                 q++;
 905                         } else {
 906                                 n = strlen(p);
 907                                 q = 0;
 908                         }
 909                         if(n) {
 910                                 Bputc(&obuf, ANAME);
 911                                 Bputc(&obuf, ANAME>>8);
 912                                 Bputc(&obuf, D_FILE);   /* type */
 913                                 Bputc(&obuf, 1);        /* sym */
 914                                 Bputc(&obuf, '<');
 915                                 Bwrite(&obuf, p, n);
 916                                 Bputc(&obuf, 0);
 917                         }
 918                         p = q;
 919                         if(p == 0 && op) {
 920                                 p = op;
 921                                 op = 0;
 922                         }
 923                 }
 924                 g.offset = h->offset;
 925
 926                 Bputc(&obuf, AHISTORY);
 927                 Bputc(&obuf, AHISTORY>>8);
 928                 Bputc(&obuf, 0);
 929                 Bputc(&obuf, h->line);
 930                 Bputc(&obuf, h->line>>8);
 931                 Bputc(&obuf, h->line>>16);
 932                 Bputc(&obuf, h->line>>24);
 933                 zaddr(&nullgen, 0);
 934                 zaddr(&g, 0);
 935         }
 936 }
 937
 938 #include "../cc/lexbody"
 939 #include "../cc/macbody"
 940 #include "../cc/compat"