1 /* Definitions of target machine for Visium. 2 Copyright (C) 2002-2021 Free Software Foundation, Inc. 3 Contributed by C.Nettleton, J.P.Parkes and P.Garbett. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it 8 under the terms of the GNU General Public License as published 9 by the Free Software Foundation; either version 3, or (at your 10 option) any later version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 15 License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 22 /* Controlling the Compilation Driver, `gcc' */ 23 24 /* Pass -mtune=* options to the assembler */ 25 #undef ASM_SPEC 26 #define ASM_SPEC "%{mcpu=gr6:-mtune=gr6; :-mtune=mcm}" 27 28 /* Define symbols for the preprocessor. */ 29 #define CPP_SPEC "%{mcpu=gr6:-D__gr6__; :-D__gr5__}" 30 31 /* Targets of a link */ 32 #define LIB_SPEC \ 33 "--start-group -lc %{msim:-lsim; mdebug:-ldebug; :-lserial} --end-group" 34 35 #define ENDFILE_SPEC "crtend.o%s crtn.o%s" 36 #define STARTFILE_SPEC "crti.o%s crtbegin.o%s crt0.o%s" 37 38 /* Run-time Target Specification */ 39 40 /* TARGET_CPU_CPP_BUILTINS() This function-like macro expands to a 41 block of code that defines built-in preprocessor macros and 42 assertions for the target cpu, using the functions builtin_define, 43 builtin_define_std and builtin_assert. When the front end calls 44 this macro it provides a trailing semicolon, and since it has 45 finished command line option processing your code can use those 46 results freely. builtin_assert takes a string in the form you pass 47 to the command-line option -A, such as cpu=mips, and creates the 48 assertion. builtin_define takes a string in the form accepted by 49 option -D and unconditionally defines the macro. 50 51 builtin_define_std takes a string representing the name of an 52 object-like macro. If it doesn't lie in the user's namespace, 53 builtin_define_std defines it unconditionally. Otherwise, it 54 defines a version with two leading underscores, and another version 55 with two leading and trailing underscores, and defines the original 56 only if an ISO standard was not requested on the command line. For 57 example, passing unix defines __unix, __unix__ and possibly unix; 58 passing _mips defines __mips, __mips__ and possibly _mips, and 59 passing _ABI64 defines only _ABI64. 60 61 You can also test for the C dialect being compiled. The variable 62 c_language is set to one of clk_c, clk_cplusplus or 63 clk_objective_c. Note that if we are preprocessing assembler, this 64 variable will be clk_c but the function-like macro 65 preprocessing_asm_p() will return true, so you might want to check 66 for that first. If you need to check for strict ANSI, the variable 67 flag_iso can be used. The function-like macro 68 preprocessing_trad_p() can be used to check for traditional 69 preprocessing. */ 70 #define TARGET_CPU_CPP_BUILTINS() \ 71 do \ 72 { \ 73 builtin_define ("__VISIUM__"); \ 74 if (TARGET_MCM) \ 75 builtin_define ("__VISIUM_ARCH_MCM__"); \ 76 if (TARGET_BMI) \ 77 builtin_define ("__VISIUM_ARCH_BMI__"); \ 78 if (TARGET_FPU_IEEE) \ 79 builtin_define ("__VISIUM_ARCH_FPU_IEEE__"); \ 80 } \ 81 while (0) 82 83 /* Recast the cpu class to be the cpu attribute. 84 Every file includes us, but not every file includes insn-attr.h. */ 85 #define visium_cpu_attr ((enum attr_cpu) visium_cpu) 86 87 /* Defining data structures for per-function information. 88 89 If the target needs to store information on a per-function basis, 90 GCC provides a macro and a couple of variables to allow this. Note, 91 just using statics to store the information is a bad idea, since 92 GCC supports nested functions, so you can be halfway through 93 encoding one function when another one comes along. 94 95 GCC defines a data structure called struct function which contains 96 all of the data specific to an individual function. This structure 97 contains a field called machine whose type is struct 98 machine_function *, which can be used by targets to point to their 99 own specific data. 100 101 If a target needs per-function specific data it should define the 102 type struct machine_function and also the macro 103 INIT_EXPANDERS. This macro should be used to initialize the 104 function pointer init_machine_status. This pointer is explained 105 below. 106 107 One typical use of per-function, target specific data is to create 108 an RTX to hold the register containing the function's return 109 address. This RTX can then be used to implement the 110 __builtin_return_address function, for level 0. 111 112 Note--earlier implementations of GCC used a single data area to 113 hold all of the per-function information. Thus when processing of a 114 nested function began the old per-function data had to be pushed 115 onto a stack, and when the processing was finished, it had to be 116 popped off the stack. GCC used to provide function pointers called 117 save_machine_status and restore_machine_status to handle the saving 118 and restoring of the target specific information. Since the single 119 data area approach is no longer used, these pointers are no longer 120 supported. 121 122 The macro and function pointers are described below. 123 124 INIT_EXPANDERS: 125 126 Macro called to initialize any target specific information. This 127 macro is called once per function, before generation of any RTL has 128 begun. The intention of this macro is to allow the initialization 129 of the function pointers below. 130 131 init_machine_status: 132 This is a void (*)(struct function *) function pointer. If this 133 pointer is non-NULL it will be called once per function, before 134 function compilation starts, in order to allow the target to 135 perform any target specific initialization of the struct function 136 structure. It is intended that this would be used to initialize the 137 machine of that structure. struct machine_function structures are 138 expected to be freed by GC. Generally, any memory that they 139 reference must be allocated by using ggc_alloc, including the 140 structure itself. */ 141 142 #define INIT_EXPANDERS visium_init_expanders () 143 144 /* Storage Layout 145 146 Note that the definitions of the macros in this table which are 147 sizes or alignments measured in bits do not need to be constant. 148 They can be C expressions that refer to static variables, such as 149 the `target_flags'. 150 151 `BITS_BIG_ENDIAN' 152 153 Define this macro to have the value 1 if the most significant bit 154 in a byte has the lowest number; otherwise define it to have the 155 value zero. This means that bit-field instructions count from the 156 most significant bit. If the machine has no bit-field 157 instructions, then this must still be defined, but it doesn't 158 matter which value it is defined to. This macro need not be a 159 constant. 160 161 This macro does not affect the way structure fields are packed into 162 bytes or words; that is controlled by `BYTES_BIG_ENDIAN'. */ 163 #define BITS_BIG_ENDIAN 1 164 165 /* `BYTES_BIG_ENDIAN' 166 167 Define this macro to have the value 1 if the most significant byte 168 in a word has the lowest number. This macro need not be a 169 constant.*/ 170 #define BYTES_BIG_ENDIAN 1 171 172 /* `WORDS_BIG_ENDIAN' 173 174 Define this macro to have the value 1 if, in a multiword object, 175 the most significant word has the lowest number. This applies to 176 both memory locations and registers; GNU CC fundamentally assumes 177 that the order of words in memory is the same as the order in 178 registers. This macro need not be a constant. */ 179 #define WORDS_BIG_ENDIAN 1 180 181 /* `BITS_PER_WORD' 182 183 Number of bits in a word; normally 32. */ 184 #define BITS_PER_WORD 32 185 186 /* `UNITS_PER_WORD' 187 188 Number of storage units in a word; normally 4. */ 189 #define UNITS_PER_WORD 4 190 191 /* `POINTER_SIZE' 192 193 Width of a pointer, in bits. You must specify a value no wider 194 than the width of `Pmode'. If it is not equal to the width of 195 `Pmode', you must define `POINTERS_EXTEND_UNSIGNED'. */ 196 #define POINTER_SIZE 32 197 198 /* `PARM_BOUNDARY' 199 200 Normal alignment required for function parameters on the stack, in 201 bits. All stack parameters receive at least this much alignment 202 regardless of data type. On most machines, this is the same as the 203 size of an integer. */ 204 #define PARM_BOUNDARY 32 205 206 /* `STACK_BOUNDARY' 207 208 Define this macro if you wish to preserve a certain alignment for 209 the stack pointer. The definition is a C expression for the 210 desired alignment (measured in bits). 211 212 If `PUSH_ROUNDING' is not defined, the stack will always be aligned 213 to the specified boundary. If `PUSH_ROUNDING' is defined and 214 specifies a less strict alignment than `STACK_BOUNDARY', the stack 215 may be momentarily unaligned while pushing arguments. */ 216 #define STACK_BOUNDARY 32 217 218 #define VISIUM_STACK_ALIGN(LOC) (((LOC) + 3) & ~3) 219 220 /* `FUNCTION_BOUNDARY' 221 222 Alignment required for a function entry point, in bits. */ 223 #define FUNCTION_BOUNDARY 32 224 225 /* `BIGGEST_ALIGNMENT' 226 227 Biggest alignment that any data type can require on this machine, 228 in bits. */ 229 #define BIGGEST_ALIGNMENT 32 230 231 /* `DATA_ALIGNMENT (TYPE, BASIC-ALIGN)` 232 233 If defined, a C expression to compute the alignment for a variable 234 in the static store. TYPE is the data type, and BASIC-ALIGN is 235 the alignment that the object would ordinarily have. The value of 236 this macro is used instead of that alignment to align the object. */ 237 #define DATA_ALIGNMENT(TYPE,ALIGN) visium_data_alignment (TYPE, ALIGN) 238 239 /* `LOCAL_ALIGNMENT (TYPE, BASIC-ALIGN)` 240 241 If defined, a C expression to compute the alignment for a variable 242 in the local store. TYPE is the data type, and BASIC-ALIGN is the 243 alignment that the object would ordinarily have. The value of this 244 macro is used instead of that alignment to align the object. */ 245 #define LOCAL_ALIGNMENT(TYPE,ALIGN) visium_data_alignment (TYPE, ALIGN) 246 247 /* `EMPTY_FIELD_BOUNDARY' 248 249 Alignment in bits to be given to a structure bit field that follows 250 an empty field such as `int : 0;'. 251 252 Note that `PCC_BITFIELD_TYPE_MATTERS' also affects the alignment 253 that results from an empty field. */ 254 #define EMPTY_FIELD_BOUNDARY 32 255 256 /* `STRICT_ALIGNMENT' 257 258 Define this macro to be the value 1 if instructions will fail to 259 work if given data not on the nominal alignment. If instructions 260 will merely go slower in that case, define this macro as 0. */ 261 #define STRICT_ALIGNMENT 1 262 263 /* `TARGET_FLOAT_FORMAT' 264 265 A code distinguishing the floating point format of the target 266 machine. There are three defined values: 267 268 `IEEE_FLOAT_FORMAT' 269 This code indicates IEEE floating point. It is the default; 270 there is no need to define this macro when the format is IEEE. 271 272 `VAX_FLOAT_FORMAT' 273 This code indicates the peculiar format used on the Vax. 274 275 `UNKNOWN_FLOAT_FORMAT' 276 This code indicates any other format. 277 278 The value of this macro is compared with `HOST_FLOAT_FORMAT' to 279 determine whether the target machine has the same format as the 280 host machine. If any other formats are actually in use on 281 supported machines, new codes should be defined for them. 282 283 The ordering of the component words of floating point values 284 stored in memory is controlled by `FLOAT_WORDS_BIG_ENDIAN' for the 285 target machine and `HOST_FLOAT_WORDS_BIG_ENDIAN' for the host. */ 286 #define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT 287 #define UNITS_PER_HWFPVALUE 4 288 289 /* Layout of Source Language Data Types 290 291 These macros define the sizes and other characteristics of the 292 standard basic data types used in programs being compiled. Unlike 293 the macros in the previous section, these apply to specific 294 features of C and related languages, rather than to fundamental 295 aspects of storage layout. */ 296 297 /* `INT_TYPE_SIZE' 298 299 A C expression for the size in bits of the type `int' on the target 300 machine. If you don't define this, the default is one word. */ 301 #define INT_TYPE_SIZE 32 302 303 /* `SHORT_TYPE_SIZE' 304 305 A C expression for the size in bits of the type `short' on the 306 target machine. If you don't define this, the default is half a 307 word. (If this would be less than one storage unit, it is rounded 308 up to one unit.) */ 309 #define SHORT_TYPE_SIZE 16 310 311 /* `LONG_TYPE_SIZE' 312 313 A C expression for the size in bits of the type `long' on the 314 target machine. If you don't define this, the default is one word. */ 315 #define LONG_TYPE_SIZE 32 316 317 /* `LONG_LONG_TYPE_SIZE' 318 319 A C expression for the size in bits of the type `long long' on the 320 target machine. If you don't define this, the default is two 321 words. If you want to support GNU Ada on your machine, the value 322 of macro must be at least 64. */ 323 #define LONG_LONG_TYPE_SIZE 64 324 325 /* `CHAR_TYPE_SIZE' 326 327 A C expression for the size in bits of the type `char' on the 328 target machine. If you don't define this, the default is one 329 quarter of a word. (If this would be less than one storage unit, 330 it is rounded up to one unit.) */ 331 #define CHAR_TYPE_SIZE 8 332 333 /* `FLOAT_TYPE_SIZE' 334 335 A C expression for the size in bits of the type `float' on the 336 target machine. If you don't define this, the default is one word. */ 337 #define FLOAT_TYPE_SIZE 32 338 339 /* `DOUBLE_TYPE_SIZE' 340 341 A C expression for the size in bits of the type `double' on the 342 target machine. If you don't define this, the default is two 343 words. */ 344 #define DOUBLE_TYPE_SIZE 64 345 346 /* `LONG_DOUBLE_TYPE_SIZE' 347 348 A C expression for the size in bits of the type `long double' on 349 the target machine. If you don't define this, the default is two 350 words. */ 351 #define LONG_DOUBLE_TYPE_SIZE DOUBLE_TYPE_SIZE 352 353 /* `WIDEST_HARDWARE_FP_SIZE' 354 355 A C expression for the size in bits of the widest floating-point 356 format supported by the hardware. If you define this macro, you 357 must specify a value less than or equal to the value of 358 `LONG_DOUBLE_TYPE_SIZE'. If you do not define this macro, the 359 value of `LONG_DOUBLE_TYPE_SIZE' is the default. */ 360 361 /* `DEFAULT_SIGNED_CHAR' 362 363 An expression whose value is 1 or 0, according to whether the type 364 `char' should be signed or unsigned by default. The user can 365 always override this default with the options `-fsigned-char' and 366 `-funsigned-char'. */ 367 #define DEFAULT_SIGNED_CHAR 0 368 369 /* `SIZE_TYPE' 370 371 A C expression for a string describing the name of the data type to 372 use for size values. The typedef name `size_t' is defined using 373 the contents of the string. 374 375 The string can contain more than one keyword. If so, separate them 376 with spaces, and write first any length keyword, then `unsigned' if 377 appropriate, and finally `int'. The string must exactly match one 378 of the data type names defined in the function 379 `init_decl_processing' in the file `c-decl.c'. You may not omit 380 `int' or change the order--that would cause the compiler to crash 381 on startup. 382 383 If you don't define this macro, the default is `"long unsigned 384 int"'. */ 385 #define SIZE_TYPE "unsigned int" 386 387 /* `PTRDIFF_TYPE' 388 389 A C expression for a string describing the name of the data type to 390 use for the result of subtracting two pointers. The typedef name 391 `ptrdiff_t' is defined using the contents of the string. See 392 `SIZE_TYPE' above for more information. 393 394 If you don't define this macro, the default is `"long int"'. */ 395 #define PTRDIFF_TYPE "long int" 396 397 /* Newlib uses the unsigned type corresponding to ptrdiff_t for 398 uintptr_t; this is the same as size_t for most newlib-using 399 targets, but not for us. */ 400 #define UINTPTR_TYPE "long unsigned int" 401 402 /* `WCHAR_TYPE' 403 404 A C expression for a string describing the name of the data type to 405 use for wide characters. The typedef name `wchar_t' is defined 406 using the contents of the string. See `SIZE_TYPE' above for more 407 information. 408 409 If you don't define this macro, the default is `"int"'. */ 410 #define WCHAR_TYPE "short int" 411 412 /* `WCHAR_TYPE_SIZE' 413 414 A C expression for the size in bits of the data type for wide 415 characters. This is used in `cpp', which cannot make use of 416 `WCHAR_TYPE'. */ 417 #define WCHAR_TYPE_SIZE 16 418 419 /* Register Usage 420 421 This section explains how to describe what registers the target 422 machine has, and how (in general) they can be used. */ 423 424 /* `FIRST_PSEUDO_REGISTER' 425 426 Number of actual hardware registers. 427 The hardware registers are assigned numbers for the compiler 428 from 0 to just below FIRST_PSEUDO_REGISTER. 429 All registers that the compiler knows about must be given numbers, 430 even those that are not normally considered general registers. 431 432 Register 51 is used as the argument pointer register. 433 Register 52 is used as the soft frame pointer register. */ 434 #define FIRST_PSEUDO_REGISTER 53 435 436 #define RETURN_REGNUM 1 437 #define PROLOGUE_TMP_REGNUM 9 438 #define LINK_REGNUM 21 439 #define GP_LAST_REGNUM 31 440 #define GP_REGISTER_P(REGNO) \ 441 (((unsigned) (REGNO)) <= GP_LAST_REGNUM) 442 443 #define MDB_REGNUM 32 444 #define MDC_REGNUM 33 445 446 #define FP_FIRST_REGNUM 34 447 #define FP_LAST_REGNUM 49 448 #define FP_RETURN_REGNUM (FP_FIRST_REGNUM + 1) 449 #define FP_REGISTER_P(REGNO) \ 450 (FP_FIRST_REGNUM <= (REGNO) && (REGNO) <= FP_LAST_REGNUM) 451 452 #define FLAGS_REGNUM 50 453 454 /* `FIXED_REGISTERS' 455 456 An initializer that says which registers are used for fixed 457 purposes all throughout the compiled code and are therefore not 458 available for general allocation. These would include the stack 459 pointer, the frame pointer (except on machines where that can be 460 used as a general register when no frame pointer is needed), the 461 program counter on machines where that is considered one of the 462 addressable registers, and any other numbered register with a 463 standard use. 464 465 This information is expressed as a sequence of numbers, separated 466 by commas and surrounded by braces. The Nth number is 1 if 467 register N is fixed, 0 otherwise. 468 469 The table initialized from this macro, and the table initialized by 470 the following one, may be overridden at run time either 471 automatically, by the actions of the macro 472 `CONDITIONAL_REGISTER_USAGE', or by the user with the command 473 options `-ffixed-REG', `-fcall-used-REG' and `-fcall-saved-REG'. 474 475 r0 and f0 are immutable registers hardwired to 0. 476 r21 is the link register used for procedure linkage. 477 r23 is the stack pointer register. 478 r29 and r30 hold the interrupt context. 479 mdc is a read-only register because the writemdc instruction 480 terminates all the operations of the EAM on the GR6. */ 481 #define FIXED_REGISTERS \ 482 { 1, 0, 0, 0, 0, 0, 0, 0, /* r0 .. r7 */ \ 483 0, 0, 0, 0, 0, 0, 0, 0, /* r8 .. r15 */ \ 484 0, 0, 0, 0, 0, 1, 0, 1, /* r16 .. r23 */ \ 485 0, 0, 0, 0, 0, 1, 1, 0, /* r24 .. r31 */ \ 486 0, 1, /* mdb, mdc */ \ 487 1, 0, 0, 0, 0, 0, 0, 0, /* f0 .. f7 */ \ 488 0, 0, 0, 0, 0, 0, 0, 0, /* f8 .. f15 */ \ 489 1, 1, 1 } /* flags, arg, frame */ 490 491 /* Like `CALL_USED_REGISTERS' except this macro doesn't require that 492 the entire set of `FIXED_REGISTERS' be included. 493 (`CALL_USED_REGISTERS' must be a superset of `FIXED_REGISTERS'). 494 This macro is optional. If not specified, it defaults to the value 495 of `CALL_USED_REGISTERS'. */ 496 #define CALL_REALLY_USED_REGISTERS \ 497 { 0, 1, 1, 1, 1, 1, 1, 1, /* r0 .. r7 */ \ 498 1, 1, 1, 0, 0, 0, 0, 0, /* r8 .. r15 */ \ 499 0, 0, 0, 0, 1, 0, 0, 0, /* r16 .. r23 */ \ 500 1, 1, 1, 1, 1, 0, 0, 1, /* r24 .. r31 */ \ 501 1, 1, /* mdb, mdc */ \ 502 1, 1, 1, 1, 1, 1, 1, 1, /* f0 .. f7 */ \ 503 1, 0, 0, 0, 0, 0, 0, 0, /* f8 .. f15 */ \ 504 1, 0, 0 } /* flags, arg, frame */ 505 506 /* `REG_ALLOC_ORDER' 507 508 If defined, an initializer for a vector of integers, containing the 509 numbers of hard registers in the order in which GCC should prefer 510 to use them (from most preferred to least). 511 512 If this macro is not defined, registers are used lowest numbered 513 first (all else being equal). */ 514 #define REG_ALLOC_ORDER \ 515 { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, /* r10 .. r1 */ \ 516 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, /* r11 .. r20 */ \ 517 22, /* fp */ \ 518 24, 25, 26, 27, 28, /* r24 .. r28 */ \ 519 31, /* r31 */ \ 520 32, 33, /* mdb, mdc */ \ 521 42, 41, 40, 39, 38, 37, 36, 35, /* f8 .. f1 */ \ 522 43, 44, 45, 46, 47, 48, 49, /* f9 .. f15 */ \ 523 21, 23, /* lr, sp */ \ 524 29, 30, /* r29, r30 */ \ 525 50, 51, 52, /* flags, arg, frame */ \ 526 0, 34 } /* r0, f0 */ 527 528 /* `HARD_REGNO_RENAME_OK (OLD_REG, NEW_REG)' 529 530 A C expression which is nonzero if hard register NEW_REG can be 531 considered for use as a rename register for hard register OLD_REG. */ 532 #define HARD_REGNO_RENAME_OK(OLD_REG, NEW_REG) \ 533 visium_hard_regno_rename_ok (OLD_REG, NEW_REG) 534 535 /* Register Classes 536 537 On many machines, the numbered registers are not all equivalent. 538 For example, certain registers may not be allowed for indexed 539 addressing; certain registers may not be allowed in some 540 instructions. These machine restrictions are described to the 541 compiler using "register classes". 542 543 `enum reg_class' 544 545 An enumeral type that must be defined with all the register class 546 names as enumeral values. `NO_REGS' must be first. `ALL_REGS' 547 must be the last register class, followed by one more enumeral 548 value, `LIM_REG_CLASSES', which is not a register class but rather 549 tells how many classes there are. 550 551 Each register class has a number, which is the value of casting the 552 class name to type `int'. The number serves as an index in many of 553 the tables described below. */ 554 555 enum reg_class 556 { 557 NO_REGS, 558 MDB, 559 MDC, 560 FP_REGS, 561 FLAGS, 562 R1, 563 R2, 564 R3, 565 SIBCALL_REGS, 566 LOW_REGS, 567 GENERAL_REGS, 568 ALL_REGS, 569 LIM_REG_CLASSES 570 }; 571 572 /* `N_REG_CLASSES' 573 574 The number of distinct register classes, defined as follows. */ 575 #define N_REG_CLASSES (int) LIM_REG_CLASSES 576 577 /* `REG_CLASS_NAMES' 578 579 An initializer containing the names of the register classes as C 580 string constants. These names are used in writing some of the 581 debugging dumps. */ 582 #define REG_CLASS_NAMES \ 583 {"NO_REGS", "MDB", "MDC", "FP_REGS", "FLAGS", "R1", "R2", "R3", \ 584 "SIBCALL_REGS", "LOW_REGS", "GENERAL_REGS", "ALL_REGS"} 585 586 /* `REG_CLASS_CONTENTS' 587 588 An initializer containing the contents of the register classes, as 589 integers which are bit masks. The Nth integer specifies the 590 contents of class N. The way the integer MASK is interpreted is 591 that register R is in the class if `MASK & (1 << R)' is 1. 592 593 When the machine has more than 32 registers, an integer does not 594 suffice. Then the integers are replaced by sub-initializers, 595 braced groupings containing several integers. Each sub-initializer 596 must be suitable as an initializer for the type `HARD_REG_SET' 597 which is defined in `hard-reg-set.h'. */ 598 #define REG_CLASS_CONTENTS { \ 599 {0x00000000, 0x00000000}, /* NO_REGS */ \ 600 {0x00000000, 0x00000001}, /* MDB */ \ 601 {0x00000000, 0x00000002}, /* MDC */ \ 602 {0x00000000, 0x0003fffc}, /* FP_REGS */ \ 603 {0x00000000, 0x00040000}, /* FLAGS */ \ 604 {0x00000002, 0x00000000}, /* R1 */ \ 605 {0x00000004, 0x00000000}, /* R2 */ \ 606 {0x00000008, 0x00000000}, /* R3 */ \ 607 {0x000005ff, 0x00000000}, /* SIBCALL_REGS */ \ 608 {0x1fffffff, 0x00000000}, /* LOW_REGS */ \ 609 {0xffffffff, 0x00180000}, /* GENERAL_REGS */ \ 610 {0xffffffff, 0x001fffff}} /* ALL_REGS */ 611 612 /* `REGNO_REG_CLASS (REGNO)' 613 614 A C expression whose value is a register class containing hard 615 register REGNO. In general there is more than one such class; 616 choose a class which is "minimal", meaning that no smaller class 617 also contains the register. */ 618 #define REGNO_REG_CLASS(REGNO) \ 619 ((REGNO) == MDB_REGNUM ? MDB : \ 620 (REGNO) == MDC_REGNUM ? MDC : \ 621 FP_REGISTER_P (REGNO) ? FP_REGS : \ 622 (REGNO) == FLAGS_REGNUM ? FLAGS : \ 623 (REGNO) == 1 ? R1 : \ 624 (REGNO) == 2 ? R2 : \ 625 (REGNO) == 3 ? R3 : \ 626 (REGNO) <= 8 || (REGNO) == 10 ? SIBCALL_REGS : \ 627 (REGNO) <= 28 ? LOW_REGS : \ 628 GENERAL_REGS) 629 630 /* `BASE_REG_CLASS' 631 632 A macro whose definition is the name of the class to which a valid 633 base register must belong. A base register is one used in an 634 address which is the register value plus a displacement. */ 635 #define BASE_REG_CLASS GENERAL_REGS 636 637 #define BASE_REGISTER_P(REGNO) \ 638 (GP_REGISTER_P (REGNO) \ 639 || (REGNO) == ARG_POINTER_REGNUM \ 640 || (REGNO) == FRAME_POINTER_REGNUM) 641 642 /* `INDEX_REG_CLASS' 643 644 A macro whose definition is the name of the class to which a valid 645 index register must belong. An index register is one used in an 646 address where its value is either multiplied by a scale factor or 647 added to another register (as well as added to a displacement). */ 648 #define INDEX_REG_CLASS NO_REGS 649 650 /* `REGNO_OK_FOR_BASE_P (NUM)' 651 652 A C expression which is nonzero if register number NUM is suitable 653 for use as a base register in operand addresses. It may be either 654 a suitable hard register or a pseudo register that has been 655 allocated such a hard register. */ 656 #define REGNO_OK_FOR_BASE_P(REGNO) \ 657 (BASE_REGISTER_P (REGNO) || BASE_REGISTER_P ((unsigned)reg_renumber[REGNO])) 658 659 /* `REGNO_OK_FOR_INDEX_P (NUM)' 660 661 A C expression which is nonzero if register number NUM is suitable 662 for use as an index register in operand addresses. It may be 663 either a suitable hard register or a pseudo register that has been 664 allocated such a hard register. 665 666 The difference between an index register and a base register is 667 that the index register may be scaled. If an address involves the 668 sum of two registers, neither one of them scaled, then either one 669 may be labeled the "base" and the other the "index"; but whichever 670 labeling is used must fit the machine's constraints of which 671 registers may serve in each capacity. The compiler will try both 672 labelings, looking for one that is valid, and will reload one or 673 both registers only if neither labeling works. */ 674 #define REGNO_OK_FOR_INDEX_P(REGNO) 0 675 676 /* `PREFERRED_RELOAD_CLASS (X, CLASS)' 677 678 A C expression that places additional restrictions on the register 679 class to use when it is necessary to copy value X into a register 680 in class CLASS. The value is a register class; perhaps CLASS, or 681 perhaps another, smaller class. 682 683 Sometimes returning a more restrictive class makes better code. 684 For example, on the 68000, when X is an integer constant that is in 685 range for a `moveq' instruction, the value of this macro is always 686 `DATA_REGS' as long as CLASS includes the data registers. 687 Requiring a data register guarantees that a `moveq' will be used. 688 689 If X is a `const_double', by returning `NO_REGS' you can force X 690 into a memory constant. This is useful on certain machines where 691 immediate floating values cannot be loaded into certain kinds of 692 registers. */ 693 #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS 694 695 #define CLASS_MAX_NREGS(CLASS, MODE) \ 696 ((CLASS) == MDB ? \ 697 ((GET_MODE_SIZE (MODE) + 2 * UNITS_PER_WORD - 1) / (2 * UNITS_PER_WORD)) \ 698 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) 699 700 /* Stack Layout and Calling Conventions 701 702 Basic Stack Layout 703 704 `STACK_GROWS_DOWNWARD' 705 Define this macro if pushing a word onto the stack moves the stack 706 pointer to a smaller address. */ 707 #define STACK_GROWS_DOWNWARD 1 708 709 /* `FIRST_PARM_OFFSET (FUNDECL)' 710 711 Offset from the argument pointer register to the first argument's 712 address. On some machines it may depend on the data type of the 713 function. 714 715 If `ARGS_GROW_DOWNWARD', this is the offset to the location above 716 the first argument's address. */ 717 #define FIRST_PARM_OFFSET(FNDECL) 0 718 719 /* `DYNAMIC_CHAIN_ADDRESS (FRAMEADDR)' 720 721 A C expression whose value is RTL representing the address in a 722 stack frame where the pointer to the caller's frame is stored. 723 Assume that FRAMEADDR is an RTL expression for the address of the 724 stack frame itself. 725 726 If you don't define this macro, the default is to return the value 727 of FRAMEADDR--that is, the stack frame address is also the address 728 of the stack word that points to the previous frame. */ 729 #define DYNAMIC_CHAIN_ADDRESS(FRAMEADDR) \ 730 visium_dynamic_chain_address (FRAMEADDR) 731 732 /* `RETURN_ADDR_RTX (COUNT, FRAMEADDR)' 733 734 A C expression whose value is RTL representing the value of the 735 return address for the frame COUNT steps up from the current frame, 736 after the prologue. FRAMEADDR is the frame pointer of the COUNT 737 frame, or the frame pointer of the COUNT - 1 frame if 738 `RETURN_ADDR_IN_PREVIOUS_FRAME' is defined. 739 740 The value of the expression must always be the correct address when 741 COUNT is zero, but may be `NULL_RTX' if there is not way to 742 determine the return address of other frames. */ 743 #define RETURN_ADDR_RTX(COUNT,FRAMEADDR) \ 744 visium_return_addr_rtx (COUNT, FRAMEADDR) 745 746 /* Exception Handling 747 748 `EH_RETURN_DATA_REGNO' 749 750 A C expression whose value is the Nth register number used for data 751 by exception handlers or INVALID_REGNUM if fewer than N registers 752 are available. 753 754 The exception handling library routines communicate with the 755 exception handlers via a set of agreed upon registers. */ 756 #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N) + 11 : INVALID_REGNUM) 757 #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (SImode, 8) 758 #define EH_RETURN_HANDLER_RTX visium_eh_return_handler_rtx () 759 760 /* Registers That Address the Stack Frame 761 762 This discusses registers that address the stack frame. 763 764 `STACK_POINTER_REGNUM' 765 766 The register number of the stack pointer register, which must also 767 be a fixed register according to `FIXED_REGISTERS'. On most 768 machines, the hardware determines which register this is. */ 769 #define STACK_POINTER_REGNUM 23 770 771 /* `FRAME_POINTER_REGNUM' 772 773 The register number of the frame pointer register, which is used to 774 access automatic variables in the stack frame. On some machines, 775 the hardware determines which register this is. On other machines, 776 you can choose any register you wish for this purpose. */ 777 #define FRAME_POINTER_REGNUM 52 778 779 /* `HARD_FRAME_POINTER_REGNUM' 780 781 On some machines the offset between the frame pointer and starting 782 offset of the automatic variables is not known until after register 783 allocation has been done (for example, because the saved registers 784 are between these two locations). On those machines, define 785 `FRAME_POINTER_REGNUM' the number of a special, fixed register to 786 be used internally until the offset is known, and define 787 `HARD_FRAME_POINTER_REGNUM' to be the actual hard register number 788 used for the frame pointer. */ 789 #define HARD_FRAME_POINTER_REGNUM 22 790 791 /* `ARG_POINTER_REGNUM' 792 793 The register number of the arg pointer register, which is used to 794 access the function's argument list. On some machines, this is the 795 same as the frame pointer register. On some machines, the hardware 796 determines which register this is. On other machines, you can 797 choose any register you wish for this purpose. If this is not the 798 same register as the frame pointer register, then you must mark it 799 as a fixed register according to `FIXED_REGISTERS', or arrange to 800 be able to eliminate it (*note Elimination::.). */ 801 #define ARG_POINTER_REGNUM 51 802 803 /* `STATIC_CHAIN_REGNUM' 804 `STATIC_CHAIN_INCOMING_REGNUM' 805 806 Register numbers used for passing a function's static chain 807 pointer. If register windows are used, the register number as seen 808 by the called function is `STATIC_CHAIN_INCOMING_REGNUM', while the 809 register number as seen by the calling function is 810 `STATIC_CHAIN_REGNUM'. If these registers are the same, 811 `STATIC_CHAIN_INCOMING_REGNUM' need not be defined. 812 813 The static chain register need not be a fixed register. 814 815 If the static chain is passed in memory, these macros should not be 816 defined; instead, the next two macros should be defined. */ 817 #define STATIC_CHAIN_REGNUM 20 818 819 /* `ELIMINABLE_REGS' 820 821 If defined, this macro specifies a table of register pairs used to 822 eliminate unneeded registers that point into the stack frame. If 823 it is not defined, the only elimination attempted by the compiler 824 is to replace references to the frame pointer with references to 825 the stack pointer. 826 827 The definition of this macro is a list of structure 828 initializations, each of which specifies an original and 829 replacement register. 830 831 On some machines, the position of the argument pointer is not known 832 until the compilation is completed. In such a case, a separate 833 hard register must be used for the argument pointer. This register 834 can be eliminated by replacing it with either the frame pointer or 835 the argument pointer, depending on whether or not the frame pointer 836 has been eliminated. 837 838 Note that the elimination of the argument pointer with the stack 839 pointer is specified first since that is the preferred elimination. */ 840 #define ELIMINABLE_REGS \ 841 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ 842 { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \ 843 { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ 844 { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}} 845 846 /* `INITIAL_ELIMINATION_OFFSET (FROM-REG, TO-REG, OFFSET-VAR)' 847 848 This macro returns the initial difference between the specified pair 849 of registers. */ 850 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ 851 (OFFSET = visium_initial_elimination_offset (FROM, TO)) 852 853 /* Passing Function Arguments on the Stack 854 855 The macros in this section control how arguments are passed on the 856 stack. See the following section for other macros that control 857 passing certain arguments in registers. 858 859 Passing Arguments in Registers 860 861 This section describes the macros which let you control how various 862 types of arguments are passed in registers or how they are arranged 863 in the stack. 864 865 Define the general purpose, and floating point registers used for 866 passing arguments */ 867 #define MAX_ARGS_IN_GP_REGISTERS 8 868 #define GP_ARG_FIRST 1 869 #define GP_ARG_LAST (GP_ARG_FIRST + MAX_ARGS_IN_GP_REGISTERS - 1) 870 #define MAX_ARGS_IN_FP_REGISTERS 8 871 #define FP_ARG_FIRST (FP_FIRST_REGNUM + 1) 872 #define FP_ARG_LAST (FP_ARG_FIRST + MAX_ARGS_IN_FP_REGISTERS - 1) 873 874 /* Define a data type for recording info about an argument list during the 875 processing of that argument list. */ 876 877 struct visium_args 878 { 879 /* The count of general registers used */ 880 int grcount; 881 /* The count of floating registers used */ 882 int frcount; 883 /* The number of stack words used by named arguments */ 884 int stack_words; 885 }; 886 887 /* `CUMULATIVE_ARGS' 888 889 A C type for declaring a variable that is used as the first 890 argument of `FUNCTION_ARG' and other related values. For some 891 target machines, the type `int' suffices and can hold the number of 892 bytes of argument so far. 893 894 There is no need to record in `CUMULATIVE_ARGS' anything about the 895 arguments that have been passed on the stack. The compiler has 896 other variables to keep track of that. For target machines on 897 which all arguments are passed on the stack, there is no need to 898 store anything in `CUMULATIVE_ARGS'; however, the data structure 899 must exist and should not be empty, so use `int'. */ 900 #define CUMULATIVE_ARGS struct visium_args 901 902 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,FNDECL,N_NAMED_ARGS) \ 903 do { \ 904 (CUM).grcount = 0; \ 905 (CUM).frcount = 0; \ 906 (CUM).stack_words = 0; \ 907 } while (0) 908 909 /* `FUNCTION_ARG_REGNO_P (REGNO)' 910 911 A C expression that is nonzero if REGNO is the number of a hard 912 register in which function arguments are sometimes passed. This 913 does *not* include implicit arguments such as the static chain and 914 the structure-value address. On many machines, no registers can be 915 used for this purpose since all function arguments are pushed on 916 the stack. */ 917 #define FUNCTION_ARG_REGNO_P(N) \ 918 ((GP_ARG_FIRST <= (N) && (N) <= GP_ARG_LAST) \ 919 || (TARGET_FPU && FP_ARG_FIRST <= (N) && (N) <= FP_ARG_LAST)) 920 921 /* `FUNCTION_VALUE_REGNO_P (REGNO)' 922 923 A C expression that is nonzero if REGNO is the number of a hard 924 register in which the values of called function may come back. 925 926 A register whose use for returning values is limited to serving as 927 the second of a pair (for a value of type `double', say) need not 928 be recognized by this macro. If the machine has register windows, 929 so that the caller and the called function use different registers 930 for the return value, this macro should recognize only the caller's 931 register numbers. */ 932 #define FUNCTION_VALUE_REGNO_P(N) \ 933 ((N) == RETURN_REGNUM || (TARGET_FPU && (N) == FP_RETURN_REGNUM)) 934 935 /* How Large Values Are Returned 936 937 When a function value's mode is `BLKmode' (and in some other 938 cases), the value is not returned according to `FUNCTION_VALUE'. 939 Instead, the caller passes the address of a block of memory in 940 which the value should be stored. This address is called the 941 "structure value address". 942 943 This section describes how to control returning structure values in 944 memory. 945 946 `DEFAULT_PCC_STRUCT_RETURN' 947 948 Define this macro to be 1 if all structure and union return values 949 must be in memory. Since this results in slower code, this should 950 be defined only if needed for compatibility with other compilers or 951 with an ABI. If you define this macro to be 0, then the 952 conventions used for structure and union return values are decided 953 by the `RETURN_IN_MEMORY' macro. 954 955 If not defined, this defaults to the value 1. */ 956 #define DEFAULT_PCC_STRUCT_RETURN 0 957 958 /* Caller-Saves Register Allocation 959 960 If you enable it, GNU CC can save registers around function calls. 961 This makes it possible to use call-clobbered registers to hold 962 variables that must live across calls. 963 964 Function Entry and Exit 965 966 This section describes the macros that output function entry 967 ("prologue") and exit ("epilogue") code. 968 969 `EXIT_IGNORE_STACK' 970 971 Define this macro as a C expression that is nonzero if the return 972 instruction or the function epilogue ignores the value of the stack 973 pointer; in other words, if it is safe to delete an instruction to 974 adjust the stack pointer before a return from the function. 975 976 Note that this macro's value is relevant only for functions for 977 which frame pointers are maintained. It is never safe to delete a 978 final stack adjustment in a function that has no frame pointer, and 979 the compiler knows this regardless of `EXIT_IGNORE_STACK'. */ 980 #define EXIT_IGNORE_STACK 1 981 982 /* `EPILOGUE_USES (REGNO)' 983 984 Define this macro as a C expression that is nonzero for registers 985 are used by the epilogue or the `return' pattern. The stack and 986 frame pointer registers are already be assumed to be used as 987 needed. */ 988 #define EPILOGUE_USES(REGNO) visium_epilogue_uses (REGNO) 989 990 /* Generating Code for Profiling 991 992 These macros will help you generate code for profiling. */ 993 994 #define PROFILE_HOOK(LABEL) visium_profile_hook () 995 #define FUNCTION_PROFILER(FILE, LABELNO) do {} while (0) 996 #define NO_PROFILE_COUNTERS 1 997 998 /* Trampolines for Nested Functions 999 1000 A trampoline is a small piece of code that is created at run time 1001 when the address of a nested function is taken. It normally resides 1002 on the stack, in the stack frame of the containing function. These 1003 macros tell GCC how to generate code to allocate and initialize a 1004 trampoline. 1005 1006 The instructions in the trampoline must do two things: load a 1007 constant address into the static chain register, and jump to the 1008 real address of the nested function. On CISC machines such as the 1009 m68k, this requires two instructions, a move immediate and a 1010 jump. Then the two addresses exist in the trampoline as word-long 1011 immediate operands. On RISC machines, it is often necessary to load 1012 each address into a register in two parts. Then pieces of each 1013 address form separate immediate operands. 1014 1015 The code generated to initialize the trampoline must store the 1016 variable parts--the static chain value and the function 1017 address--into the immediate operands of the instructions. On a CISC 1018 machine, this is simply a matter of copying each address to a 1019 memory reference at the proper offset from the start of the 1020 trampoline. On a RISC machine, it may be necessary to take out 1021 pieces of the address and store them separately. 1022 1023 On the Visium, the trampoline is 1024 1025 moviu r9,%u FUNCTION 1026 movil r9,%l FUNCTION 1027 [nop] 1028 moviu r20,%u STATIC 1029 bra tr,r9,r0 1030 movil r20,%l STATIC 1031 1032 A difficulty is setting the correct instruction parity at run time. 1033 1034 1035 TRAMPOLINE_SIZE 1036 A C expression for the size in bytes of the trampoline, as an integer. */ 1037 #define TRAMPOLINE_SIZE (visium_cpu == PROCESSOR_GR6 ? 24 : 20) 1038 1039 /* Alignment required for trampolines, in bits. */ 1040 #define TRAMPOLINE_ALIGNMENT (visium_cpu == PROCESSOR_GR6 ? 64 : 32) 1041 1042 /* Implicit calls to library routines 1043 1044 Avoid calling library routines (sqrtf) just to set `errno' to EDOM */ 1045 #define TARGET_EDOM 33 1046 1047 /* Addressing Modes 1048 1049 `MAX_REGS_PER_ADDRESS' 1050 1051 A number, the maximum number of registers that can appear in a 1052 valid memory address. Note that it is up to you to specify a value 1053 equal to the maximum number that `TARGET_LEGITIMATE_ADDRESS_P' would 1054 ever accept. */ 1055 #define MAX_REGS_PER_ADDRESS 1 1056 1057 /* `LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS, WIN)' 1058 1059 A C compound statement that attempts to replace X, which is an 1060 address that needs reloading, with a valid memory address for an 1061 operand of mode MODE. WIN will be a C statement label elsewhere 1062 in the code. It is not necessary to define this macro, but it 1063 might be useful for performance reasons. */ 1064 #define LEGITIMIZE_RELOAD_ADDRESS(AD, MODE, OPNUM, TYPE, IND, WIN) \ 1065 do \ 1066 { \ 1067 rtx new_x = visium_legitimize_reload_address ((AD), (MODE), (OPNUM), \ 1068 (int) (TYPE), (IND)); \ 1069 if (new_x) \ 1070 { \ 1071 (AD) = new_x; \ 1072 goto WIN; \ 1073 } \ 1074 } while (0) 1075 1076 /* Given a comparison code (EQ, NE, etc.) and the operands of a COMPARE, 1077 return the mode to be used for the comparison. */ 1078 #define SELECT_CC_MODE(OP,X,Y) visium_select_cc_mode ((OP), (X), (Y)) 1079 1080 /* Return nonzero if MODE implies a floating point inequality can be 1081 reversed. For Visium this is always true because we have a full 1082 compliment of ordered and unordered comparisons, but until generic 1083 code knows how to reverse it correctly we keep the old definition. */ 1084 #define REVERSIBLE_CC_MODE(MODE) ((MODE) != CCFPEmode && (MODE) != CCFPmode) 1085 1086 /* `BRANCH_COST' 1087 1088 A C expression for the cost of a branch instruction. A value of 1 1089 is the default; other values are interpreted relative to that. */ 1090 #define BRANCH_COST(A,B) 10 1091 1092 /* Override BRANCH_COST heuristics for complex logical ops. */ 1093 #define LOGICAL_OP_NON_SHORT_CIRCUIT 0 1094 1095 /* `SLOW_BYTE_ACCESS' 1096 1097 Define this macro as a C expression which is nonzero if accessing 1098 less than a word of memory (i.e. a `char' or a `short') is no 1099 faster than accessing a word of memory, i.e., if such access 1100 require more than one instruction or if there is no difference in 1101 cost between byte and (aligned) word loads. 1102 1103 When this macro is not defined, the compiler will access a field by 1104 finding the smallest containing object; when it is defined, a 1105 fullword load will be used if alignment permits. Unless bytes 1106 accesses are faster than word accesses, using word accesses is 1107 preferable since it may eliminate subsequent memory access if 1108 subsequent accesses occur to other fields in the same word of the 1109 structure, but to different bytes. */ 1110 #define SLOW_BYTE_ACCESS 0 1111 1112 /* `MOVE_RATIO (SPEED)` 1113 1114 The threshold of number of scalar memory-to-memory move insns, 1115 _below_ which a sequence of insns should be generated instead of a 1116 string move insn or a library call. Increasing the value will 1117 always make code faster, but eventually incurs high cost in 1118 increased code size. 1119 1120 Since we have a cpymemsi pattern, the default MOVE_RATIO is 2, which 1121 is too low given that cpymemsi will invoke a libcall. */ 1122 #define MOVE_RATIO(speed) ((speed) ? 9 : 3) 1123 1124 /* `CLEAR_RATIO (SPEED)` 1125 1126 The threshold of number of scalar move insns, _below_ which a 1127 sequence of insns should be generated to clear memory instead of a 1128 string clear insn or a library call. Increasing the value will 1129 always make code faster, but eventually incurs high cost in 1130 increased code size. 1131 1132 Since we have a setmemsi pattern, the default CLEAR_RATIO is 2, which 1133 is too low given that setmemsi will invoke a libcall. */ 1134 #define CLEAR_RATIO(speed) ((speed) ? 13 : 5) 1135 1136 /* `MOVE_MAX' 1137 1138 The maximum number of bytes that a single instruction can move 1139 quickly between memory and registers or between two memory 1140 locations. */ 1141 #define MOVE_MAX 4 1142 1143 /* `MAX_MOVE_MAX' 1144 1145 The maximum number of bytes that a single instruction can move 1146 quickly between memory and registers or between two memory 1147 locations. If this is undefined, the default is `MOVE_MAX'. 1148 Otherwise, it is the constant value that is the largest value that 1149 `MOVE_MAX' can have at run-time. */ 1150 #define MAX_MOVE_MAX 4 1151 1152 /* `SHIFT_COUNT_TRUNCATED' 1153 1154 A C expression that is nonzero if on this machine the number of 1155 bits actually used for the count of a shift operation is equal to 1156 the number of bits needed to represent the size of the object being 1157 shifted. When this macro is non-zero, the compiler will assume 1158 that it is safe to omit a sign-extend, zero-extend, and certain 1159 bitwise `and' instructions that truncates the count of a shift 1160 operation. On machines that have instructions that act on 1161 bitfields at variable positions, which may include `bit test' 1162 instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables 1163 deletion of truncations of the values that serve as arguments to 1164 bitfield instructions. */ 1165 #define SHIFT_COUNT_TRUNCATED 0 1166 1167 /* `STORE_FLAG_VALUE' 1168 1169 A C expression describing the value returned by a comparison 1170 operator with an integral mode and stored by a store-flag 1171 instruction (`sCOND') when the condition is true. This description 1172 must apply to *all* the `sCOND' patterns and all the comparison 1173 operators whose results have a `MODE_INT' mode. */ 1174 #define STORE_FLAG_VALUE 1 1175 1176 /* `Pmode' 1177 1178 An alias for the machine mode for pointers. On most machines, 1179 define this to be the integer mode corresponding to the width of a 1180 hardware pointer; `SImode' on 32-bit machine or `DImode' on 64-bit 1181 machines. On some machines you must define this to be one of the 1182 partial integer modes, such as `PSImode'. 1183 1184 The width of `Pmode' must be at least as large as the value of 1185 `POINTER_SIZE'. If it is not equal, you must define the macro 1186 `POINTERS_EXTEND_UNSIGNED' to specify how pointers are extended to 1187 `Pmode'. */ 1188 #define Pmode SImode 1189 1190 /* `FUNCTION_MODE' 1191 1192 An alias for the machine mode used for memory references to 1193 functions being called, in `call' RTL expressions. On most 1194 machines this should be `QImode'. */ 1195 #define FUNCTION_MODE SImode 1196 1197 /* Dividing the Output into Sections (Texts, Data, ...) 1198 1199 An object file is divided into sections containing different types 1200 of data. In the most common case, there are three sections: the 1201 "text section", which holds instructions and read-only data; the 1202 "data section", which holds initialized writable data; and the "bss 1203 section", which holds uninitialized data. Some systems have other 1204 kinds of sections. 1205 1206 `TEXT_SECTION_ASM_OP' 1207 1208 A C expression whose value is a string containing the assembler 1209 operation that should precede instructions and read-only data. 1210 Normally `".text"' is right. */ 1211 #define TEXT_SECTION_ASM_OP "\t.text" 1212 1213 /* `DATA_SECTION_ASM_OP' 1214 1215 A C expression whose value is a string containing the assembler 1216 operation to identify the following data as writable initialized 1217 data. Normally `".data"' is right. */ 1218 #define DATA_SECTION_ASM_OP "\t.data" 1219 1220 /* `BSS_SECTION_ASM_OP' 1221 1222 If defined, a C expression whose value is a string containing the 1223 assembler operation to identify the following data as uninitialized 1224 global data. If not defined, and neither `ASM_OUTPUT_BSS' nor 1225 `ASM_OUTPUT_ALIGNED_BSS' are defined, uninitialized global data 1226 will be output in the data section if `-fno-common' is passed, 1227 otherwise `ASM_OUTPUT_COMMON' will be used. 1228 1229 `EXTRA_SECTIONS' 1230 1231 A list of names for sections other than the standard two, which are 1232 `in_text' and `in_data'. You need not define this macro on a 1233 system with no other sections (that GCC needs to use). 1234 1235 `EXTRA_SECTION_FUNCTIONS' 1236 1237 One or more functions to be defined in `varasm.c'. These functions 1238 should do jobs analogous to those of `text_section' and 1239 `data_section', for your additional sections. Do not define this 1240 macro if you do not define `EXTRA_SECTIONS'. 1241 1242 `JUMP_TABLES_IN_TEXT_SECTION' Define this macro if jump tables (for 1243 `tablejump' insns) should be output in the text section, along with 1244 the assembler instructions. Otherwise, the readonly data section 1245 is used. 1246 1247 This macro is irrelevant if there is no separate readonly data 1248 section. */ 1249 #undef JUMP_TABLES_IN_TEXT_SECTION 1250 1251 1252 /* The Overall Framework of an Assembler File 1253 1254 This describes the overall framework of an assembler file. 1255 1256 `ASM_COMMENT_START' 1257 1258 A C string constant describing how to begin a comment in the target 1259 assembler language. The compiler assumes that the comment will end 1260 at the end of the line. */ 1261 #define ASM_COMMENT_START ";" 1262 1263 /* `ASM_APP_ON' 1264 1265 A C string constant for text to be output before each `asm' 1266 statement or group of consecutive ones. Normally this is `"#APP"', 1267 which is a comment that has no effect on most assemblers but tells 1268 the GNU assembler that it must check the lines that follow for all 1269 valid assembler constructs. */ 1270 #define ASM_APP_ON "#APP\n" 1271 1272 /* `ASM_APP_OFF' 1273 1274 A C string constant for text to be output after each `asm' 1275 statement or group of consecutive ones. Normally this is 1276 `"#NO_APP"', which tells the GNU assembler to resume making the 1277 time-saving assumptions that are valid for ordinary compiler 1278 output. */ 1279 #define ASM_APP_OFF "#NO_APP\n" 1280 1281 /* Output of Data 1282 1283 This describes data output. 1284 1285 Output and Generation of Labels 1286 1287 This is about outputting labels. 1288 1289 `ASM_OUTPUT_LABEL (STREAM, NAME)' 1290 1291 A C statement (sans semicolon) to output to the stdio stream STREAM 1292 the assembler definition of a label named NAME. Use the expression 1293 `assemble_name (STREAM, NAME)' to output the name itself; before 1294 and after that, output the additional assembler syntax for defining 1295 the name, and a newline. */ 1296 #define ASM_OUTPUT_LABEL(STREAM,NAME) \ 1297 do { assemble_name (STREAM, NAME); fputs (":\n", STREAM); } while (0) 1298 1299 /* Globalizing directive for a label */ 1300 #define GLOBAL_ASM_OP "\t.global " 1301 1302 /* `ASM_OUTPUT_LABELREF (STREAM, NAME)' 1303 1304 A C statement (sans semicolon) to output to the stdio stream STREAM 1305 a reference in assembler syntax to a label named NAME. This should 1306 add `_' to the front of the name, if that is customary on your 1307 operating system, as it is in most Berkeley Unix systems. This 1308 macro is used in `assemble_name'. */ 1309 #define ASM_OUTPUT_LABELREF(STREAM,NAME) \ 1310 asm_fprintf (STREAM, "%U%s", NAME) 1311 1312 /* Output of Assembler Instructions 1313 1314 This describes assembler instruction output. 1315 1316 `REGISTER_NAMES' 1317 1318 A C initializer containing the assembler's names for the machine 1319 registers, each one as a C string constant. This is what 1320 translates register numbers in the compiler into assembler 1321 language. */ 1322 #define REGISTER_NAMES \ 1323 {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \ 1324 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", \ 1325 "r16", "r17", "r18", "r19", "r20", "r21", "fp", "sp", \ 1326 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", \ 1327 "mdb", "mdc", \ 1328 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \ 1329 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \ 1330 "flags","argp","sfp" } 1331 1332 /* `ADDITIONAL_REGISTER_NAMES` 1333 1334 If defined, a C initializer for an array of structures containing 1335 a name and a register number. This macro defines additional names 1336 for hard registers, thus allowing the `asm' option in declarations 1337 to refer to registers using alternate names. */ 1338 #define ADDITIONAL_REGISTER_NAMES \ 1339 {{"r22", HARD_FRAME_POINTER_REGNUM}, {"r23", STACK_POINTER_REGNUM}} 1340 1341 /* `REGISTER_PREFIX' 1342 `LOCAL_LABEL_PREFIX' 1343 `USER_LABEL_PREFIX' 1344 `IMMEDIATE_PREFIX' 1345 1346 If defined, C string expressions to be used for the `%R', `%L', 1347 `%U', and `%I' options of `asm_fprintf' (see `final.c'). These are 1348 useful when a single `md' file must support multiple assembler 1349 formats. In that case, the various `tm.h' files can define these 1350 macros differently. */ 1351 #define REGISTER_PREFIX "" 1352 #define LOCAL_LABEL_PREFIX "." 1353 #define IMMEDIATE_PREFIX "#" 1354 1355 /* `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)' 1356 1357 A C expression to output to STREAM some assembler code which will 1358 push hard register number REGNO onto the stack. The code need not 1359 be optimal, since this macro is used only when profiling. */ 1360 #define ASM_OUTPUT_REG_PUSH(STREAM,REGNO) \ 1361 asm_fprintf (STREAM, "\tsubi sp,4\n\twrite.l (sp),%s\n", \ 1362 reg_names[REGNO]) 1363 1364 /* `ASM_OUTPUT_REG_POP (STREAM, REGNO)' 1365 1366 A C expression to output to STREAM some assembler code which will 1367 pop hard register number REGNO off of the stack. The code need not 1368 be optimal, since this macro is used only when profiling. */ 1369 #define ASM_OUTPUT_REG_POP(STREAM,REGNO) \ 1370 asm_fprintf (STREAM, "\tread.l %s,(sp)\n\taddi sp,4\n", \ 1371 reg_names[REGNO]) 1372 1373 1374 /* Output of Dispatch Tables 1375 1376 This concerns dispatch tables. 1377 1378 `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)' 1379 1380 A C statement to output to the stdio stream STREAM an assembler 1381 pseudo-instruction to generate a difference between two labels. 1382 VALUE and REL are the numbers of two internal labels. The 1383 definitions of these labels are output using 1384 `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the same 1385 way here. 1386 1387 You must provide this macro on machines where the addresses in a 1388 dispatch table are relative to the table's own address. If 1389 defined, GNU CC will also use this macro on all machines when 1390 producing PIC. */ 1391 #define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM,BODY,VALUE,REL) \ 1392 switch (GET_MODE (BODY)) \ 1393 { \ 1394 case E_SImode: \ 1395 asm_fprintf ((STREAM), "\t.long\t%LL%d-%LL%d\n", (VALUE),(REL)); \ 1396 break; \ 1397 case E_HImode: \ 1398 asm_fprintf ((STREAM), "\t.word\t%LL%d-%LL%d\n", (VALUE),(REL)); \ 1399 break; \ 1400 case E_QImode: \ 1401 asm_fprintf ((STREAM), "\t.byte\t%LL%d-%LL%d\n", (VALUE),(REL)); \ 1402 break; \ 1403 default: \ 1404 break; \ 1405 } 1406 1407 /* `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)' 1408 1409 This macro should be provided on machines where the addresses in a 1410 dispatch table are absolute. 1411 1412 The definition should be a C statement to output to the stdio 1413 stream STREAM an assembler pseudo-instruction to generate a 1414 reference to a label. VALUE is the number of an internal label 1415 whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. */ 1416 #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \ 1417 asm_fprintf (STREAM, "\t.long %LL%d\n", VALUE) 1418 1419 /* `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)' 1420 1421 Define this if something special must be output at the end of a 1422 jump-table. The definition should be a C statement to be executed 1423 after the assembler code for the table is written. It should write 1424 the appropriate code to stdio stream STREAM. The argument TABLE is 1425 the jump-table insn, and NUM is the label-number of the preceding 1426 label. 1427 1428 If this macro is not defined, nothing special is output at the end 1429 of a jump table. 1430 1431 Here we output a word of zero so that jump-tables can be seperated 1432 in reverse assembly. */ 1433 #define ASM_OUTPUT_CASE_END(STREAM, NUM, TABLE) \ 1434 asm_fprintf (STREAM, "\t.long 0\n") 1435 1436 /* Support subalignment values. */ 1437 1438 #define SUBALIGN_LOG 3 1439 1440 /* Assembler Commands for Alignment 1441 1442 This describes commands for alignment. 1443 1444 `ASM_OUTPUT_ALIGN_CODE (STREAM)' 1445 1446 A C expression to output text to align the location counter in the 1447 way that is desirable at a point in the code that is reached only 1448 by jumping. 1449 1450 This macro need not be defined if you don't want any special 1451 alignment to be done at such a time. Most machine descriptions do 1452 not currently define the macro. */ 1453 #undef ASM_OUTPUT_ALIGN_CODE 1454 1455 /* `ASM_OUTPUT_LOOP_ALIGN (STREAM)' 1456 1457 A C expression to output text to align the location counter in the 1458 way that is desirable at the beginning of a loop. 1459 1460 This macro need not be defined if you don't want any special 1461 alignment to be done at such a time. Most machine descriptions do 1462 not currently define the macro. */ 1463 #undef ASM_OUTPUT_LOOP_ALIGN 1464 1465 /* `ASM_OUTPUT_ALIGN (STREAM, POWER)' 1466 1467 A C statement to output to the stdio stream STREAM an assembler 1468 command to advance the location counter to a multiple of 2 to the 1469 POWER bytes. POWER will be a C expression of type `int'. */ 1470 #define ASM_OUTPUT_ALIGN(STREAM,LOG) \ 1471 if ((LOG) != 0) \ 1472 fprintf (STREAM, "\t.align %d\n", (1 << (LOG))) 1473 1474 /* `ASM_OUTPUT_MAX_SKIP_ALIGN (STREAM, POWER, MAX_SKIP)` 1475 1476 A C statement to output to the stdio stream STREAM an assembler 1477 command to advance the location counter to a multiple of 2 to the 1478 POWER bytes, but only if MAX_SKIP or fewer bytes are needed to 1479 satisfy the alignment request. POWER and MAX_SKIP will be a C 1480 expression of type `int'. */ 1481 #define ASM_OUTPUT_MAX_SKIP_ALIGN(STREAM,LOG,MAX_SKIP) \ 1482 if ((LOG) != 0) { \ 1483 if ((MAX_SKIP) == 0 || (MAX_SKIP) >= (1 << (LOG)) - 1) \ 1484 fprintf ((STREAM), "\t.p2align %d\n", (LOG)); \ 1485 else \ 1486 fprintf ((STREAM), "\t.p2align %d,,%d\n", (LOG), (MAX_SKIP)); \ 1487 } 1488 1489 /* Controlling Debugging Information Format 1490 1491 This describes how to specify debugging information. 1492 1493 mda is known to GDB, but not to GCC. */ 1494 #define DBX_REGISTER_NUMBER(REGNO) \ 1495 ((REGNO) > MDB_REGNUM ? (REGNO) + 1 : (REGNO)) 1496 1497 /* `DEBUGGER_AUTO_OFFSET (X)' 1498 1499 A C expression that returns the integer offset value for an 1500 automatic variable having address X (an RTL expression). The 1501 default computation assumes that X is based on the frame-pointer 1502 and gives the offset from the frame-pointer. This is required for 1503 targets that produce debugging output for DBX and allow the frame-pointer 1504 to be eliminated when the `-g' options is used. */ 1505 #define DEBUGGER_AUTO_OFFSET(X) \ 1506 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) 1507 1508 /* Miscellaneous Parameters 1509 1510 `CASE_VECTOR_MODE' 1511 1512 An alias for a machine mode name. This is the machine mode that 1513 elements of a jump-table should have. */ 1514 #define CASE_VECTOR_MODE SImode 1515 1516 /* `CASE_VECTOR_PC_RELATIVE' 1517 Define this macro if jump-tables should contain relative addresses. */ 1518 #undef CASE_VECTOR_PC_RELATIVE 1519 1520 /* This says how to output assembler code to declare an 1521 unitialised external linkage data object. */ 1522 #define ASM_OUTPUT_COMMON(STREAM, NAME, SIZE, ROUNDED) \ 1523 ( fputs ("\n\t.comm ", (STREAM)), \ 1524 assemble_name ((STREAM), (NAME)), \ 1525 fprintf ((STREAM), "," HOST_WIDE_INT_PRINT_UNSIGNED"\n", ROUNDED)) 1526 1527 /* This says how to output assembler code to declare an 1528 unitialised internal linkage data object. */ 1529 #define ASM_OUTPUT_LOCAL(STREAM, NAME, SIZE, ROUNDED) \ 1530 ( fputs ("\n\t.lcomm ", (STREAM)), \ 1531 assemble_name ((STREAM), (NAME)), \ 1532 fprintf ((STREAM), "," HOST_WIDE_INT_PRINT_UNSIGNED"\n", ROUNDED)) 1533 1534 /* Prettify the assembly. */ 1535 extern int visium_indent_opcode; 1536 1537 #define ASM_OUTPUT_OPCODE(FILE, PTR) \ 1538 do { \ 1539 if (visium_indent_opcode) \ 1540 { \ 1541 putc (' ', FILE); \ 1542 visium_indent_opcode = 0; \ 1543 } \ 1544 } while (0) 1545 1546 /* Configure-time default values for common options. */ 1547 #define OPTION_DEFAULT_SPECS { "cpu", "%{!mcpu=*:-mcpu=%(VALUE)}" } 1548 1549 /* Values of TARGET_CPU_DEFAULT specified via --with-cpu. */ 1550 #define TARGET_CPU_gr5 0 1551 #define TARGET_CPU_gr6 1 1552 1553 /* Default -mcpu multilib for above values. */ 1554 #if TARGET_CPU_DEFAULT == TARGET_CPU_gr5 1555 #define MULTILIB_DEFAULTS { "mcpu=gr5" } 1556 #elif TARGET_CPU_DEFAULT == TARGET_CPU_gr6 1557 #define MULTILIB_DEFAULTS { "mcpu=gr6" } 1558 #else 1559 #error Unrecognized value in TARGET_CPU_DEFAULT 1560 #endif 1561