![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m88k.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / config / m88k|
Return to m88k.h CVS log | Up to [GCC 2.x] / gcc / config / m88k |
1.1.1.3 ! root 1: /* Definitions of target machine for GNU compiler for 1.1 root 2: Motorola m88100 in an 88open OCS/BCS environment. 1.1.1.3 ! root 3: Copyright (C) 1988, 89, 90, 91, 93, 1994 Free Software Foundation, Inc. 1.1 root 4: Contributed by Michael Tiemann ([email protected]) 5: Enhanced by Michael Meissner ([email protected]) 1.1.1.3 ! root 6: Version 2 port by Tom Wood ([email protected]) 1.1 root 7: 8: This file is part of GNU CC. 9: 10: GNU CC is free software; you can redistribute it and/or modify 11: it under the terms of the GNU General Public License as published by 12: the Free Software Foundation; either version 2, or (at your option) 13: any later version. 14: 15: GNU CC is distributed in the hope that it will be useful, 16: but WITHOUT ANY WARRANTY; without even the implied warranty of 17: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18: GNU General Public License for more details. 19: 20: You should have received a copy of the GNU General Public License 21: along with GNU CC; see the file COPYING. If not, write to 22: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ 23: 24: /* The m88100 port of GNU CC adheres to the various standards from 88open. 25: These documents are available by writing: 26: 27: 88open Consortium Ltd. 28: 100 Homeland Court, Suite 800 29: San Jose, CA 95112 30: (408) 436-6600 31: 32: In brief, the current standards are: 33: 34: Binary Compatibility Standard, Release 1.1A, May 1991 35: This provides for portability of application-level software at the 36: executable level for AT&T System V Release 3.2. 37: 38: Object Compatibility Standard, Release 1.1A, May 1991 39: This provides for portability of application-level software at the 40: object file and library level for C, Fortran, and Cobol, and again, 41: largely for SVR3. 42: 43: Under development are standards for AT&T System V Release 4, based on the 44: [generic] System V Application Binary Interface from AT&T. These include: 45: 46: System V Application Binary Interface, Motorola 88000 Processor Supplement 47: Another document from AT&T for SVR4 specific to the m88100. 48: Available from Prentice Hall. 49: 50: System V Application Binary Interface, Motorola 88000 Processor Supplement, 51: Release 1.1, Draft H, May 6, 1991 52: A proposed update to the AT&T document from 88open. 53: 54: System V ABI Implementation Guide for the M88000 Processor, 55: Release 1.0, January 1991 56: A companion ABI document from 88open. */ 57: 1.1.1.3 ! root 58: /* Other *.h files in config/m88k include this one and override certain items. ! 59: Currently these are sysv3.h, sysv4.h, dgux.h, dolph.h, tekXD88.h, and luna.h. ! 60: Additionally, sysv4.h and dgux.h include svr4.h first. All other ! 61: m88k targets except luna.h are based on svr3.h. */ 1.1 root 62: 63: /* Choose SVR3 as the default. */ 64: #if !defined(DBX_DEBUGGING_INFO) && !defined(DWARF_DEBUGGING_INFO) 65: #include "svr3.h" 66: #endif 67: 68: /* External types used. */ 69: 70: /* What instructions are needed to manufacture an integer constant. */ 71: enum m88k_instruction { 72: m88k_zero, 73: m88k_or, 74: m88k_subu, 75: m88k_or_lo16, 76: m88k_or_lo8, 77: m88k_set, 78: m88k_oru_hi16, 79: m88k_oru_or 80: }; 81: 1.1.1.3 ! root 82: /* Which processor to schedule for. The elements of the enumeration ! 83: must match exactly the cpu attribute in the m88k.md machine description. */ ! 84: ! 85: enum processor_type { ! 86: PROCESSOR_M88100, ! 87: PROCESSOR_M88110, ! 88: PROCESSOR_M88000, ! 89: }; ! 90: ! 91: /* Recast the cpu class to be the cpu attribute. */ ! 92: #define m88k_cpu_attr ((enum attr_cpu)m88k_cpu) ! 93: 1.1 root 94: /* External variables/functions defined in m88k.c. */ 95: 96: extern char *m88k_pound_sign; 97: extern char *m88k_short_data; 98: extern char *m88k_version; 99: extern char m88k_volatile_code; 100: 1.1.1.3 ! root 101: extern unsigned m88k_gp_threshold; 1.1 root 102: extern int m88k_prologue_done; 103: extern int m88k_function_number; 104: extern int m88k_fp_offset; 105: extern int m88k_stack_size; 106: extern int m88k_case_index; 107: 108: extern struct rtx_def *m88k_compare_reg; 109: extern struct rtx_def *m88k_compare_op0; 110: extern struct rtx_def *m88k_compare_op1; 111: 1.1.1.3 ! root 112: extern enum processor_type m88k_cpu; 1.1 root 113: 114: extern int null_prologue (); 115: extern int integer_ok_for_set (); 116: extern int m88k_debugger_offset (); 117: 118: extern void emit_bcnd (); 119: extern void expand_block_move (); 120: extern void m88k_layout_frame (); 121: extern void m88k_expand_prologue (); 122: extern void m88k_begin_prologue (); 123: extern void m88k_end_prologue (); 124: extern void m88k_expand_epilogue (); 125: extern void m88k_begin_epilogue (); 126: extern void m88k_end_epilogue (); 127: extern void output_function_profiler (); 128: extern void output_function_block_profiler (); 129: extern void output_block_profiler (); 130: extern void output_file_start (); 131: extern void output_ascii (); 132: extern void output_label (); 133: extern void print_operand (); 134: extern void print_operand_address (); 135: 136: extern char *output_load_const_int (); 137: extern char *output_load_const_float (); 138: extern char *output_load_const_double (); 139: extern char *output_load_const_dimode (); 140: extern char *output_and (); 141: extern char *output_ior (); 142: extern char *output_xor (); 143: extern char *output_call (); 144: 145: extern struct rtx_def *emit_test (); 146: extern struct rtx_def *legitimize_address (); 147: extern struct rtx_def *legitimize_operand (); 148: extern struct rtx_def *m88k_function_arg (); 149: extern struct rtx_def *m88k_builtin_saveregs (); 150: 151: extern enum m88k_instruction classify_integer (); 152: 153: /* external variables defined elsewhere in the compiler */ 154: 155: extern int target_flags; /* -m compiler switches */ 156: extern int frame_pointer_needed; /* current function has a FP */ 157: extern int current_function_pretend_args_size; /* args size without ... */ 158: extern int flag_delayed_branch; /* -fdelayed-branch */ 159: extern int flag_pic; /* -fpic */ 160: extern char * reg_names[]; 161: 162: /* Specify the default monitors. The meaning of these values can 163: be obtained by doing "grep MONITOR_GCC *m88k*". Generally, the 164: values downward from 0x8000 are tests that will soon go away. 165: values upward from 0x1 are generally useful tests that will remain. */ 166: 167: #ifndef MONITOR_GCC 168: #define MONITOR_GCC 0 169: #endif 170: 171: /*** Controlling the Compilation Driver, `gcc' ***/ 1.1.1.3 ! root 172: /* Show we can debug even without a frame pointer. */ ! 173: #define CAN_DEBUG_WITHOUT_FP 1.1 root 174: 175: /* If -m88100 is in effect, add -D__m88100__; similarly for -m88110. 176: Here, the CPU_DEFAULT is assumed to be -m88100. */ 177: #undef CPP_SPEC 178: #define CPP_SPEC "%{!m88000:%{!m88100:%{m88110:-D__m88110__}}} \ 179: %{!m88000:%{!m88110:-D__m88100__}}" 180: 181: /* LIB_SPEC, LINK_SPEC, and STARTFILE_SPEC defined in svr3.h. 182: ASM_SPEC, ASM_FINAL_SPEC, LIB_SPEC, LINK_SPEC, and STARTFILE_SPEC redefined 183: in svr4.h. 184: CPP_SPEC, ASM_SPEC, ASM_FINAL_SPEC, LIB_SPEC, LINK_SPEC, and 1.1.1.3 ! root 185: STARTFILE_SPEC redefined in dgux.h. */ 1.1 root 186: 187: /*** Run-time Target Specification ***/ 188: 189: /* Names to predefine in the preprocessor for this target machine. 1.1.1.3 ! root 190: Redefined in sysv3.h, sysv4.h, dgux.h, and luna.h. */ ! 191: #define CPP_PREDEFINES "-Dm88000 -Dm88k -Dunix -D__CLASSIFY_TYPE__=2" 1.1 root 192: 193: #define TARGET_VERSION fprintf (stderr, " (%s%s)", \ 194: VERSION_INFO1, VERSION_INFO2) 195: 196: /* Print subsidiary information on the compiler version in use. 1.1.1.3 ! root 197: Redefined in sysv4.h, and luna.h. */ 1.1 root 198: #define VERSION_INFO1 "88open OCS/BCS, " 1.1.1.3 ! root 199: #ifndef VERSION_INFO2 ! 200: #define VERSION_INFO2 "$Revision: 1.61 $" ! 201: #endif ! 202: ! 203: #ifndef VERSION_STRING ! 204: #define VERSION_STRING version_string ! 205: #ifdef __STDC__ ! 206: #define TM_RCS_ID "@(#)" __FILE__ " $Revision: 1.61 $ " __DATE__ ! 207: #else ! 208: #define TM_RCS_ID "$What$" ! 209: #endif /* __STDC__ */ ! 210: #else ! 211: #define TM_RCS_ID "@(#)" __FILE__ " " VERSION_INFO2 " " __DATE__ ! 212: #endif /* VERSION_STRING */ 1.1 root 213: 214: /* Run-time compilation parameters selecting different hardware subsets. */ 215: 216: /* Macro to define tables used to set the flags. 217: This is a list in braces of pairs in braces, 218: each pair being { "NAME", VALUE } 219: where VALUE is the bits to set or minus the bits to clear. 220: An empty string NAME is used to identify the default VALUE. */ 221: 222: #define MASK_88100 0x00000001 /* Target m88100 */ 223: #define MASK_88110 0x00000002 /* Target m88110 */ 224: #define MASK_OCS_DEBUG_INFO 0x00000004 /* Emit .tdesc info */ 225: #define MASK_OCS_FRAME_POSITION 0x00000008 /* Debug frame = CFA, not r30 */ 226: #define MASK_SVR4 0x00000010 /* Target is AT&T System V.4 */ 1.1.1.3 ! root 227: #define MASK_SVR3 0x00000020 /* Target is AT&T System V.3 */ 1.1 root 228: #define MASK_NO_UNDERSCORES 0x00000040 /* Don't emit a leading `_' */ 229: #define MASK_BIG_PIC 0x00000080 /* PIC with large got-rel's -fPIC */ 230: #define MASK_TRAP_LARGE_SHIFT 0x00000100 /* Trap if shift not <= 31 */ 231: #define MASK_HANDLE_LARGE_SHIFT 0x00000200 /* Handle shift count >= 32 */ 232: #define MASK_CHECK_ZERO_DIV 0x00000400 /* Check for int div. by 0 */ 233: #define MASK_USE_DIV 0x00000800 /* No signed div. checks */ 234: #define MASK_IDENTIFY_REVISION 0x00001000 /* Emit ident, with GCC rev */ 235: #define MASK_WARN_PASS_STRUCT 0x00002000 /* Warn about passed structs */ 236: #define MASK_OPTIMIZE_ARG_AREA 0x00004000 /* Save stack space */ 1.1.1.2 root 237: #define MASK_NO_SERIALIZE_VOLATILE 0x00008000 /* Serialize volatile refs */ 1.1 root 238: 239: #define MASK_88000 (MASK_88100 | MASK_88110) 240: #define MASK_EITHER_LARGE_SHIFT (MASK_TRAP_LARGE_SHIFT | \ 241: MASK_HANDLE_LARGE_SHIFT) 242: 243: #define TARGET_88100 ((target_flags & MASK_88000) == MASK_88100) 244: #define TARGET_88110 ((target_flags & MASK_88000) == MASK_88110) 245: #define TARGET_88000 ((target_flags & MASK_88000) == MASK_88000) 246: 247: #define TARGET_OCS_DEBUG_INFO (target_flags & MASK_OCS_DEBUG_INFO) 248: #define TARGET_OCS_FRAME_POSITION (target_flags & MASK_OCS_FRAME_POSITION) 249: #define TARGET_SVR4 (target_flags & MASK_SVR4) 1.1.1.3 ! root 250: #define TARGET_SVR3 (target_flags & MASK_SVR3) 1.1 root 251: #define TARGET_NO_UNDERSCORES (target_flags & MASK_NO_UNDERSCORES) 252: #define TARGET_BIG_PIC (target_flags & MASK_BIG_PIC) 253: #define TARGET_TRAP_LARGE_SHIFT (target_flags & MASK_TRAP_LARGE_SHIFT) 254: #define TARGET_HANDLE_LARGE_SHIFT (target_flags & MASK_HANDLE_LARGE_SHIFT) 255: #define TARGET_CHECK_ZERO_DIV (target_flags & MASK_CHECK_ZERO_DIV) 256: #define TARGET_USE_DIV (target_flags & MASK_USE_DIV) 257: #define TARGET_IDENTIFY_REVISION (target_flags & MASK_IDENTIFY_REVISION) 258: #define TARGET_WARN_PASS_STRUCT (target_flags & MASK_WARN_PASS_STRUCT) 259: #define TARGET_OPTIMIZE_ARG_AREA (target_flags & MASK_OPTIMIZE_ARG_AREA) 1.1.1.2 root 260: #define TARGET_SERIALIZE_VOLATILE (!(target_flags & MASK_NO_SERIALIZE_VOLATILE)) 1.1 root 261: 262: #define TARGET_EITHER_LARGE_SHIFT (target_flags & MASK_EITHER_LARGE_SHIFT) 263: 1.1.1.3 ! root 264: /* Redefined in sysv3.h, sysv4.h, and dgux.h. */ 1.1 root 265: #define TARGET_DEFAULT (MASK_CHECK_ZERO_DIV) 266: #define CPU_DEFAULT MASK_88100 267: 268: #define TARGET_SWITCHES \ 269: { \ 270: { "88110", MASK_88110 }, \ 271: { "88100", MASK_88100 }, \ 272: { "88000", MASK_88000 }, \ 273: { "ocs-debug-info", MASK_OCS_DEBUG_INFO }, \ 274: { "no-ocs-debug-info", -MASK_OCS_DEBUG_INFO }, \ 275: { "ocs-frame-position", MASK_OCS_FRAME_POSITION }, \ 276: { "no-ocs-frame-position", -MASK_OCS_FRAME_POSITION }, \ 277: { "svr4", MASK_SVR4 }, \ 278: { "svr3", -MASK_SVR4 }, \ 279: { "no-underscores", MASK_NO_UNDERSCORES }, \ 280: { "big-pic", MASK_BIG_PIC }, \ 281: { "trap-large-shift", MASK_TRAP_LARGE_SHIFT }, \ 282: { "handle-large-shift", MASK_HANDLE_LARGE_SHIFT }, \ 283: { "check-zero-division", MASK_CHECK_ZERO_DIV }, \ 284: { "no-check-zero-division", -MASK_CHECK_ZERO_DIV }, \ 285: { "use-div-instruction", MASK_USE_DIV }, \ 286: { "identify-revision", MASK_IDENTIFY_REVISION }, \ 287: { "warn-passed-structs", MASK_WARN_PASS_STRUCT }, \ 288: { "optimize-arg-area", MASK_OPTIMIZE_ARG_AREA }, \ 289: { "no-optimize-arg-area", -MASK_OPTIMIZE_ARG_AREA }, \ 290: { "no-serialize-volatile", MASK_NO_SERIALIZE_VOLATILE }, \ 1.1.1.2 root 291: { "serialize-volatile", -MASK_NO_SERIALIZE_VOLATILE }, \ 1.1 root 292: SUBTARGET_SWITCHES \ 293: /* Default switches */ \ 294: { "", TARGET_DEFAULT }, \ 295: } 296: 1.1.1.3 ! root 297: /* Redefined in dgux.h. */ 1.1 root 298: #define SUBTARGET_SWITCHES 299: 300: /* Macro to define table for command options with values. */ 301: 302: #define TARGET_OPTIONS { { "short-data-", &m88k_short_data }, \ 303: { "version-", &m88k_version } } 304: 305: /* Do any checking or such that is needed after processing the -m switches. */ 306: 307: #define OVERRIDE_OPTIONS \ 308: do { \ 309: register int i; \ 310: \ 311: if ((target_flags & MASK_88000) == 0) \ 312: target_flags |= CPU_DEFAULT; \ 313: \ 1.1.1.3 ! root 314: if (TARGET_88110) \ ! 315: { \ ! 316: target_flags |= MASK_USE_DIV; \ ! 317: target_flags &= ~MASK_CHECK_ZERO_DIV; \ ! 318: } \ ! 319: \ ! 320: m88k_cpu = (TARGET_88000 ? PROCESSOR_M88000 \ ! 321: : (TARGET_88100 ? PROCESSOR_M88100 : PROCESSOR_M88110)); \ 1.1 root 322: \ 323: if (TARGET_BIG_PIC) \ 324: flag_pic = 2; \ 325: \ 326: if ((target_flags & MASK_EITHER_LARGE_SHIFT) == MASK_EITHER_LARGE_SHIFT) \ 327: error ("-mtrap-large-shift and -mhandle-large-shift are incompatible");\ 328: \ 1.1.1.3 ! root 329: if (TARGET_SVR4) \ 1.1 root 330: { \ 331: for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) \ 332: reg_names[i]--; \ 333: m88k_pound_sign = "#"; \ 334: } \ 1.1.1.3 ! root 335: else \ ! 336: { \ ! 337: target_flags |= MASK_SVR3; \ ! 338: target_flags &= ~MASK_SVR4; \ ! 339: } \ 1.1 root 340: \ 341: if (m88k_short_data) \ 342: { \ 343: char *p = m88k_short_data; \ 344: while (*p) \ 345: if (*p >= '0' && *p <= '9') \ 346: p++; \ 347: else \ 348: { \ 349: error ("Invalid option `-mshort-data-%s'", m88k_short_data); \ 350: break; \ 351: } \ 352: m88k_gp_threshold = atoi (m88k_short_data); \ 1.1.1.3 ! root 353: if (m88k_gp_threshold > 0x7fffffff) \ ! 354: error ("-mshort-data-%s is too large ", m88k_short_data); \ 1.1 root 355: if (flag_pic) \ 356: error ("-mshort-data-%s and PIC are incompatible", m88k_short_data); \ 357: } \ 358: } while (0) 359: 360: /*** Storage Layout ***/ 361: 362: /* Sizes in bits of the various types. */ 363: #define CHAR_TYPE_SIZE 8 364: #define SHORT_TYPE_SIZE 16 365: #define INT_TYPE_SIZE 32 366: #define LONG_TYPE_SIZE 32 367: #define LONG_LONG_TYPE_SIZE 64 368: #define FLOAT_TYPE_SIZE 32 369: #define DOUBLE_TYPE_SIZE 64 370: #define LONG_DOUBLE_TYPE_SIZE 64 371: 372: /* Define this if most significant bit is lowest numbered 373: in instructions that operate on numbered bit-fields. 374: Somewhat arbitrary. It matches the bit field patterns. */ 375: #define BITS_BIG_ENDIAN 1 376: 377: /* Define this if most significant byte of a word is the lowest numbered. 378: That is true on the m88000. */ 379: #define BYTES_BIG_ENDIAN 1 380: 381: /* Define this if most significant word of a multiword number is the lowest 382: numbered. 383: For the m88000 we can decide arbitrarily since there are no machine 384: instructions for them. */ 385: #define WORDS_BIG_ENDIAN 1 386: 387: /* Number of bits in an addressable storage unit */ 388: #define BITS_PER_UNIT 8 389: 390: /* Width in bits of a "word", which is the contents of a machine register. 391: Note that this is not necessarily the width of data type `int'; 392: if using 16-bit ints on a 68000, this would still be 32. 393: But on a machine with 16-bit registers, this would be 16. */ 394: #define BITS_PER_WORD 32 395: 396: /* Width of a word, in units (bytes). */ 397: #define UNITS_PER_WORD 4 398: 399: /* Width in bits of a pointer. 400: See also the macro `Pmode' defined below. */ 401: #define POINTER_SIZE 32 402: 403: /* Allocation boundary (in *bits*) for storing arguments in argument list. */ 404: #define PARM_BOUNDARY 32 405: 406: /* Largest alignment for stack parameters (if greater than PARM_BOUNDARY). */ 407: #define MAX_PARM_BOUNDARY 64 408: 409: /* Boundary (in *bits*) on which stack pointer should be aligned. */ 410: #define STACK_BOUNDARY 128 411: 412: /* Allocation boundary (in *bits*) for the code of a function. On the 413: m88100, it is desirable to align to a cache line. However, SVR3 targets 414: only provided 8 byte alignment. The m88110 cache is small, so align 415: to an 8 byte boundary. Pack code tightly when compiling crtstuff.c. */ 416: #define FUNCTION_BOUNDARY (flag_inhibit_size_directive ? 32 : \ 417: (TARGET_88100 && TARGET_SVR4 ? 128 : 64)) 418: 419: /* No data type wants to be aligned rounder than this. */ 420: #define BIGGEST_ALIGNMENT 64 421: 422: /* The best alignment to use in cases where we have a choice. */ 423: #define FASTEST_ALIGNMENT (TARGET_88100 ? 32 : 64) 424: 425: /* Make strings 4/8 byte aligned so strcpy from constants will be faster. */ 426: #define CONSTANT_ALIGNMENT(EXP, ALIGN) \ 427: ((TREE_CODE (EXP) == STRING_CST \ 428: && (ALIGN) < FASTEST_ALIGNMENT) \ 429: ? FASTEST_ALIGNMENT : (ALIGN)) 430: 431: /* Make arrays of chars 4/8 byte aligned for the same reasons. */ 432: #define DATA_ALIGNMENT(TYPE, ALIGN) \ 433: (TREE_CODE (TYPE) == ARRAY_TYPE \ 434: && TYPE_MODE (TREE_TYPE (TYPE)) == QImode \ 435: && (ALIGN) < FASTEST_ALIGNMENT ? FASTEST_ALIGNMENT : (ALIGN)) 436: 437: /* Alignment of field after `int : 0' in a structure. 438: Ignored with PCC_BITFIELD_TYPE_MATTERS. */ 439: /* #define EMPTY_FIELD_BOUNDARY 8 */ 440: 441: /* Every structure's size must be a multiple of this. */ 442: #define STRUCTURE_SIZE_BOUNDARY 8 443: 444: /* Set this nonzero if move instructions will actually fail to work 445: when given unaligned data. */ 446: #define STRICT_ALIGNMENT 1 447: 448: /* A bitfield declared as `int' forces `int' alignment for the struct. */ 449: #define PCC_BITFIELD_TYPE_MATTERS 1 450: 451: /* Maximum size (in bits) to use for the largest integral type that 452: replaces a BLKmode type. */ 453: /* #define MAX_FIXED_MODE_SIZE 0 */ 454: 455: /* Check a `double' value for validity for a particular machine mode. 456: This is defined to avoid crashes outputting certain constants. 457: Since we output the number in hex, the assembler won't choke on it. */ 458: /* #define CHECK_FLOAT_VALUE(MODE,VALUE) */ 459: 460: /* A code distinguishing the floating point format of the target machine. */ 461: /* #define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT */ 462: 463: /*** Register Usage ***/ 464: 465: /* Number of actual hardware registers. 466: The hardware registers are assigned numbers for the compiler 467: from 0 to just below FIRST_PSEUDO_REGISTER. 468: All registers that the compiler knows about must be given numbers, 469: even those that are not normally considered general registers. 470: 471: The m88100 has a General Register File (GRF) of 32 32-bit registers. 472: The m88110 adds an Extended Register File (XRF) of 32 80-bit registers. */ 473: #define FIRST_PSEUDO_REGISTER 64 474: #define FIRST_EXTENDED_REGISTER 32 475: 476: /* General notes on extended registers, their use and misuse. 477: 478: Possible good uses: 479: 480: spill area instead of memory. 481: -waste if only used once 482: 483: floating point calculations 484: -probably a waste unless we have run out of general purpose registers 485: 486: freeing up general purpose registers 487: -e.g. may be able to have more loop invariants if floating 488: point is moved into extended registers. 489: 490: 491: I've noticed wasteful moves into and out of extended registers; e.g. a load 492: into x21, then inside a loop a move into r24, then r24 used as input to 493: an fadd. Why not just load into r24 to begin with? Maybe the new cse.c 494: will address this. This wastes a move, but the load,store and move could 495: have been saved had extended registers been used throughout. 496: E.g. in the code following code, if z and xz are placed in extended 497: registers, there is no need to save preserve registers. 498: 499: long c=1,d=1,e=1,f=1,g=1,h=1,i=1,j=1,k; 500: 501: double z=0,xz=4.5; 502: 503: foo(a,b) 504: long a,b; 505: { 506: while (a < b) 507: { 508: k = b + c + d + e + f + g + h + a + i + j++; 509: z += xz; 510: a++; 511: } 512: printf("k= %d; z=%f;\n", k, z); 513: } 514: 515: I've found that it is possible to change the constraints (putting * before 516: the 'r' constraints int the fadd.ddd instruction) and get the entire 517: addition and store to go into extended registers. However, this also 518: forces simple addition and return of floating point arguments to a 519: function into extended registers. Not the correct solution. 520: 521: Found the following note in local-alloc.c which may explain why I can't 522: get both registers to be in extended registers since two are allocated in 523: local-alloc and one in global-alloc. Doesn't explain (I don't believe) 524: why an extended register is used instead of just using the preserve 525: register. 526: 527: from local-alloc.c: 528: We have provision to exempt registers, even when they are contained 529: within the block, that can be tied to others that are not contained in it. 530: This is so that global_alloc could process them both and tie them then. 531: But this is currently disabled since tying in global_alloc is not 532: yet implemented. 533: 534: The explanation of why the preserved register is not used is as follows, 535: I believe. The registers are being allocated in order. Tying is not 536: done so efficiently, so when it comes time to do the first allocation, 537: there are no registers left to use without spilling except extended 538: registers. Then when the next pseudo register needs a hard reg, there 539: are still no registers to be had for free, but this one must be a GRF 540: reg instead of an extended reg, so a preserve register is spilled. Thus 541: the move from extended to GRF is necessitated. I do not believe this can 542: be 'fixed' through the config/*m88k* files. 543: 544: gcc seems to sometimes make worse use of register allocation -- not counting 545: moves -- whenever extended registers are present. For example in the 546: whetstone, the simple for loop (slightly modified) 547: for(i = 1; i <= n1; i++) 548: { 549: x1 = (x1 + x2 + x3 - x4) * t; 550: x2 = (x1 + x2 - x3 + x4) * t; 551: x3 = (x1 - x2 + x3 + x4) * t; 552: x4 = (x1 + x2 + x3 + x4) * t; 553: } 554: in general loads the high bits of the addresses of x2-x4 and i into registers 555: outside the loop. Whenever extended registers are used, it loads all of 556: these inside the loop. My conjecture is that since the 88110 has so many 557: registers, and gcc makes no distinction at this point -- just that they are 558: not fixed, that in loop.c it believes it can expect a number of registers 559: to be available. Then it allocates 'too many' in local-alloc which causes 560: problems later. 'Too many' are allocated because a large portion of the 561: registers are extended registers and cannot be used for certain purposes 562: ( e.g. hold the address of a variable). When this loop is compiled on its 563: own, the problem does not occur. I don't know the solution yet, though it 564: is probably in the base sources. Possibly a different way to calculate 565: "threshold". */ 566: 567: /* 1 for registers that have pervasive standard uses and are not available 568: for the register allocator. Registers r14-r25 and x22-x29 are expected 569: to be preserved across function calls. 570: 571: On the 88000, the standard uses of the General Register File (GRF) are: 572: Reg 0 = Pseudo argument pointer (hardware fixed to 0). 573: Reg 1 = Subroutine return pointer (hardware). 574: Reg 2-9 = Parameter registers (OCS). 575: Reg 10 = OCS reserved temporary. 576: Reg 11 = Static link if needed [OCS reserved temporary]. 577: Reg 12 = Address of structure return (OCS). 578: Reg 13 = OCS reserved temporary. 579: Reg 14-25 = Preserved register set. 580: Reg 26-29 = Reserved by OCS and ABI. 581: Reg 30 = Frame pointer (Common use). 582: Reg 31 = Stack pointer. 583: 584: The following follows the current 88open UCS specification for the 585: Extended Register File (XRF): 586: Reg 32 = x0 Always equal to zero 587: Reg 33-53 = x1-x21 Temporary registers (Caller Save) 588: Reg 54-61 = x22-x29 Preserver registers (Callee Save) 589: Reg 62-63 = x30-x31 Reserved for future ABI use. 590: 591: Note: The current 88110 extended register mapping is subject to change. 592: The bias towards caller-save registers is based on the 593: presumption that memory traffic can potentially be reduced by 594: allowing the "caller" to save only that part of the register 595: which is actually being used. (i.e. don't do a st.x if a st.d 596: is sufficient). Also, in scientific code (a.k.a. Fortran), the 597: large number of variables defined in common blocks may require 598: that almost all registers be saved across calls anyway. */ 599: 600: #define FIXED_REGISTERS \ 601: {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ 602: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, \ 603: 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ 604: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1} 605: 606: /* 1 for registers not available across function calls. 607: These must include the FIXED_REGISTERS and also any 608: registers that can be used without being saved. 609: The latter must include the registers where values are returned 610: and the register where structure-value addresses are passed. 611: Aside from that, you can include as many other registers as you like. */ 612: 613: #define CALL_USED_REGISTERS \ 614: {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, \ 615: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, \ 616: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 617: 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1} 618: 619: /* Macro to conditionally modify fixed_regs/call_used_regs. */ 620: #define CONDITIONAL_REGISTER_USAGE \ 621: { \ 622: if (! TARGET_88110) \ 623: { \ 624: register int i; \ 625: for (i = FIRST_EXTENDED_REGISTER; i < FIRST_PSEUDO_REGISTER; i++) \ 626: { \ 627: fixed_regs[i] = 1; \ 628: call_used_regs[i] = 1; \ 629: } \ 630: } \ 631: if (flag_pic) \ 632: { \ 633: /* Current hack to deal with -fpic -O2 problems. */ \ 634: fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; \ 635: call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; \ 636: global_regs[PIC_OFFSET_TABLE_REGNUM] = 1; \ 637: } \ 638: } 639: 640: /* These interfaces that don't apply to the m88000. */ 641: /* OVERLAPPING_REGNO_P(REGNO) 0 */ 642: /* INSN_CLOBBERS_REGNO_P(INSN, REGNO) 0 */ 643: /* PRESERVE_DEATH_INFO_REGNO_P(REGNO) 0 */ 644: 645: /* True if register is an extended register. */ 646: #define XRF_REGNO_P(N) ((N) < FIRST_PSEUDO_REGISTER && (N) >= FIRST_EXTENDED_REGISTER) 647: 648: /* Return number of consecutive hard regs needed starting at reg REGNO 649: to hold something of mode MODE. 650: This is ordinarily the length in words of a value of mode MODE 651: but can be less for certain modes in special long registers. 652: 653: On the m88000, GRF registers hold 32-bits and XRF registers hold 80-bits. 654: An XRF register can hold any mode, but two GRF registers are required 655: for larger modes. */ 656: #define HARD_REGNO_NREGS(REGNO, MODE) \ 657: (XRF_REGNO_P (REGNO) \ 658: ? 1 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) 659: 660: /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE. 661: 662: For double integers, we never put the value into an odd register so that 663: the operators don't run into the situation where the high part of one of 664: the inputs is the low part of the result register. (It's ok if the output 665: registers are the same as the input registers.) The XRF registers can 666: hold all modes, but only DF and SF modes can be manipulated in these 667: registers. The compiler should be allowed to use these as a fast spill 668: area. */ 669: #define HARD_REGNO_MODE_OK(REGNO, MODE) \ 670: (XRF_REGNO_P(REGNO) \ 671: ? (TARGET_88110 && GET_MODE_CLASS (MODE) == MODE_FLOAT) \ 672: : (((MODE) != DImode && (MODE) != DFmode && (MODE) != DCmode) \ 673: || ((REGNO) & 1) == 0)) 674: 675: /* Value is 1 if it is a good idea to tie two pseudo registers 676: when one has mode MODE1 and one has mode MODE2. 677: If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2, 678: for any hard reg, then this must be 0 for correct output. */ 679: #define MODES_TIEABLE_P(MODE1, MODE2) \ 680: (((MODE1) == DFmode || (MODE1) == DCmode || (MODE1) == DImode \ 681: || (TARGET_88110 && GET_MODE_CLASS (MODE1) == MODE_FLOAT)) \ 682: == ((MODE2) == DFmode || (MODE2) == DCmode || (MODE2) == DImode \ 683: || (TARGET_88110 && GET_MODE_CLASS (MODE2) == MODE_FLOAT))) 684: 685: /* Specify the registers used for certain standard purposes. 686: The values of these macros are register numbers. */ 687: 688: /* the m88000 pc isn't overloaded on a register that the compiler knows about. */ 689: /* #define PC_REGNUM */ 690: 691: /* Register to use for pushing function arguments. */ 692: #define STACK_POINTER_REGNUM 31 693: 694: /* Base register for access to local variables of the function. */ 695: #define FRAME_POINTER_REGNUM 30 696: 697: /* Base register for access to arguments of the function. */ 698: #define ARG_POINTER_REGNUM 0 699: 700: /* Register used in cases where a temporary is known to be safe to use. */ 701: #define TEMP_REGNUM 10 702: 703: /* Register in which static-chain is passed to a function. */ 704: #define STATIC_CHAIN_REGNUM 11 705: 706: /* Register in which address to store a structure value 707: is passed to a function. */ 708: #define STRUCT_VALUE_REGNUM 12 709: 710: /* Register to hold the addressing base for position independent 711: code access to data items. */ 712: #define PIC_OFFSET_TABLE_REGNUM 25 713: 714: /* Order in which registers are preferred (most to least). Use temp 715: registers, then param registers top down. Preserve registers are 716: top down to maximize use of double memory ops for register save. 717: The 88open reserved registers (r26-r29 and x30-x31) may commonly be used 718: in most environments with the -fcall-used- or -fcall-saved- options. */ 719: #define REG_ALLOC_ORDER \ 720: { \ 721: 13, 12, 11, 10, 29, 28, 27, 26, \ 722: 62, 63, 9, 8, 7, 6, 5, 4, \ 723: 3, 2, 1, 53, 52, 51, 50, 49, \ 724: 48, 47, 46, 45, 44, 43, 42, 41, \ 725: 40, 39, 38, 37, 36, 35, 34, 33, \ 726: 25, 24, 23, 22, 21, 20, 19, 18, \ 727: 17, 16, 15, 14, 61, 60, 59, 58, \ 728: 57, 56, 55, 54, 30, 31, 0, 32} 729: 730: /* Order for leaf functions. */ 731: #define REG_LEAF_ALLOC_ORDER \ 732: { \ 733: 9, 8, 7, 6, 13, 12, 11, 10, \ 734: 29, 28, 27, 26, 62, 63, 5, 4, \ 735: 3, 2, 0, 53, 52, 51, 50, 49, \ 736: 48, 47, 46, 45, 44, 43, 42, 41, \ 737: 40, 39, 38, 37, 36, 35, 34, 33, \ 738: 25, 24, 23, 22, 21, 20, 19, 18, \ 739: 17, 16, 15, 14, 61, 60, 59, 58, \ 740: 57, 56, 55, 54, 30, 31, 1, 32} 741: 742: /* Switch between the leaf and non-leaf orderings. The purpose is to avoid 743: write-over scoreboard delays between caller and callee. */ 744: #define ORDER_REGS_FOR_LOCAL_ALLOC \ 745: { \ 746: static int leaf[] = REG_LEAF_ALLOC_ORDER; \ 747: static int nonleaf[] = REG_ALLOC_ORDER; \ 748: \ 749: bcopy (regs_ever_live[1] ? nonleaf : leaf, reg_alloc_order, \ 750: FIRST_PSEUDO_REGISTER * sizeof (int)); \ 751: } 752: 753: /*** Register Classes ***/ 754: 755: /* Define the classes of registers for register constraints in the 756: machine description. Also define ranges of constants. 757: 758: One of the classes must always be named ALL_REGS and include all hard regs. 759: If there is more than one class, another class must be named NO_REGS 760: and contain no registers. 761: 762: The name GENERAL_REGS must be the name of a class (or an alias for 763: another name such as ALL_REGS). This is the class of registers 764: that is allowed by "g" or "r" in a register constraint. 765: Also, registers outside this class are allocated only when 766: instructions express preferences for them. 767: 768: The classes must be numbered in nondecreasing order; that is, 769: a larger-numbered class must never be contained completely 770: in a smaller-numbered class. 771: 772: For any two classes, it is very desirable that there be another 773: class that represents their union. */ 774: 775: /* The m88000 hardware has two kinds of registers. In addition, we denote 776: the arg pointer as a separate class. */ 777: 778: enum reg_class { NO_REGS, AP_REG, XRF_REGS, GENERAL_REGS, AGRF_REGS, 779: XGRF_REGS, ALL_REGS, LIM_REG_CLASSES }; 780: 781: #define N_REG_CLASSES (int) LIM_REG_CLASSES 782: 783: /* Give names of register classes as strings for dump file. */ 784: #define REG_CLASS_NAMES {"NO_REGS", "AP_REG", "XRF_REGS", "GENERAL_REGS", \ 785: "AGRF_REGS", "XGRF_REGS", "ALL_REGS" } 786: 787: /* Define which registers fit in which classes. 788: This is an initializer for a vector of HARD_REG_SET 789: of length N_REG_CLASSES. */ 790: #define REG_CLASS_CONTENTS {{0x00000000, 0x00000000}, \ 791: {0x00000001, 0x00000000}, \ 792: {0x00000000, 0xffffffff}, \ 793: {0xfffffffe, 0x00000000}, \ 794: {0xffffffff, 0x00000000}, \ 795: {0xfffffffe, 0xffffffff}, \ 796: {0xffffffff, 0xffffffff}} 797: 798: /* The same information, inverted: 799: Return the class number of the smallest class containing 800: reg number REGNO. This could be a conditional expression 801: or could index an array. */ 802: #define REGNO_REG_CLASS(REGNO) \ 803: ((REGNO) ? ((REGNO < 32) ? GENERAL_REGS : XRF_REGS) : AP_REG) 804: 805: /* The class value for index registers, and the one for base regs. */ 806: #define BASE_REG_CLASS AGRF_REGS 807: #define INDEX_REG_CLASS GENERAL_REGS 808: 809: /* Get reg_class from a letter such as appears in the machine description. 810: For the 88000, the following class/letter is defined for the XRF: 811: x - Extended register file */ 812: #define REG_CLASS_FROM_LETTER(C) \ 813: (((C) == 'x') ? XRF_REGS : NO_REGS) 814: 815: /* Macros to check register numbers against specific register classes. 816: These assume that REGNO is a hard or pseudo reg number. 817: They give nonzero only if REGNO is a hard reg of the suitable class 818: or a pseudo reg currently allocated to a suitable hard reg. 819: Since they use reg_renumber, they are safe only once reg_renumber 820: has been allocated, which happens in local-alloc.c. */ 821: #define REGNO_OK_FOR_BASE_P(REGNO) \ 822: ((REGNO) < FIRST_EXTENDED_REGISTER \ 823: || (unsigned) reg_renumber[REGNO] < FIRST_EXTENDED_REGISTER) 824: #define REGNO_OK_FOR_INDEX_P(REGNO) \ 825: (((REGNO) && (REGNO) < FIRST_EXTENDED_REGISTER) \ 826: || (unsigned) reg_renumber[REGNO] < FIRST_EXTENDED_REGISTER) 827: 828: /* Given an rtx X being reloaded into a reg required to be 829: in class CLASS, return the class of reg to actually use. 830: In general this is just CLASS; but on some machines 831: in some cases it is preferable to use a more restrictive class. 832: Double constants should be in a register iff they can be made cheaply. */ 833: #define PREFERRED_RELOAD_CLASS(X,CLASS) \ 834: (CONSTANT_P(X) && (CLASS == XRF_REGS) ? NO_REGS : (CLASS)) 835: 836: /* Return the register class of a scratch register needed to load IN 837: into a register of class CLASS in MODE. On the m88k, when PIC, we 838: need a temporary when loading some addresses into a register. */ 839: #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, IN) \ 840: ((flag_pic \ 841: && GET_CODE (IN) == CONST \ 842: && GET_CODE (XEXP (IN, 0)) == PLUS \ 843: && GET_CODE (XEXP (XEXP (IN, 0), 0)) == CONST_INT \ 844: && ! SMALL_INT (XEXP (XEXP (IN, 0), 1))) ? GENERAL_REGS : NO_REGS) 845: 846: /* Return the maximum number of consecutive registers 847: needed to represent mode MODE in a register of class CLASS. */ 848: #define CLASS_MAX_NREGS(CLASS, MODE) \ 849: ((((CLASS) == XRF_REGS) ? 1 \ 850: : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))) 851: 852: /* Letters in the range `I' through `P' in a register constraint string can 853: be used to stand for particular ranges of immediate operands. The C 854: expression is true iff C is a known letter and VALUE is appropriate for 855: that letter. 856: 857: For the m88000, the following constants are used: 858: `I' requires a non-negative 16-bit value. 859: `J' requires a non-positive 16-bit value. 860: `K' requires a non-negative value < 32. 861: `L' requires a constant with only the upper 16-bits set. 862: `M' requires constant values that can be formed with `set'. 863: `N' requires a negative value. 864: `O' requires zero. 865: `P' requires a non-negative value. */ 866: 867: /* Quick tests for certain values. */ 868: #define SMALL_INT(X) (SMALL_INTVAL (INTVAL (X))) 869: #define SMALL_INTVAL(I) ((unsigned) (I) < 0x10000) 870: #define ADD_INT(X) (ADD_INTVAL (INTVAL (X))) 871: #define ADD_INTVAL(I) ((unsigned) (I) + 0xffff < 0x1ffff) 872: #define POWER_OF_2(I) ((I) && POWER_OF_2_or_0(I)) 873: #define POWER_OF_2_or_0(I) (((I) & ((unsigned)(I) - 1)) == 0) 874: 875: #define CONST_OK_FOR_LETTER_P(VALUE, C) \ 876: ((C) == 'I' ? SMALL_INTVAL (VALUE) \ 877: : (C) == 'J' ? SMALL_INTVAL (-(VALUE)) \ 878: : (C) == 'K' ? (unsigned)(VALUE) < 32 \ 879: : (C) == 'L' ? ((VALUE) & 0xffff) == 0 \ 880: : (C) == 'M' ? integer_ok_for_set (VALUE) \ 881: : (C) == 'N' ? (VALUE) < 0 \ 882: : (C) == 'O' ? (VALUE) == 0 \ 883: : (C) == 'P' ? (VALUE) >= 0 \ 884: : 0) 885: 886: /* Similar, but for floating constants, and defining letters G and H. 887: Here VALUE is the CONST_DOUBLE rtx itself. For the m88000, the 888: constraints are: `G' requires zero, and `H' requires one or two. */ 889: #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \ 890: ((C) == 'G' ? (CONST_DOUBLE_HIGH (VALUE) == 0 \ 891: && CONST_DOUBLE_LOW (VALUE) == 0) \ 892: : 0) 893: 894: /* Letters in the range `Q' through `U' in a register constraint string 895: may be defined in a machine-dependent fashion to stand for arbitrary 896: operand types. 897: 898: For the m88k, `Q' handles addresses in a call context. */ 899: 900: #define EXTRA_CONSTRAINT(OP, C) \ 901: ((C) == 'Q' ? symbolic_address_p (OP) : 0) 902: 903: /*** Describing Stack Layout ***/ 904: 905: /* Define this if pushing a word on the stack moves the stack pointer 906: to a smaller address. */ 907: #define STACK_GROWS_DOWNWARD 908: 909: /* Define this if the addresses of local variable slots are at negative 910: offsets from the frame pointer. */ 911: /* #define FRAME_GROWS_DOWNWARD */ 912: 913: /* Offset from the frame pointer to the first local variable slot to be 914: allocated. For the m88k, the debugger wants the return address (r1) 915: stored at location r30+4, and the previous frame pointer stored at 916: location r30. */ 917: #define STARTING_FRAME_OFFSET 8 918: 919: /* If we generate an insn to push BYTES bytes, this says how many the 920: stack pointer really advances by. The m88k has no push instruction. */ 921: /* #define PUSH_ROUNDING(BYTES) */ 922: 923: /* If defined, the maximum amount of space required for outgoing arguments 924: will be computed and placed into the variable 925: `current_function_outgoing_args_size'. No space will be pushed 926: onto the stack for each call; instead, the function prologue should 927: increase the stack frame size by this amount. */ 928: #define ACCUMULATE_OUTGOING_ARGS 929: 930: /* Offset from the stack pointer register to the first location at which 931: outgoing arguments are placed. Use the default value zero. */ 932: /* #define STACK_POINTER_OFFSET 0 */ 933: 934: /* Offset of first parameter from the argument pointer register value. 935: Using an argument pointer, this is 0 for the m88k. GCC knows 936: how to eliminate the argument pointer references if necessary. */ 937: #define FIRST_PARM_OFFSET(FNDECL) 0 938: 939: /* Define this if functions should assume that stack space has been 940: allocated for arguments even when their values are passed in 941: registers. 942: 943: The value of this macro is the size, in bytes, of the area reserved for 944: arguments passed in registers. 945: 946: This space can either be allocated by the caller or be a part of the 947: machine-dependent stack frame: `OUTGOING_REG_PARM_STACK_SPACE' 948: says which. */ 949: #define REG_PARM_STACK_SPACE(FNDECL) 32 950: 951: /* Define this macro if REG_PARM_STACK_SPACE is defined but stack 952: parameters don't skip the area specified by REG_PARM_STACK_SPACE. 953: Normally, when a parameter is not passed in registers, it is placed on 954: the stack beyond the REG_PARM_STACK_SPACE area. Defining this macro 955: suppresses this behavior and causes the parameter to be passed on the 956: stack in its natural location. */ 957: #define STACK_PARMS_IN_REG_PARM_AREA 958: 959: /* Define this if it is the responsibility of the caller to allocate the 960: area reserved for arguments passed in registers. If 961: `ACCUMULATE_OUTGOING_ARGS' is also defined, the only effect of this 962: macro is to determine whether the space is included in 963: `current_function_outgoing_args_size'. */ 964: /* #define OUTGOING_REG_PARM_STACK_SPACE */ 965: 966: /* Offset from the stack pointer register to an item dynamically allocated 967: on the stack, e.g., by `alloca'. 968: 969: The default value for this macro is `STACK_POINTER_OFFSET' plus the 970: length of the outgoing arguments. The default is correct for most 971: machines. See `function.c' for details. */ 972: /* #define STACK_DYNAMIC_OFFSET(FUNDECL) ... */ 973: 974: /* Value is the number of bytes of arguments automatically 975: popped when returning from a subroutine call. 976: FUNTYPE is the data type of the function (as a tree), 977: or for a library call it is an identifier node for the subroutine name. 978: SIZE is the number of bytes of arguments passed on the stack. */ 979: #define RETURN_POPS_ARGS(FUNTYPE,SIZE) 0 980: 981: /* Define how to find the value returned by a function. 982: VALTYPE is the data type of the value (as a tree). 983: If the precise function being called is known, FUNC is its FUNCTION_DECL; 984: otherwise, FUNC is 0. */ 985: #define FUNCTION_VALUE(VALTYPE, FUNC) \ 986: gen_rtx (REG, \ 987: TYPE_MODE (VALTYPE) == BLKmode ? SImode : TYPE_MODE (VALTYPE), \ 988: 2) 989: 990: /* Define this if it differs from FUNCTION_VALUE. */ 991: /* #define FUNCTION_OUTGOING_VALUE(VALTYPE, FUNC) ... */ 992: 993: /* Disable the promotion of some structures and unions to registers. */ 994: #define RETURN_IN_MEMORY(TYPE) \ 995: (TYPE_MODE (TYPE) == BLKmode \ 996: || ((TREE_CODE (TYPE) == RECORD_TYPE || TREE_CODE(TYPE) == UNION_TYPE) \ 997: && !(TYPE_MODE (TYPE) == SImode \ 998: || (TYPE_MODE (TYPE) == BLKmode \ 999: && TYPE_ALIGN (TYPE) == BITS_PER_WORD \ 1000: && int_size_in_bytes (TYPE) == UNITS_PER_WORD)))) 1001: 1002: /* Don't default to pcc-struct-return, because we have already specified 1003: exactly how to return structures in the RETURN_IN_MEMORY macro. */ 1004: #define DEFAULT_PCC_STRUCT_RETURN 0 1005: 1006: /* Define how to find the value returned by a library function 1007: assuming the value has mode MODE. */ 1008: #define LIBCALL_VALUE(MODE) gen_rtx (REG, MODE, 2) 1009: 1010: /* True if N is a possible register number for a function value 1011: as seen by the caller. */ 1012: #define FUNCTION_VALUE_REGNO_P(N) ((N) == 2) 1013: 1014: /* Determine whether a function argument is passed in a register, and 1015: which register. See m88k.c. */ 1016: #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \ 1017: m88k_function_arg (CUM, MODE, TYPE, NAMED) 1018: 1019: /* Define this if it differs from FUNCTION_ARG. */ 1020: /* #define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) ... */ 1021: 1022: /* A C expression for the number of words, at the beginning of an 1023: argument, must be put in registers. The value must be zero for 1024: arguments that are passed entirely in registers or that are entirely 1025: pushed on the stack. */ 1026: #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) (0) 1027: 1028: /* A C expression that indicates when an argument must be passed by 1029: reference. If nonzero for an argument, a copy of that argument is 1030: made in memory and a pointer to the argument is passed instead of the 1031: argument itself. The pointer is passed in whatever way is appropriate 1032: for passing a pointer to that type. */ 1033: #define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) (0) 1034: 1035: /* A C type for declaring a variable that is used as the first argument 1036: of `FUNCTION_ARG' and other related values. It suffices to count 1037: the number of words of argument so far. */ 1038: #define CUMULATIVE_ARGS int 1039: 1040: /* Initialize a variable CUM of type CUMULATIVE_ARGS for a call to a 1041: function whose data type is FNTYPE. For a library call, FNTYPE is 0. */ 1042: #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME) ((CUM) = 0) 1043: 1044: /* A C statement (sans semicolon) to update the summarizer variable 1045: CUM to advance past an argument in the argument list. The values 1046: MODE, TYPE and NAMED describe that argument. Once this is done, 1047: the variable CUM is suitable for analyzing the *following* argument 1048: with `FUNCTION_ARG', etc. (TYPE is null for libcalls where that 1049: information may not be available.) */ 1050: #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \ 1051: do { \ 1052: enum machine_mode __mode = (TYPE) ? TYPE_MODE (TYPE) : (MODE); \ 1053: if ((CUM & 1) \ 1054: && (__mode == DImode || __mode == DFmode \ 1055: || ((TYPE) && TYPE_ALIGN (TYPE) > BITS_PER_WORD))) \ 1056: CUM++; \ 1057: CUM += (((__mode != BLKmode) \ 1058: ? GET_MODE_SIZE (MODE) : int_size_in_bytes (TYPE)) \ 1059: + 3) / 4; \ 1060: } while (0) 1061: 1062: /* True if N is a possible register number for function argument passing. 1063: On the m88000, these are registers 2 through 9. */ 1064: #define FUNCTION_ARG_REGNO_P(N) ((N) <= 9 && (N) >= 2) 1065: 1066: /* A C expression which determines whether, and in which direction, 1067: to pad out an argument with extra space. The value should be of 1068: type `enum direction': either `upward' to pad above the argument, 1069: `downward' to pad below, or `none' to inhibit padding. 1070: 1071: This macro does not control the *amount* of padding; that is always 1072: just enough to reach the next multiple of `FUNCTION_ARG_BOUNDARY'. */ 1073: #define FUNCTION_ARG_PADDING(MODE, TYPE) \ 1074: ((MODE) == BLKmode \ 1075: || ((TYPE) && (TREE_CODE (TYPE) == RECORD_TYPE \ 1076: || TREE_CODE (TYPE) == UNION_TYPE)) \ 1077: ? upward : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY ? downward : none) 1078: 1079: /* If defined, a C expression that gives the alignment boundary, in bits, 1080: of an argument with the specified mode and type. If it is not defined, 1081: `PARM_BOUNDARY' is used for all arguments. */ 1082: #define FUNCTION_ARG_BOUNDARY(MODE, TYPE) \ 1083: (((TYPE) ? TYPE_ALIGN (TYPE) : GET_MODE_SIZE (MODE)) <= PARM_BOUNDARY \ 1084: ? PARM_BOUNDARY : 2 * PARM_BOUNDARY) 1085: 1086: /* Generate necessary RTL for __builtin_saveregs(). 1087: ARGLIST is the argument list; see expr.c. */ 1088: #define EXPAND_BUILTIN_SAVEREGS(ARGLIST) m88k_builtin_saveregs (ARGLIST) 1089: 1090: /* Generate the assembly code for function entry. */ 1091: #define FUNCTION_PROLOGUE(FILE, SIZE) m88k_begin_prologue(FILE, SIZE) 1092: 1093: /* Perform special actions at the point where the prologue ends. */ 1094: #define FUNCTION_END_PROLOGUE(FILE) m88k_end_prologue(FILE) 1095: 1096: /* Output assembler code to FILE to increment profiler label # LABELNO 1.1.1.3 ! root 1097: for profiling a function entry. Redefined in sysv3.h, sysv4.h and ! 1098: dgux.h. */ 1.1 root 1099: #define FUNCTION_PROFILER(FILE, LABELNO) \ 1100: output_function_profiler (FILE, LABELNO, "mcount", 1) 1101: 1102: /* Maximum length in instructions of the code output by FUNCTION_PROFILER. */ 1103: #define FUNCTION_PROFILER_LENGTH (5+3+1+5) 1104: 1105: /* Output assembler code to FILE to initialize basic-block profiling for 1106: the current module. LABELNO is unique to each instance. */ 1107: #define FUNCTION_BLOCK_PROFILER(FILE, LABELNO) \ 1108: output_function_block_profiler (FILE, LABELNO) 1109: 1110: /* Maximum length in instructions of the code output by 1111: FUNCTION_BLOCK_PROFILER. */ 1112: #define FUNCTION_BLOCK_PROFILER_LENGTH (3+5+2+5) 1113: 1114: /* Output assembler code to FILE to increment the count associated with 1115: the basic block number BLOCKNO. */ 1116: #define BLOCK_PROFILER(FILE, BLOCKNO) output_block_profiler (FILE, BLOCKNO) 1117: 1118: /* Maximum length in instructions of the code output by BLOCK_PROFILER. */ 1119: #define BLOCK_PROFILER_LENGTH 4 1120: 1121: /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function, 1122: the stack pointer does not matter. The value is tested only in 1123: functions that have frame pointers. 1124: No definition is equivalent to always zero. */ 1125: #define EXIT_IGNORE_STACK (1) 1126: 1127: /* Generate the assembly code for function exit. */ 1128: #define FUNCTION_EPILOGUE(FILE, SIZE) m88k_end_epilogue(FILE, SIZE) 1129: 1130: /* Perform special actions at the point where the epilogue begins. */ 1131: #define FUNCTION_BEGIN_EPILOGUE(FILE) m88k_begin_epilogue(FILE) 1132: 1133: /* Value should be nonzero if functions must have frame pointers. 1134: Zero means the frame pointer need not be set up (and parms 1135: may be accessed via the stack pointer) in functions that seem suitable. 1136: This is computed in `reload', in reload1.c. */ 1137: #define FRAME_POINTER_REQUIRED \ 1138: (frame_pointer_needed \ 1139: || (write_symbols != NO_DEBUG && !TARGET_OCS_FRAME_POSITION)) 1140: 1141: /* Definitions for register eliminations. 1142: 1143: We have two registers that can be eliminated on the m88k. First, the 1144: frame pointer register can often be eliminated in favor of the stack 1145: pointer register. Secondly, the argument pointer register can always be 1146: eliminated; it is replaced with either the stack or frame pointer. */ 1147: 1148: /* This is an array of structures. Each structure initializes one pair 1149: of eliminable registers. The "from" register number is given first, 1150: followed by "to". Eliminations of the same "from" register are listed 1151: in order of preference. */ 1152: #define ELIMINABLE_REGS \ 1153: {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ 1154: { ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \ 1155: { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}} 1156: 1157: /* Given FROM and TO register numbers, say whether this elimination 1158: is allowed. */ 1159: #define CAN_ELIMINATE(FROM, TO) \ 1160: (!((FROM) == FRAME_POINTER_REGNUM && FRAME_POINTER_REQUIRED)) 1161: 1162: /* Define the offset between two registers, one to be eliminated, and the other 1163: its replacement, at the start of a routine. */ 1164: #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ 1165: { m88k_layout_frame (); \ 1166: if ((FROM) == FRAME_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM) \ 1167: (OFFSET) = m88k_fp_offset; \ 1168: else if ((FROM) == ARG_POINTER_REGNUM && (TO) == FRAME_POINTER_REGNUM) \ 1169: (OFFSET) = m88k_stack_size - m88k_fp_offset; \ 1170: else if ((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM) \ 1171: (OFFSET) = m88k_stack_size; \ 1172: else \ 1173: abort (); \ 1174: } 1175: 1176: /*** Trampolines for Nested Functions ***/ 1177: 1178: /* Output assembler code for a block containing the constant parts 1179: of a trampoline, leaving space for the variable parts. 1180: 1181: This block is placed on the stack and filled in. It is aligned 1182: 0 mod 128 and those portions that are executed are constant. 1183: This should work for instruction caches that have cache lines up 1184: to the aligned amount (128 is arbitrary), provided no other code 1185: producer is attempting to play the same game. This of course is 1186: in violation of any number of 88open standards. */ 1187: 1188: #define TRAMPOLINE_TEMPLATE(FILE) \ 1189: { \ 1190: char buf[256]; \ 1191: static int labelno = 0; \ 1192: labelno++; \ 1193: ASM_GENERATE_INTERNAL_LABEL (buf, "LTRMP", labelno); \ 1194: /* Save the return address (r1) in the static chain reg (r11). */ \ 1195: fprintf (FILE, "\tor\t %s,%s,0\n", reg_names[11], reg_names[1]); \ 1196: /* Locate this block; transfer to the next instruction. */ \ 1197: fprintf (FILE, "\tbsr\t %s\n", &buf[1]); \ 1198: ASM_OUTPUT_INTERNAL_LABEL (FILE, "LTRMP", labelno); \ 1199: /* Save r10; use it as the relative pointer; restore r1. */ \ 1200: fprintf (FILE, "\tst\t %s,%s,24\n", reg_names[10], reg_names[1]); \ 1201: fprintf (FILE, "\tor\t %s,%s,0\n", reg_names[10], reg_names[1]); \ 1202: fprintf (FILE, "\tor\t %s,%s,0\n", reg_names[1], reg_names[11]); \ 1203: /* Load the function's address and go there. */ \ 1204: fprintf (FILE, "\tld\t %s,%s,32\n", reg_names[11], reg_names[10]); \ 1205: fprintf (FILE, "\tjmp.n\t %s\n", reg_names[11]); \ 1206: /* Restore r10 and load the static chain register. */ \ 1207: fprintf (FILE, "\tld.d\t %s,%s,24\n", reg_names[10], reg_names[10]); \ 1208: /* Storage: r10 save area, static chain, function address. */ \ 1209: ASM_OUTPUT_INT (FILE, const0_rtx); \ 1210: ASM_OUTPUT_INT (FILE, const0_rtx); \ 1211: ASM_OUTPUT_INT (FILE, const0_rtx); \ 1212: } 1213: 1214: /* Length in units of the trampoline for entering a nested function. 1215: This is really two components. The first 32 bytes are fixed and 1216: must be copied; the last 12 bytes are just storage that's filled 1217: in later. So for allocation purposes, it's 32+12 bytes, but for 1218: initialization purposes, it's 32 bytes. */ 1219: 1220: #define TRAMPOLINE_SIZE (32+12) 1221: 1222: /* Alignment required for a trampoline. 128 is used to find the 1223: beginning of a line in the instruction cache and to allow for 1224: instruction cache lines of up to 128 bytes. */ 1225: 1226: #define TRAMPOLINE_ALIGNMENT 128 1227: 1228: /* Emit RTL insns to initialize the variable parts of a trampoline. 1229: FNADDR is an RTX for the address of the function's pure code. 1230: CXT is an RTX for the static chain value for the function. */ 1231: 1232: #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \ 1233: { \ 1234: emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 40)), FNADDR); \ 1235: emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 36)), CXT); \ 1236: } 1237: 1238: /*** Library Subroutine Names ***/ 1239: 1240: /* Define this macro if GNU CC should generate calls to the System V 1241: (and ANSI C) library functions `memcpy' and `memset' rather than 1242: the BSD functions `bcopy' and `bzero'. */ 1243: #define TARGET_MEM_FUNCTIONS 1244: 1245: /*** Addressing Modes ***/ 1246: 1.1.1.2 root 1247: #define EXTRA_CC_MODES CCEVENmode 1248: 1249: #define EXTRA_CC_NAMES "CCEVEN" 1250: 1251: #define SELECT_CC_MODE(OP,X,Y) CCmode 1252: 1.1 root 1253: /* #define HAVE_POST_INCREMENT */ 1254: /* #define HAVE_POST_DECREMENT */ 1255: 1256: /* #define HAVE_PRE_DECREMENT */ 1257: /* #define HAVE_PRE_INCREMENT */ 1258: 1.1.1.3 ! root 1259: /* Recognize any constant value that is a valid address. ! 1260: When PIC, we do not accept an address that would require a scratch reg ! 1261: to load into a register. */ ! 1262: 1.1 root 1263: #define CONSTANT_ADDRESS_P(X) \ 1264: (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \ 1.1.1.3 ! root 1265: || GET_CODE (X) == CONST_INT || GET_CODE (X) == HIGH \ ! 1266: || (GET_CODE (X) == CONST \ ! 1267: && ! (flag_pic && pic_address_needs_scratch (X)))) ! 1268: 1.1 root 1269: 1270: /* Maximum number of registers that can appear in a valid memory address. */ 1271: #define MAX_REGS_PER_ADDRESS 2 1272: 1273: /* The condition for memory shift insns. */ 1274: #define SCALED_ADDRESS_P(ADDR) \ 1275: (GET_CODE (ADDR) == PLUS \ 1276: && (GET_CODE (XEXP (ADDR, 0)) == MULT \ 1277: || GET_CODE (XEXP (ADDR, 1)) == MULT)) 1278: 1279: /* Can the reference to X be made short? */ 1280: #define SHORT_ADDRESS_P(X,TEMP) \ 1281: ((TEMP) = (GET_CODE (X) == CONST ? get_related_value (X) : X), \ 1282: ((TEMP) && GET_CODE (TEMP) == SYMBOL_REF && SYMBOL_REF_FLAG (TEMP))) 1283: 1284: /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression 1285: that is a valid memory address for an instruction. 1286: The MODE argument is the machine mode for the MEM expression 1287: that wants to use this address. 1288: 1289: On the m88000, a legitimate address has the form REG, REG+REG, 1290: REG+SMALLINT, REG+(REG*modesize) (REG[REG]), or SMALLINT. 1291: 1292: The register elimination process should deal with the argument 1293: pointer and frame pointer changing to REG+SMALLINT. */ 1294: 1295: #define LEGITIMATE_INDEX_P(X, MODE) \ 1296: ((GET_CODE (X) == CONST_INT \ 1297: && SMALL_INT (X)) \ 1298: || (REG_P (X) \ 1299: && REG_OK_FOR_INDEX_P (X)) \ 1300: || (GET_CODE (X) == MULT \ 1301: && REG_P (XEXP (X, 0)) \ 1302: && REG_OK_FOR_INDEX_P (XEXP (X, 0)) \ 1303: && GET_CODE (XEXP (X, 1)) == CONST_INT \ 1304: && INTVAL (XEXP (X, 1)) == GET_MODE_SIZE (MODE))) 1305: 1.1.1.3 ! root 1306: #define RTX_OK_FOR_BASE_P(X) \ ! 1307: ((GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X)) \ ! 1308: || (GET_CODE (X) == SUBREG \ ! 1309: && GET_CODE (SUBREG_REG (X)) == REG \ ! 1310: && REG_OK_FOR_BASE_P (SUBREG_REG (X)))) ! 1311: ! 1312: #define RTX_OK_FOR_INDEX_P(X) \ ! 1313: ((GET_CODE (X) == REG && REG_OK_FOR_INDEX_P (X)) \ ! 1314: || (GET_CODE (X) == SUBREG \ ! 1315: && GET_CODE (SUBREG_REG (X)) == REG \ ! 1316: && REG_OK_FOR_INDEX_P (SUBREG_REG (X)))) ! 1317: 1.1 root 1318: #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ 1319: { \ 1320: register rtx _x; \ 1321: if (REG_P (X)) \ 1322: { \ 1323: if (REG_OK_FOR_BASE_P (X)) \ 1324: goto ADDR; \ 1325: } \ 1326: else if (GET_CODE (X) == PLUS) \ 1327: { \ 1328: register rtx _x0 = XEXP (X, 0); \ 1329: register rtx _x1 = XEXP (X, 1); \ 1330: if ((flag_pic \ 1331: && _x0 == pic_offset_table_rtx \ 1332: && (flag_pic == 2 \ 1.1.1.3 ! root 1333: ? RTX_OK_FOR_BASE_P (_x1) \ 1.1 root 1334: : (GET_CODE (_x1) == SYMBOL_REF \ 1335: || GET_CODE (_x1) == LABEL_REF))) \ 1336: || (REG_P (_x0) \ 1337: && (REG_OK_FOR_BASE_P (_x0) \ 1338: && LEGITIMATE_INDEX_P (_x1, MODE))) \ 1339: || (REG_P (_x1) \ 1340: && (REG_OK_FOR_BASE_P (_x1) \ 1341: && LEGITIMATE_INDEX_P (_x0, MODE)))) \ 1342: goto ADDR; \ 1343: } \ 1344: else if (GET_CODE (X) == LO_SUM) \ 1345: { \ 1346: register rtx _x0 = XEXP (X, 0); \ 1347: register rtx _x1 = XEXP (X, 1); \ 1348: if (((REG_P (_x0) \ 1349: && REG_OK_FOR_BASE_P (_x0)) \ 1350: || (GET_CODE (_x0) == SUBREG \ 1351: && REG_P (SUBREG_REG (_x0)) \ 1352: && REG_OK_FOR_BASE_P (SUBREG_REG (_x0)))) \ 1353: && CONSTANT_P (_x1)) \ 1354: goto ADDR; \ 1355: } \ 1356: else if (GET_CODE (X) == CONST_INT \ 1357: && SMALL_INT (X)) \ 1358: goto ADDR; \ 1359: else if (SHORT_ADDRESS_P (X, _x)) \ 1360: goto ADDR; \ 1361: } 1362: 1363: /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx 1364: and check its validity for a certain class. 1365: We have two alternate definitions for each of them. 1366: The usual definition accepts all pseudo regs; the other rejects 1367: them unless they have been allocated suitable hard regs. 1368: The symbol REG_OK_STRICT causes the latter definition to be used. 1369: 1370: Most source files want to accept pseudo regs in the hope that 1371: they will get allocated to the class that the insn wants them to be in. 1372: Source files for reload pass need to be strict. 1373: After reload, it makes no difference, since pseudo regs have 1374: been eliminated by then. */ 1375: 1376: #ifndef REG_OK_STRICT 1377: 1378: /* Nonzero if X is a hard reg that can be used as an index 1379: or if it is a pseudo reg. Not the argument pointer. */ 1380: #define REG_OK_FOR_INDEX_P(X) \ 1381: (!XRF_REGNO_P(REGNO (X))) 1382: /* Nonzero if X is a hard reg that can be used as a base reg 1383: or if it is a pseudo reg. */ 1384: #define REG_OK_FOR_BASE_P(X) (REG_OK_FOR_INDEX_P (X)) 1385: 1386: #else 1387: 1388: /* Nonzero if X is a hard reg that can be used as an index. */ 1389: #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X)) 1390: /* Nonzero if X is a hard reg that can be used as a base reg. */ 1391: #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X)) 1392: 1393: #endif 1394: 1395: /* Try machine-dependent ways of modifying an illegitimate address 1396: to be legitimate. If we find one, return the new, valid address. 1397: This macro is used in only one place: `memory_address' in explow.c. 1398: 1399: OLDX is the address as it was before break_out_memory_refs was called. 1400: In some cases it is useful to look at this to decide what needs to be done. 1401: 1402: MODE and WIN are passed so that this macro can use 1403: GO_IF_LEGITIMATE_ADDRESS. 1404: 1405: It is always safe for this macro to do nothing. It exists to recognize 1406: opportunities to optimize the output. */ 1407: 1408: /* On the m88000, change REG+N into REG+REG, and REG+(X*Y) into REG+REG. */ 1409: 1410: #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) \ 1411: { \ 1412: if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1))) \ 1413: (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \ 1414: copy_to_mode_reg (SImode, XEXP (X, 1))); \ 1415: if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 0))) \ 1416: (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \ 1417: copy_to_mode_reg (SImode, XEXP (X, 0))); \ 1418: if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == MULT) \ 1419: (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \ 1420: force_operand (XEXP (X, 0), 0)); \ 1421: if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == MULT) \ 1422: (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \ 1423: force_operand (XEXP (X, 1), 0)); \ 1.1.1.3 ! root 1424: if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == PLUS) \ ! 1425: (X) = gen_rtx (PLUS, Pmode, force_operand (XEXP (X, 0), NULL_RTX),\ ! 1426: XEXP (X, 1)); \ ! 1427: if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == PLUS) \ ! 1428: (X) = gen_rtx (PLUS, Pmode, XEXP (X, 0), \ ! 1429: force_operand (XEXP (X, 1), NULL_RTX)); \ 1.1 root 1430: if (GET_CODE (X) == SYMBOL_REF || GET_CODE (X) == CONST \ 1431: || GET_CODE (X) == LABEL_REF) \ 1432: (X) = legitimize_address (flag_pic, X, 0, 0); \ 1433: if (memory_address_p (MODE, X)) \ 1434: goto WIN; } 1435: 1436: /* Go to LABEL if ADDR (a legitimate address expression) 1437: has an effect that depends on the machine mode it is used for. 1438: On the the m88000 this is never true. */ 1439: 1440: #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) 1441: 1442: /* Nonzero if the constant value X is a legitimate general operand. 1443: It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */ 1444: #define LEGITIMATE_CONSTANT_P(X) (1) 1.1.1.3 ! root 1445: ! 1446: /* Define this, so that when PIC, reload won't try to reload invalid ! 1447: addresses which require two reload registers. */ ! 1448: ! 1449: #define LEGITIMATE_PIC_OPERAND_P(X) (! pic_address_needs_scratch (X)) ! 1450: 1.1 root 1451: 1452: /*** Condition Code Information ***/ 1453: 1454: /* C code for a data type which is used for declaring the `mdep' 1455: component of `cc_status'. It defaults to `int'. */ 1456: /* #define CC_STATUS_MDEP int */ 1457: 1458: /* A C expression to initialize the `mdep' field to "empty". */ 1459: /* #define CC_STATUS_MDEP_INIT (cc_status.mdep = 0) */ 1460: 1461: /* Macro to zap the normal portions of CC_STATUS, but leave the 1462: machine dependent parts (ie, literal synthesis) alone. */ 1463: /* #define CC_STATUS_INIT_NO_MDEP \ 1464: (cc_status.flags = 0, cc_status.value1 = 0, cc_status.value2 = 0) */ 1465: 1466: /* When using a register to hold the condition codes, the cc_status 1467: mechanism cannot be used. */ 1468: #define NOTICE_UPDATE_CC(EXP, INSN) (0) 1469: 1470: /*** Miscellaneous Parameters ***/ 1471: 1472: /* Define the codes that are matched by predicates in m88k.c. */ 1473: #define PREDICATE_CODES \ 1474: {"move_operand", {SUBREG, REG, CONST_INT, LO_SUM, MEM}}, \ 1475: {"call_address_operand", {SUBREG, REG, SYMBOL_REF, LABEL_REF, CONST}}, \ 1476: {"arith_operand", {SUBREG, REG, CONST_INT}}, \ 1477: {"arith5_operand", {SUBREG, REG, CONST_INT}}, \ 1478: {"arith32_operand", {SUBREG, REG, CONST_INT}}, \ 1479: {"arith64_operand", {SUBREG, REG, CONST_INT}}, \ 1480: {"int5_operand", {CONST_INT}}, \ 1481: {"int32_operand", {CONST_INT}}, \ 1482: {"add_operand", {SUBREG, REG, CONST_INT}}, \ 1483: {"reg_or_bbx_mask_operand", {SUBREG, REG, CONST_INT}}, \ 1484: {"real_or_0_operand", {SUBREG, REG, CONST_DOUBLE}}, \ 1.1.1.3 ! root 1485: {"reg_or_0_operand", {SUBREG, REG, CONST_INT}}, \ 1.1 root 1486: {"relop", {EQ, NE, LT, LE, GE, GT, LTU, LEU, GEU, GTU}}, \ 1.1.1.2 root 1487: {"even_relop", {EQ, LT, GT, LTU, GTU}}, \ 1488: {"odd_relop", { NE, LE, GE, LEU, GEU}}, \ 1489: {"partial_ccmode_register_operand", { SUBREG, REG}}, \ 1.1 root 1490: {"relop_no_unsigned", {EQ, NE, LT, LE, GE, GT}}, \ 1491: {"equality_op", {EQ, NE}}, \ 1492: {"pc_or_label_ref", {PC, LABEL_REF}}, 1493: 1494: /* The case table contains either words or branch instructions. This says 1495: which. We always claim that the vector is PC-relative. It is position 1496: independent when -fpic is used. */ 1497: #define CASE_VECTOR_INSNS (TARGET_88100 || flag_pic) 1498: 1499: /* An alias for a machine mode name. This is the machine mode that 1500: elements of a jump-table should have. */ 1501: #define CASE_VECTOR_MODE SImode 1502: 1503: /* Define this macro if jump-tables should contain relative addresses. */ 1504: #define CASE_VECTOR_PC_RELATIVE 1505: 1506: /* Define this if control falls through a `case' insn when the index 1507: value is out of range. This means the specified default-label is 1508: actually ignored by the `case' insn proper. */ 1509: /* #define CASE_DROPS_THROUGH */ 1510: 1511: /* Define this to be the smallest number of different values for which it 1512: is best to use a jump-table instead of a tree of conditional branches. 1513: The default is 4 for machines with a casesi instruction and 5 otherwise. 1514: The best 88110 number is around 7, though the exact number isn't yet 1515: known. A third alternative for the 88110 is to use a binary tree of 1516: bb1 instructions on bits 2/1/0 if the range is dense. This may not 1517: win very much though. */ 1518: #define CASE_VALUES_THRESHOLD (TARGET_88100 ? 4 : 7) 1519: 1520: /* Specify the tree operation to be used to convert reals to integers. */ 1521: #define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR 1522: 1523: /* This is the kind of divide that is easiest to do in the general case. */ 1524: #define EASY_DIV_EXPR TRUNC_DIV_EXPR 1525: 1526: /* Define this as 1 if `char' should by default be signed; else as 0. */ 1527: #define DEFAULT_SIGNED_CHAR 1 1528: 1529: /* The 88open ABI says size_t is unsigned int. */ 1530: #define SIZE_TYPE "unsigned int" 1531: 1532: /* Allow and ignore #sccs directives */ 1533: #define SCCS_DIRECTIVE 1534: 1535: /* Handle #pragma pack and sometimes #pragma weak. */ 1536: #define HANDLE_SYSV_PRAGMA 1537: 1538: /* Tell when to handle #pragma weak. This is only done for V.4. */ 1539: #define HANDLE_PRAGMA_WEAK TARGET_SVR4 1540: 1541: /* Max number of bytes we can move from memory to memory 1542: in one reasonably fast instruction. */ 1543: #define MOVE_MAX 8 1544: 1.1.1.3 ! root 1545: /* Define if normal loads of shorter-than-word items from memory clears ! 1546: the rest of the bigs in the register. */ ! 1547: #define BYTE_LOADS_ZERO_EXTEND 1.1 root 1548: 1549: /* Zero if access to memory by bytes is faster. */ 1550: #define SLOW_BYTE_ACCESS 1 1551: 1552: /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits 1553: is done just by pretending it is already truncated. */ 1554: #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 1555: 1556: /* Define this if addresses of constant functions 1557: shouldn't be put through pseudo regs where they can be cse'd. 1558: Desirable on machines where ordinary constants are expensive 1559: but a CALL with constant address is cheap. */ 1560: #define NO_FUNCTION_CSE 1561: 1562: /* Define this macro if an argument declared as `char' or 1563: `short' in a prototype should actually be passed as an 1564: `int'. In addition to avoiding errors in certain cases of 1565: mismatch, it also makes for better code on certain machines. */ 1566: #define PROMOTE_PROTOTYPES 1567: 1568: /* Define this macro if a float function always returns float 1.1.1.3 ! root 1569: (even in traditional mode). Redefined in luna.h. */ 1.1 root 1570: #define TRADITIONAL_RETURN_FLOAT 1571: 1572: /* We assume that the store-condition-codes instructions store 0 for false 1573: and some other value for true. This is the value stored for true. */ 1574: #define STORE_FLAG_VALUE -1 1575: 1576: /* Specify the machine mode that pointers have. 1577: After generation of rtl, the compiler makes no further distinction 1578: between pointers and any other objects of this machine mode. */ 1579: #define Pmode SImode 1580: 1581: /* A function address in a call instruction 1582: is a word address (for indexing purposes) 1583: so give the MEM rtx word mode. */ 1584: #define FUNCTION_MODE SImode 1585: 1586: /* A barrier will be aligned so account for the possible expansion. 1587: A volatile load may be preceded by a serializing instruction. 1588: Account for profiling code output at NOTE_INSN_PROLOGUE_END. 1589: Account for block profiling code at basic block boundaries. */ 1590: #define ADJUST_INSN_LENGTH(RTX, LENGTH) \ 1591: if (GET_CODE (RTX) == BARRIER \ 1592: || (TARGET_SERIALIZE_VOLATILE \ 1593: && GET_CODE (RTX) == INSN \ 1594: && GET_CODE (PATTERN (RTX)) == SET \ 1595: && ((GET_CODE (SET_SRC (PATTERN (RTX))) == MEM \ 1596: && MEM_VOLATILE_P (SET_SRC (PATTERN (RTX))))))) \ 1597: LENGTH += 1; \ 1598: else if (GET_CODE (RTX) == NOTE \ 1599: && NOTE_LINE_NUMBER (RTX) == NOTE_INSN_PROLOGUE_END) \ 1600: { \ 1601: if (profile_block_flag) \ 1602: LENGTH += FUNCTION_BLOCK_PROFILER_LENGTH; \ 1603: if (profile_flag) \ 1604: LENGTH += (FUNCTION_PROFILER_LENGTH + REG_PUSH_LENGTH \ 1605: + REG_POP_LENGTH); \ 1606: } \ 1607: else if (profile_block_flag \ 1608: && (GET_CODE (RTX) == CODE_LABEL \ 1609: || GET_CODE (RTX) == JUMP_INSN \ 1610: || (GET_CODE (RTX) == INSN \ 1611: && GET_CODE (PATTERN (RTX)) == SEQUENCE \ 1612: && GET_CODE (XVECEXP (PATTERN (RTX), 0, 0)) == JUMP_INSN)))\ 1613: LENGTH += BLOCK_PROFILER_LENGTH; 1614: 1615: /* Track the state of the last volatile memory reference. Clear the 1616: state with CC_STATUS_INIT for now. */ 1617: #define CC_STATUS_INIT m88k_volatile_code = '\0' 1618: 1619: /* Compute the cost of computing a constant rtl expression RTX 1620: whose rtx-code is CODE. The body of this macro is a portion 1621: of a switch statement. If the code is computed here, 1622: return it with a return statement. Otherwise, break from the switch. 1623: 1624: We assume that any 16 bit integer can easily be recreated, so we 1625: indicate 0 cost, in an attempt to get GCC not to optimize things 1626: like comparison against a constant. 1627: 1628: The cost of CONST_DOUBLE is zero (if it can be placed in an insn, it 1629: is as good as a register; since it can't be placed in any insn, it 1630: won't do anything in cse, but it will cause expand_binop to pass the 1631: constant to the define_expands). */ 1632: #define CONST_COSTS(RTX,CODE,OUTER_CODE) \ 1633: case CONST_INT: \ 1634: if (SMALL_INT (RTX)) \ 1635: return 0; \ 1636: else if (SMALL_INTVAL (- INTVAL (RTX))) \ 1637: return 2; \ 1638: else if (classify_integer (SImode, INTVAL (RTX)) != m88k_oru_or) \ 1639: return 4; \ 1640: return 7; \ 1641: case HIGH: \ 1642: return 2; \ 1643: case CONST: \ 1644: case LABEL_REF: \ 1645: case SYMBOL_REF: \ 1646: if (flag_pic) \ 1647: return (flag_pic == 2) ? 11 : 8; \ 1648: return 5; \ 1649: case CONST_DOUBLE: \ 1650: return 0; 1651: 1652: /* Provide the costs of an addressing mode that contains ADDR. 1653: If ADDR is not a valid address, its cost is irrelevant. 1654: REG+REG is made slightly more expensive because it might keep 1655: a register live for longer than we might like. */ 1656: #define ADDRESS_COST(ADDR) \ 1657: (GET_CODE (ADDR) == REG ? 1 : \ 1658: GET_CODE (ADDR) == LO_SUM ? 1 : \ 1659: GET_CODE (ADDR) == HIGH ? 2 : \ 1660: GET_CODE (ADDR) == MULT ? 1 : \ 1661: GET_CODE (ADDR) != PLUS ? 4 : \ 1662: (REG_P (XEXP (ADDR, 0)) && REG_P (XEXP (ADDR, 1))) ? 2 : 1) 1663: 1664: /* Provide the costs of a rtl expression. This is in the body of a 1665: switch on CODE. */ 1666: #define RTX_COSTS(X,CODE,OUTER_CODE) \ 1667: case MEM: \ 1668: return COSTS_N_INSNS (2); \ 1669: case MULT: \ 1670: return COSTS_N_INSNS (3); \ 1671: case DIV: \ 1672: case UDIV: \ 1673: case MOD: \ 1674: case UMOD: \ 1675: return COSTS_N_INSNS (38); 1676: 1677: /* A C expressions returning the cost of moving data of MODE from a register 1678: to or from memory. This is more costly than between registers. */ 1679: #define MEMORY_MOVE_COST(MODE) 4 1680: 1681: /* Provide the cost of a branch. Exact meaning under development. */ 1682: #define BRANCH_COST (TARGET_88100 ? 1 : 2) 1683: 1684: /* A C statement (sans semicolon) to update the integer variable COST 1685: based on the relationship between INSN that is dependent on 1686: DEP_INSN through the dependence LINK. The default is to make no 1687: adjustment to COST. On the m88k, ignore the cost of anti- and 1688: output-dependencies. On the m88100, a store can issue two cycles 1689: before the value (not the address) has finished computing. */ 1690: #define ADJUST_COST(INSN,LINK,DEP_INSN,COST) \ 1691: do { \ 1692: if (REG_NOTE_KIND (LINK) != 0) \ 1693: (COST) = 0; /* Anti or output dependence. */ \ 1694: else if (! TARGET_88100 \ 1695: && recog_memoized (INSN) >= 0 \ 1696: && get_attr_type (INSN) == TYPE_STORE \ 1697: && SET_SRC (PATTERN (INSN)) == SET_DEST (PATTERN (DEP_INSN))) \ 1698: (COST) -= 4; /* 88110 store reservation station. */ \ 1699: } while (0) 1700: 1701: /* Define this to be nonzero if the character `$' should be allowed 1702: by default in identifier names. */ 1703: #define DOLLARS_IN_IDENTIFIERS 1 1704: 1705: /* Do not break .stabs pseudos into continuations. */ 1706: #define DBX_CONTIN_LENGTH 0 1707: 1708: /*** Output of Assembler Code ***/ 1709: 1710: /* Control the assembler format that we output. */ 1711: 1712: /* Allow pseudo-ops to be overridden. Override these in svr[34].h. */ 1713: #undef INT_ASM_OP 1714: #undef ASCII_DATA_ASM_OP 1715: #undef CONST_SECTION_ASM_OP 1716: #undef CTORS_SECTION_ASM_OP 1717: #undef DTORS_SECTION_ASM_OP 1718: #undef INIT_SECTION_ASM_OP 1719: #undef FINI_SECTION_ASM_OP 1720: #undef TYPE_ASM_OP 1721: #undef SIZE_ASM_OP 1722: #undef WEAK_ASM_OP 1723: #undef SET_ASM_OP 1724: #undef SKIP_ASM_OP 1725: #undef COMMON_ASM_OP 1726: #undef ALIGN_ASM_OP 1727: #undef IDENT_ASM_OP 1728: 1729: /* These are used in varasm.c as well. */ 1730: #define TEXT_SECTION_ASM_OP "text" 1731: #define DATA_SECTION_ASM_OP "data" 1732: 1733: /* Other sections. */ 1.1.1.3 ! root 1734: #define CONST_SECTION_ASM_OP (TARGET_SVR4 \ 1.1 root 1735: ? "section\t .rodata,\"a\"" \ 1736: : "section\t .rodata,\"x\"") 1.1.1.3 ! root 1737: #define TDESC_SECTION_ASM_OP (TARGET_SVR4 \ 1.1 root 1738: ? "section\t .tdesc,\"a\"" \ 1739: : "section\t .tdesc,\"x\"") 1740: 1741: /* These must be constant strings for crtstuff.c. */ 1742: #define CTORS_SECTION_ASM_OP "section\t .ctors,\"d\"" 1743: #define DTORS_SECTION_ASM_OP "section\t .dtors,\"d\"" 1744: #define INIT_SECTION_ASM_OP "section\t .init,\"x\"" 1745: #define FINI_SECTION_ASM_OP "section\t .fini,\"x\"" 1746: 1747: /* These are pretty much common to all assemblers. */ 1748: #define IDENT_ASM_OP "ident" 1749: #define FILE_ASM_OP "file" 1750: #define SECTION_ASM_OP "section" 1751: #define SET_ASM_OP "def" 1752: #define GLOBAL_ASM_OP "global" 1753: #define ALIGN_ASM_OP "align" 1754: #define SKIP_ASM_OP "zero" 1755: #define COMMON_ASM_OP "comm" 1756: #define BSS_ASM_OP "bss" 1757: #define FLOAT_ASM_OP "float" 1758: #define DOUBLE_ASM_OP "double" 1759: #define INT_ASM_OP "word" 1760: #define ASM_LONG INT_ASM_OP 1761: #define SHORT_ASM_OP "half" 1762: #define CHAR_ASM_OP "byte" 1763: #define ASCII_DATA_ASM_OP "string" 1764: 1765: /* These are particular to the global pool optimization. */ 1766: #define SBSS_ASM_OP "sbss" 1767: #define SCOMM_ASM_OP "scomm" 1768: #define SDATA_SECTION_ASM_OP "sdata" 1769: 1770: /* These are specific to PIC. */ 1771: #define TYPE_ASM_OP "type" 1772: #define SIZE_ASM_OP "size" 1773: #define WEAK_ASM_OP "weak" 1774: #ifndef AS_BUG_POUND_TYPE /* Faulty assemblers require @ rather than #. */ 1775: #undef TYPE_OPERAND_FMT 1776: #define TYPE_OPERAND_FMT "#%s" 1777: #endif 1778: 1779: /* These are specific to version 03.00 assembler syntax. */ 1780: #define INTERNAL_ASM_OP "local" 1781: #define VERSION_ASM_OP "version" 1782: #define UNALIGNED_SHORT_ASM_OP "uahalf" 1783: #define UNALIGNED_INT_ASM_OP "uaword" 1784: #define PUSHSECTION_ASM_OP "section" 1785: #define POPSECTION_ASM_OP "previous" 1786: 1787: /* These are specific to the version 04.00 assembler syntax. */ 1788: #define REQUIRES_88110_ASM_OP "requires_88110" 1789: 1790: /* Output any initial stuff to the assembly file. Always put out 1791: a file directive, even if not debugging. 1792: 1793: Immediately after putting out the file, put out a "sem.<value>" 1794: declaration. This should be harmless on other systems, and 1795: is used in DG/UX by the debuggers to supplement COFF. The 1796: fields in the integer value are as follows: 1797: 1798: Bits Value Meaning 1799: ---- ----- ------- 1800: 0-1 0 No information about stack locations 1801: 1 Auto/param locations are based on r30 1802: 2 Auto/param locations are based on CFA 1803: 1804: 3-2 0 No information on dimension order 1805: 1 Array dims in sym table matches source language 1806: 2 Array dims in sym table is in reverse order 1807: 1808: 5-4 0 No information about the case of global names 1809: 1 Global names appear in the symbol table as in the source 1810: 2 Global names have been converted to lower case 1811: 3 Global names have been converted to upper case. */ 1812: 1813: #ifdef SDB_DEBUGGING_INFO 1814: #define ASM_COFFSEM(FILE) \ 1815: if (write_symbols == SDB_DEBUG) \ 1816: { \ 1817: fprintf (FILE, "\nsem.%x:\t\t; %s\n", \ 1818: (((TARGET_OCS_FRAME_POSITION) ? 2 : 1) << 0) + (1 << 2) + (1 << 4),\ 1819: (TARGET_OCS_FRAME_POSITION) \ 1820: ? "frame is CFA, normal array dims, case unchanged" \ 1821: : "frame is r30, normal array dims, case unchanged"); \ 1822: } 1823: #else 1824: #define ASM_COFFSEM(FILE) 1825: #endif 1826: 1.1.1.3 ! root 1827: /* Output the first line of the assembly file. Redefined in dgux.h. */ 1.1 root 1828: 1829: #define ASM_FIRST_LINE(FILE) \ 1830: do { \ 1.1.1.3 ! root 1831: if (TARGET_SVR4) \ ! 1832: { \ ! 1833: if (TARGET_88110) \ ! 1834: fprintf (FILE, "\t%s\t \"%s\"\n", VERSION_ASM_OP, "04.00"); \ ! 1835: else \ ! 1836: fprintf (FILE, "\t%s\t \"%s\"\n", VERSION_ASM_OP, "03.00"); \ ! 1837: } \ 1.1 root 1838: } while (0) 1839: 1840: /* Override svr[34].h. */ 1841: #undef ASM_FILE_START 1842: #define ASM_FILE_START(FILE) \ 1843: output_file_start (FILE, f_options, sizeof f_options / sizeof f_options[0], \ 1844: W_options, sizeof W_options / sizeof W_options[0]) 1845: 1846: #undef ASM_FILE_END 1847: 1848: #define ASM_OUTPUT_SOURCE_FILENAME(FILE, NAME) \ 1.1.1.3 ! root 1849: fprintf (FILE, "\t%s\t \"%s\"\n", FILE_ASM_OP, NAME) 1.1 root 1850: 1851: #ifdef SDB_DEBUGGING_INFO 1.1.1.3 ! root 1852: #undef ASM_OUTPUT_SOURCE_LINE 1.1 root 1853: #define ASM_OUTPUT_SOURCE_LINE(FILE, LINE) \ 1854: if (m88k_prologue_done) \ 1855: fprintf (FILE, "\n\tln\t %d\t\t\t\t; Real source line %d\n",\ 1856: LINE - sdb_begin_function_line, LINE) 1857: #endif 1858: 1859: /* Code to handle #ident directives. Override svr[34].h definition. */ 1860: #undef ASM_OUTPUT_IDENT 1861: #ifdef DBX_DEBUGGING_INFO 1862: #define ASM_OUTPUT_IDENT(FILE, NAME) 1863: #else 1864: #define ASM_OUTPUT_IDENT(FILE, NAME) \ 1865: output_ascii (FILE, IDENT_ASM_OP, 4000, NAME, strlen (NAME)); 1866: #endif 1867: 1868: /* Output to assembler file text saying following lines 1869: may contain character constants, extra white space, comments, etc. */ 1870: #define ASM_APP_ON "" 1871: 1872: /* Output to assembler file text saying following lines 1873: no longer contain unusual constructs. */ 1874: #define ASM_APP_OFF "" 1875: 1876: /* Format the assembly opcode so that the arguments are all aligned. 1877: The maximum instruction size is 8 characters (fxxx.xxx), so a tab and a 1878: space will do to align the output. Abandon the output if a `%' is 1879: encountered. */ 1880: #define ASM_OUTPUT_OPCODE(STREAM, PTR) \ 1881: { \ 1882: int ch; \ 1883: char *orig_ptr; \ 1884: \ 1885: for (orig_ptr = (PTR); \ 1886: (ch = *(PTR)) && ch != ' ' && ch != '\t' && ch != '\n' && ch != '%'; \ 1887: (PTR)++) \ 1888: putc (ch, STREAM); \ 1889: \ 1890: if (ch == ' ' && orig_ptr != (PTR) && (PTR) - orig_ptr < 8) \ 1891: putc ('\t', STREAM); \ 1892: } 1893: 1894: /* How to refer to registers in assembler output. 1895: This sequence is indexed by compiler's hard-register-number. 1896: Updated by OVERRIDE_OPTIONS to include the # for version 03.00 syntax. */ 1897: 1898: #define REGISTER_NAMES \ 1899: {"#r0"+1, "#r1"+1, "#r2"+1, "#r3"+1, "#r4"+1, "#r5"+1, "#r6"+1, "#r7"+1, \ 1900: "#r8"+1, "#r9"+1, "#r10"+1,"#r11"+1,"#r12"+1,"#r13"+1,"#r14"+1,"#r15"+1,\ 1901: "#r16"+1,"#r17"+1,"#r18"+1,"#r19"+1,"#r20"+1,"#r21"+1,"#r22"+1,"#r23"+1,\ 1902: "#r24"+1,"#r25"+1,"#r26"+1,"#r27"+1,"#r28"+1,"#r29"+1,"#r30"+1,"#r31"+1,\ 1903: "#x0"+1, "#x1"+1, "#x2"+1, "#x3"+1, "#x4"+1, "#x5"+1, "#x6"+1, "#x7"+1, \ 1904: "#x8"+1, "#x9"+1, "#x10"+1,"#x11"+1,"#x12"+1,"#x13"+1,"#x14"+1,"#x15"+1,\ 1905: "#x16"+1,"#x17"+1,"#x18"+1,"#x19"+1,"#x20"+1,"#x21"+1,"#x22"+1,"#x23"+1,\ 1906: "#x24"+1,"#x25"+1,"#x26"+1,"#x27"+1,"#x28"+1,"#x29"+1,"#x30"+1,"#x31"+1} 1907: 1908: /* Define additional names for use in asm clobbers and asm declarations. 1909: 1910: We define the fake Condition Code register as an alias for reg 0 (which 1911: is our `condition code' register), so that condition codes can easily 1912: be clobbered by an asm. The carry bit in the PSR is now used. */ 1913: 1914: #define ADDITIONAL_REGISTER_NAMES {"psr", 0, "cc", 0} 1915: 1916: /* How to renumber registers for dbx and gdb. */ 1917: #define DBX_REGISTER_NUMBER(REGNO) (REGNO) 1918: 1919: /* Tell when to declare ASM names. Override svr4.h to provide this hook. */ 1920: #undef DECLARE_ASM_NAME 1921: #define DECLARE_ASM_NAME TARGET_SVR4 1922: 1923: /* Write the extra assembler code needed to declare a function properly. */ 1924: #undef ASM_DECLARE_FUNCTION_NAME 1925: #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \ 1926: do { \ 1927: if (DECLARE_ASM_NAME) \ 1928: { \ 1929: fprintf (FILE, "\t%s\t ", TYPE_ASM_OP); \ 1930: assemble_name (FILE, NAME); \ 1931: putc (',', FILE); \ 1932: fprintf (FILE, TYPE_OPERAND_FMT, "function"); \ 1933: putc ('\n', FILE); \ 1934: } \ 1935: ASM_OUTPUT_LABEL(FILE, NAME); \ 1936: } while (0) 1937: 1938: /* Write the extra assembler code needed to declare an object properly. */ 1939: #undef ASM_DECLARE_OBJECT_NAME 1.1.1.2 root 1940: #define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL) \ 1941: do { \ 1942: if (DECLARE_ASM_NAME) \ 1943: { \ 1944: fprintf (FILE, "\t%s\t ", TYPE_ASM_OP); \ 1945: assemble_name (FILE, NAME); \ 1946: putc (',', FILE); \ 1947: fprintf (FILE, TYPE_OPERAND_FMT, "object"); \ 1948: putc ('\n', FILE); \ 1949: size_directive_output = 0; \ 1950: if (!flag_inhibit_size_directive && DECL_SIZE (DECL)) \ 1951: { \ 1952: size_directive_output = 1; \ 1953: fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ 1954: assemble_name (FILE, NAME); \ 1955: fprintf (FILE, ",%d\n", int_size_in_bytes (TREE_TYPE (DECL))); \ 1956: } \ 1957: } \ 1958: ASM_OUTPUT_LABEL(FILE, NAME); \ 1959: } while (0) 1960: 1961: /* Output the size directive for a decl in rest_of_decl_compilation 1962: in the case where we did not do so before the initializer. 1963: Once we find the error_mark_node, we know that the value of 1964: size_directive_output was set 1965: by ASM_DECLARE_OBJECT_NAME when it was run for the same decl. */ 1966: 1967: #undef ASM_FINISH_DECLARE_OBJECT 1968: #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END) \ 1969: do { \ 1970: char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0); \ 1971: if (!flag_inhibit_size_directive && DECL_SIZE (DECL) \ 1972: && DECLARE_ASM_NAME \ 1973: && ! AT_END && TOP_LEVEL \ 1974: && DECL_INITIAL (DECL) == error_mark_node \ 1975: && !size_directive_output) \ 1976: { \ 1.1.1.3 ! root 1977: size_directive_output = 1; \ 1.1.1.2 root 1978: fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ 1979: assemble_name (FILE, name); \ 1980: fprintf (FILE, ",%d\n", int_size_in_bytes (TREE_TYPE (DECL))); \ 1981: } \ 1982: } while (0) 1.1 root 1983: 1984: /* This is how to declare the size of a function. */ 1985: #undef ASM_DECLARE_FUNCTION_SIZE 1986: #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \ 1987: do { \ 1988: if (DECLARE_ASM_NAME) \ 1989: { \ 1990: if (!flag_inhibit_size_directive) \ 1991: { \ 1992: char label[256]; \ 1993: static int labelno = 0; \ 1994: labelno++; \ 1995: ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno); \ 1996: ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno); \ 1997: fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ 1998: assemble_name (FILE, (FNAME)); \ 1999: fprintf (FILE, ",%s-", &label[1]); \ 2000: assemble_name (FILE, (FNAME)); \ 2001: putc ('\n', FILE); \ 2002: } \ 2003: } \ 2004: } while (0) 2005: 2006: /* This is how to output the definition of a user-level label named NAME, 2007: such as the label on a static function or variable NAME. */ 2008: #define ASM_OUTPUT_LABEL(FILE,NAME) \ 2009: do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0) 2010: 2011: /* This is how to output a command to make the user-level label named NAME 2012: defined for reference from other files. */ 2013: #define ASM_GLOBALIZE_LABEL(FILE,NAME) \ 2014: do { \ 2015: fprintf (FILE, "\t%s\t ", GLOBAL_ASM_OP); \ 2016: assemble_name (FILE, NAME); \ 2017: putc ('\n', FILE); \ 2018: } while (0) 2019: 2020: /* This is how to output a reference to a user-level label named NAME. 2021: Override svr[34].h. */ 2022: #undef ASM_OUTPUT_LABELREF 2023: #define ASM_OUTPUT_LABELREF(FILE,NAME) \ 2024: { \ 1.1.1.3 ! root 2025: if (!TARGET_NO_UNDERSCORES && !TARGET_SVR4) \ 1.1 root 2026: fputc ('_', FILE); \ 2027: fputs (NAME, FILE); \ 2028: } 2029: 2030: /* This is how to output an internal numbered label where 2031: PREFIX is the class of label and NUM is the number within the class. 2032: For V.4, labels use `.' rather than `@'. */ 2033: 2034: #undef ASM_OUTPUT_INTERNAL_LABEL 2035: #ifdef AS_BUG_DOT_LABELS /* The assembler requires a declaration of local. */ 2036: #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \ 1.1.1.3 ! root 2037: fprintf (FILE, TARGET_SVR4 ? ".%s%d:\n\t%s\t .%s%d\n" : "@%s%d:\n", \ 1.1 root 2038: PREFIX, NUM, INTERNAL_ASM_OP, PREFIX, NUM) 2039: #else 2040: #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \ 1.1.1.3 ! root 2041: fprintf (FILE, TARGET_SVR4 ? ".%s%d:\n" : "@%s%d:\n", PREFIX, NUM) 1.1 root 2042: #endif /* AS_BUG_DOT_LABELS */ 2043: 2044: /* This is how to store into the string LABEL 2045: the symbol_ref name of an internal numbered label where 2046: PREFIX is the class of label and NUM is the number within the class. 2047: This is suitable for output with `assemble_name'. This must agree 2048: with ASM_OUTPUT_INTERNAL_LABEL above, except for being prefixed 2049: with an `*'. */ 2050: 2051: #undef ASM_GENERATE_INTERNAL_LABEL 2052: #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \ 1.1.1.3 ! root 2053: sprintf (LABEL, TARGET_SVR4 ? "*.%s%d" : "*@%s%d", PREFIX, NUM) 1.1 root 2054: 2055: /* Internal macro to get a single precision floating point value into 2056: an int, so we can print it's value in hex. */ 2057: #define FLOAT_TO_INT_INTERNAL( FVALUE, IVALUE ) \ 2058: { union { \ 2059: REAL_VALUE_TYPE d; \ 2060: struct { \ 2061: unsigned sign : 1; \ 2062: unsigned exponent1 : 1; \ 2063: unsigned exponent2 : 3; \ 2064: unsigned exponent3 : 7; \ 2065: unsigned mantissa1 : 20; \ 2066: unsigned mantissa2 : 3; \ 2067: unsigned mantissa3 : 29; \ 2068: } s; \ 2069: } _u; \ 2070: \ 2071: union { \ 2072: int i; \ 2073: struct { \ 2074: unsigned sign : 1; \ 2075: unsigned exponent1 : 1; \ 2076: unsigned exponent3 : 7; \ 2077: unsigned mantissa1 : 20; \ 2078: unsigned mantissa2 : 3; \ 2079: } s; \ 2080: } _u2; \ 2081: \ 2082: _u.d = REAL_VALUE_TRUNCATE (SFmode, FVALUE); \ 2083: _u2.s.sign = _u.s.sign; \ 2084: _u2.s.exponent1 = _u.s.exponent1; \ 2085: _u2.s.exponent3 = _u.s.exponent3; \ 2086: _u2.s.mantissa1 = _u.s.mantissa1; \ 2087: _u2.s.mantissa2 = _u.s.mantissa2; \ 2088: IVALUE = _u2.i; \ 2089: } 2090: 2091: /* This is how to output an assembler line defining a `double' constant. 2092: Use "word" pseudos to avoid printing NaNs, infinity, etc. */ 2093: #define ASM_OUTPUT_DOUBLE(FILE,VALUE) \ 2094: do { \ 2095: union { REAL_VALUE_TYPE d; long l[2]; } x; \ 2096: x.d = (VALUE); \ 2097: fprintf (FILE, "\t%s\t 0x%.8x, 0x%.8x\n", INT_ASM_OP, \ 2098: x.l[0], x.l[1]); \ 2099: } while (0) 2100: 2101: /* This is how to output an assembler line defining a `float' constant. */ 2102: #define ASM_OUTPUT_FLOAT(FILE,VALUE) \ 2103: do { \ 2104: int i; \ 2105: FLOAT_TO_INT_INTERNAL (VALUE, i); \ 2106: fprintf (FILE, "\t%s\t 0x%.8x\n", INT_ASM_OP, i); \ 2107: } while (0) 2108: 2109: /* Likewise for `int', `short', and `char' constants. */ 2110: #define ASM_OUTPUT_INT(FILE,VALUE) \ 2111: ( fprintf (FILE, "\t%s\t ", INT_ASM_OP), \ 2112: output_addr_const (FILE, (VALUE)), \ 2113: fprintf (FILE, "\n")) 2114: 2115: #define ASM_OUTPUT_SHORT(FILE,VALUE) \ 2116: ( fprintf (FILE, "\t%s\t ", SHORT_ASM_OP), \ 2117: output_addr_const (FILE, (VALUE)), \ 2118: fprintf (FILE, "\n")) 2119: 2120: #define ASM_OUTPUT_CHAR(FILE,VALUE) \ 2121: ( fprintf (FILE, "\t%s\t ", CHAR_ASM_OP), \ 2122: output_addr_const (FILE, (VALUE)), \ 2123: fprintf (FILE, "\n")) 2124: 2125: /* This is how to output an assembler line for a numeric constant byte. */ 2126: #define ASM_OUTPUT_BYTE(FILE,VALUE) \ 2127: fprintf (FILE, "\t%s\t 0x%x\n", CHAR_ASM_OP, (VALUE)) 2128: 2129: /* The single-byte pseudo-op is the default. Override svr[34].h. */ 2130: #undef ASM_BYTE_OP 2131: #define ASM_BYTE_OP "byte" 2132: #undef ASM_OUTPUT_ASCII 2133: #define ASM_OUTPUT_ASCII(FILE, P, SIZE) \ 2134: output_ascii (FILE, ASCII_DATA_ASM_OP, 48, P, SIZE) 2135: 2136: /* Override svr4.h. Change to the readonly data section for a table of 2137: addresses. final_scan_insn changes back to the text section. */ 2138: #undef ASM_OUTPUT_CASE_LABEL 2139: #define ASM_OUTPUT_CASE_LABEL(FILE, PREFIX, NUM, TABLE) \ 2140: do { \ 2141: if (! CASE_VECTOR_INSNS) \ 2142: { \ 2143: readonly_data_section (); \ 2144: ASM_OUTPUT_ALIGN (FILE, 2); \ 2145: } \ 2146: ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM); \ 2147: } while (0) 2148: 2149: /* Epilogue for case labels. This jump instruction is called by casesi 2150: to transfer to the appropriate branch instruction within the table. 2151: The label `@L<n>e' is coined to mark the end of the table. */ 2152: #define ASM_OUTPUT_CASE_END(FILE, NUM, TABLE) \ 2153: do { \ 2154: if (CASE_VECTOR_INSNS) \ 2155: { \ 2156: char label[256]; \ 2157: ASM_GENERATE_INTERNAL_LABEL (label, "L", NUM); \ 2158: fprintf (FILE, "%se:\n", &label[1]); \ 2159: if (! flag_delayed_branch) \ 2160: fprintf (FILE, "\tlda\t %s,%s[%s]\n", reg_names[1], \ 2161: reg_names[1], reg_names[m88k_case_index]); \ 2162: fprintf (FILE, "\tjmp\t %s\n", reg_names[1]); \ 2163: } \ 2164: } while (0) 2165: 2166: /* This is how to output an element of a case-vector that is absolute. */ 2167: #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ 2168: do { \ 2169: char buffer[256]; \ 2170: ASM_GENERATE_INTERNAL_LABEL (buffer, "L", VALUE); \ 2171: fprintf (FILE, CASE_VECTOR_INSNS ? "\tbr\t %s\n" : "\tword\t %s\n", \ 2172: &buffer[1]); \ 2173: } while (0) 2174: 2175: /* This is how to output an element of a case-vector that is relative. */ 2176: #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \ 2177: ASM_OUTPUT_ADDR_VEC_ELT (FILE, VALUE) 2178: 2179: /* This is how to output an assembler line 2180: that says to advance the location counter 2181: to a multiple of 2**LOG bytes. */ 2182: #define ASM_OUTPUT_ALIGN(FILE,LOG) \ 2183: if ((LOG) != 0) \ 2184: fprintf (FILE, "\t%s\t %d\n", ALIGN_ASM_OP, 1<<(LOG)) 2185: 2186: /* On the m88100, align the text address to half a cache boundary when it 2187: can only be reached by jumping. Pack code tightly when compiling 2188: crtstuff.c. */ 2189: #define ASM_OUTPUT_ALIGN_CODE(FILE) \ 2190: ASM_OUTPUT_ALIGN (FILE, \ 2191: (TARGET_88100 && !flag_inhibit_size_directive ? 3 : 2)) 2192: 2193: /* Override svr[34].h. */ 2194: #undef ASM_OUTPUT_SKIP 2195: #define ASM_OUTPUT_SKIP(FILE,SIZE) \ 2196: fprintf (FILE, "\t%s\t %u\n", SKIP_ASM_OP, (SIZE)) 2197: 2198: /* Override svr4.h. */ 2199: #undef ASM_OUTPUT_EXTERNAL_LIBCALL 2200: 2201: /* This says how to output an assembler line to define a global common 2202: symbol. Size can be zero for the unusual case of a `struct { int : 0; }'. 2203: Override svr[34].h. */ 2204: #undef ASM_OUTPUT_COMMON 2205: #undef ASM_OUTPUT_ALIGNED_COMMON 2206: #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \ 2207: ( fprintf ((FILE), "\t%s\t ", \ 2208: ((SIZE) ? (SIZE) : 1) <= m88k_gp_threshold ? SCOMM_ASM_OP : COMMON_ASM_OP), \ 2209: assemble_name ((FILE), (NAME)), \ 2210: fprintf ((FILE), ",%u\n", (SIZE) ? (SIZE) : 1)) 2211: 2212: /* This says how to output an assembler line to define a local common 2213: symbol. Override svr[34].h. */ 2214: #undef ASM_OUTPUT_LOCAL 2215: #undef ASM_OUTPUT_ALIGNED_LOCAL 2216: #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \ 2217: ( fprintf ((FILE), "\t%s\t ", \ 2218: ((SIZE) ? (SIZE) : 1) <= m88k_gp_threshold ? SBSS_ASM_OP : BSS_ASM_OP), \ 2219: assemble_name ((FILE), (NAME)), \ 2220: fprintf ((FILE), ",%u,%d\n", (SIZE) ? (SIZE) : 1, (SIZE) <= 4 ? 4 : 8)) 2221: 2222: /* Store in OUTPUT a string (made with alloca) containing 2223: an assembler-name for a local static variable named NAME. 2224: LABELNO is an integer which is different for each call. */ 2225: #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \ 2226: ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10), \ 2227: sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO))) 2228: 2229: /* This is how to output an insn to push a register on the stack. 2230: It need not be very fast code. */ 2231: #define ASM_OUTPUT_REG_PUSH(FILE,REGNO) \ 2232: fprintf (FILE, "\tsubu\t %s,%s,%d\n\tst\t %s,%s,0\n", \ 2233: reg_names[STACK_POINTER_REGNUM], \ 2234: reg_names[STACK_POINTER_REGNUM], \ 2235: (STACK_BOUNDARY / BITS_PER_UNIT), \ 2236: reg_names[REGNO], \ 2237: reg_names[STACK_POINTER_REGNUM]) 2238: 2239: /* Length in instructions of the code output by ASM_OUTPUT_REG_PUSH. */ 2240: #define REG_PUSH_LENGTH 2 2241: 2242: /* This is how to output an insn to pop a register from the stack. */ 2243: #define ASM_OUTPUT_REG_POP(FILE,REGNO) \ 2244: fprintf (FILE, "\tld\t %s,%s,0\n\taddu\t %s,%s,%d\n", \ 2245: reg_names[REGNO], \ 2246: reg_names[STACK_POINTER_REGNUM], \ 2247: reg_names[STACK_POINTER_REGNUM], \ 2248: reg_names[STACK_POINTER_REGNUM], \ 2249: (STACK_BOUNDARY / BITS_PER_UNIT)) 2250: 2251: /* Length in instructions of the code output by ASM_OUTPUT_REG_POP. */ 2252: #define REG_POP_LENGTH 2 2253: 2254: /* Define the parentheses used to group arithmetic operations 2255: in assembler code. */ 2256: #define ASM_OPEN_PAREN "(" 2257: #define ASM_CLOSE_PAREN ")" 2258: 2259: /* Define results of standard character escape sequences. */ 2260: #define TARGET_BELL 007 2261: #define TARGET_BS 010 2262: #define TARGET_TAB 011 2263: #define TARGET_NEWLINE 012 2264: #define TARGET_VT 013 2265: #define TARGET_FF 014 2266: #define TARGET_CR 015 2267: 2268: /* Macros to deal with OCS debug information */ 2269: 2270: #define OCS_START_PREFIX "Ltb" 2271: #define OCS_END_PREFIX "Lte" 2272: 2273: #define PUT_OCS_FUNCTION_START(FILE) \ 2274: { ASM_OUTPUT_INTERNAL_LABEL (FILE, OCS_START_PREFIX, m88k_function_number); } 2275: 2276: #define PUT_OCS_FUNCTION_END(FILE) \ 2277: { ASM_OUTPUT_INTERNAL_LABEL (FILE, OCS_END_PREFIX, m88k_function_number); } 2278: 2279: /* Macros for debug information */ 2280: #define DEBUGGER_AUTO_OFFSET(X) \ 2281: (m88k_debugger_offset (X, 0) \ 2282: + (TARGET_OCS_FRAME_POSITION ? 0 : m88k_stack_size - m88k_fp_offset)) 2283: 2284: #define DEBUGGER_ARG_OFFSET(OFFSET, X) \ 2285: (m88k_debugger_offset (X, OFFSET) \ 2286: + (TARGET_OCS_FRAME_POSITION ? 0 : m88k_stack_size - m88k_fp_offset)) 2287: 2288: /* Macros to deal with SDB debug information */ 2289: #ifdef SDB_DEBUGGING_INFO 2290: 2291: /* Output structure tag names even when it causes a forward reference. */ 2292: #define SDB_ALLOW_FORWARD_REFERENCES 2293: 2294: /* Print out extra debug information in the assembler file */ 2295: #define PUT_SDB_SCL(a) \ 2296: do { \ 2297: register int s = (a); \ 2298: register char *scl; \ 2299: switch (s) \ 2300: { \ 2301: case C_EFCN: scl = "end of function"; break; \ 2302: case C_NULL: scl = "NULL storage class"; break; \ 2303: case C_AUTO: scl = "automatic"; break; \ 2304: case C_EXT: scl = "external"; break; \ 2305: case C_STAT: scl = "static"; break; \ 2306: case C_REG: scl = "register"; break; \ 2307: case C_EXTDEF: scl = "external definition"; break; \ 2308: case C_LABEL: scl = "label"; break; \ 2309: case C_ULABEL: scl = "undefined label"; break; \ 2310: case C_MOS: scl = "structure member"; break; \ 2311: case C_ARG: scl = "argument"; break; \ 2312: case C_STRTAG: scl = "structure tag"; break; \ 2313: case C_MOU: scl = "union member"; break; \ 2314: case C_UNTAG: scl = "union tag"; break; \ 2315: case C_TPDEF: scl = "typedef"; break; \ 2316: case C_USTATIC: scl = "uninitialized static"; break; \ 2317: case C_ENTAG: scl = "enumeration tag"; break; \ 2318: case C_MOE: scl = "member of enumeration"; break; \ 2319: case C_REGPARM: scl = "register parameter"; break; \ 2320: case C_FIELD: scl = "bit field"; break; \ 2321: case C_BLOCK: scl = "block start/end"; break; \ 2322: case C_FCN: scl = "function start/end"; break; \ 2323: case C_EOS: scl = "end of structure"; break; \ 2324: case C_FILE: scl = "filename"; break; \ 2325: case C_LINE: scl = "line"; break; \ 2326: case C_ALIAS: scl = "duplicated tag"; break; \ 2327: case C_HIDDEN: scl = "hidden"; break; \ 2328: default: scl = "unknown"; break; \ 2329: } \ 2330: \ 2331: fprintf(asm_out_file, "\tscl\t %d\t\t\t\t; %s\n", s, scl); \ 2332: } while (0) 2333: 2334: #define PUT_SDB_TYPE(a) \ 2335: do { \ 2336: register int t = (a); \ 2337: static char buffer[100]; \ 2338: register char *p = buffer, *q; \ 2339: register int typ = t; \ 2340: register int i,d; \ 2341: \ 2342: for (i = 0; i <= 5; i++) \ 2343: { \ 2344: switch ((typ >> ((i*N_TSHIFT) + N_BTSHFT)) & 03) \ 2345: { \ 2346: case DT_PTR: \ 2347: strcpy (p, "ptr to "); \ 2348: p += sizeof("ptr to"); \ 2349: break; \ 2350: \ 2351: case DT_ARY: \ 2352: strcpy (p, "array of "); \ 2353: p += sizeof("array of"); \ 2354: break; \ 2355: \ 2356: case DT_FCN: \ 2357: strcpy (p, "func ret "); \ 2358: p += sizeof("func ret"); \ 2359: break; \ 2360: } \ 2361: } \ 2362: \ 2363: switch (typ & N_BTMASK) \ 2364: { \ 2365: case T_NULL: q = "<no type>"; break; \ 2366: case T_CHAR: q = "char"; break; \ 2367: case T_SHORT: q = "short"; break; \ 2368: case T_INT: q = "int"; break; \ 2369: case T_LONG: q = "long"; break; \ 2370: case T_FLOAT: q = "float"; break; \ 2371: case T_DOUBLE: q = "double"; break; \ 2372: case T_STRUCT: q = "struct"; break; \ 2373: case T_UNION: q = "union"; break; \ 2374: case T_ENUM: q = "enum"; break; \ 2375: case T_MOE: q = "enum member"; break; \ 2376: case T_UCHAR: q = "unsigned char"; break; \ 2377: case T_USHORT: q = "unsigned short"; break; \ 2378: case T_UINT: q = "unsigned int"; break; \ 2379: case T_ULONG: q = "unsigned long"; break; \ 2380: default: q = "void"; break; \ 2381: } \ 2382: \ 2383: strcpy (p, q); \ 2384: fprintf(asm_out_file, "\ttype\t %d\t\t\t\t; %s\n", \ 2385: t, buffer); \ 2386: } while (0) 2387: 2388: #define PUT_SDB_INT_VAL(a) \ 2389: fprintf (asm_out_file, "\tval\t %d\n", (a)) 2390: 2391: #define PUT_SDB_VAL(a) \ 2392: ( fprintf (asm_out_file, "\tval\t "), \ 2393: output_addr_const (asm_out_file, (a)), \ 2394: fputc ('\n', asm_out_file)) 2395: 2396: #define PUT_SDB_DEF(a) \ 2397: do { fprintf (asm_out_file, "\tsdef\t "); \ 2398: ASM_OUTPUT_LABELREF (asm_out_file, a); \ 2399: fputc ('\n', asm_out_file); \ 2400: } while (0) 2401: 2402: #define PUT_SDB_PLAIN_DEF(a) \ 2403: fprintf(asm_out_file,"\tsdef\t .%s\n", a) 2404: 2405: /* Simply and endef now. */ 2406: #define PUT_SDB_ENDEF \ 2407: fputs("\tendef\n\n", asm_out_file) 2408: 2409: #define PUT_SDB_SIZE(a) \ 2410: fprintf (asm_out_file, "\tsize\t %d\n", (a)) 2411: 2412: /* Max dimensions to store for debug information (limited by COFF). */ 2413: #define SDB_MAX_DIM 6 2414: 2415: /* New method for dim operations. */ 2416: #define PUT_SDB_START_DIM \ 2417: fputs("\tdim\t ", asm_out_file) 2418: 2419: /* How to end the DIM sequence. */ 2420: #define PUT_SDB_LAST_DIM(a) \ 2421: fprintf(asm_out_file, "%d\n", a) 2422: 2423: #define PUT_SDB_TAG(a) \ 2424: do { \ 2425: fprintf (asm_out_file, "\ttag\t "); \ 2426: ASM_OUTPUT_LABELREF (asm_out_file, a); \ 2427: fputc ('\n', asm_out_file); \ 2428: } while( 0 ) 2429: 2430: #define PUT_SDB_BLOCK_OR_FUNCTION(NAME, SCL, LINE) \ 2431: do { \ 2432: fprintf (asm_out_file, "\n\tsdef\t %s\n\tval\t .\n", \ 2433: NAME); \ 2434: PUT_SDB_SCL( SCL ); \ 2435: fprintf (asm_out_file, "\tline\t %d\n\tendef\n\n", \ 2436: (LINE)); \ 2437: } while (0) 2438: 2439: #define PUT_SDB_BLOCK_START(LINE) \ 2440: PUT_SDB_BLOCK_OR_FUNCTION (".bb", C_BLOCK, (LINE)) 2441: 2442: #define PUT_SDB_BLOCK_END(LINE) \ 2443: PUT_SDB_BLOCK_OR_FUNCTION (".eb", C_BLOCK, (LINE)) 2444: 2445: #define PUT_SDB_FUNCTION_START(LINE) \ 2446: do { \ 2447: fprintf (asm_out_file, "\tln\t 1\n"); \ 2448: PUT_SDB_BLOCK_OR_FUNCTION (".bf", C_FCN, (LINE)); \ 2449: } while (0) 2450: 2451: #define PUT_SDB_FUNCTION_END(LINE) \ 2452: do { \ 2453: PUT_SDB_BLOCK_OR_FUNCTION (".ef", C_FCN, (LINE)); \ 2454: } while (0) 2455: 2456: #define PUT_SDB_EPILOGUE_END(NAME) \ 2457: do { \ 2458: text_section (); \ 2459: fprintf (asm_out_file, "\n\tsdef\t "); \ 2460: ASM_OUTPUT_LABELREF(asm_out_file, (NAME)); \ 2461: fputc('\n', asm_out_file); \ 2462: PUT_SDB_SCL( C_EFCN ); \ 2463: fprintf (asm_out_file, "\tendef\n\n"); \ 2464: } while (0) 2465: 2466: #define SDB_GENERATE_FAKE(BUFFER, NUMBER) \ 2467: sprintf ((BUFFER), ".%dfake", (NUMBER)); 2468: 2469: #endif /* SDB_DEBUGGING_INFO */ 2470: 2471: /* Support const and tdesc sections. Generally, a const section will 2472: be distinct from the text section whenever we do V.4-like things 2473: and so follows DECLARE_ASM_NAME. Note that strings go in text 2474: rather than const. Override svr[34].h. */ 2475: 2476: #undef USE_CONST_SECTION 2477: #undef EXTRA_SECTIONS 2478: 2479: #define USE_CONST_SECTION DECLARE_ASM_NAME 2480: 2481: #if defined(USING_SVR4_H) 2482: 2483: #define EXTRA_SECTIONS in_const, in_tdesc, in_sdata, in_ctors, in_dtors 2484: #define INIT_SECTION_FUNCTION 2485: #define FINI_SECTION_FUNCTION 2486: 2487: #else 2488: #if defined(USING_SVR3_H) 2489: 2490: #define EXTRA_SECTIONS in_const, in_tdesc, in_sdata, in_ctors, in_dtors, \ 2491: in_init, in_fini 2492: 1.1.1.3 ! root 2493: #else /* luna or other not based on svr[34].h. */ 1.1 root 2494: 2495: #undef INIT_SECTION_ASM_OP 2496: #define EXTRA_SECTIONS in_const, in_tdesc, in_sdata 2497: #define CONST_SECTION_FUNCTION \ 2498: void \ 2499: const_section () \ 2500: { \ 2501: text_section(); \ 2502: } 2503: #define CTORS_SECTION_FUNCTION 2504: #define DTORS_SECTION_FUNCTION 2505: #define INIT_SECTION_FUNCTION 2506: #define FINI_SECTION_FUNCTION 2507: 2508: #endif /* USING_SVR3_H */ 2509: #endif /* USING_SVR4_H */ 2510: 2511: #undef EXTRA_SECTION_FUNCTIONS 2512: #define EXTRA_SECTION_FUNCTIONS \ 2513: CONST_SECTION_FUNCTION \ 2514: \ 2515: void \ 2516: tdesc_section () \ 2517: { \ 2518: if (in_section != in_tdesc) \ 2519: { \ 2520: fprintf (asm_out_file, "%s\n", TDESC_SECTION_ASM_OP); \ 2521: in_section = in_tdesc; \ 2522: } \ 2523: } \ 2524: \ 2525: void \ 2526: sdata_section () \ 2527: { \ 2528: if (in_section != in_sdata) \ 2529: { \ 2530: fprintf (asm_out_file, "%s\n", SDATA_SECTION_ASM_OP); \ 2531: in_section = in_sdata; \ 2532: } \ 2533: } \ 2534: \ 2535: CTORS_SECTION_FUNCTION \ 2536: DTORS_SECTION_FUNCTION \ 2537: INIT_SECTION_FUNCTION \ 2538: FINI_SECTION_FUNCTION 2539: 2540: /* A C statement or statements to switch to the appropriate 2541: section for output of DECL. DECL is either a `VAR_DECL' node 2542: or a constant of some sort. RELOC indicates whether forming 2543: the initial value of DECL requires link-time relocations. 2544: 2545: For strings, the section is selected before the segment info is encoded. */ 2546: #undef SELECT_SECTION 2547: #define SELECT_SECTION(DECL,RELOC) \ 2548: { \ 2549: if (TREE_CODE (DECL) == STRING_CST) \ 2550: { \ 2551: if (! flag_writable_strings) \ 2552: const_section (); \ 1.1.1.3 ! root 2553: else if ( TREE_STRING_LENGTH (DECL) <= m88k_gp_threshold) \ 1.1 root 2554: sdata_section (); \ 2555: else \ 2556: data_section (); \ 2557: } \ 2558: else if (TREE_CODE (DECL) == VAR_DECL) \ 2559: { \ 2560: if (SYMBOL_REF_FLAG (XEXP (DECL_RTL (DECL), 0))) \ 2561: sdata_section (); \ 2562: else if ((flag_pic && RELOC) \ 1.1.1.3 ! root 2563: || !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL) \ ! 2564: || !DECL_INITIAL (DECL) \ ! 2565: || (DECL_INITIAL (DECL) != error_mark_node \ ! 2566: && !TREE_CONSTANT (DECL_INITIAL (DECL)))) \ 1.1 root 2567: data_section (); \ 2568: else \ 2569: const_section (); \ 2570: } \ 2571: else \ 2572: const_section (); \ 2573: } 2574: 2575: /* Jump tables consist of branch instructions and should be output in 2576: the text section. When we use a table of addresses, we explicitly 2577: change to the readonly data section. */ 2578: #define JUMP_TABLES_IN_TEXT_SECTION 1 2579: 2580: /* Define this macro if references to a symbol must be treated differently 2581: depending on something about the variable or function named by the 2582: symbol (such as what section it is in). 2583: 2584: The macro definition, if any, is executed immediately after the rtl for 2585: DECL has been created and stored in `DECL_RTL (DECL)'. The value of the 2586: rtl will be a `mem' whose address is a `symbol_ref'. 2587: 2588: For the m88k, determine if the item should go in the global pool. */ 2589: #define ENCODE_SECTION_INFO(DECL) \ 2590: do { \ 2591: if (m88k_gp_threshold > 0) \ 2592: if (TREE_CODE (DECL) == VAR_DECL) \ 2593: { \ 2594: if (!TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL)) \ 2595: { \ 2596: int size = int_size_in_bytes (TREE_TYPE (DECL)); \ 2597: \ 2598: if (size > 0 && size <= m88k_gp_threshold) \ 2599: SYMBOL_REF_FLAG (XEXP (DECL_RTL (DECL), 0)) = 1; \ 2600: } \ 2601: } \ 2602: else if (TREE_CODE (DECL) == STRING_CST \ 2603: && flag_writable_strings \ 2604: && TREE_STRING_LENGTH (DECL) <= m88k_gp_threshold) \ 2605: SYMBOL_REF_FLAG (XEXP (TREE_CST_RTL (DECL), 0)) = 1; \ 2606: } while (0) 2607: 2608: /* Print operand X (an rtx) in assembler syntax to file FILE. 2609: CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified. 2610: For `%' followed by punctuation, CODE is the punctuation and X is null. */ 2611: #define PRINT_OPERAND_PUNCT_VALID_P(c) \ 2612: ((c) == '#' || (c) == '.' || (c) == '!' || (c) == '*' || (c) == ';') 2613: 2614: #define PRINT_OPERAND(FILE, X, CODE) print_operand (FILE, X, CODE) 2615: 2616: /* Print a memory address as an operand to reference that memory location. */ 2617: #define PRINT_OPERAND_ADDRESS(FILE, ADDR) print_operand_address (FILE, ADDR) 1.1.1.3 ! root 2618: ! 2619: /* This says not to strength reduce the addr calculations within loops ! 2620: (otherwise it does not take advantage of m88k scaled loads and stores */ ! 2621: ! 2622: #define DONT_REDUCE_ADDR
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.