![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tahoe.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc / config / tahoe|
Return to tahoe.h CVS log | Up to [Apple XNU] / GNUtools / cc / config / tahoe |
1.1 ! root 1: /* Definitions of target machine for GNU compiler. Tahoe version. ! 2: Copyright (C) 1989 Free Software Foundation, Inc. ! 3: ! 4: This file is part of GNU CC. ! 5: ! 6: GNU CC is free software; you can redistribute it and/or modify ! 7: it under the terms of the GNU General Public License as published by ! 8: the Free Software Foundation; either version 2, or (at your option) ! 9: any later version. ! 10: ! 11: GNU CC is distributed in the hope that it will be useful, ! 12: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 14: GNU General Public License for more details. ! 15: ! 16: You should have received a copy of the GNU General Public License ! 17: along with GNU CC; see the file COPYING. If not, write to ! 18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 19: ! 20: /* ! 21: * File: tahoe.h ! 22: * ! 23: * Original port made at the University of Buffalo by Devon Bowen, ! 24: * Dale Wiles and Kevin Zachmann. ! 25: * ! 26: * HCX/UX version by Piet van Oostrum ([email protected]) ! 27: * ! 28: * Performance hacking by Michael Tiemann ([email protected]) ! 29: * ! 30: * Mail bugs reports or fixes to: [email protected] ! 31: */ ! 32: ! 33: /* define this for the HCX/UX version */ ! 34: ! 35: /* #define HCX_UX */ ! 36: ! 37: /* ! 38: * Run-time Target Specification ! 39: */ ! 40: ! 41: #ifdef HCX_UX ! 42: /* no predefines, see Makefile and hcx-universe.c */ ! 43: /* have cc1 print that this is the hcx version */ ! 44: #define TARGET_VERSION printf (" (hcx)"); ! 45: #else ! 46: /* we want "tahoe" and "unix" defined for all future compilations */ ! 47: #define CPP_PREDEFINES "-Dtahoe -Dunix -Asystem(unix) -Acpu(tahoe) -Amachine(tahoe)" ! 48: /* have cc1 print that this is the tahoe version */ ! 49: #define TARGET_VERSION printf (" (tahoe)"); ! 50: #endif ! 51: ! 52: /* this is required in all tm files to hold flags */ ! 53: ! 54: extern int target_flags; ! 55: ! 56: /* Zero if it is safe to output .dfloat and .float pseudos. */ ! 57: #define TARGET_HEX_FLOAT (target_flags & 1) ! 58: ! 59: #define TARGET_DEFAULT 1 ! 60: ! 61: #define TARGET_SWITCHES \ ! 62: { {"hex-float", 1}, \ ! 63: {"no-hex-float", -1}, \ ! 64: { "", TARGET_DEFAULT} } ! 65: ! 66: ! 67: /* ! 68: * Storage Layout ! 69: */ ! 70: ! 71: /* This symbol was previously not mentioned, so apparently the tahoe ! 72: is little-endian for bits, or else doesn't care. */ ! 73: #define BITS_BIG_ENDIAN 0 ! 74: ! 75: /* tahoe uses a big endian byte order */ ! 76: ! 77: #define BYTES_BIG_ENDIAN 1 ! 78: ! 79: /* tahoe uses a big endian word order */ ! 80: ! 81: #define WORDS_BIG_ENDIAN 1 ! 82: ! 83: /* standard byte size is usable on tahoe */ ! 84: ! 85: #define BITS_PER_UNIT 8 ! 86: ! 87: /* longs on the tahoe are 4 byte groups */ ! 88: ! 89: #define BITS_PER_WORD 32 ! 90: ! 91: /* from the last two params we get 4 bytes per word */ ! 92: ! 93: #define UNITS_PER_WORD 4 ! 94: ! 95: /* addresses are 32 bits (one word) */ ! 96: ! 97: #define POINTER_SIZE 32 ! 98: ! 99: /* all parameters line up on 32 boundaries */ ! 100: ! 101: #define PARM_BOUNDARY 32 ! 102: ! 103: /* stack should line up on 32 boundaries */ ! 104: ! 105: #define STACK_BOUNDARY 32 ! 106: ! 107: /* line functions up on 32 bits */ ! 108: ! 109: #define FUNCTION_BOUNDARY 32 ! 110: ! 111: /* the biggest alignment the tahoe needs in 32 bits */ ! 112: ! 113: #define BIGGEST_ALIGNMENT 32 ! 114: ! 115: /* we have to align after an 'int : 0' in a structure */ ! 116: ! 117: #define EMPTY_FIELD_BOUNDARY 32 ! 118: ! 119: #ifdef HCX_UX ! 120: /* structures must be made of full words */ ! 121: ! 122: #define STRUCTURE_SIZE_BOUNDARY 32 ! 123: #else ! 124: /* structures must be made of full bytes */ ! 125: ! 126: #define STRUCTURE_SIZE_BOUNDARY 8 ! 127: #endif ! 128: ! 129: /* tahoe is picky about data alignment */ ! 130: ! 131: #define STRICT_ALIGNMENT 1 ! 132: ! 133: /* keep things standard with pcc */ ! 134: ! 135: #define PCC_BITFIELD_TYPE_MATTERS 1 ! 136: ! 137: /* this section is borrowed from the vax version since the */ ! 138: /* formats are the same in both of the architectures */ ! 139: ! 140: #define CHECK_FLOAT_VALUE(mode, d) \ ! 141: if ((mode) == SFmode) \ ! 142: { \ ! 143: if ((d) > 1.7014117331926443e+38) \ ! 144: { error ("magnitude of constant too large for `float'"); \ ! 145: (d) = 1.7014117331926443e+38; } \ ! 146: else if ((d) < -1.7014117331926443e+38) \ ! 147: { error ("magnitude of constant too large for `float'"); \ ! 148: (d) = -1.7014117331926443e+38; } \ ! 149: else if (((d) > 0) && ((d) < 2.9387358770557188e-39)) \ ! 150: { warning ("`float' constant truncated to zero"); \ ! 151: (d) = 0.0; } \ ! 152: else if (((d) < 0) && ((d) > -2.9387358770557188e-39)) \ ! 153: { warning ("`float' constant truncated to zero"); \ ! 154: (d) = 0.0; } \ ! 155: } ! 156: ! 157: ! 158: /* ! 159: * Register Usage ! 160: */ ! 161: ! 162: /* define 15 general regs plus one for the floating point reg (FPP) */ ! 163: ! 164: #define FIRST_PSEUDO_REGISTER 17 ! 165: ! 166: /* let the compiler know what the fp, sp and pc are */ ! 167: ! 168: #define FIXED_REGISTERS {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0} ! 169: ! 170: /* lots of regs aren't guaranteed to return from a call. The FPP reg */ ! 171: /* must be included in these since it can't be saved by the reg mask */ ! 172: ! 173: #define CALL_USED_REGISTERS {1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1} ! 174: ! 175: /* A single fp reg can handle any type of float. ! 176: CPU regs hold just 32 bits. */ ! 177: ! 178: #define HARD_REGNO_NREGS(REGNO, MODE) \ ! 179: (REGNO != 16 ? ((GET_MODE_SIZE(MODE)+UNITS_PER_WORD-1) / UNITS_PER_WORD) \ ! 180: : GET_MODE_NUNITS ((MODE))) ! 181: ! 182: /* any mode greater than 4 bytes (doubles) can only go in an even regs */ ! 183: /* and the FPP can only hold SFmode and DFmode */ ! 184: ! 185: #define HARD_REGNO_MODE_OK(REGNO, MODE) \ ! 186: (REGNO != 16 \ ! 187: ? (GET_MODE_UNIT_SIZE (MODE) <= 4 ? 1 : (REGNO % 2 - 1)) \ ! 188: : ((MODE) == SFmode || (MODE) == DFmode \ ! 189: || (MODE) == SCmode || (MODE) == DCmode)) ! 190: ! 191: /* if mode1 or mode2, but not both, are doubles then modes cannot be tied */ ! 192: ! 193: #define MODES_TIEABLE_P(MODE1, MODE2) \ ! 194: (((MODE1) == DFmode || (MODE1) == DCmode) \ ! 195: == ((MODE2) == DFmode || (MODE2) == DCmode)) ! 196: ! 197: /* return nonzero if register variable of mode MODE is not ! 198: a priori a bad idea. Used only if defined. */ ! 199: #define MODE_OK_FOR_USERVAR(MODE) \ ! 200: ((MODE) == SImode) ! 201: ! 202: /* the program counter is reg 15 */ ! 203: ! 204: #define PC_REGNUM 15 ! 205: ! 206: /* the stack pointer is reg 14 */ ! 207: ! 208: #define STACK_POINTER_REGNUM 14 ! 209: ! 210: /* the frame pointer is reg 13 */ ! 211: ! 212: #define FRAME_POINTER_REGNUM 13 ! 213: ! 214: /* tahoe does require an fp */ ! 215: ! 216: #define FRAME_POINTER_REQUIRED 1 ! 217: ! 218: /* since tahoe doesn't have a argument pointer, make it the fp */ ! 219: ! 220: #define ARG_POINTER_REGNUM 13 ! 221: ! 222: /* this isn't currently used since C doesn't support this feature */ ! 223: ! 224: #define STATIC_CHAIN_REGNUM 0 ! 225: ! 226: /* we'll use reg 1 for structure passing cause the destination */ ! 227: /* of the eventual movblk requires it to be there anyway. */ ! 228: ! 229: #define STRUCT_VALUE_REGNUM 1 ! 230: ! 231: ! 232: /* ! 233: * Register Classes ! 234: */ ! 235: ! 236: /* tahoe has two types of regs. GENERAL_REGS are all the regs up */ ! 237: /* to number 15. FPP_REG is the special floating point processor */ ! 238: /* register class (only one reg). */ ! 239: ! 240: enum reg_class {NO_REGS,GENERAL_REGS,FPP_REG,ALL_REGS,LIM_REG_CLASSES}; ! 241: ! 242: /* defines the number of reg classes. */ ! 243: ! 244: #define N_REG_CLASSES (int) LIM_REG_CLASSES ! 245: ! 246: /* this defines what the classes are officially named for debugging */ ! 247: ! 248: #define REG_CLASS_NAMES \ ! 249: {"NO_REGS","GENERAL_REGS","FPP_REG","ALL_REGS"} ! 250: ! 251: /* set general regs to be the first 16 regs and the fpp reg to be 17th */ ! 252: ! 253: #define REG_CLASS_CONTENTS {0,0xffff,0x10000,0x1ffff} ! 254: ! 255: /* register class for the fpp reg is FPP_REG, all others are GENERAL_REGS */ ! 256: ! 257: #define REGNO_REG_CLASS(REGNO) (REGNO == 16 ? FPP_REG : GENERAL_REGS) ! 258: ! 259: /* only general registers can be used as a base reg */ ! 260: ! 261: #define BASE_REG_CLASS GENERAL_REGS ! 262: ! 263: /* only general registers can be used to index */ ! 264: ! 265: #define INDEX_REG_CLASS GENERAL_REGS ! 266: ! 267: /* 'a' as a constraint in the md file means the FFP_REG class */ ! 268: ! 269: #define REG_CLASS_FROM_LETTER(C) (C == 'a' ? FPP_REG : NO_REGS) ! 270: ! 271: /* any general reg but the fpp can be a base reg */ ! 272: ! 273: #define REGNO_OK_FOR_BASE_P(regno) \ ! 274: ((regno) < FIRST_PSEUDO_REGISTER - 1 || reg_renumber[regno] >= 0) ! 275: ! 276: /* any general reg except the pc and fpp can be an index reg */ ! 277: ! 278: #define REGNO_OK_FOR_INDEX_P(regno) \ ! 279: ((regno) < FIRST_PSEUDO_REGISTER - 2 || reg_renumber[regno] >= 0) ! 280: ! 281: /* if your loading a floating point constant, it can't be done */ ! 282: /* through a register. Force it to be a memory constant. */ ! 283: ! 284: #define PREFERRED_RELOAD_CLASS(X,CLASS) \ ! 285: ((GET_CODE (X) == CONST_DOUBLE) ? NO_REGS : CLASS) ! 286: ! 287: /* for the fpp reg, all modes fit; for any others, you need two for doubles */ ! 288: ! 289: #define CLASS_MAX_NREGS(CLASS, MODE) \ ! 290: (CLASS != FPP_REG ? ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) : 1) ! 291: ! 292: /* we don't define any special constant sizes so all should fail */ ! 293: ! 294: #define CONST_OK_FOR_LETTER_P(VALUE, C) 0 ! 295: ! 296: /* we don't define any special double sizes so all should fail */ ! 297: ! 298: #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 0 ! 299: ! 300: ! 301: /* ! 302: * Describing Stack Layout ! 303: */ ! 304: ! 305: /* tahoe stack grows from high to low memory */ ! 306: ! 307: #define STACK_GROWS_DOWNWARD ! 308: ! 309: /* Define this if longjmp restores from saved registers ! 310: rather than from what setjmp saved. */ ! 311: #define LONGJMP_RESTORE_FROM_STACK ! 312: ! 313: /* tahoe call frames grow from high to low memory on the stack */ ! 314: ! 315: #define FRAME_GROWS_DOWNWARD ! 316: ! 317: /* the tahoe fp points to the *top* of the frame instead of the */ ! 318: /* bottom, so we have to make this offset a constant large enough */ ! 319: /* to jump over the biggest frame possible. */ ! 320: ! 321: #define STARTING_FRAME_OFFSET -52 ! 322: ! 323: /* tahoe always pushes 4 bytes unless it's a double in which case */ ! 324: /* it pushes a full 8 bytes. */ ! 325: ! 326: #define PUSH_ROUNDING(BYTES) (BYTES <= 4 ? 4 : 8) ! 327: ! 328: /* the first parameter in a function is at the fp + 4 */ ! 329: ! 330: #define FIRST_PARM_OFFSET(FNDECL) 4 ! 331: ! 332: /* the tahoe return function takes care of everything on the stack */ ! 333: ! 334: #define RETURN_POPS_ARGS(FUNTYPE,SIZE) (SIZE) ! 335: ! 336: /* function values for all types are returned in register 0 */ ! 337: ! 338: #define FUNCTION_VALUE(VALTYPE, FUNC) \ ! 339: gen_rtx (REG, TYPE_MODE (VALTYPE), 0) ! 340: ! 341: /* library routines also return things in reg 0 */ ! 342: ! 343: #define LIBCALL_VALUE(MODE) gen_rtx (REG, MODE, 0) ! 344: ! 345: /* Tahoe doesn't return structures in a reentrant way */ ! 346: ! 347: #define PCC_STATIC_STRUCT_RETURN ! 348: ! 349: /* we only return values from a function in reg 0 */ ! 350: ! 351: #define FUNCTION_VALUE_REGNO_P(N) ((N) == 0) ! 352: ! 353: /* we never pass args through a register */ ! 354: ! 355: #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) 0 ! 356: ! 357: /* int is fine to hold the argument summary in FUNCTION_ARG */ ! 358: ! 359: #define CUMULATIVE_ARGS int ! 360: ! 361: /* we just set CUM to 0 before the FUNCTION_ARG call. No matter what */ ! 362: /* we make it, FUNCTION_ARG will return 0 anyway */ ! 363: ! 364: #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME) \ ! 365: ((CUM) = 0) ! 366: ! 367: /* all modes push their size rounded to the nearest word boundary */ ! 368: /* except block which is the size of the block rounded up */ ! 369: ! 370: #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \ ! 371: ((CUM) += ((MODE) != BLKmode \ ! 372: ? (GET_MODE_SIZE (MODE) + 3) & ~3 \ ! 373: : (int_size_in_bytes (TYPE) + 3) & ~3)) ! 374: ! 375: /* this is always false since we never pass params in regs */ ! 376: ! 377: #define FUNCTION_ARG_REGNO_P(N) 0 ! 378: ! 379: /* this code calculates the register entry mask and sets up */ ! 380: /* the stack pointer for the function. The stack is set down */ ! 381: /* far enough from the fp to jump over any push regs and local */ ! 382: /* vars. This is a problem since the tahoe has the fp pointing */ ! 383: /* to the top of the frame and the compiler must know the off- */ ! 384: /* set off the fp to the local vars. */ ! 385: ! 386: #define FUNCTION_PROLOGUE(FILE, SIZE) \ ! 387: { register int regno; \ ! 388: register int mask = 0; \ ! 389: extern char call_used_regs[]; \ ! 390: for (regno = 0; regno < FIRST_PSEUDO_REGISTER-1; regno++) \ ! 391: if (regs_ever_live[regno] && !call_used_regs[regno]) \ ! 392: mask |= 1 << regno; \ ! 393: fprintf (FILE, "\t.word 0x%x\n", mask); \ ! 394: if (SIZE != 0) fprintf (FILE, "\tsubl3 $%d,fp,sp\n", (SIZE) - STARTING_FRAME_OFFSET); } ! 395: ! 396: /* Zero out global variable in case it was used in this function. */ ! 397: #define FUNCTION_EPILOGUE(FILE, SIZE) \ ! 398: { extern rtx tahoe_reg_conversion_loc; \ ! 399: tahoe_reg_conversion_loc = 0; \ ! 400: } ! 401: ! 402: #ifdef HCX_UX ! 403: ! 404: /* to call the profiler, the address of the counter var is placed */ ! 405: /* on the stack and then passed into mcount this way */ ! 406: ! 407: #define FUNCTION_PROFILER(FILE, LABELNO) \ ! 408: fprintf (FILE, "\tpushal LP%d\n\tcallf $8,mcount\n", (LABELNO)); ! 409: ! 410: #else ! 411: ! 412: /* to call the profiler, push the variable value onto the stack */ ! 413: /* and call mcount like a regular function. */ ! 414: ! 415: #define FUNCTION_PROFILER(FILE, LABELNO) \ ! 416: fprintf (FILE, "\tpushl $LP%d\n\tcallf $8,mcount\n", (LABELNO)); ! 417: ! 418: #endif ! 419: ! 420: /* all stack handling at the end of a function is handled by the */ ! 421: /* return command. */ ! 422: ! 423: #define EXIT_IGNORE_STACK 1 ! 424: ! 425: /* ! 426: * Library Subroutine Names ! 427: */ ! 428: ! 429: /* udiv is a valid C library routine in libc.a, so we call that */ ! 430: ! 431: #define UDIVSI3_LIBCALL "*udiv" ! 432: ! 433: /* urem is a valid C library routine in libc.a, so we call that */ ! 434: /* but not so on hcx/ux */ ! 435: ! 436: #ifdef HCX_UX ! 437: #undef UMODSI3_LIBCALL ! 438: #else ! 439: #define UMODSI3_LIBCALL "*urem" ! 440: #endif ! 441: ! 442: ! 443: /* ! 444: * Addressing Modes ! 445: */ ! 446: ! 447: /* constant addresses can be treated exactly the same as normal constants */ ! 448: ! 449: #define CONSTANT_ADDRESS_P(X) \ ! 450: (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \ ! 451: || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST \ ! 452: || GET_CODE (X) == HIGH) ! 453: ! 454: /* we can have as many as two regs in any given address */ ! 455: ! 456: #define MAX_REGS_PER_ADDRESS 2 ! 457: ! 458: /* The following is all the code for GO_IF_LEGITIMATE_ADDRESS */ ! 459: /* most of this taken directly from the vax tm file since the */ ! 460: /* tahoe and vax addressing modes are nearly identical. */ ! 461: ! 462: /* Is x an indirectable address? */ ! 463: ! 464: #define INDIRECTABLE_ADDRESS_P(X) \ ! 465: (CONSTANT_ADDRESS_P (X) \ ! 466: || (GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X)) \ ! 467: || (GET_CODE (X) == PLUS \ ! 468: && GET_CODE (XEXP (X, 0)) == REG \ ! 469: && REG_OK_FOR_BASE_P (XEXP (X, 0)) \ ! 470: && CONSTANT_ADDRESS_P (XEXP (X, 1)))) ! 471: ! 472: /* If x is a non-indexed-address, go to ADDR. */ ! 473: ! 474: #define GO_IF_NONINDEXED_ADDRESS(X, ADDR) \ ! 475: { register rtx xfoob = (X); \ ! 476: if (GET_CODE (xfoob) == REG) goto ADDR; \ ! 477: if (INDIRECTABLE_ADDRESS_P (xfoob)) goto ADDR; \ ! 478: xfoob = XEXP (X, 0); \ ! 479: if (GET_CODE (X) == MEM && INDIRECTABLE_ADDRESS_P (xfoob)) \ ! 480: goto ADDR; \ ! 481: if ((GET_CODE (X) == PRE_DEC || GET_CODE (X) == POST_INC) \ ! 482: && GET_CODE (xfoob) == REG && REGNO (xfoob) == 14) \ ! 483: goto ADDR; } ! 484: ! 485: /* Is PROD an index term in mode MODE. */ ! 486: ! 487: #define INDEX_TERM_P(PROD, MODE) \ ! 488: (GET_MODE_SIZE (MODE) == 1 \ ! 489: ? (GET_CODE (PROD) == REG && REG_OK_FOR_BASE_P (PROD)) \ ! 490: : (GET_CODE (PROD) == MULT \ ! 491: && \ ! 492: (xfoo0 = XEXP (PROD, 0), xfoo1 = XEXP (PROD, 1), \ ! 493: ((GET_CODE (xfoo0) == CONST_INT \ ! 494: && INTVAL (xfoo0) == GET_MODE_SIZE (MODE) \ ! 495: && GET_CODE (xfoo1) == REG \ ! 496: && REG_OK_FOR_INDEX_P (xfoo1)) \ ! 497: || \ ! 498: (GET_CODE (xfoo1) == CONST_INT \ ! 499: && INTVAL (xfoo1) == GET_MODE_SIZE (MODE) \ ! 500: && GET_CODE (xfoo0) == REG \ ! 501: && REG_OK_FOR_INDEX_P (xfoo0)))))) ! 502: ! 503: /* Is the addition to the index a reg? */ ! 504: ! 505: #define GO_IF_REG_PLUS_INDEX(X, MODE, ADDR) \ ! 506: { register rtx xfooa; \ ! 507: if (GET_CODE (X) == PLUS) \ ! 508: { if (GET_CODE (XEXP (X, 0)) == REG \ ! 509: && REG_OK_FOR_BASE_P (XEXP (X, 0)) \ ! 510: && (xfooa = XEXP (X, 1), \ ! 511: INDEX_TERM_P (xfooa, MODE))) \ ! 512: goto ADDR; \ ! 513: if (GET_CODE (XEXP (X, 1)) == REG \ ! 514: && REG_OK_FOR_BASE_P (XEXP (X, 1)) \ ! 515: && (xfooa = XEXP (X, 0), \ ! 516: INDEX_TERM_P (xfooa, MODE))) \ ! 517: goto ADDR; } } ! 518: ! 519: /* Is the rtx X a valid memory address for operand of mode MODE? */ ! 520: /* If it is, go to ADDR */ ! 521: ! 522: #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ ! 523: { register rtx xfoo, xfoo0, xfoo1; \ ! 524: GO_IF_NONINDEXED_ADDRESS (X, ADDR); \ ! 525: if (GET_CODE (X) == PLUS) \ ! 526: { xfoo = XEXP (X, 0); \ ! 527: if (INDEX_TERM_P (xfoo, MODE)) \ ! 528: { GO_IF_NONINDEXED_ADDRESS (XEXP (X, 1), ADDR); } \ ! 529: xfoo = XEXP (X, 1); \ ! 530: if (INDEX_TERM_P (xfoo, MODE)) \ ! 531: { GO_IF_NONINDEXED_ADDRESS (XEXP (X, 0), ADDR); } \ ! 532: if (CONSTANT_ADDRESS_P (XEXP (X, 0))) \ ! 533: { if (GET_CODE (XEXP (X, 1)) == REG \ ! 534: && REG_OK_FOR_BASE_P (XEXP (X, 1))) \ ! 535: goto ADDR; \ ! 536: GO_IF_REG_PLUS_INDEX (XEXP (X, 1), MODE, ADDR); } \ ! 537: if (CONSTANT_ADDRESS_P (XEXP (X, 1))) \ ! 538: { if (GET_CODE (XEXP (X, 0)) == REG \ ! 539: && REG_OK_FOR_BASE_P (XEXP (X, 0))) \ ! 540: goto ADDR; \ ! 541: GO_IF_REG_PLUS_INDEX (XEXP (X, 0), MODE, ADDR); } } } ! 542: ! 543: /* Register 16 can never be used for index or base */ ! 544: ! 545: #ifndef REG_OK_STRICT ! 546: #define REG_OK_FOR_INDEX_P(X) (REGNO(X) != 16) ! 547: #define REG_OK_FOR_BASE_P(X) (REGNO(X) != 16) ! 548: #else ! 549: #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X)) ! 550: #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X)) ! 551: #endif ! 552: ! 553: /* Addressing is too simple to allow optimizing here */ ! 554: ! 555: #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) {} ! 556: ! 557: /* Post_inc and pre_dec always adds 4 */ ! 558: ! 559: #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \ ! 560: { if (GET_CODE(ADDR) == POST_INC || GET_CODE(ADDR) == PRE_DEC) \ ! 561: goto LABEL; \ ! 562: if (GET_CODE (ADDR) == PLUS) \ ! 563: { if (CONSTANT_ADDRESS_P (XEXP (ADDR, 0)) \ ! 564: && GET_CODE (XEXP (ADDR, 1)) == REG); \ ! 565: else if (CONSTANT_ADDRESS_P (XEXP (ADDR, 1)) \ ! 566: && GET_CODE (XEXP (ADDR, 0)) == REG); \ ! 567: else goto LABEL; }} ! 568: ! 569: /* Double's are not legitimate as immediate operands */ ! 570: ! 571: #define LEGITIMATE_CONSTANT_P(X) \ ! 572: (GET_CODE (X) != CONST_DOUBLE) ! 573: ! 574: ! 575: /* ! 576: * Miscellaneous Parameters ! 577: */ ! 578: ! 579: /* the elements in the case jump table are all words */ ! 580: ! 581: #define CASE_VECTOR_MODE HImode ! 582: ! 583: /* each of the table elements in a case are relative to the jump address */ ! 584: ! 585: #define CASE_VECTOR_PC_RELATIVE ! 586: ! 587: /* tahoe case instructions just fall through to the next instruction */ ! 588: /* if not satisfied. It doesn't support a default action */ ! 589: ! 590: #define CASE_DROPS_THROUGH ! 591: ! 592: /* the standard answer is given here and work ok */ ! 593: ! 594: #define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR ! 595: ! 596: /* in a general div case, it's easiest to use TRUNC_DIV_EXPR */ ! 597: ! 598: #define EASY_DIV_EXPR TRUNC_DIV_EXPR ! 599: ! 600: /* the standard seems to be leaving char's as signed so we left it */ ! 601: /* this way even though we think they should be unsigned! */ ! 602: ! 603: #define DEFAULT_SIGNED_CHAR 1 ! 604: ! 605: /* the most we can move without cutting down speed is 4 bytes */ ! 606: ! 607: #define MOVE_MAX 4 ! 608: ! 609: /* our int is 32 bits */ ! 610: ! 611: #define INT_TYPE_SIZE 32 ! 612: ! 613: /* byte access isn't really slower than anything else */ ! 614: ! 615: #define SLOW_BYTE_ACCESS 0 ! 616: ! 617: /* zero extension is more than one instruction so try to avoid it */ ! 618: ! 619: #define SLOW_ZERO_EXTEND ! 620: ! 621: /* any bits higher than the low 4 are ignored in the shift count */ ! 622: /* so don't bother zero extending or sign extending them */ ! 623: ! 624: #define SHIFT_COUNT_TRUNCATED 1 ! 625: ! 626: /* we don't need to officially convert from one fixed type to another */ ! 627: /* in order to use it as that type. We can just assume it's the same */ ! 628: ! 629: #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 ! 630: ! 631: /* pass chars as ints */ ! 632: ! 633: #define PROMOTE_PROTOTYPES ! 634: ! 635: /* pointers can be represented by an si mode expression */ ! 636: ! 637: #define Pmode SImode ! 638: ! 639: /* function addresses are made by specifying a byte address */ ! 640: ! 641: #define FUNCTION_MODE QImode ! 642: ! 643: /* Define this if addresses of constant functions ! 644: shouldn't be put through pseudo regs where they can be cse'd. ! 645: On the tahoe a call with a constant address is much faster than one with a ! 646: register. */ ! 647: ! 648: #define NO_FUNCTION_CSE ! 649: ! 650: /* specify the costs of various sorts of constants, ! 651: and also indicate that multiplication is cheap on this machine. */ ! 652: ! 653: #define CONST_COSTS(RTX,CODE,OUTER_CODE) \ ! 654: case CONST_INT: \ ! 655: /* Constant zero is super cheap due to clr instruction. */ \ ! 656: if (RTX == const0_rtx) return 0; \ ! 657: if ((unsigned) INTVAL (RTX) < 077) return 1; \ ! 658: if (INTVAL (RTX) <= 127 && INTVAL (RTX) >= -128) return 2; \ ! 659: case CONST: \ ! 660: case LABEL_REF: \ ! 661: case SYMBOL_REF: \ ! 662: return 3; \ ! 663: case CONST_DOUBLE: \ ! 664: return 5; \ ! 665: case MULT: \ ! 666: total = 2; ! 667: ! 668: ! 669: /* ! 670: * Condition Code Information ! 671: */ ! 672: ! 673: /* Nonzero if the results of the previous comparison are ! 674: in the floating point condition code register. */ ! 675: ! 676: #define CC_UNCHANGED 04000 ! 677: ! 678: ! 679: #define NOTICE_UPDATE_CC(EXP, INSN) \ ! 680: { if (cc_status.flags & CC_UNCHANGED) \ ! 681: /* Happens for cvtld and a few other insns. */ \ ! 682: cc_status.flags &= ~CC_UNCHANGED; \ ! 683: else if (GET_CODE (EXP) == SET) \ ! 684: { if (GET_CODE (SET_SRC (EXP)) == CALL) \ ! 685: CC_STATUS_INIT; \ ! 686: else if (GET_CODE (SET_DEST (EXP)) != PC) \ ! 687: { cc_status.flags = 0; \ ! 688: cc_status.value1 = SET_DEST (EXP); \ ! 689: cc_status.value2 = SET_SRC (EXP); } } \ ! 690: else if (GET_CODE (EXP) == PARALLEL \ ! 691: && GET_CODE (XVECEXP (EXP, 0, 0)) == SET \ ! 692: && GET_CODE (SET_DEST (XVECEXP (EXP, 0, 0))) != PC) \ ! 693: { cc_status.flags = 0; \ ! 694: cc_status.value1 = SET_DEST (XVECEXP (EXP, 0, 0)); \ ! 695: cc_status.value2 = SET_SRC (XVECEXP (EXP, 0, 0)); } \ ! 696: /* PARALLELs whose first element sets the PC are aob, sob insns. \ ! 697: They do change the cc's. So drop through and forget the cc's. */ \ ! 698: else CC_STATUS_INIT; \ ! 699: if (cc_status.value1 && GET_CODE (cc_status.value1) == REG \ ! 700: && cc_status.value2 \ ! 701: && reg_overlap_mentioned_p (cc_status.value1, cc_status.value2)) \ ! 702: cc_status.value2 = 0; \ ! 703: if (cc_status.value1 && GET_CODE (cc_status.value1) == MEM \ ! 704: && cc_status.value2 \ ! 705: && GET_CODE (cc_status.value2) == MEM) \ ! 706: cc_status.value2 = 0; } ! 707: /* Actual condition, one line up, should be that value2's address ! 708: depends on value1, but that is too much of a pain. */ ! 709: ! 710: ! 711: /* ! 712: * Output of Assembler Code ! 713: */ ! 714: ! 715: /* print which tahoe version compiled this code and print a directive */ ! 716: /* to the gnu assembler to say that the following is normal assembly */ ! 717: ! 718: #ifdef HCX_UX ! 719: #define ASM_FILE_START(FILE) \ ! 720: { fprintf (FILE, "#gcc hcx 1.0\n\n"); \ ! 721: output_file_directive ((FILE), main_input_filename);} while (0) ! 722: #else ! 723: #define ASM_FILE_START(FILE) fprintf (FILE, "#gcc tahoe 1.0\n#NO_APP\n"); ! 724: #endif ! 725: ! 726: /* the instruction that turns on the APP for the gnu assembler */ ! 727: ! 728: #define ASM_APP_ON "#APP\n" ! 729: ! 730: /* the instruction that turns off the APP for the gnu assembler */ ! 731: ! 732: #define ASM_APP_OFF "#NO_APP\n" ! 733: ! 734: /* what to output before read-only data. */ ! 735: ! 736: #define TEXT_SECTION_ASM_OP ".text" ! 737: ! 738: /* what to output before writable data. */ ! 739: ! 740: #define DATA_SECTION_ASM_OP ".data" ! 741: ! 742: /* this is what we call each of the regs. notice that the FPP reg is */ ! 743: /* called "ac". This should never get used due to the way we've set */ ! 744: /* up FPP instructions in the md file. But we call it "ac" here to */ ! 745: /* fill the list. */ ! 746: ! 747: #define REGISTER_NAMES \ ! 748: {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", \ ! 749: "r9", "r10", "r11", "r12", "fp", "sp", "pc", "ac"} ! 750: ! 751: #ifdef HCX_UX ! 752: /* allow generation of sdb info in the assembly */ ! 753: #define SDB_DEBUGGING_INFO ! 754: #else ! 755: /* allow generation of dbx info in the assembly */ ! 756: ! 757: #define DBX_DEBUGGING_INFO ! 758: ! 759: /* our dbx doesn't support this */ ! 760: ! 761: #define DBX_NO_XREFS ! 762: ! 763: /* we don't want symbols broken up */ ! 764: ! 765: #define DBX_CONTIN_LENGTH 0 ! 766: ! 767: /* this'll really never be used, but we'll leave it at this */ ! 768: ! 769: #define DBX_CONTIN_CHAR '?' ! 770: ! 771: #endif /* HCX_UX */ ! 772: ! 773: /* registers are called the same thing in dbx anything else */ ! 774: /* This is necessary even if we generate SDB output */ ! 775: ! 776: #define DBX_REGISTER_NUMBER(REGNO) (REGNO) ! 777: ! 778: /* labels are the label followed by a colon and a newline */ ! 779: /* must be a statement, so surround it in a null loop */ ! 780: ! 781: #define ASM_OUTPUT_LABEL(FILE,NAME) \ ! 782: do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0) ! 783: ! 784: /* use the .globl directive to make labels global for the linker */ ! 785: ! 786: #define ASM_GLOBALIZE_LABEL(FILE,NAME) \ ! 787: do { fputs (".globl ", FILE); assemble_name (FILE, NAME); fputs ("\n", FILE);} while (0) ! 788: ! 789: /* output a label by appending an underscore to it */ ! 790: ! 791: #define ASM_OUTPUT_LABELREF(FILE,NAME) \ ! 792: fprintf (FILE, "_%s", NAME) ! 793: ! 794: /* use the standard format for printing internal labels */ ! 795: ! 796: #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \ ! 797: fprintf (FILE, "%s%d:\n", PREFIX, NUM) ! 798: ! 799: /* a * is used for label indirection in unix assembly */ ! 800: ! 801: #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \ ! 802: sprintf (LABEL, "*%s%d", PREFIX, NUM) ! 803: ! 804: /* outputting a double is easy cause we only have one kind */ ! 805: ! 806: #ifdef HCX_UX ! 807: #define ASM_OUTPUT_DOUBLE(FILE,VALUE) \ ! 808: fprintf (FILE, "\t.double 0d%.20e\n", (VALUE)) ! 809: #else ! 810: #define ASM_OUTPUT_DOUBLE(FILE,VALUE) \ ! 811: { \ ! 812: union { int i[2]; double d;} temp; \ ! 813: temp.d = (VALUE); \ ! 814: if (TARGET_HEX_FLOAT) \ ! 815: fprintf ((FILE), "\t.long 0x%x,0x%x # %.20e\n", \ ! 816: temp.i[0], temp.i[1], temp.d); \ ! 817: else \ ! 818: fprintf (FILE, "\t.dfloat 0d%.20e\n", temp.d); \ ! 819: } ! 820: #endif ! 821: ! 822: /* This is how to output an assembler line defining a `float' constant. */ ! 823: ! 824: #ifdef HCX_UX ! 825: #define ASM_OUTPUT_FLOAT(FILE,VALUE) \ ! 826: fprintf (FILE, "\t.float 0f%.20e\n", (VALUE)) ! 827: #else ! 828: #define ASM_OUTPUT_FLOAT(FILE,VALUE) \ ! 829: { \ ! 830: union { int i; float f;} temp; \ ! 831: temp.f = (float) (VALUE); \ ! 832: if (TARGET_HEX_FLOAT) \ ! 833: fprintf ((FILE), "\t.long 0x%x # %.20e\n", \ ! 834: temp.i, temp.f); \ ! 835: else \ ! 836: fprintf (FILE, "\t.float 0f%.20e\n", temp.f); \ ! 837: } ! 838: #endif ! 839: ! 840: /* This is how to output an assembler line defining an `int' constant. */ ! 841: ! 842: #define ASM_OUTPUT_INT(FILE,VALUE) \ ! 843: ( fprintf (FILE, "\t.long "), \ ! 844: output_addr_const (FILE, (VALUE)), \ ! 845: fprintf (FILE, "\n")) ! 846: ! 847: /* Likewise for `char' and `short' constants. */ ! 848: ! 849: #define ASM_OUTPUT_SHORT(FILE,VALUE) \ ! 850: ( fprintf (FILE, "\t.word "), \ ! 851: output_addr_const (FILE, (VALUE)), \ ! 852: fprintf (FILE, "\n")) ! 853: ! 854: #define ASM_OUTPUT_CHAR(FILE,VALUE) \ ! 855: ( fprintf (FILE, "\t.byte "), \ ! 856: output_addr_const (FILE, (VALUE)), \ ! 857: fprintf (FILE, "\n")) ! 858: ! 859: #ifdef HCX_UX ! 860: /* This is how to output an assembler line for an ASCII string. */ ! 861: ! 862: #define ASM_OUTPUT_ASCII(FILE, p, size) \ ! 863: { register int i; \ ! 864: fprintf ((FILE), "\t.ascii \""); \ ! 865: for (i = 0; i < (size); i++) \ ! 866: { \ ! 867: register int c = (p)[i]; \ ! 868: if (c == '\'' || c == '\\') \ ! 869: putc ('\\', (FILE)); \ ! 870: if (c >= ' ' && c < 0177 && c != '\"') \ ! 871: putc (c, (FILE)); \ ! 872: else \ ! 873: { \ ! 874: fprintf ((FILE), "\\%03o", c); \ ! 875: } \ ! 876: } \ ! 877: fprintf ((FILE), "\"\n"); } ! 878: #endif ! 879: ! 880: /* This is how to output an assembler line for a numeric constant byte. */ ! 881: ! 882: #define ASM_OUTPUT_BYTE(FILE,VALUE) \ ! 883: fprintf (FILE, "\t.byte 0x%x\n", (VALUE)) ! 884: ! 885: /* this is the insn to push a register onto the stack */ ! 886: ! 887: #define ASM_OUTPUT_REG_PUSH(FILE,REGNO) \ ! 888: fprintf (FILE, "\tpushl %s\n", reg_names[REGNO]) ! 889: ! 890: /* this is the insn to pop a register from the stack */ ! 891: ! 892: #define ASM_OUTPUT_REG_POP(FILE,REGNO) \ ! 893: fprintf (FILE, "\tmovl (sp)+,%s\n", reg_names[REGNO]) ! 894: ! 895: /* this is required even thought tahoe doesn't support it */ ! 896: /* cause the C code expects it to be defined */ ! 897: ! 898: #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ ! 899: fprintf (FILE, "\t.long L%d\n", VALUE) ! 900: ! 901: /* This is how to output an element of a case-vector that is relative. */ ! 902: ! 903: #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \ ! 904: fprintf (FILE, "\t.word L%d-L%d\n", VALUE, REL) ! 905: ! 906: /* This is how to output an assembler line ! 907: that says to advance the location counter ! 908: to a multiple of 2**LOG bytes. */ ! 909: ! 910: #ifdef HCX_UX ! 911: #define CASE_ALIGNMENT 2 ! 912: #define ASM_OUTPUT_ALIGN(FILE,LOG) \ ! 913: if ((LOG)!=0) fprintf ((FILE), "\t.align %d\n", 1<<(LOG)) ! 914: #else ! 915: #define CASE_ALIGNMENT 1 ! 916: #define ASM_OUTPUT_ALIGN(FILE,LOG) \ ! 917: LOG ? fprintf (FILE, "\t.align %d\n", (LOG)) : 0 ! 918: #endif ! 919: ! 920: /* This is how to skip over some space */ ! 921: ! 922: #define ASM_OUTPUT_SKIP(FILE,SIZE) \ ! 923: fprintf (FILE, "\t.space %u\n", (SIZE)) ! 924: ! 925: /* This defines common variables across files */ ! 926: ! 927: #ifdef HCX_UX ! 928: #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \ ! 929: ( fputs (".comm ", (FILE)), \ ! 930: assemble_name ((FILE), (NAME)), \ ! 931: fprintf ((FILE), ",%u\n", (SIZE))) ! 932: #else ! 933: #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \ ! 934: ( fputs (".comm ", (FILE)), \ ! 935: assemble_name ((FILE), (NAME)), \ ! 936: fprintf ((FILE), ",%u\n", (ROUNDED))) ! 937: #endif ! 938: ! 939: /* This says how to output an assembler line ! 940: to define a local common symbol. */ ! 941: ! 942: #ifdef HCX_UX ! 943: #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \ ! 944: ( fputs ("\t.bss ", (FILE)), \ ! 945: assemble_name ((FILE), (NAME)), \ ! 946: fprintf ((FILE), ",%u,4\n", (SIZE),(ROUNDED))) ! 947: #else ! 948: #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \ ! 949: ( fputs (".lcomm ", (FILE)), \ ! 950: assemble_name ((FILE), (NAME)), \ ! 951: fprintf ((FILE), ",%u\n", (ROUNDED))) ! 952: #endif ! 953: ! 954: /* code to generate a label */ ! 955: ! 956: #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \ ! 957: ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10), \ ! 958: sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO))) ! 959: ! 960: /* Define the parentheses used to group arithmetic operations ! 961: in assembler code. */ ! 962: ! 963: #define ASM_OPEN_PAREN "(" ! 964: #define ASM_CLOSE_PAREN ")" ! 965: ! 966: /* Define results of standard character escape sequences. */ ! 967: ! 968: #define TARGET_BELL 007 ! 969: #define TARGET_BS 010 ! 970: #define TARGET_TAB 011 ! 971: #define TARGET_NEWLINE 012 ! 972: #define TARGET_VT 013 ! 973: #define TARGET_FF 014 ! 974: #define TARGET_CR 015 ! 975: ! 976: /* Print an instruction operand X on file FILE. ! 977: CODE is the code from the %-spec that requested printing this operand; ! 978: if `%z3' was used to print operand 3, then CODE is 'z'. ! 979: On the Vax, the only code used is `#', indicating that either ! 980: `d' or `g' should be printed, depending on whether we're using dfloat ! 981: or gfloat. */ ! 982: /* Print an operand. Some difference from the vax code, ! 983: since the tahoe can't support immediate floats and doubles. ! 984: ! 985: %@ means print the proper alignment operand for aligning after a casesi. ! 986: This depends on the assembler syntax. ! 987: This is 1 for our assembler, since .align is logarithmic. ! 988: ! 989: %s means the number given is supposed to be a shift value, but on ! 990: the tahoe it should be converted to a number that can be used as a ! 991: multiplicative constant (cause multiplication is a whole lot faster ! 992: than shifting). So make the number 2^n instead. */ ! 993: ! 994: #define PRINT_OPERAND_PUNCT_VALID_P(CODE) \ ! 995: ((CODE) == '@') ! 996: ! 997: #define PRINT_OPERAND(FILE, X, CODE) \ ! 998: { if (CODE == '@') \ ! 999: putc ('0' + CASE_ALIGNMENT, FILE); \ ! 1000: else if (CODE == 's') \ ! 1001: fprintf (FILE, "$%d", 1 << INTVAL(X)); \ ! 1002: else if (GET_CODE (X) == REG) \ ! 1003: fprintf (FILE, "%s", reg_names[REGNO (X)]); \ ! 1004: else if (GET_CODE (X) == MEM) \ ! 1005: output_address (XEXP (X, 0)); \ ! 1006: else { putc ('$', FILE); output_addr_const (FILE, X); }} ! 1007: ! 1008: /* When the operand is an address, call print_operand_address to */ ! 1009: /* do the work from output-tahoe.c. */ ! 1010: ! 1011: #define PRINT_OPERAND_ADDRESS(FILE, ADDR) \ ! 1012: print_operand_address (FILE, ADDR) ! 1013: ! 1014: /* This is for G++ */ ! 1015: ! 1016: #define CRT0_DUMMIES ! 1017: #define DOT_GLOBAL_START ! 1018: #ifdef HCX_UX ! 1019: #define NO_GNU_LD /* because of COFF format */ ! 1020: #define LINK_SPEC "-L/usr/staff/lib" ! 1021: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.