1 /* clr.h (tm.h) 2 * Jeremy Singer 3 * 7 Jan 03 4 */ 5 6 /* This is the header file for the 7 * machine description for the 8 * .NET Common Language Runtime (CLR). 9 * It contains 10 * C macros for machine fundamentals, 11 * compiler environment, 12 * machine description support and 13 * application-binary interface. 14 */ 15 16 /* This file is adapted from the egcs-jvm source code, which came 17 * with the following caveat: 18 * 19 * 20 * Note that this machine description is based on the CRIS 21 * architecture so some portions of this file may not be 22 * relevant to the JVM (I never really got around to triming 23 * the fat). The CRIS architecture was selected because the 24 * machine description files were heavily documented, not 25 * because of any similarity with the JVM. 26 * 27 * - Trent Waddington, 9/9/1999 28 * 29 * 30 * 31 */ 32 33 /********************************************************************** 34 This file is part of GNU CC. 35 36 GNU CC is free software; you can redistribute it and/or modify 37 it under the terms of the GNU General Public License as published by 38 the Free Software Foundation; either version 2, or (at your option) 39 any later version. 40 41 GNU CC is distributed in the hope that it will be useful, 42 but WITHOUT ANY WARRANTY; without even the implied warranty of 43 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 44 GNU General Public License for more details. 45 46 You should have received a copy of the GNU General Public License 47 along with GNU CC; see the file COPYING. If not, write to 48 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 49 **************************************************************************/ 50 51 52 #include <stdio.h> 53 54 /* jvm specific stuff snipped */ 55 56 57 /* After this comment lies all preprocessor directives and attached 58 declarations described in the info files (or the "Using and Porting 59 GNU CC" manual) in the same order as found in the "Target macros" 60 section in the gcc-2.7.2 edition. 61 First there is a comment with the same text as found in the info 62 files, then one or more jvm-specific comments, then the 63 definition/declarations (if applicable). Every section is 64 precluded with a `Section: Section name' comment. 65 All preprocessor directives, including unused/undefined are 66 represented here. If an entire section is excluded, then only the 67 section-comment is present. */ 68 69 70 /* Section: Driver */ 71 72 /* 73 `SWITCH_TAKES_ARG (CHAR)' 74 A C expression which determines whether the option `-CHAR' takes 75 arguments. The value should be the number of arguments that 76 option takes-zero, for many options. 77 78 By default, this macro is defined to handle the standard options 79 properly. You need not define it unless you wish to add additional 80 options which take arguments. 81 */ 82 /* No definition */ 83 84 85 /* 86 `WORD_SWITCH_TAKES_ARG (NAME)' 87 A C expression which determines whether the option `-NAME' takes 88 arguments. The value should be the number of arguments that 89 option takes-zero, for many options. This macro rather than 90 `SWITCH_TAKES_ARG' is used for multi-character option names. 91 92 By default, this macro is defined as 93 `DEFAULT_WORD_SWITCH_TAKES_ARG', which handles the standard options 94 properly. You need not define `WORD_SWITCH_TAKES_ARG' unless you 95 wish to add additional options which take arguments. Any 96 redefinition should call `DEFAULT_WORD_SWITCH_TAKES_ARG' and then 97 check for additional options. 98 */ 99 /* No definition */ 100 101 102 /* 103 `SWITCHES_NEED_SPACES' 104 A string-valued C expression which is nonempty if the linker needs 105 a space between the `-L' or `-o' option and its argument. 106 107 If this macro is not defined, the default value is 0. 108 */ 109 /* No definition */ 110 111 112 /* 113 `CPP_SPEC' 114 A C string constant that tells the GNU CC driver program options to 115 pass to CPP. It can also specify how to translate options you 116 give to GNU CC into options for GNU CC to pass to the CPP. 117 */ 118 /* No definition */ 119 120 121 /* 122 `NO_BUILTIN_SIZE_TYPE' 123 If this macro is defined, the preprocessor will not define the 124 builtin macro `__SIZE_TYPE__'. The macro `__SIZE_TYPE__' must 125 then be defined by `CPP_SPEC' instead. 126 127 This should be defined if `SIZE_TYPE' depends on target dependent 128 flags which are not accessible to the preprocessor. Otherwise, it 129 should not be defined. 130 */ 131 /* No definition */ 132 133 134 /* 135 `NO_BUILTIN_PTRDIFF_TYPE' 136 If this macro is defined, the preprocessor will not define the 137 builtin macro `__PTRDIFF_TYPE__'. The macro `__PTRDIFF_TYPE__' 138 must then be defined by `CPP_SPEC' instead. 139 140 This should be defined if `PTRDIFF_TYPE' depends on target 141 dependent flags which are not accessible to the preprocessor. 142 Otherwise, it should not be defined. 143 */ 144 /* No definition */ 145 146 147 /* 148 `SIGNED_CHAR_SPEC' 149 A C string constant that tells the GNU CC driver program options to 150 pass to CPP. By default, this macro is defined to pass the option 151 `-D__CHAR_UNSIGNED__' to CPP if `char' will be treated as 152 `unsigned char' by `cc1'. 153 154 Do not define this macro unless you need to override the default 155 definition. 156 */ 157 /* No definition */ 158 159 160 /* 161 `CC1_SPEC' 162 A C string constant that tells the GNU CC driver program options to 163 pass to `cc1'. It can also specify how to translate options you 164 give to GNU CC into options for GNU CC to pass to the `cc1'. 165 166 Do not define this macro if it does not need to do anything. 167 */ 168 /* No definition */ 169 170 171 /* 172 `CC1PLUS_SPEC' 173 A C string constant that tells the GNU CC driver program options to 174 pass to `cc1plus'. It can also specify how to translate options 175 you give to GNU CC into options for GNU CC to pass to the 176 `cc1plus'. 177 178 Do not define this macro if it does not need to do anything. 179 */ 180 /* Use the same as for CC1. */ 181 #define CC1PLUS_SPEC CC1_SPEC 182 183 184 /* 185 `ASM_SPEC' 186 A C string constant that tells the GNU CC driver program options to 187 pass to the assembler. It can also specify how to translate 188 options you give to GNU CC into options for GNU CC to pass to the 189 assembler. See the file `sun3.h' for an example of this. 190 191 Do not define this macro if it does not need to do anything. 192 */ 193 /* No definition */ 194 195 196 /* 197 `ASM_FINAL_SPEC' 198 A C string constant that tells the GNU CC driver program how to 199 run any programs which cleanup after the normal assembler. 200 Normally, this is not needed. See the file `mips.h' for an 201 example of this. 202 203 Do not define this macro if it does not need to do anything. 204 */ 205 /* No definition */ 206 207 208 /* 209 `LINK_SPEC' 210 A C string constant that tells the GNU CC driver program options to 211 pass to the linker. It can also specify how to translate options 212 you give to GNU CC into options for GNU CC to pass to the linker. 213 214 Do not define this macro if it does not need to do anything. 215 */ 216 /* No definition */ 217 218 219 /* 220 `LIB_SPEC' 221 Another C string constant used much like `LINK_SPEC'. The 222 difference between the two is that `LIB_SPEC' is used at the end 223 of the command given to the linker. 224 225 If this macro is not defined, a default is provided that loads the 226 standard C library from the usual place. See `gcc.c'. 227 */ 228 /* No definition */ 229 230 231 /* 232 `LIBGCC_SPEC' 233 Another C string constant that tells the GNU CC driver program how 234 and when to place a reference to `libgcc.a' into the linker 235 command line. This constant is placed both before and after the 236 value of `LIB_SPEC'. 237 238 If this macro is not defined, the GNU CC driver provides a default 239 that passes the string `-lgcc' to the linker unless the `-shared' 240 option is specified. 241 */ 242 /* No definition */ 243 244 245 /* 246 `STARTFILE_SPEC' 247 Another C string constant used much like `LINK_SPEC'. The 248 difference between the two is that `STARTFILE_SPEC' is used at the 249 very beginning of the command given to the linker. 250 251 If this macro is not defined, a default is provided that loads the 252 standard C startup file from the usual place. See `gcc.c'. 253 */ 254 /* No definition */ 255 256 /* 257 `ENDFILE_SPEC' 258 Another C string constant used much like `LINK_SPEC'. The 259 difference between the two is that `ENDFILE_SPEC' is used at the 260 very end of the command given to the linker. 261 262 Do not define this macro if it does not need to do anything. 263 */ 264 /* No definition */ 265 266 267 /* 268 `LINK_LIBGCC_SPECIAL' 269 Define this macro if the driver program should find the library 270 `libgcc.a' itself and should not pass `-L' options to the linker. 271 If you do not define this macro, the driver program will pass the 272 argument `-lgcc' to tell the linker to do the search and will pass 273 `-L' options to it. 274 */ 275 /* No definition */ 276 277 278 /* 279 `LINK_LIBGCC_SPECIAL_1' 280 Define this macro if the driver program should find the library 281 `libgcc.a'. If you do not define this macro, the driver program 282 will pass the argument `-lgcc' to tell the linker to do the search. 283 This macro is similar to `LINK_LIBGCC_SPECIAL', except that it does 284 not affect `-L' options. 285 */ 286 /* No definition */ 287 288 289 /* 290 `MULTILIB_DEFAULTS' 291 Define this macro as a C expression for the initializer of an 292 array of string to tell the driver program which options are 293 defaults for this target and thus do not need to be handled 294 specially when using `MULTILIB_OPTIONS'. 295 296 Do not define this macro if `MULTILIB_OPTIONS' is not defined in 297 the target makefile fragment or if none of the options listed in 298 `MULTILIB_OPTIONS' are set by default. *Note Target Fragment::. 299 */ 300 /* No definition */ 301 302 303 /* 304 `RELATIVE_PREFIX_NOT_LINKDIR' 305 Define this macro to tell `gcc' that it should only translate a 306 `-B' prefix into a `-L' linker option if the prefix indicates an 307 absolute file name. 308 */ 309 /* No definition */ 310 311 312 /* 313 `STANDARD_EXEC_PREFIX' 314 Define this macro as a C string constant if you wish to override 315 the standard choice of `/usr/local/lib/gcc-lib/' as the default 316 prefix to try when searching for the executable files of the 317 compiler. 318 */ 319 /* No definition */ 320 321 322 /* 323 `MD_EXEC_PREFIX' 324 If defined, this macro is an additional prefix to try after 325 `STANDARD_EXEC_PREFIX'. `MD_EXEC_PREFIX' is not searched when the 326 `-b' option is used, or the compiler is built as a cross compiler. 327 */ 328 /* No definition */ 329 330 331 /* 332 `STANDARD_STARTFILE_PREFIX' 333 Define this macro as a C string constant if you wish to override 334 the standard choice of `/usr/local/lib/' as the default prefix to 335 try when searching for startup files such as `crt0.o'. 336 */ 337 /* No definition */ 338 339 340 /* 341 `MD_STARTFILE_PREFIX' 342 If defined, this macro supplies an additional prefix to try after 343 the standard prefixes. `MD_EXEC_PREFIX' is not searched when the 344 `-b' option is used, or when the compiler is built as a cross 345 compiler. 346 */ 347 /* No definition */ 348 349 350 /* 351 `MD_STARTFILE_PREFIX_1' 352 If defined, this macro supplies yet another prefix to try after the 353 standard prefixes. It is not searched when the `-b' option is 354 used, or when the compiler is built as a cross compiler. 355 */ 356 /* No definition */ 357 358 359 /* 360 `INIT_ENVIRONMENT' 361 Define this macro as a C string constant if you with to set 362 environment variables for programs called by the driver, such as 363 the assembler and loader. The driver passes the value of this 364 macro to `putenv' to initialize the necessary environment 365 variables. 366 */ 367 /* No definition */ 368 369 370 /* 371 `LOCAL_INCLUDE_DIR' 372 Define this macro as a C string constant if you wish to override 373 the standard choice of `/usr/local/include' as the default prefix 374 to try when searching for local header files. `LOCAL_INCLUDE_DIR' 375 comes before `SYSTEM_INCLUDE_DIR' in the search order. 376 377 Cross compilers do not use this macro and do not search either 378 `/usr/local/include' or its replacement. 379 */ 380 /* No definition */ 381 382 383 /* 384 `SYSTEM_INCLUDE_DIR' 385 Define this macro as a C string constant if you wish to specify a 386 system-specific directory to search for header files before the 387 standard directory. `SYSTEM_INCLUDE_DIR' comes before 388 `STANDARD_INCLUDE_DIR' in the search order. 389 390 Cross compilers do not use this macro and do not search the 391 directory specified. 392 */ 393 /* No definition */ 394 395 396 /* 397 `STANDARD_INCLUDE_DIR' 398 Define this macro as a C string constant if you wish to override 399 the standard choice of `/usr/include' as the default prefix to try 400 when searching for header files. 401 402 Cross compilers do not use this macro and do not search either 403 `/usr/include' or its replacement. 404 */ 405 /* No definition */ 406 407 408 /* 409 `INCLUDE_DEFAULTS' 410 Define this macro if you wish to override the entire default 411 search path for include files. The default search path includes 412 `GCC_INCLUDE_DIR', `LOCAL_INCLUDE_DIR', `SYSTEM_INCLUDE_DIR', 413 `GPLUSPLUS_INCLUDE_DIR', and `STANDARD_INCLUDE_DIR'. In addition, 414 `GPLUSPLUS_INCLUDE_DIR' and `GCC_INCLUDE_DIR' are defined 415 automatically by `Makefile', and specify private search areas for 416 GCC. The directory `GPLUSPLUS_INCLUDE_DIR' is used only for C++ 417 programs. 418 419 The definition should be an initializer for an array of structures. 420 Each array element should have two elements: the directory name (a 421 string constant) and a flag for C++-only directories. Mark the 422 end of the array with a null element. For example, here is the 423 definition used for VMS: 424 425 #define INCLUDE_DEFAULTS \ 426 { \ 427 { "GNU_GXX_INCLUDE:", 1}, \ 428 { "GNU_CC_INCLUDE:", 0}, \ 429 { "SYS$SYSROOT:[SYSLIB.]", 0}, \ 430 { ".", 0}, \ 431 { 0, 0} \ 432 } 433 434 Here is the order of prefixes tried for exec files: 435 436 1. Any prefixes specified by the user with `-B'. 437 438 2. The environment variable `GCC_EXEC_PREFIX', if any. 439 440 3. The directories specified by the environment variable 441 `COMPILER_PATH'. 442 443 4. The macro `STANDARD_EXEC_PREFIX'. 444 445 5. `/usr/lib/gcc/'. 446 447 6. The macro `MD_EXEC_PREFIX', if any. 448 449 Here is the order of prefixes tried for startfiles: 450 451 1. Any prefixes specified by the user with `-B'. 452 453 2. The environment variable `GCC_EXEC_PREFIX', if any. 454 455 3. The directories specified by the environment variable 456 `LIBRARY_PATH' (native only, cross compilers do not use this). 457 458 4. The macro `STANDARD_EXEC_PREFIX'. 459 460 5. `/usr/lib/gcc/'. 461 462 6. The macro `MD_EXEC_PREFIX', if any. 463 464 7. The macro `MD_STARTFILE_PREFIX', if any. 465 466 8. The macro `STANDARD_STARTFILE_PREFIX'. 467 468 9. `/lib/'. 469 470 10. `/usr/lib/'. 471 */ 472 /* All the same as the default, except we dont want anything from the 473 tool-include-dir. Yes, we keep the cross-include-dir; we may need 474 some special place to keep any kludge sys-files (Ulf needed kludge 475 include-files to compile libg++, so we may need it). 476 (Also, the t-jvm part changes gxx_include_dir to start from the 477 same directory as c-include: ".../jvm/GCC_VER/include" but being 478 ".../jvm/GCC_VER/g++-include", instead of something down lower in 479 the path. But we dont see it here.) */ 480 #define INCLUDE_DEFAULTS \ 481 { \ 482 /* Pick up GNU C++ specific include files. */ \ 483 { GPLUSPLUS_INCLUDE_DIR, 1, 1 }, \ 484 /* This is the dir for fixincludes. Put it just before \ 485 the files that we fix. */ \ 486 { GCC_INCLUDE_DIR, 0, 0 }, \ 487 /* For cross-compilation, this dir name is generated \ 488 automatically in Makefile.in. */ \ 489 { CROSS_INCLUDE_DIR, 0, 0 }, \ 490 } 491 492 /* Section: Run-time Target */ 493 494 /* 495 `CPP_PREDEFINES' 496 Define this to be a string constant containing `-D' options to 497 define the predefined macros that identify this machine and system. 498 These macros will be predefined unless the `-ansi' option is 499 specified. 500 501 In addition, a parallel set of macros are predefined, whose names 502 are made by appending `__' at the beginning and at the end. These 503 `__' macros are permitted by the ANSI standard, so they are 504 predefined regardless of whether `-ansi' is specified. 505 506 For example, on the Sun, one can use the following value: 507 508 "-Dmc68000 -Dsun -Dunix" 509 510 The result is to define the macros `__mc68000__', `__sun__' and 511 `__unix__' unconditionally, and the macros `mc68000', `sun' and 512 `unix' provided `-ansi' is not specified. 513 */ 514 #define CPP_PREDEFINES "-Dclr -DCLR -DGNU_CLR" 515 516 517 /* 518 `extern int target_flags;' 519 This declaration should be present. 520 */ 521 /* Lets just HOPE this is 32bit... else doom waits. */ 522 extern int target_flags; 523 524 525 /* 526 `TARGET_...' 527 This series of macros is to allow compiler command arguments to 528 enable or disable the use of optional features of the target 529 machine. For example, one machine description serves both the 530 68000 and the 68020; a command argument tells the compiler whether 531 it should use 68020-only instructions or not. This command 532 argument works by means of a macro `TARGET_68020' that tests a bit 533 in `target_flags'. 534 535 Define a macro `TARGET_FEATURENAME' for each such option. Its 536 definition should test a bit in `target_flags'; for example: 537 538 #define TARGET_68020 (target_flags & 1) 539 540 One place where these macros are used is in the 541 condition-expressions of instruction patterns. Note how 542 `TARGET_68020' appears frequently in the 68000 machine description 543 file, `m68k.md'. Another place they are used is in the 544 definitions of the other macros in the `MACHINE.h' file. 545 */ 546 /* Debug options. NOT USED ANYMORE */ 547 #define TARGET_GO_DEBUG (target_flags & 1) 548 #define TARGET_PO_DEBUG (target_flags & 2) 549 550 /* Just affects aligment. */ 551 #define TARGET_SVINTO (target_flags & 4) 552 553 /* If to use condition-codes generated by insns other than the immediately 554 preceding compare/test insn. 555 Used to check for errors in notice_update_cc. */ 556 #define TARGET_CCINIT (target_flags & 8) 557 558 /* If you change define_delay then this may be useful to test if 559 there is any change in the delayed-branch sceduling. NOT USED 560 ANYMORE 561 #define TARGET_SLOTALL (target_flags & 16) 562 */ 563 564 /* If to use 16-bit ints (not tested). DO NOT USE */ 565 #define TARGET_SHORT (target_flags & 32) 566 567 /* Used when compiling library functions for modes > 32bit. 568 USED ONLY WHEN MAKING libgcc2.a */ 569 #define TARGET_LIBFUNC (target_flags & 64) 570 571 /* Debug option. NOT USED ANYMORE */ 572 #define TARGET_PDEBUG (target_flags & 128) 573 574 /* If to use side-effect patterns. (Actually the opposite of the 575 intuitive function. Used to debug the [rx=ry+i] type patterns. */ 576 #define TARGET_SPLIT (target_flags & 256) 577 578 /* If to patch non-optimal cse:ing of addresses. NOT USED ANYMORE */ 579 #define TARGET_EXTRA_CSE (target_flags & 512) 580 581 /* If to use the [rx+[ry].S] and [rx+[ry+].S] addressing modes. 582 NOT USED ANYMORE */ 583 #define TARGET_BDAP (target_flags & 1024) 584 585 /* If to use the [[rx+]] addressing mode. NOT USED ANYMORE */ 586 #define TARGET_DIPINC (target_flags & 2048) 587 588 /* If to expand mul into mstep. ONLY USED WHEN MAKING libc.a */ 589 #define TARGET_MUL (target_flags & 4096) 590 591 /* If to change add.w 65539,r9 into addq 3,r9. NOT USED ANYMORE */ 592 #define TARGET_MODIFY_OPERANDS (target_flags & 8192) 593 594 /* If to use add, sub, and, or in HImode && QImode. NOT USED ANYMORE */ 595 #define TARGET_SMALL_ARIT (target_flags & 16384) 596 597 /* If to KEEP (not force) alignment of stack at 16 bits. */ 598 #define TARGET_STACK_ALIGN (target_flags & 32768) 599 600 /* If to do alignment on individual non-modifiable objects. */ 601 #define TARGET_CONST_ALIGN (target_flags & 65536) 602 603 /* If to do alignment on individual modifiable objects. */ 604 #define TARGET_DATA_ALIGN (target_flags & 131072) 605 606 /* If to remove unused constant strings. */ 607 #define TARGET_USED_STRINGS (target_flags & 524288) 608 609 /* If not to omit funtion prologue and epilogue */ 610 #define TARGET_PROLOGUE_EPILOGUE (target_flags & 1048576) 611 612 613 /* 614 `TARGET_SWITCHES' 615 This macro defines names of command options to set and clear bits 616 in `target_flags'. Its definition is an initializer with a 617 subgrouping for each command option. 618 619 Each subgrouping contains a string constant, that defines the 620 option name, and a number, which contains the bits to set in 621 `target_flags'. A negative number says to clear bits instead; the 622 negative of the number is which bits to clear. The actual option 623 name is made by appending `-m' to the specified name. 624 625 One of the subgroupings should have a null string. The number in 626 this grouping is the default value for `target_flags'. Any target 627 options act starting with that value. 628 629 Here is an example which defines `-m68000' and `-m68020' with 630 opposite meanings, and picks the latter as the default: 631 632 #define TARGET_SWITCHES \ 633 { { "68020", 1}, \ 634 { "68000", -1}, \ 635 { "", 1}} 636 */ 637 #define TARGET_SWITCHES \ 638 { \ 639 { "go_debug", 1}, \ 640 { "nogo_debug", -1}, \ 641 { "po_debug", 2}, \ 642 { "nopo_debug", -2}, \ 643 { "svinto" , 4}, \ 644 { "no-svinto", -4}, \ 645 { "100" , 4}, \ 646 { "no-100" , -4}, \ 647 { "32" , 4}, \ 648 { "16" , -4}, \ 649 { "etrax100" , 4}, \ 650 { "no-etrax100" , 4}, \ 651 { "etrax" , -4}, \ 652 { "no-etrax" , -4}, \ 653 { "cc-init", 8}, \ 654 { "no-cc-init", -8}, \ 655 { "slot-all", 16}, \ 656 { "no-slot-all", -16}, \ 657 { "short", 32}, \ 658 { "no-short", -32}, \ 659 { "libfunc", 64}, \ 660 { "no-libfunc", -64}, \ 661 { "pdebug", 128}, \ 662 { "no-pdebug", -128}, \ 663 { "split", 256}, \ 664 { "no-split", -256}, \ 665 { "extra-cse", 512}, \ 666 { "no-extra-cse", -512}, \ 667 { "bdap", 1024}, \ 668 { "no-bdap", -1024}, \ 669 { "dip-inc", 2048}, \ 670 { "no-dip-inc", -2048}, \ 671 { "mstep", 4096}, \ 672 { "step", 4096}, \ 673 { "no-mstep", -4096}, \ 674 { "ul", 4096}, \ 675 { "no-mul", -4096}, \ 676 { "modify-operands", 8192}, \ 677 { "odify-operands", 8192}, \ 678 { "no-modify-operands", -8192}, \ 679 { "small-arit", 16384}, \ 680 { "no-small-arit", -16384}, \ 681 { "align", 32768 + 65536 + 131072 + 262144}, \ 682 { "stack-align", 32768}, \ 683 { "no-stack-align", -32768}, \ 684 { "data-align", 131072}, \ 685 { "no-data-align", -131072}, \ 686 { "const-align", 65536}, \ 687 { "no-const-align", -65536}, \ 688 { "used-strings-only", 524288}, \ 689 { "no-used-strings-only", -524288}, \ 690 { "16-bit", 32768 + 65536 + 131072}, \ 691 { "8-bit", -(32768 + 65536 + 131072)}, \ 692 { "16bit", 32768 + 65536 + 131072}, \ 693 { "8bit", -(32768 + 65536 + 131072)}, \ 694 { "prologue-epilogue" , 1048576}, \ 695 { "no-prologue-epilogue" , -1048576}, \ 696 { "", TARGET_DEFAULT}} 697 698 /* Default target_flags if no switches specified. */ 699 #ifndef TARGET_DEFAULT 700 #define TARGET_DEFAULT (256+512+1024+2048+8192+16384+32768+65536+131072+262144+524288+1048576) 701 #endif 702 703 704 /* 705 `TARGET_OPTIONS' 706 This macro is similar to `TARGET_SWITCHES' but defines names of 707 command options that have values. Its definition is an 708 initializer with a subgrouping for each command option. 709 710 Each subgrouping contains a string constant, that defines the 711 fixed part of the option name, and the address of a variable. The 712 variable, type `char *', is set to the variable part of the given 713 option if the fixed part matches. The actual option name is made 714 by appending `-m' to the specified name. 715 716 Here is an example which defines `-mshort-data-NUMBER'. If the 717 given option is `-mshort-data-512', the variable `m88k_short_data' 718 will be set to the string `"512"'. 719 720 extern char *m88k_short_data; 721 #define TARGET_OPTIONS \ 722 { { "short-data-", &m88k_short_data } } 723 */ 724 /* No definition */ 725 726 727 /* 728 `TARGET_VERSION' 729 This macro is a C statement to print on `stderr' a string 730 describing the particular machine description choice. Every 731 machine description should define `TARGET_VERSION'. For example: 732 733 #ifdef MOTOROLA 734 #define TARGET_VERSION \ 735 fprintf (stderr, " (68k, Motorola syntax)"); 736 #else 737 #define TARGET_VERSION \ 738 fprintf (stderr, " (68k, MIT syntax)"); 739 #endif 740 */ 741 /* Print subsidiary information on the compiler version in use. 742 Do not use VD.D syntax (D=digit), since this will cause confusion 743 with the base gcc version among users, when we ask which version of 744 gcc-jvm they are using. Please use some flavor of "R<number>" for 745 the version (no need for major.minor versions, I believe). */ 746 #define TARGET_VERSION fprintf (stderr, ".NET CLR"); 747 748 749 /* 750 `OVERRIDE_OPTIONS' 751 Sometimes certain combinations of command options do not make 752 sense on a particular target machine. You can define a macro 753 `OVERRIDE_OPTIONS' to take account of this. This macro, if 754 defined, is executed once just after all the command options have 755 been parsed. 756 757 Don't use this macro to turn on various extra optimizations for 758 `-O'. That is what `OPTIMIZATION_OPTIONS' is for. 759 */ 760 /* FIXME Do we need this? 761 * #define OVERRIDE_OPTIONS override_options() 762 * extern void override_options(); 763 */ 764 765 /* 766 `OPTIMIZATION_OPTIONS (LEVEL)' 767 Some machines may desire to change what optimizations are 768 performed for various optimization levels. This macro, if 769 defined, is executed once just after the optimization level is 770 determined and before the remainder of the command options have 771 been parsed. Values set in this macro are used as the default 772 values for the other command line options. 773 774 LEVEL is the optimization level specified; 2 if `-O2' is 775 specified, 1 if `-O' is specified, and 0 if neither is specified. 776 777 You should not use this macro to change options that are not 778 machine-specific. These should uniformly selected by the same 779 optimization level on all supported machines. Use this macro to 780 enable machbine-specific optimizations. 781 782 *Do not examine `write_symbols' in this macro!* The debugging 783 options are not supposed to alter the generated code. 784 */ 785 /* The following are found to give better (faster and smaller) code 786 some time long ago. This may have changed (test thorougly!) */ 787 788 /* FIXME Do we need this? 789 //#define OPTIMIZATION_OPTIONS(OPTIMIZE,unused) \ 790 //{ \ 791 // if (OPTIMIZE >= 2) \ 792 // { \ 793 // // flag_unroll_loops = \ 794 // flag_force_addr = flag_force_mem = \ 795 // flag_omit_frame_pointer = 1; \ 796 // } \ 797 //} 798 */ 799 800 801 /* 802 `CAN_DEBUG_WITHOUT_FP' 803 Define this macro if debugging can be performed even without a 804 frame pointer. If this macro is defined, GNU CC will turn on the 805 `-fomit-frame-pointer' option whenever `-O' is specified. 806 */ 807 /* No definition */ 808 809 810 /* Section: Storage Layout */ 811 812 /* 813 `BITS_BIG_ENDIAN' 814 Define this macro to have the value 1 if the most significant bit 815 in a byte has the lowest number; otherwise define it to have the 816 value zero. This means that bit-field instructions count from the 817 most significant bit. If the machine has no bit-field 818 instructions, then this must still be defined, but it doesn't 819 matter which value it is defined to. This macro need not be a 820 constant. 821 822 This macro does not affect the way structure fields are packed into 823 bytes or words; that is controlled by `BYTES_BIG_ENDIAN'. 824 */ 825 #define BITS_BIG_ENDIAN 0 826 827 828 /* 829 `BYTES_BIG_ENDIAN' 830 Define this macro to have the value 1 if the most significant byte 831 in a word has the lowest number. This macro need not be a 832 constant. 833 */ 834 #define BYTES_BIG_ENDIAN 0 835 836 837 /* 838 `WORDS_BIG_ENDIAN' 839 Define this macro to have the value 1 if, in a multiword object, 840 the most significant word has the lowest number. This applies to 841 both memory locations and registers; GNU CC fundamentally assumes 842 that the order of words in memory is the same as the order in 843 registers. This macro need not be a constant. 844 */ 845 /* FIXME Is this right? */ 846 #define WORDS_BIG_ENDIAN 0 847 848 849 /* 850 `LIBGCC2_WORDS_BIG_ENDIAN' 851 Define this macro if WORDS_BIG_ENDIAN is not constant. This must 852 be a constant value with the same meaning as WORDS_BIG_ENDIAN, 853 which will be used only when compiling libgcc2.c. Typically the 854 value will be set based on preprocessor defines. 855 */ 856 /* No definition */ 857 858 859 /* 860 `FLOAT_WORDS_BIG_ENDIAN' 861 Define this macro to have the value 1 if `DFmode', `XFmode' or 862 `TFmode' floating point numbers are stored in memory with the word 863 containing the sign bit at the lowest address; otherwise define it 864 to have the value 0. This macro need not be a constant. 865 866 You need not define this macro if the ordering is the same as for 867 multi-word integers. 868 */ 869 /* No definition (use WORDS_BIG_ENDIAN) */ 870 871 872 /* 873 `BITS_PER_UNIT' 874 Define this macro to be the number of bits in an addressable 875 storage unit (byte); normally 8. 876 */ 877 #define BITS_PER_UNIT 8 878 879 880 /* 881 `BITS_PER_WORD' 882 Number of bits in a word; normally 32. 883 */ 884 #define BITS_PER_WORD 32 885 886 887 /* 888 `MAX_BITS_PER_WORD' 889 Maximum number of bits in a word. If this is undefined, the 890 default is `BITS_PER_WORD'. Otherwise, it is the constant value 891 that is the largest value that `BITS_PER_WORD' can have at 892 run-time. 893 */ 894 /* No definition */ 895 896 897 /* 898 `UNITS_PER_WORD' 899 Number of storage units in a word; normally 4. 900 */ 901 #define UNITS_PER_WORD 4 902 903 904 /* 905 `MIN_UNITS_PER_WORD' 906 Minimum number of units in a word. If this is undefined, the 907 default is `UNITS_PER_WORD'. Otherwise, it is the constant value 908 that is the smallest value that `UNITS_PER_WORD' can have at 909 run-time. 910 */ 911 /* No definition */ 912 913 914 /* 915 `POINTER_SIZE' 916 Width of a pointer, in bits. You must specify a value no wider 917 than the width of `Pmode'. If it is not equal to the width of 918 `Pmode', you must define `POINTERS_EXTEND_UNSIGNED'. 919 */ 920 #define POINTER_SIZE 32 921 922 923 /* 924 `POINTERS_EXTEND_UNSIGNED' 925 A C expression whose value is nonzero if pointers that need to be 926 extended from being `POINTER_SIZE' bits wide to `Pmode' are 927 sign-extended and zero if they are zero-extended. 928 929 You need not define this macro if the `POINTER_SIZE' is equal to 930 the width of `Pmode'. 931 */ 932 /* No definition */ 933 934 935 /* 936 `PROMOTE_MODE (M, UNSIGNEDP, TYPE)' 937 A macro to update M and UNSIGNEDP when an object whose type is 938 TYPE and which has the specified mode and signedness is to be 939 stored in a register. This macro is only called when TYPE is a 940 scalar type. 941 942 On most RISC machines, which only have operations that operate on 943 a full register, define this macro to set M to `word_mode' if M is 944 an integer mode narrower than `BITS_PER_WORD'. In most cases, 945 only integer modes should be widened because wider-precision 946 floating-point operations are usually more expensive than their 947 narrower counterparts. 948 949 For most machines, the macro definition does not change UNSIGNEDP. 950 However, some machines, have instructions that preferentially 951 handle either signed or unsigned quantities of certain modes. For 952 example, on the DEC Alpha, 32-bit loads from memory and 32-bit add 953 instructions sign-extend the result to 64 bits. On such machines, 954 set UNSIGNEDP according to which kind of extension is more 955 efficient. 956 957 Do not define this macro if it would never modify M. 958 */ 959 /* Maybe define this later, when we play with optimizations. */ 960 961 962 /* 963 `PROMOTE_FUNCTION_ARGS' 964 Define this macro if the promotion described by `PROMOTE_MODE' 965 should also be done for outgoing function arguments. 966 */ 967 /* Maybe define this later, when we play with optimizations. */ 968 969 970 /* 971 `PROMOTE_FUNCTION_RETURN' 972 Define this macro if the promotion described by `PROMOTE_MODE' 973 should also be done for the return value of functions. 974 975 If this macro is defined, `FUNCTION_VALUE' must perform the same 976 promotions done by `PROMOTE_MODE'. 977 */ 978 /* Maybe define this later, when we play with optimizations. */ 979 980 981 /* 982 `PROMOTE_FOR_CALL_ONLY' 983 Define this macro if the promotion described by `PROMOTE_MODE' 984 should *only* be performed for outgoing function arguments or 985 function return values, as specified by `PROMOTE_FUNCTION_ARGS' 986 and `PROMOTE_FUNCTION_RETURN', respectively. 987 */ 988 /* Maybe define this later, when we play with optimizations. */ 989 990 991 /* 992 `PARM_BOUNDARY' 993 Normal alignment required for function parameters on the stack, in 994 bits. All stack parameters receive at least this much alignment 995 regardless of data type. On most machines, this is the same as the 996 size of an integer. 997 */ 998 /* We will be using prototype promotion, so they will be 32 bit. */ 999 #define PARM_BOUNDARY 32 1000 1001 1002 /* 1003 `STACK_BOUNDARY' 1004 Define this macro if you wish to preserve a certain alignment for 1005 the stack pointer. The definition is a C expression for the 1006 desired alignment (measured in bits). 1007 1008 If `PUSH_ROUNDING' is not defined, the stack will always be aligned 1009 to the specified boundary. If `PUSH_ROUNDING' is defined and 1010 specifies a less strict alignment than `STACK_BOUNDARY', the stack 1011 may be momentarily unaligned while pushing arguments. 1012 */ 1013 /* Stack boundary is guided by -mstack-align, -mno-stack-align, 1014 -malign. 1015 Old comment: (2.1: still valid in 2.7.2?) 1016 Note that to make this macro affect the alignment of stack 1017 locals, a fix was required, and special precautions when handling 1018 the stack pointer in various other macros (FUNCTION_PROLOGUE et al) 1019 were required. See file "function.c". If you would just define 1020 this macro, it would only affect the builtin alloca() and variable 1021 local data (non-ANSI, non-K&R, Gnu C extension). 1022 */ 1023 #define STACK_BOUNDARY (TARGET_STACK_ALIGN ? (TARGET_SVINTO ? 32 : 16) : 8) 1024 1025 1026 /* 1027 `FUNCTION_BOUNDARY' 1028 Alignment required for a function entry point, in bits. 1029 */ 1030 #define FUNCTION_BOUNDARY 16 1031 1032 1033 /* 1034 `BIGGEST_ALIGNMENT' 1035 Biggest alignment that any data type can require on this machine, 1036 in bits. 1037 */ 1038 /* Do not change this (when optimizing), as it will affect strange 1039 places, at least in 2.1. */ 1040 #define BIGGEST_ALIGNMENT 8 1041 1042 1043 /* 1044 `BIGGEST_FIELD_ALIGNMENT' 1045 Biggest alignment that any structure field can require on this 1046 machine, in bits. If defined, this overrides `BIGGEST_ALIGNMENT' 1047 for structure fields only. 1048 */ 1049 /* No definition */ 1050 1051 1052 /* 1053 `MAX_OFILE_ALIGNMENT' 1054 Biggest alignment supported by the object file format of this 1055 machine. Use this macro to limit the alignment which can be 1056 specified using the `__attribute__ ((aligned (N)))' construct. If 1057 not defined, the default value is `BIGGEST_ALIGNMENT'. 1058 */ 1059 /* Cannot be defined because of restrictions in a.out; it's no use just 1060 to "#define MAX_OFILE_ALIGNMENT (32768*8)" since that will just be 1061 confusing, partly by shutting of the warning. */ 1062 1063 1064 /* 1065 `DATA_ALIGNMENT (TYPE, BASIC-ALIGN)' 1066 If defined, a C expression to compute the alignment for a static 1067 variable. TYPE is the data type, and BASIC-ALIGN is the alignment 1068 that the object would ordinarily have. The value of this macro is 1069 used instead of that alignment to align the object. 1070 1071 If this macro is not defined, then BASIC-ALIGN is used. 1072 1073 One use of this macro is to increase alignment of medium-size data 1074 to make it all fit in fewer cache lines. Another is to cause 1075 character arrays to be word-aligned so that `strcpy' calls that 1076 copy constants to character arrays can be done inline. 1077 */ 1078 /* If -m16bit, -m16-bit, -malign or -mdata-align, 1079 align everything to 16 bit. */ 1080 #define DATA_ALIGNMENT(TYPE, BASIC_ALIGN) \ 1081 (TARGET_DATA_ALIGN ? (TARGET_SVINTO ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \ 1082 : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN) 1083 1084 /* 1085 `CONSTANT_ALIGNMENT (CONSTANT, BASIC-ALIGN)' 1086 If defined, a C expression to compute the alignment given to a 1087 constant that is being placed in memory. CONSTANT is the constant 1088 and BASIC-ALIGN is the alignment that the object would ordinarily 1089 have. The value of this macro is used instead of that alignment to 1090 align the object. 1091 1092 If this macro is not defined, then BASIC-ALIGN is used. 1093 1094 The typical use of this macro is to increase alignment for string 1095 constants to be word aligned so that `strcpy' calls that copy 1096 constants can be done inline. 1097 */ 1098 /* Note that this has the effect of making gcc believe that ALL 1099 references to constant stuff (in code segment, like strings) has 1100 this alignment. That is a rather rushed assumption. Luckily we do 1101 not care about the "alignment" operand to builtin memcpy (only 1102 place where it counts), so it doesnt affect us in any bad spots. */ 1103 #define CONSTANT_ALIGNMENT(CONSTANT, BASIC_ALIGN) \ 1104 (TARGET_CONST_ALIGN ? (TARGET_SVINTO ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \ 1105 : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN) 1106 1107 1108 /* 1109 `EMPTY_FIELD_BOUNDARY' 1110 Alignment in bits to be given to a structure bit field that 1111 follows an empty field such as `int : 0;'. 1112 1113 Note that `PCC_BITFIELD_TYPE_MATTERS' also affects the alignment 1114 that results from an empty field. 1115 */ 1116 #define EMPTY_FIELD_BOUNDARY 8 1117 1118 1119 /* 1120 `STRUCTURE_SIZE_BOUNDARY' 1121 Number of bits which any structure or union's size must be a 1122 multiple of. Each structure or union's size is rounded up to a 1123 multiple of this. 1124 1125 If you do not define this macro, the default is the same as 1126 `BITS_PER_UNIT'. 1127 */ 1128 #define STRUCTURE_SIZE_BOUNDARY 8 1129 1130 1131 /* 1132 `STRICT_ALIGNMENT' 1133 Define this macro to be the value 1 if instructions will fail to 1134 work if given data not on the nominal alignment. If instructions 1135 will merely go slower in that case, define this macro as 0. 1136 */ 1137 #define STRICT_ALIGNMENT 0 1138 1139 1140 /* 1141 `PCC_BITFIELD_TYPE_MATTERS' 1142 Define this if you wish to imitate the way many other C compilers 1143 handle alignment of bitfields and the structures that contain them. 1144 1145 The behavior is that the type written for a bitfield (`int', 1146 `short', or other integer type) imposes an alignment for the 1147 entire structure, as if the structure really did contain an 1148 ordinary field of that type. In addition, the bitfield is placed 1149 within the structure so that it would fit within such a field, not 1150 crossing a boundary for it. 1151 1152 Thus, on most machines, a bitfield whose type is written as `int' 1153 would not cross a four-byte boundary, and would force four-byte 1154 alignment for the whole structure. (The alignment used may not be 1155 four bytes; it is controlled by the other alignment parameters.) 1156 1157 If the macro is defined, its definition should be a C expression; 1158 a nonzero value for the expression enables this behavior. 1159 1160 Note that if this macro is not defined, or its value is zero, some 1161 bitfields may cross more than one alignment boundary. The 1162 compiler can support such references if there are `insv', `extv', 1163 and `extzv' insns that can directly reference memory. 1164 1165 The other known way of making bitfields work is to define 1166 `STRUCTURE_SIZE_BOUNDARY' as large as `BIGGEST_ALIGNMENT'. Then 1167 every structure can be accessed with fullwords. 1168 1169 Unless the machine has bitfield instructions or you define 1170 `STRUCTURE_SIZE_BOUNDARY' that way, you must define 1171 `PCC_BITFIELD_TYPE_MATTERS' to have a nonzero value. 1172 1173 If your aim is to make GNU CC use the same conventions for laying 1174 out bitfields as are used by another compiler, here is how to 1175 investigate what the other compiler does. Compile and run this 1176 program: 1177 1178 struct foo1 1179 { 1180 char x; 1181 char :0; 1182 char y; 1183 }; 1184 1185 struct foo2 1186 { 1187 char x; 1188 int :0; 1189 char y; 1190 }; 1191 1192 main () 1193 { 1194 printf ("Size of foo1 is %d\n", 1195 sizeof (struct foo1)); 1196 printf ("Size of foo2 is %d\n", 1197 sizeof (struct foo2)); 1198 exit (0); 1199 } 1200 1201 If this prints 2 and 5, then the compiler's behavior is what you 1202 would get from `PCC_BITFIELD_TYPE_MATTERS'. 1203 */ 1204 /* No definition */ 1205 1206 1207 /* 1208 `BITFIELD_NBYTES_LIMITED' 1209 Like PCC_BITFIELD_TYPE_MATTERS except that its effect is limited to 1210 aligning a bitfield within the structure. 1211 */ 1212 /* No definition */ 1213 1214 1215 /* 1216 `ROUND_TYPE_SIZE (STRUCT, SIZE, ALIGN)' 1217 Define this macro as an expression for the overall size of a 1218 structure (given by STRUCT as a tree node) when the size computed 1219 from the fields is SIZE and the alignment is ALIGN. 1220 1221 The default is to round SIZE up to a multiple of ALIGN. 1222 */ 1223 /* No definition */ 1224 1225 1226 /* 1227 `ROUND_TYPE_ALIGN (STRUCT, COMPUTED, SPECIFIED)' 1228 Define this macro as an expression for the alignment of a structure 1229 (given by STRUCT as a tree node) if the alignment computed in the 1230 usual way is COMPUTED and the alignment explicitly specified was 1231 SPECIFIED. 1232 1233 The default is to use SPECIFIED if it is larger; otherwise, use 1234 the smaller of COMPUTED and `BIGGEST_ALIGNMENT' 1235 */ 1236 /* No definition */ 1237 1238 1239 /* 1240 `MAX_FIXED_MODE_SIZE' 1241 An integer expression for the size in bits of the largest integer 1242 machine mode that should actually be used. All integer machine 1243 modes of this size or smaller can be used for structures and 1244 unions with the appropriate sizes. If this macro is undefined, 1245 `GET_MODE_BITSIZE (DImode)' is assumed. 1246 */ 1247 /* Strange stuff happens to structs if we use anything larger than 1248 largest actually used datum size, so lets make it 32. The type 1249 "long long" will still work (or not, if there are "other" bugs)... */ 1250 #define MAX_FIXED_MODE_SIZE 32 1251 1252 1253 /* 1254 `CHECK_FLOAT_VALUE (MODE, VALUE, OVERFLOW)' 1255 A C statement to validate the value VALUE (of type `double') for 1256 mode MODE. This means that you check whether VALUE fits within 1257 the possible range of values for mode MODE on this target machine. 1258 The mode MODE is always a mode of class `MODE_FLOAT'. OVERFLOW 1259 is nonzero if the value is already known to be out of range. 1260 1261 If VALUE is not valid or if OVERFLOW is nonzero, you should set 1262 OVERFLOW to 1 and then assign some valid value to VALUE. Allowing 1263 an invalid value to go through the compiler can produce incorrect 1264 assembler code which may even cause Unix assemblers to crash. 1265 1266 This macro need not be defined if there is no work for it to do. 1267 */ 1268 /* No definition */ 1269 1270 1271 /* 1272 `TARGET_FLOAT_FORMAT' 1273 A code distinguishing the floating point format of the target 1274 machine. There are three defined values: 1275 1276 `IEEE_FLOAT_FORMAT' 1277 This code indicates IEEE floating point. It is the default; 1278 there is no need to define this macro when the format is IEEE. 1279 1280 `VAX_FLOAT_FORMAT' 1281 This code indicates the peculiar format used on the Vax. 1282 1283 `UNKNOWN_FLOAT_FORMAT' 1284 This code indicates any other format. 1285 1286 The value of this macro is compared with `HOST_FLOAT_FORMAT' 1287 (*note Config::.) to determine whether the target machine has the 1288 same format as the host machine. If any other formats are 1289 actually in use on supported machines, new codes should be defined 1290 for them. 1291 1292 The ordering of the component words of floating point values 1293 stored in memory is controlled by `FLOAT_WORDS_BIG_ENDIAN' for the 1294 target machine and `HOST_FLOAT_WORDS_BIG_ENDIAN' for the host. 1295 */ 1296 /* No definition (use IEEE_FLOAT_FORMAT) */ 1297 1298 1299 /* Section: Type Layout */ 1300 1301 /* 1302 `INT_TYPE_SIZE' 1303 A C expression for the size in bits of the type `int' on the 1304 target machine. If you don't define this, the default is one word. 1305 */ 1306 /* No definition */ 1307 1308 1309 /* 1310 `MAX_INT_TYPE_SIZE' 1311 Maximum number for the size in bits of the type `int' on the target 1312 machine. If this is undefined, the default is `INT_TYPE_SIZE'. 1313 Otherwise, it is the constant value that is the largest value that 1314 `INT_TYPE_SIZE' can have at run-time. This is used in `cpp'. 1315 */ 1316 /* No definition */ 1317 1318 1319 /* 1320 `SHORT_TYPE_SIZE' 1321 A C expression for the size in bits of the type `short' on the 1322 target machine. If you don't define this, the default is half a 1323 word. (If this would be less than one storage unit, it is rounded 1324 up to one unit.) 1325 */ 1326 /* No definition */ 1327 1328 1329 /* 1330 `LONG_TYPE_SIZE' 1331 A C expression for the size in bits of the type `long' on the 1332 target machine. If you don't define this, the default is one word. 1333 */ 1334 /* No definition */ 1335 1336 1337 /* 1338 `MAX_LONG_TYPE_SIZE' 1339 Maximum number for the size in bits of the type `long' on the 1340 target machine. If this is undefined, the default is 1341 `LONG_TYPE_SIZE'. Otherwise, it is the constant value that is the 1342 largest value that `LONG_TYPE_SIZE' can have at run-time. This is 1343 used in `cpp'. 1344 */ 1345 /* No definition */ 1346 1347 1348 /* 1349 `LONG_LONG_TYPE_SIZE' 1350 A C expression for the size in bits of the type `long long' on the 1351 target machine. If you don't define this, the default is two 1352 words. If you want to support GNU Ada on your machine, the value 1353 of macro must be at least 64. 1354 */ 1355 /* No definition */ 1356 1357 1358 /* 1359 `CHAR_TYPE_SIZE' 1360 A C expression for the size in bits of the type `char' on the 1361 target machine. If you don't define this, the default is one 1362 quarter of a word. (If this would be less than one storage unit, 1363 it is rounded up to one unit.) 1364 */ 1365 /* No definition */ 1366 1367 1368 /* 1369 `MAX_CHAR_TYPE_SIZE' 1370 Maximum number for the size in bits of the type `char' on the 1371 target machine. If this is undefined, the default is 1372 `CHAR_TYPE_SIZE'. Otherwise, it is the constant value that is the 1373 largest value that `CHAR_TYPE_SIZE' can have at run-time. This is 1374 used in `cpp'. 1375 */ 1376 /* No definition */ 1377 1378 1379 /* 1380 `FLOAT_TYPE_SIZE' 1381 A C expression for the size in bits of the type `float' on the 1382 target machine. If you don't define this, the default is one word. 1383 */ 1384 /* No definition */ 1385 1386 1387 /* 1388 `DOUBLE_TYPE_SIZE' 1389 A C expression for the size in bits of the type `double' on the 1390 target machine. If you don't define this, the default is two 1391 words. 1392 */ 1393 /* No definition */ 1394 1395 1396 /* 1397 `LONG_DOUBLE_TYPE_SIZE' 1398 A C expression for the size in bits of the type `long double' on 1399 the target machine. If you don't define this, the default is two 1400 words. 1401 */ 1402 /* No definition */ 1403 1404 1405 /* 1406 `DEFAULT_SIGNED_CHAR' 1407 An expression whose value is 1 or 0, according to whether the type 1408 `char' should be signed or unsigned by default. The user can 1409 always override this default with the options `-fsigned-char' and 1410 `-funsigned-char'. 1411 */ 1412 /* For compatibility && historical reasons, it should be signed. */ 1413 #define DEFAULT_SIGNED_CHAR 1 1414 1415 1416 /* 1417 `DEFAULT_SHORT_ENUMS' 1418 A C expression to determine whether to give an `enum' type only as 1419 many bytes as it takes to represent the range of possible values 1420 of that type. A nonzero value means to do that; a zero value 1421 means all `enum' types should be allocated like `int'. 1422 1423 If you don't define the macro, the default is 0. 1424 */ 1425 /* No definition */ 1426 1427 1428 /* 1429 `SIZE_TYPE' 1430 A C expression for a string describing the name of the data type 1431 to use for size values. The typedef name `size_t' is defined 1432 using the contents of the string. 1433 1434 The string can contain more than one keyword. If so, separate 1435 them with spaces, and write first any length keyword, then 1436 `unsigned' if appropriate, and finally `int'. The string must 1437 exactly match one of the data type names defined in the function 1438 `init_decl_processing' in the file `c-decl.c'. You may not omit 1439 `int' or change the order--that would cause the compiler to crash 1440 on startup. 1441 1442 If you don't define this macro, the default is `"long unsigned 1443 int"'. 1444 */ 1445 /* No definition */ 1446 1447 1448 /* 1449 `PTRDIFF_TYPE' 1450 A C expression for a string describing the name of the data type 1451 to use for the result of subtracting two pointers. The typedef 1452 name `ptrdiff_t' is defined using the contents of the string. See 1453 `SIZE_TYPE' above for more information. 1454 1455 If you don't define this macro, the default is `"long int"'. 1456 */ 1457 /* No definition */ 1458 1459 1460 /* 1461 `WCHAR_TYPE' 1462 A C expression for a string describing the name of the data type 1463 to use for wide characters. The typedef name `wchar_t' is defined 1464 using the contents of the string. See `SIZE_TYPE' above for more 1465 information. 1466 1467 If you don't define this macro, the default is `"int"'. 1468 */ 1469 /* Note that WCHAR_TYPE_SIZE is used in cexp.y, 1470 where TARGET_SHORT is not available. */ 1471 #define WCHAR_TYPE "long int" 1472 1473 1474 /* 1475 `WCHAR_TYPE_SIZE' 1476 A C expression for the size in bits of the data type for wide 1477 characters. This is used in `cpp', which cannot make use of 1478 `WCHAR_TYPE'. 1479 */ 1480 #define WCHAR_TYPE_SIZE 32 1481 1482 1483 /* 1484 `MAX_WCHAR_TYPE_SIZE' 1485 Maximum number for the size in bits of the data type for wide 1486 characters. If this is undefined, the default is 1487 `WCHAR_TYPE_SIZE'. Otherwise, it is the constant value that is the 1488 largest value that `WCHAR_TYPE_SIZE' can have at run-time. This is 1489 used in `cpp'. 1490 */ 1491 /* No definition */ 1492 1493 1494 /* 1495 `OBJC_INT_SELECTORS' 1496 Define this macro if the type of Objective C selectors should be 1497 `int'. 1498 1499 If this macro is not defined, then selectors should have the type 1500 `struct objc_selector *'. 1501 */ 1502 /* No definition */ 1503 1504 1505 /* 1506 `OBJC_SELECTORS_WITHOUT_LABELS' 1507 Define this macro if the compiler can group all the selectors 1508 together into a vector and use just one label at the beginning of 1509 the vector. Otherwise, the compiler must give each selector its 1510 own assembler label. 1511 1512 On certain machines, it is important to have a separate label for 1513 each selector because this enables the linker to eliminate 1514 duplicate selectors. 1515 */ 1516 /* No definition */ 1517 1518 1519 /* 1520 `TARGET_BELL' 1521 A C constant expression for the integer value for escape sequence 1522 `\a'. 1523 */ 1524 #define TARGET_BELL 007 1525 1526 1527 /* 1528 `TARGET_BS' 1529 `TARGET_TAB' 1530 `TARGET_NEWLINE' 1531 C constant expressions for the integer values for escape sequences 1532 `\b', `\t' and `\n'. 1533 */ 1534 #define TARGET_BS 010 1535 #define TARGET_TAB 011 1536 #define TARGET_NEWLINE 012 1537 1538 1539 /* 1540 `TARGET_VT' 1541 `TARGET_FF' 1542 `TARGET_CR' 1543 C constant expressions for the integer values for escape sequences 1544 `\v', `\f' and `\r'. 1545 */ 1546 #define TARGET_VT 013 1547 #define TARGET_FF 014 1548 #define TARGET_CR 015 1549 1550 1551 /* Section: Registers::Register Basics */ 1552 1553 /* 1554 `FIRST_PSEUDO_REGISTER' 1555 Number of hardware registers known to the compiler. They receive 1556 numbers 0 through `FIRST_PSEUDO_REGISTER-1'; thus, the first 1557 pseudo register's number really is assigned the number 1558 `FIRST_PSEUDO_REGISTER'. 1559 */ 1560 /* Note that we count in all 16 non-special registers plus SRP */ 1561 #define FIRST_PSEUDO_REGISTER 32 1562 /* Last register in main register bank r0..r15. (Jvm only). 1563 NOT USED BY GCC (other than by other macros in this file). */ 1564 #define LAST_GENERAL_REGISTER 31 /* JDS31 - should this be 26 ?? */ 1565 1566 /* Descriptions of registers used for arguments. These are local to this 1567 file (and possibly aux-output-jvm.c as well). */ 1568 #define FIRST_ARG_REG 19 1569 #define FIRST_ARG_REG_IN 11 1570 1571 #define MAX_ARGS_IN_REGS 8 1572 1573 1574 /* 1575 `FIXED_REGISTERS' 1576 An initializer that says which registers are used for fixed 1577 purposes all throughout the compiled code and are therefore not 1578 available for general allocation. These would include the stack 1579 pointer, the frame pointer (except on machines where that can be 1580 used as a general register when no frame pointer is needed), the 1581 program counter on machines where that is considered one of the 1582 addressable registers, and any other numbered register with a 1583 standard use. 1584 1585 This information is expressed as a sequence of numbers, separated 1586 by commas and surrounded by braces. The Nth number is 1 if 1587 register N is fixed, 0 otherwise. 1588 1589 The table initialized from this macro, and the table initialized by 1590 the following one, may be overridden at run time either 1591 automatically, by the actions of the macro 1592 `CONDITIONAL_REGISTER_USAGE', or by the user with the command 1593 options `-ffixed-REG', `-fcall-used-REG' and `-fcall-saved-REG'. 1594 */ 1595 /* A 1 for registers that have pervasive standard uses 1596 and are not available for the register allocator. 1597 For Jvm, these are 15 (pc) and 14 (sp). r8 is used as an FP (not fixed). 1598 SRP is not included in general registers and will not be used 1599 automatically. It is only used as an indicator for leaf-functions 1600 (now quite obsolete because of function leaf_function_p() ) */ 1601 1602 /* --- jds31 --- CLR register file layout 1603 * These so-called registers are the first 32 entries in the 1604 * local variable table. 1605 * r0-r10 are general purpose registers 1606 * r11-r18 are incoming arguments registers 1607 * r19-r26 are outgoing arguments registers 1608 * r27 is static chain pointer 1609 * r28 is stack frame pointer, also argument pointer 1610 * r29 is stack pointer 1611 * r30 is return address pointer (SRP) -- not quite sure about this?? 1612 * r31 is program counter 1613 * 1614 * 1615 * Actually, I'm not really sure how many of r27-r31 are strictly 1616 * necessary, but I put them in for good measure. 1617 */ 1618 1619 #define FIXED_REGISTERS { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ 1620 0, 0, 0, 0, 0, 0, 0, 0, \ 1621 0, 0, 0, 0, 0, 0, 0, 0, \ 1622 1, 1, 1, 1, 1 } 1623 1624 1625 1626 1627 /* 1628 `CALL_USED_REGISTERS' 1629 Like `FIXED_REGISTERS' but has 1 for each register that is 1630 clobbered (in general) by function calls as well as for fixed 1631 registers. This macro therefore identifies the registers that are 1632 not available for general allocation of values that must live 1633 across function calls. 1634 1635 If a register has 0 in `CALL_USED_REGISTERS', the compiler 1636 automatically saves it on function entry and restores it on 1637 function exit, if the register is used within the function. 1638 */ 1639 /* JVM - was 1640 * 9 for structure-address, 10-13 for parameters, 10- for return values 1641 */ 1642 /* CLR - is r0 for return value, and then r27-r31 for special regs */ 1643 /* --- jds31 --- Note! 1644 * We don't actually need to save any of the registers onto the stack 1645 * at function entry, and restore them at function exit, since 1646 * the CLR does this AUTOMATICALLY on a call instruction. 1647 * I hope we can convince GCC about this... FIXME???? 1648 */ 1649 #define CALL_USED_REGISTERS { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ 1650 0, 0, 0, 0, 0, 0, 0, 0, \ 1651 0, 0, 0, 0, 0, 0, 0, 0, \ 1652 1, 1, 1, 1, 1 } 1653 1654 1655 /* 1656 `CONDITIONAL_REGISTER_USAGE' 1657 Zero or more C statements that may conditionally modify two 1658 variables `fixed_regs' and `call_used_regs' (both of type `char 1659 []') after they have been initialized from the two preceding 1660 macros. 1661 1662 This is necessary in case the fixed or call-clobbered registers 1663 depend on target flags. 1664 1665 You need not define this macro if it has no work to do. 1666 1667 If the usage of an entire class of registers depends on the target 1668 flags, you may indicate this to GCC by using this macro to modify 1669 `fixed_regs' and `call_used_regs' to 1 for each of the registers 1670 in the classes which should not be used by GCC. Also define the 1671 macro `REG_CLASS_FROM_LETTER' to return `NO_REGS' if it is called 1672 with a letter for a class that shouldn't be used. 1673 1674 (However, if this class is not included in `GENERAL_REGS' and all 1675 of the insn patterns whose constraints permit this class are 1676 controlled by target switches, then GCC will automatically avoid 1677 using these registers when the target switches are opposed to 1678 them.) 1679 */ 1680 /* No definition */ 1681 1682 1683 /* 1684 `NON_SAVING_SETJMP' 1685 If this macro is defined and has a nonzero value, it means that 1686 `setjmp' and related functions fail to save the registers, or that 1687 `longjmp' fails to restore them. To compensate, the compiler 1688 avoids putting variables in registers in functions that use 1689 `setjmp'. 1690 */ 1691 /* No definition */ 1692 1693 1694 /* 1695 `INCOMING_REGNO (OUT)' 1696 Define this macro if the target machine has register windows. 1697 This C expression returns the register number as seen by the 1698 called function corresponding to the register number OUT as seen 1699 by the calling function. Return OUT if register number OUT is not 1700 an outbound register. 1701 */ 1702 /* No definition */ 1703 1704 1705 /* 1706 `OUTGOING_REGNO (IN)' 1707 Define this macro if the target machine has register windows. 1708 This C expression returns the register number as seen by the 1709 calling function corresponding to the register number IN as seen 1710 by the called function. Return IN if register number IN is not an 1711 inbound register. 1712 */ 1713 /* No definition */ 1714 1715 1716 /* Section: Registers::Allocation Order */ 1717 1718 /* 1719 `REG_ALLOC_ORDER' 1720 If defined, an initializer for a vector of integers, containing the 1721 numbers of hard registers in the order in which GNU CC should 1722 prefer to use them (from most preferred to least). 1723 1724 If this macro is not defined, registers are used lowest numbered 1725 first (all else being equal). 1726 1727 One use of this macro is on machines where the highest numbered 1728 registers must always be saved and the save-multiple-registers 1729 instruction supports only sequences of consecutive registers. On 1730 such machines, define `REG_ALLOC_ORDER' to be an initializer that 1731 lists the highest numbered allocatable register first. 1732 */ 1733 /* We need this on jvm, because call-used regs should be used first, 1734 (so we dont need to push). Else start using registers from 0 and 1735 up. 1736 This preference is mainly because if we put call-used-regs from 0 1737 and up, then we cant use movem to push the rest, (who has to be pushed 1738 if we use them, and movem has to start with reg 0). 1739 NOTE: this is a place where register numbers have to be explicit 1740 (No macros). Change here if you change which registers to use as 1741 call registers. 1742 Call-used-regs first, then 0 and up, last fp & sp & pc as fillers. 1743 Call-used in opposite order, so they will not conflict if a 1744 function has few args (<= 3) and it wants a scratch reg. 1745 Use struct-return address first, since very few functions use 1746 structure return values. (It is 1747 in fact quite unportable, and not re-entrant on some systems). 1748 The following is found to be quite optimal. */ 1749 /* 1750 * #define REG_ALLOC_ORDER \ 1751 * { 9, 13, 12, 11, 10, 1, 2, 3, 4, 5, 6, 7, 8, 14, 15, 16} 1752 */ 1753 1754 /* --- jds31 --- 1755 * We will just keep the default values for the CLR 1756 */ 1757 1758 /* 1759 `ORDER_REGS_FOR_LOCAL_ALLOC' 1760 A C statement (sans semicolon) to choose the order in which to 1761 allocate hard registers for pseudo-registers local to a basic 1762 block. 1763 1764 Store the desired register order in the array `reg_alloc_order'. 1765 Element 0 should be the register to allocate first; element 1, the 1766 next register; and so on. 1767 1768 The macro body should not assume anything about the contents of 1769 `reg_alloc_order' before execution of the macro. 1770 1771 On most machines, it is not necessary to define this macro. 1772 */ 1773 /* No definition */ 1774 1775 1776 /* Section: Registers::Values in Registers */ 1777 1778 /* 1779 `HARD_REGNO_NREGS (REGNO, MODE)' 1780 A C expression for the number of consecutive hard registers, 1781 starting at register number REGNO, required to hold a value of mode 1782 MODE. 1783 1784 On a machine where all registers are exactly one word, a suitable 1785 definition of this macro is 1786 1787 #define HARD_REGNO_NREGS(REGNO, MODE) \ 1788 ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) \ 1789 / UNITS_PER_WORD)) 1790 */ 1791 /* The VOIDmode test is so we can omit mode on anonymous insns. */ 1792 #define HARD_REGNO_NREGS(REGNO, MODE) \ 1793 (MODE == VOIDmode \ 1794 ? 1 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) 1795 1796 1797 /* 1798 `HARD_REGNO_MODE_OK (REGNO, MODE)' 1799 A C expression that is nonzero if it is permissible to store a 1800 value of mode MODE in hard register number REGNO (or in several 1801 registers starting with that one). For a machine where all 1802 registers are equivalent, a suitable definition is 1803 1804 #define HARD_REGNO_MODE_OK(REGNO, MODE) 1 1805 1806 It is not necessary for this macro to check for the numbers of 1807 fixed registers, because the allocation mechanism considers them 1808 to be always occupied. 1809 1810 On some machines, double-precision values must be kept in even/odd 1811 register pairs. The way to implement that is to define this macro 1812 to reject odd register numbers for such modes. 1813 1814 The minimum requirement for a mode to be OK in a register is that 1815 the `movMODE' instruction pattern support moves between the 1816 register and any other hard register for which the mode is OK; and 1817 that moving a value into the register and back out not alter it. 1818 1819 Since the same instruction used to move `SImode' will work for all 1820 narrower integer modes, it is not necessary on any machine for 1821 `HARD_REGNO_MODE_OK' to distinguish between these modes, provided 1822 you define patterns `movhi', etc., to take advantage of this. This 1823 is useful because of the interaction between `HARD_REGNO_MODE_OK' 1824 and `MODES_TIEABLE_P'; it is very desirable for all integer modes 1825 to be tieable. 1826 1827 Many machines have special registers for floating point arithmetic. 1828 Often people assume that floating point machine modes are allowed 1829 only in floating point registers. This is not true. Any 1830 registers that can hold integers can safely *hold* a floating 1831 point machine mode, whether or not floating arithmetic can be done 1832 on it in those registers. Integer move instructions can be used 1833 to move the values. 1834 1835 On some machines, though, the converse is true: fixed-point machine 1836 modes may not go in floating registers. This is true if the 1837 floating registers normalize any value stored in them, because 1838 storing a non-floating value there would garble it. In this case, 1839 `HARD_REGNO_MODE_OK' should reject fixed-point machine modes in 1840 floating registers. But if the floating registers do not 1841 automatically normalize, if you can store any bit pattern in one 1842 and retrieve it unchanged without a trap, then any machine mode 1843 may go in a floating register, so you can define this macro to say 1844 so. 1845 1846 The primary significance of special floating registers is rather 1847 that they are the registers acceptable in floating point arithmetic 1848 instructions. However, this is of no concern to 1849 `HARD_REGNO_MODE_OK'. You handle it by writing the proper 1850 constraints for those instructions. 1851 1852 On some machines, the floating registers are especially slow to 1853 access, so that it is better to store a value in a stack frame 1854 than in such a register if floating point arithmetic is not being 1855 done. As long as the floating registers are not in class 1856 `GENERAL_REGS', they will not be used unless some pattern's 1857 constraint asks for one. 1858 */ 1859 /* Jvm permits all registers to hold all modes. */ 1860 #define HARD_REGNO_MODE_OK(REGNO, MODE) 1 1861 1862 1863 /* 1864 `MODES_TIEABLE_P (MODE1, MODE2)' 1865 A C expression that is nonzero if it is desirable to choose 1866 register allocation so as to avoid move instructions between a 1867 value of mode MODE1 and a value of mode MODE2. 1868 1869 If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R, 1870 MODE2)' are ever different for any R, then `MODES_TIEABLE_P (MODE1, 1871 MODE2)' must be zero. 1872 */ 1873 #define MODES_TIEABLE_P(MODE1, MODE2) 1 1874 1875 1876 /* Section: Registers::Leaf Functions */ 1877 /* (no definitions) */ 1878 1879 /* Section: Registers::Stack Registers */ 1880 /* (no definitions) */ 1881 1882 /* Section: Registers::Obsolete Register Macros */ 1883 /* (no definitions) */ 1884 1885 1886 /* Section: Register Classes */ 1887 1888 /* 1889 `enum reg_class' 1890 An enumeral type that must be defined with all the register class 1891 names as enumeral values. `NO_REGS' must be first. `ALL_REGS' 1892 must be the last register class, followed by one more enumeral 1893 value, `LIM_REG_CLASSES', which is not a register class but rather 1894 tells how many classes there are. 1895 1896 Each register class has a number, which is the value of casting 1897 the class name to type `int'. The number serves as an index in 1898 many of the tables described below. 1899 */ 1900 /* Jvm has only one kind of registers, so NO_REGS and ALL_REGS 1901 are the only classes. */ 1902 /* NOTE: Because gcc 2.1 is broken when it comes to check reload operands 1903 strictly (i.e. it accepts 'r' if the operand is a stack slot), we 1904 use a fix to make !(GENERAL_REGS == ALL_REGS). 1905 The breaking part is that when constraints are checked strictly, 1906 and GENERAL_REGS == ALL_REGS, then instead of calling 1907 reg_fits_class_p (which includes a check to see if it really is a 1908 pseudo register) it assumes that everything is ok. 1909 It seems no other ports of gcc 2.1 have registers that are this 1910 general, and will not allow all types operands to all operators. 1911 (Vaxen has general registers, but allows any stack-relative operand 1912 for any register.) 1913 No other comments (than this one) is added. The error is clearly 1914 in gcc, not this file. You will find '#if 0':d lines below that 1915 reflects the fixes for this problem. 1916 1917 It seems that 2.6.3 and later 2.7.2 has fixed this. Try the 1918 correct definition later (may speed up compilation a little). 1919 */ 1920 enum reg_class { NO_REGS, 1921 #if 0 1922 #define GENERAL_REGS ALL_REGS 1923 #else 1924 GENERAL_REGS, 1925 #endif 1926 ALL_REGS, 1927 LIM_REG_CLASSES }; 1928 1929 1930 /* 1931 `N_REG_CLASSES' 1932 The number of distinct register classes, defined as follows: 1933 1934 #define N_REG_CLASSES (int) LIM_REG_CLASSES 1935 */ 1936 #define N_REG_CLASSES (int) LIM_REG_CLASSES 1937 1938 1939 /* 1940 `REG_CLASS_NAMES' 1941 An initializer containing the names of the register classes as C 1942 string constants. These names are used in writing some of the 1943 debugging dumps. 1944 */ 1945 #if 0 1946 #define REG_CLASS_NAMES \ 1947 {"NO_REGS", "ALL_REGS" } 1948 #else 1949 #define REG_CLASS_NAMES \ 1950 {"NO_REGS", "GENERAL_REGS", "ALL_REGS" } 1951 #endif 1952 1953 1954 /* 1955 `REG_CLASS_CONTENTS' 1956 An initializer containing the contents of the register classes, as 1957 integers which are bit masks. The Nth integer specifies the 1958 contents of class N. The way the integer MASK is interpreted is 1959 that register R is in the class if `MASK & (1 << R)' is 1. 1960 1961 When the machine has more than 32 registers, an integer does not 1962 suffice. Then the integers are replaced by sub-initializers, 1963 braced groupings containing several integers. Each 1964 sub-initializer must be suitable as an initializer for the type 1965 `HARD_REG_SET' which is defined in `hard-reg-set.h'. 1966 */ 1967 /* Don't put srp in here. Keeping it out keeps gcc from using it. */ 1968 1969 #if 0 1970 # define REG_CLASS_CONTENTS {0, 0xffff } 1971 #else 1972 # define REG_CLASS_CONTENTS {0, 0xffffffff, 0xffffffff } 1973 #endif 1974 1975 /* 1976 `REGNO_REG_CLASS (REGNO)' 1977 A C expression whose value is a register class containing hard 1978 register REGNO. In general there is more than one such class; 1979 choose a class which is "minimal", meaning that no smaller class 1980 also contains the register. 1981 */ 1982 #if 0 1983 #define REGNO_REG_CLASS(REGNO) ALL_REGS 1984 #else 1985 #define REGNO_REG_CLASS(REGNO) GENERAL_REGS 1986 #endif 1987 1988 1989 /* 1990 `BASE_REG_CLASS' 1991 A macro whose definition is the name of the class to which a valid 1992 base register must belong. A base register is one used in an 1993 address which is the register value plus a displacement. 1994 */ 1995 #if 0 1996 #define BASE_REG_CLASS ALL_REGS 1997 #else 1998 #define BASE_REG_CLASS GENERAL_REGS 1999 #endif 2000 2001 2002 /* 2003 `INDEX_REG_CLASS' 2004 A macro whose definition is the name of the class to which a valid 2005 index register must belong. An index register is one used in an 2006 address where its value is either multiplied by a scale factor or 2007 added to another register (as well as added to a displacement). 2008 */ 2009 #if 0 2010 #define INDEX_REG_CLASS ALL_REGS 2011 #else 2012 #define INDEX_REG_CLASS GENERAL_REGS 2013 #endif 2014 2015 2016 /* 2017 `REG_CLASS_FROM_LETTER (CHAR)' 2018 A C expression which defines the machine-dependent operand 2019 constraint letters for register classes. If CHAR is such a 2020 letter, the value should be the register class corresponding to 2021 it. Otherwise, the value should be `NO_REGS'. The register 2022 letter `r', corresponding to class `GENERAL_REGS', will not be 2023 passed to this macro; you do not need to handle it. 2024 */ 2025 /* Get reg_class from a letter such as appears in the machine description. 2026 No letters are used, since 'r' is used for any register. */ 2027 #define REG_CLASS_FROM_LETTER(C) NO_REGS 2028 2029 2030 /* 2031 `REGNO_OK_FOR_BASE_P (NUM)' 2032 A C expression which is nonzero if register number NUM is suitable 2033 for use as a base register in operand addresses. It may be either 2034 a suitable hard register or a pseudo register that has been 2035 allocated such a hard register. 2036 */ 2037 /* Since it uses reg_renumber, it is safe only once reg_renumber 2038 has been allocated, which happens in local-alloc.c. */ 2039 #define REGNO_OK_FOR_BASE_P(REGNO) \ 2040 ((REGNO) <= LAST_GENERAL_REGISTER || \ 2041 (unsigned) reg_renumber[REGNO] <= LAST_GENERAL_REGISTER) 2042 2043 2044 /* 2045 `REGNO_OK_FOR_INDEX_P (NUM)' 2046 A C expression which is nonzero if register number NUM is suitable 2047 for use as an index register in operand addresses. It may be 2048 either a suitable hard register or a pseudo register that has been 2049 allocated such a hard register. 2050 2051 The difference between an index register and a base register is 2052 that the index register may be scaled. If an address involves the 2053 sum of two registers, neither one of them scaled, then either one 2054 may be labeled the "base" and the other the "index"; but whichever 2055 labeling is used must fit the machine's constraints of which 2056 registers may serve in each capacity. The compiler will try both 2057 labelings, looking for one that is valid, and will reload one or 2058 both registers only if neither labeling works. 2059 */ 2060 /* Since it uses reg_renumber, it is safe only once reg_renumber 2061 has been allocated, which happens in local-alloc.c. */ 2062 #define REGNO_OK_FOR_INDEX_P(REGNO) \ 2063 ((REGNO) <= LAST_GENERAL_REGISTER || \ 2064 (unsigned) reg_renumber[REGNO] <= LAST_GENERAL_REGISTER) 2065 2066 2067 /* 2068 `PREFERRED_RELOAD_CLASS (X, CLASS)' 2069 A C expression that places additional restrictions on the register 2070 class to use when it is necessary to copy value X into a register 2071 in class CLASS. The value is a register class; perhaps CLASS, or 2072 perhaps another, smaller class. On many machines, the following 2073 definition is safe: 2074 2075 #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS 2076 2077 Sometimes returning a more restrictive class makes better code. 2078 For example, on the 68000, when X is an integer constant that is 2079 in range for a `moveq' instruction, the value of this macro is 2080 always `DATA_REGS' as long as CLASS includes the data registers. 2081 Requiring a data register guarantees that a `moveq' will be used. 2082 2083 If X is a `const_double', by returning `NO_REGS' you can force X 2084 into a memory constant. This is useful on certain machines where 2085 immediate floating values cannot be loaded into certain kinds of 2086 registers. 2087 */ 2088 /* It seems like gcc may send "NO_REGS" as the class. Tho avoid 2089 forcing out a constant into the constant pool, we will trap this 2090 case and return something a bit more sane. */ 2091 #define PREFERRED_RELOAD_CLASS(X,CLASS) \ 2092 ((CLASS) == NO_REGS ? GENERAL_REGS : (CLASS)) 2093 2094 2095 /* 2096 `PREFERRED_OUTPUT_RELOAD_CLASS (X, CLASS)' 2097 Like `PREFERRED_RELOAD_CLASS', but for output reloads instead of 2098 input reloads. If you don't define this macro, the default is to 2099 use CLASS, unchanged. 2100 */ 2101 /* No definition */ 2102 2103 2104 /* 2105 `LIMIT_RELOAD_CLASS (MODE, CLASS)' 2106 A C expression that places additional restrictions on the register 2107 class to use when it is necessary to be able to hold a value of 2108 mode MODE in a reload register for which class CLASS would 2109 ordinarily be used. 2110 2111 Unlike `PREFERRED_RELOAD_CLASS', this macro should be used when 2112 there are certain modes that simply can't go in certain reload 2113 classes. 2114 2115 The value is a register class; perhaps CLASS, or perhaps another, 2116 smaller class. 2117 2118 Don't define this macro unless the target machine has limitations 2119 which require the macro to do something nontrivial. 2120 */ 2121 /* No definition */ 2122 2123 2124 /* 2125 `SECONDARY_RELOAD_CLASS (CLASS, MODE, X)' 2126 `SECONDARY_INPUT_RELOAD_CLASS (CLASS, MODE, X)' 2127 `SECONDARY_OUTPUT_RELOAD_CLASS (CLASS, MODE, X)' 2128 Many machines have some registers that cannot be copied directly 2129 to or from memory or even from other types of registers. An 2130 example is the `MQ' register, which on most machines, can only be 2131 copied to or from general registers, but not memory. Some 2132 machines allow copying all registers to and from memory, but 2133 require a scratch register for stores to some memory locations 2134 (e.g., those with symbolic address on the RT, and those with 2135 certain symbolic address on the Sparc when compiling PIC). In 2136 some cases, both an intermediate and a scratch register are 2137 required. 2138 2139 You should define these macros to indicate to the reload phase 2140 that it may need to allocate at least one register for a reload in 2141 addition to the register to contain the data. Specifically, if 2142 copying X to a register CLASS in MODE requires an intermediate 2143 register, you should define `SECONDARY_INPUT_RELOAD_CLASS' to 2144 return the largest register class all of whose registers can be 2145 used as intermediate registers or scratch registers. 2146 2147 If copying a register CLASS in MODE to X requires an intermediate 2148 or scratch register, `SECONDARY_OUTPUT_RELOAD_CLASS' should be 2149 defined to return the largest register class required. If the 2150 requirements for input and output reloads are the same, the macro 2151 `SECONDARY_RELOAD_CLASS' should be used instead of defining both 2152 macros identically. 2153 2154 The values returned by these macros are often `GENERAL_REGS'. 2155 Return `NO_REGS' if no spare register is needed; i.e., if X can be 2156 directly copied to or from a register of CLASS in MODE without 2157 requiring a scratch register. Do not define this macro if it 2158 would always return `NO_REGS'. 2159 2160 If a scratch register is required (either with or without an 2161 intermediate register), you should define patterns for 2162 `reload_inM' or `reload_outM', as required (*note Standard 2163 Names::.. These patterns, which will normally be implemented with 2164 a `define_expand', should be similar to the `movM' patterns, 2165 except that operand 2 is the scratch register. 2166 2167 Define constraints for the reload register and scratch register 2168 that contain a single register class. If the original reload 2169 register (whose class is CLASS) can meet the constraint given in 2170 the pattern, the value returned by these macros is used for the 2171 class of the scratch register. Otherwise, two additional reload 2172 registers are required. Their classes are obtained from the 2173 constraints in the insn pattern. 2174 2175 X might be a pseudo-register or a `subreg' of a pseudo-register, 2176 which could either be in a hard register or in memory. Use 2177 `true_regnum' to find out; it will return -1 if the pseudo is in 2178 memory and the hard register number if it is in a register. 2179 2180 These macros should not be used in the case where a particular 2181 class of registers can only be copied to memory and not to another 2182 class of registers. In that case, secondary reload registers are 2183 not needed and would not be helpful. Instead, a stack location 2184 must be used to perform the copy and the `movM' pattern should use 2185 memory as a intermediate storage. This case often occurs between 2186 floating-point and general registers. 2187 */ 2188 /* No definition */ 2189 2190 2191 /* 2192 `SECONDARY_MEMORY_NEEDED (CLASS1, CLASS2, M)' 2193 Certain machines have the property that some registers cannot be 2194 copied to some other registers without using memory. Define this 2195 macro on those machines to be a C expression that is non-zero if 2196 objects of mode M in registers of CLASS1 can only be copied to 2197 registers of class CLASS2 by storing a register of CLASS1 into 2198 memory and loading that memory location into a register of CLASS2. 2199 2200 Do not define this macro if its value would always be zero. 2201 */ 2202 /* No definition */ 2203 2204 2205 /* 2206 `SECONDARY_MEMORY_NEEDED_RTX (MODE)' 2207 Normally when `SECONDARY_MEMORY_NEEDED' is defined, the compiler 2208 allocates a stack slot for a memory location needed for register 2209 copies. If this macro is defined, the compiler instead uses the 2210 memory location defined by this macro. 2211 2212 Do not define this macro if you do not define 2213 `SECONDARY_MEMORY_NEEDED'. 2214 */ 2215 /* No definition */ 2216 2217 2218 /* 2219 `SECONDARY_MEMORY_NEEDED_MODE (MODE)' 2220 When the compiler needs a secondary memory location to copy 2221 between two registers of mode MODE, it normally allocates 2222 sufficient memory to hold a quantity of `BITS_PER_WORD' bits and 2223 performs the store and load operations in a mode that many bits 2224 wide and whose class is the same as that of MODE. 2225 2226 This is right thing to do on most machines because it ensures that 2227 all bits of the register are copied and prevents accesses to the 2228 registers in a narrower mode, which some machines prohibit for 2229 floating-point registers. 2230 2231 However, this default behavior is not correct on some machines, 2232 such as the DEC Alpha, that store short integers in floating-point 2233 registers differently than in integer registers. On those 2234 machines, the default widening will not work correctly and you 2235 must define this macro to suppress that widening in some cases. 2236 See the file `alpha.h' for details. 2237 2238 Do not define this macro if you do not define 2239 `SECONDARY_MEMORY_NEEDED' or if widening MODE to a mode that is 2240 `BITS_PER_WORD' bits wide is correct for your machine. 2241 */ 2242 /* No definition */ 2243 2244 2245 /* 2246 `SMALL_REGISTER_CLASSES' 2247 Normally the compiler avoids choosing registers that have been 2248 explicitly mentioned in the rtl as spill registers (these 2249 registers are normally those used to pass parameters and return 2250 values). However, some machines have so few registers of certain 2251 classes that there would not be enough registers to use as spill 2252 registers if this were done. 2253 2254 Define `SMALL_REGISTER_CLASSES' on these machines. When it is 2255 defined, the compiler allows registers explicitly used in the rtl 2256 to be used as spill registers but avoids extending the lifetime of 2257 these registers. 2258 2259 It is always safe to define this macro, but if you unnecessarily 2260 define it, you will reduce the amount of optimizations that can be 2261 performed in some cases. If you do not define this macro when it 2262 is required, the compiler will run out of spill registers and 2263 print a fatal error message. For most machines, you should not 2264 define this macro. 2265 */ 2266 /* No definition */ 2267 2268 2269 /* 2270 `CLASS_LIKELY_SPILLED_P (CLASS)' 2271 A C expression whose value is nonzero if pseudos that have been 2272 assigned to registers of class CLASS would likely be spilled 2273 because registers of CLASS are needed for spill registers. 2274 2275 The default value of this macro returns 1 if CLASS has exactly one 2276 register and zero otherwise. On most machines, this default 2277 should be used. Only define this macro to some other expression 2278 if pseudo allocated by `local-alloc.c' end up in memory because 2279 their hard registers were needed for spill registers. If this 2280 macro returns nonzero for those classes, those pseudos will only 2281 be allocated by `global.c', which knows how to reallocate the 2282 pseudo to another register. If there would not be another 2283 register available for reallocation, you should not change the 2284 definition of this macro since the only effect of such a 2285 definition would be to slow down register allocation. 2286 */ 2287 /* No definition */ 2288 2289 2290 /* 2291 `CLASS_MAX_NREGS (CLASS, MODE)' 2292 A C expression for the maximum number of consecutive registers of 2293 class CLASS needed to hold a value of mode MODE. 2294 2295 This is closely related to the macro `HARD_REGNO_NREGS'. In fact, 2296 the value of the macro `CLASS_MAX_NREGS (CLASS, MODE)' should be 2297 the maximum value of `HARD_REGNO_NREGS (REGNO, MODE)' for all 2298 REGNO values in the class CLASS. 2299 2300 This macro helps control the handling of multiple-word values in 2301 the reload pass. 2302 */ 2303 /* For Jvm, this is always the size of MODE in words, 2304 since all registers are the same size. */ 2305 /* To use omitted modes in patterns with reload constraints, you 2306 must say widest size allowed for VOIDmode. */ 2307 #define CLASS_MAX_NREGS(CLASS, MODE) \ 2308 ((MODE) == VOIDmode \ 2309 ? 1 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) 2310 2311 2312 /* 2313 `CLASS_CANNOT_CHANGE_SIZE' 2314 If defined, a C expression for a class that contains registers 2315 which the compiler must always access in a mode that is the same 2316 size as the mode in which it loaded the register. 2317 2318 For the example, loading 32-bit integer or floating-point objects 2319 into floating-point registers on the Alpha extends them to 64-bits. 2320 Therefore loading a 64-bit object and then storing it as a 32-bit 2321 object does not store the low-order 32-bits, as would be the case 2322 for a normal register. Therefore, `alpha.h' defines this macro as 2323 `FLOAT_REGS'. 2324 */ 2325 /* No definition */ 2326 2327 2328 /* 2329 `CONST_OK_FOR_LETTER_P (VALUE, C)' 2330 A C expression that defines the machine-dependent operand 2331 constraint letters that specify particular ranges of integer 2332 values. If C is one of those letters, the expression should check 2333 that VALUE, an integer, is in the appropriate range and return 1 2334 if so, 0 otherwise. If C is not one of those letters, the value 2335 should be 0 regardless of VALUE. 2336 */ 2337 /* The letters I, J, K, L and M in a register constraint string 2338 can be used to stand for particular ranges of immediate operands. 2339 This macro defines what the ranges are. 2340 C is the letter, and VALUE is a constant value. 2341 Return 1 if VALUE is in the range specified by C. 2342 We are actually out of letters (could use ten more), 2343 which makes us use C-code in the 'md' file. */ 2344 2345 #define CONST_OK_FOR_LETTER_P(VALUE, C) \ 2346 ((C) == 'I' ? (VALUE) >= -32 && (VALUE) <= 31 : /* MOVEQ CMPQ ANDQ ORQ */ \ 2347 (C) == 'J' ? (VALUE) >= 0 && (VALUE) <= 63 : /* ADDQ SUBQ */ \ 2348 (C) == 'K' ? (VALUE) >= 0 && (VALUE) <= 31 : /* ASR BTST LSR LSL */ \ 2349 (C) == 'L' ? (VALUE) >= -32768 && (VALUE) <= 32767 : /* 16bit signed */ \ 2350 (C) == 'M' ? (VALUE) == 0 : /* constant 0 for CLEAR */ \ 2351 (C) == 'N' ? (VALUE) >= -63 && (VALUE) < 0 : /* negative ADDQ SUBQ */ \ 2352 (C) == 'O' ? (VALUE) >= 0 && (VALUE) <= 65535 /* quick:d ints, QI && HI */\ 2353 && ((VALUE) >= (65535-31) \ 2354 || ((VALUE) >= (255-31) \ 2355 && (VALUE) <= 255 )): \ 2356 (C) == 'P' ? (VALUE) >= -32768 && (VALUE) <= 65535 : /* 16-bits */ \ 2357 0) 2358 2359 2360 /* 2361 `CONST_DOUBLE_OK_FOR_LETTER_P (VALUE, C)' 2362 A C expression that defines the machine-dependent operand 2363 constraint letters that specify particular ranges of 2364 `const_double' values. 2365 2366 If C is one of those letters, the expression should check that 2367 VALUE, an RTX of code `const_double', is in the appropriate range 2368 and return 1 if so, 0 otherwise. If C is not one of those 2369 letters, the value should be 0 regardless of VALUE. 2370 2371 `const_double' is used for all floating-point constants and for 2372 `DImode' fixed-point constants. A given letter can accept either 2373 or both kinds of values. It can use `GET_MODE' to distinguish 2374 between these kinds. 2375 */ 2376 /* It is really simple to make up a 0.0; it is the same as int-0 in IEEE754. */ 2377 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \ 2378 ((C) == 'G' && ((VALUE) == CONST0_RTX (DFmode) \ 2379 || (VALUE) == CONST0_RTX (SFmode))) 2380 2381 2382 /* 2383 `EXTRA_CONSTRAINT (VALUE, C)' 2384 A C expression that defines the optional machine-dependent 2385 constraint letters that can be used to segregate specific types of 2386 operands, usually memory references, for the target machine. 2387 Normally this macro will not be defined. If it is required for a 2388 particular target machine, it should return 1 if VALUE corresponds 2389 to the operand type represented by the constraint letter C. If C 2390 is not defined as an extra constraint, the value returned should 2391 be 0 regardless of VALUE. 2392 2393 For example, on the ROMP, load instructions cannot have their 2394 output in r0 if the memory reference contains a symbolic address. 2395 Constraint letter `Q' is defined as representing a memory address 2396 that does *not* contain a symbolic address. An alternative is 2397 specified with a `Q' constraint on the input and `r' on the 2398 output. The next alternative specifies `m' on the input and a 2399 register class that does not include r0 on the output. 2400 */ 2401 /* We need this on jvm to distinguish delay-slottable addressing modes. */ 2402 #define EXTRA_CONSTRAINT(X, C) \ 2403 ((C) == 'Q' ? EXTRA_CONSTRAINT_Q(X) : /* Slottable address mode ? */ \ 2404 (C) == 'R' ? EXTRA_CONSTRAINT_R(X) : /* Operand to BDAP or BIAP ? */ \ 2405 (C) == 'T' ? EXTRA_CONSTRAINT_T(X) : /* Three address addr mode ? */ \ 2406 0) 2407 2408 #define EXTRA_CONSTRAINT_Q(X) \ 2409 ((BASE_P(X) && REGNO(X) != PC_REGNUM) /* reg */ \ 2410 || (GET_CODE(X) == MEM && BASE_P(XEXP(X,0)) /* [reg] */ \ 2411 && REGNO(XEXP(X,0)) != PC_REGNUM)) 2412 2413 #define EXTRA_CONSTRAINT_R(X) \ 2414 (BIAP_INDEX_P(X) /* BIAP; r.S */ \ 2415 || BDAP_INDEX_P(X) /* [reg] or (int) [reg] maybe with post incr */ \ 2416 || CONSTANT_INDEX_P(X)) 2417 2418 #define EXTRA_CONSTRAINT_T(X) \ 2419 (GET_CODE(X) == MEM /* all are [...], of course */\ 2420 && ((GET_CODE(XEXP(X, 0)) == MEM \ 2421 && (BASE_OR_AUTOINCR_P(XEXP(XEXP(X, 0), 0)))) /*[[reg]] or [[reg+]]*/\ 2422 || CONSTANT_P(XEXP(X,0)) /* [const] */\ 2423 || (GET_CODE(XEXP(X,0)) == PLUS /* some indexed; [... + ...] */\ 2424 &&((BASE_P(XEXP(XEXP(X, 0), 0)) /* bdap: [reg+(8|16|32)bitoffs] */\ 2425 && CONSTANT_INDEX_P(XEXP(XEXP(X, 0), 1)))\ 2426 || (BASE_P(XEXP(XEXP(X, 0), 1)) /*(swap arguments to above) */\ 2427 && CONSTANT_INDEX_P(XEXP(XEXP(X, 0), 0)))\ 2428 || (BASE_P(XEXP(XEXP(X, 0), 0)) /* bdap: [reg+[reg(+)].S] */\ 2429 && BDAP_INDEX_P(XEXP(XEXP(X, 0), 1)))\ 2430 || (BASE_P(XEXP(XEXP(X, 0), 1)) /*(swap arguments to above) */\ 2431 && BDAP_INDEX_P(XEXP(XEXP(X, 0), 0)))\ 2432 || (BASE_P(XEXP(XEXP(X, 0), 0)) /* biap: [reg+reg.s] */\ 2433 && BIAP_INDEX_P(XEXP(XEXP(X, 0), 1)))\ 2434 || (BASE_P(XEXP(XEXP(X, 0), 1)) /* swap arguments to above */\ 2435 && BIAP_INDEX_P(XEXP(XEXP(X, 0), 0)))))\ 2436 /* || (BASE_P(XEXP(X,0))) / * is three-addr too; NONOPTIMAL [reg+0] */)) 2437 2438 2439 /* Section: Stack and Calling::Frame Layout */ 2440 2441 /* 2442 `STACK_GROWS_DOWNWARD' 2443 Define this macro if pushing a word onto the stack moves the stack 2444 pointer to a smaller address. 2445 2446 When we say, "define this macro if ...," it means that the 2447 compiler checks this macro only with `#ifdef' so the precise 2448 definition used does not matter. 2449 */ 2450 #define STACK_GROWS_DOWNWARD 2451 2452 /* 2453 `FRAME_GROWS_DOWNWARD' 2454 Define this macro if the addresses of local variable slots are at 2455 negative offsets from the frame pointer. 2456 */ 2457 #define FRAME_GROWS_DOWNWARD 2458 2459 2460 /* 2461 `ARGS_GROW_DOWNWARD' 2462 Define this macro if successive arguments to a function occupy 2463 decreasing addresses on the stack. 2464 */ 2465 /* No definition */ 2466 2467 2468 /* 2469 `STARTING_FRAME_OFFSET' 2470 Offset from the frame pointer to the first local variable slot to 2471 be allocated. 2472 2473 If `FRAME_GROWS_DOWNWARD', find the next slot's offset by 2474 subtracting the first slot's length from `STARTING_FRAME_OFFSET'. 2475 Otherwise, it is found by adding the length of the first slot to 2476 the value `STARTING_FRAME_OFFSET'. 2477 */ 2478 /* It seems to be indicated in the code (at least 2.1) that this is 2479 better a constant, and best 0. */ 2480 #define STARTING_FRAME_OFFSET 0 2481 2482 2483 /* 2484 `STACK_POINTER_OFFSET' 2485 Offset from the stack pointer register to the first location at 2486 which outgoing arguments are placed. If not specified, the 2487 default value of zero is used. This is the proper value for most 2488 machines. 2489 2490 If `ARGS_GROW_DOWNWARD', this is the offset to the location above 2491 the first location at which outgoing arguments are placed. 2492 */ 2493 /* No definition */ 2494 2495 2496 /* 2497 `FIRST_PARM_OFFSET (FUNDECL)' 2498 Offset from the argument pointer register to the first argument's 2499 address. On some machines it may depend on the data type of the 2500 function. 2501 2502 If `ARGS_GROW_DOWNWARD', this is the offset to the location above 2503 the first argument's address. 2504 */ 2505 /* Is saved-fp + saved-return-address (if not leaf function) */ 2506 /* We cannot use frame_pointer_needed here, so adjust stack in 2507 function_prologue() if needed. Same goes for whether this is a 2508 leaf-function or not (if SRP is saved). */ 2509 /* --- jds31 --- FIXME 2510 * Not really sure about this, on CLR. Do we need to save return 2511 * address? CLR does this for us, automatically, I think. 2512 * I know we probably need to save fp, if we are using it ... 2513 */ 2514 2515 #define FIRST_PARM_OFFSET(FNDECL) (4+4) 2516 2517 2518 /* 2519 `STACK_DYNAMIC_OFFSET (FUNDECL)' 2520 Offset from the stack pointer register to an item dynamically 2521 allocated on the stack, e.g., by `alloca'. 2522 2523 The default value for this macro is `STACK_POINTER_OFFSET' plus the 2524 length of the outgoing arguments. The default is correct for most 2525 machines. See `function.c' for details. 2526 */ 2527 /* No definition */ 2528 2529 2530 /* 2531 `DYNAMIC_CHAIN_ADDRESS (FRAMEADDR)' 2532 A C expression whose value is RTL representing the address in a 2533 stack frame where the pointer to the caller's frame is stored. 2534 Assume that FRAMEADDR is an RTL expression for the address of the 2535 stack frame itself. 2536 2537 If you don't define this macro, the default is to return the value 2538 of FRAMEADDR--that is, the stack frame address is also the address 2539 of the stack word that points to the previous frame. 2540 */ 2541 /* No definition (seems like the default should be correct) */ 2542 2543 2544 /* 2545 `SETUP_FRAME_ADDRESSES ()' 2546 If defined, a C expression that produces the machine-specific code 2547 to setup the stack so that arbitrary frames can be accessed. For 2548 example, on the Sparc, we must flush all of the register windows 2549 to the stack before we can access arbitrary stack frames. This 2550 macro will seldom need to be defined. 2551 */ 2552 /* No definition */ 2553 2554 2555 /* 2556 `RETURN_ADDR_RTX (COUNT, FRAMEADDR)' 2557 A C expression whose value is RTL representing the value of the 2558 return address for the frame COUNT steps up from the current frame. 2559 fRAMEADDR is the frame pointer of the COUNT frame, or the frame 2560 pointer of the COUNT - 1 frame if `RETURN_ADDR_IN_PREVIOUS_FRAME' 2561 is defined. 2562 */ 2563 /* Not defined (should be if we want to use __builtin_return_address() ) */ 2564 2565 2566 /* 2567 `RETURN_ADDR_IN_PREVIOUS_FRAME' 2568 Define this if the return address of a particular stack frame is 2569 accessed from the frame pointer of the previous stack frame. 2570 */ 2571 /* Not defined */ 2572 2573 2574 /* Section: Stack and Calling::Frame Registers */ 2575 2576 /* First a few convenience definitions that should fit into this section. */ 2577 /* Convenience for jvm (used above). It used to be used by gcc, but no more. */ 2578 /* "pc" is 15 */ 2579 /* CLR program counter is r31 */ 2580 #define PC_REGNUM 31 2581 2582 /* Register used for return addresses (Jvm only) */ 2583 /* --- jds31 --- not sure about this, 2584 * but CLR srp is r30 2585 */ 2586 #define SRP_REGNUM 30 2587 2588 2589 /* 2590 `STACK_POINTER_REGNUM' 2591 The register number of the stack pointer register, which must also 2592 be a fixed register according to `FIXED_REGISTERS'. On most 2593 machines, the hardware determines which register this is. 2594 */ 2595 /* Register to use for pushing function arguments. Not actually 2596 defined by the hardware, but it would not be so smart to put it 2597 somewhere else. */ 2598 /* CLR sp is r29 */ 2599 #define STACK_POINTER_REGNUM 29 2600 2601 2602 /* 2603 `FRAME_POINTER_REGNUM' 2604 The register number of the frame pointer register, which is used to 2605 access automatic variables in the stack frame. On some machines, 2606 the hardware determines which register this is. On other 2607 machines, you can choose any register you wish for this purpose. 2608 */ 2609 /* Register used for frame pointer. This is also the last of the saved 2610 registers, when a frame pointer is not used. */ 2611 /* CLR fp is r28 */ 2612 #define FRAME_POINTER_REGNUM 28 2613 2614 2615 /* 2616 `HARD_FRAME_POINTER_REGNUM' 2617 On some machines the offset between the frame pointer and starting 2618 offset of the automatic variables is not known until after register 2619 allocation has been done (for example, because the saved registers 2620 are between these two locations). On those machines, define 2621 `FRAME_POINTER_REGNUM' the number of a special, fixed register to 2622 be used internally until the offset is known, and define 2623 `HARD_FRAME_POINTER_REGNUM' to be actual the hard register number 2624 used for the frame pointer. 2625 2626 You should define this macro only in the very rare circumstances 2627 when it is not possible to calculate the offset between the frame 2628 pointer and the automatic variables until after register 2629 allocation has been completed. When this macro is defined, you 2630 must also indicate in your definition of `ELIMINABLE_REGS' how to 2631 eliminate `FRAME_POINTER_REGNUM' into either 2632 `HARD_FRAME_POINTER_REGNUM' or `STACK_POINTER_REGNUM'. 2633 2634 Do not define this macro if it would be the same as 2635 `FRAME_POINTER_REGNUM'. 2636 */ 2637 /* Not defined */ 2638 2639 2640 /* 2641 `ARG_POINTER_REGNUM' 2642 The register number of the arg pointer register, which is used to 2643 access the function's argument list. On some machines, this is 2644 the same as the frame pointer register. On some machines, the 2645 hardware determines which register this is. On other machines, 2646 you can choose any register you wish for this purpose. If this is 2647 not the same register as the frame pointer register, then you must 2648 mark it as a fixed register according to `FIXED_REGISTERS', or 2649 arrange to be able to eliminate it (*note Elimination::.). 2650 */ 2651 #define ARG_POINTER_REGNUM FRAME_POINTER_REGNUM 2652 2653 2654 /* 2655 `STATIC_CHAIN_REGNUM' 2656 `STATIC_CHAIN_INCOMING_REGNUM' 2657 Register numbers used for passing a function's static chain 2658 pointer. If register windows are used, the register number as 2659 seen by the called function is `STATIC_CHAIN_INCOMING_REGNUM', 2660 while the register number as seen by the calling function is 2661 `STATIC_CHAIN_REGNUM'. If these registers are the same, 2662 `STATIC_CHAIN_INCOMING_REGNUM' need not be defined. 2663 2664 The static chain register need not be a fixed register. 2665 2666 If the static chain is passed in memory, these macros should not be 2667 defined; instead, the next two macros should be defined. 2668 */ 2669 /* It is NOT TESTED if this definition is allright. */ 2670 /* CLR staic chain ptr is r27 */ 2671 #define STATIC_CHAIN_REGNUM 27 2672 2673 2674 /* 2675 `STATIC_CHAIN' 2676 `STATIC_CHAIN_INCOMING' 2677 If the static chain is passed in memory, these macros provide rtx 2678 giving `mem' expressions that denote where they are stored. 2679 `STATIC_CHAIN' and `STATIC_CHAIN_INCOMING' give the locations as 2680 seen by the calling and called functions, respectively. Often the 2681 former will be at an offset from the stack pointer and the latter 2682 at an offset from the frame pointer. 2683 2684 The variables `stack_pointer_rtx', `frame_pointer_rtx', and 2685 `arg_pointer_rtx' will have been initialized prior to the use of 2686 these macros and should be used to refer to those items. 2687 2688 If the static chain is passed in a register, the two previous 2689 macros should be defined instead. 2690 */ 2691 /* Not defined */ 2692 2693 2694 /* Section: Stack and Calling::Elimination */ 2695 2696 /* 2697 `FRAME_POINTER_REQUIRED' 2698 A C expression which is nonzero if a function must have and use a 2699 frame pointer. This expression is evaluated in the reload pass. 2700 If its value is nonzero the function will have a frame pointer. 2701 2702 The expression can in principle examine the current function and 2703 decide according to the facts, but on most machines the constant 0 2704 or the constant 1 suffices. Use 0 when the machine allows code to 2705 be generated with no frame pointer, and doing so saves some time 2706 or space. Use 1 when there is no possible advantage to avoiding a 2707 frame pointer. 2708 2709 In certain cases, the compiler does not know how to produce valid 2710 code without a frame pointer. The compiler recognizes those cases 2711 and automatically gives the function a frame pointer regardless of 2712 what `FRAME_POINTER_REQUIRED' says. You don't need to worry about 2713 them. 2714 2715 In a function that does not require a frame pointer, the frame 2716 pointer register can be allocated for ordinary usage, unless you 2717 mark it as a fixed register. See `FIXED_REGISTERS' for more 2718 information. 2719 */ 2720 /* Really only needed if the stack frame has variable length (alloca() 2721 or variable sized local arguments (Gnu extension). */ 2722 #define FRAME_POINTER_REQUIRED 0 2723 2724 2725 /* 2726 `INITIAL_FRAME_POINTER_OFFSET (DEPTH-VAR)' 2727 A C statement to store in the variable DEPTH-VAR the difference 2728 between the frame pointer and the stack pointer values immediately 2729 after the function prologue. The value would be computed from 2730 information such as the result of `get_frame_size ()' and the 2731 tables of registers `regs_ever_live' and `call_used_regs'. 2732 2733 If `ELIMINABLE_REGS' is defined, this macro will be not be used and 2734 need not be defined. Otherwise, it must be defined even if 2735 `FRAME_POINTER_REQUIRED' is defined to always be true; in that 2736 case, you may set DEPTH-VAR to anything. 2737 */ 2738 /* Note that if NON_SAVING_SETJMP then current_function_calls_setjmp 2739 must be considered. */ 2740 /* FIXME - not sure about this one */ 2741 #define INITIAL_FRAME_POINTER_OFFSET(DEPTH) \ 2742 { (DEPTH) = initial_fp_sp_offset();} 2743 2744 extern int initial_fp_sp_offset(void); 2745 2746 2747 /* 2748 `ELIMINABLE_REGS' 2749 If defined, this macro specifies a table of register pairs used to 2750 eliminate unneeded registers that point into the stack frame. If 2751 it is not defined, the only elimination attempted by the compiler 2752 is to replace references to the frame pointer with references to 2753 the stack pointer. 2754 2755 The definition of this macro is a list of structure 2756 initializations, each of which specifies an original and 2757 replacement register. 2758 2759 On some machines, the position of the argument pointer is not 2760 known until the compilation is completed. In such a case, a 2761 separate hard register must be used for the argument pointer. 2762 This register can be eliminated by replacing it with either the 2763 frame pointer or the argument pointer, depending on whether or not 2764 the frame pointer has been eliminated. 2765 2766 In this case, you might specify: 2767 #define ELIMINABLE_REGS \ 2768 {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ 2769 {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \ 2770 {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}} 2771 2772 Note that the elimination of the argument pointer with the stack 2773 pointer is specified first since that is the preferred elimination. 2774 */ 2775 /* Not defined */ 2776 2777 2778 /* 2779 `CAN_ELIMINATE (FROM-REG, TO-REG)' 2780 A C expression that returns non-zero if the compiler is allowed to 2781 try to replace register number FROM-REG with register number 2782 TO-REG. This macro need only be defined if `ELIMINABLE_REGS' is 2783 defined, and will usually be the constant 1, since most of the 2784 cases preventing register elimination are things that the compiler 2785 already knows about. 2786 */ 2787 /* Not defined */ 2788 2789 2790 /* 2791 `INITIAL_ELIMINATION_OFFSET (FROM-REG, TO-REG, OFFSET-VAR)' 2792 This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'. It 2793 specifies the initial difference between the specified pair of 2794 registers. This macro must be defined if `ELIMINABLE_REGS' is 2795 defined. 2796 */ 2797 /* Not defined */ 2798 2799 2800 /* 2801 `LONGJMP_RESTORE_FROM_STACK' 2802 Define this macro if the `longjmp' function restores registers from 2803 the stack frames, rather than from those saved specifically by 2804 `setjmp'. Certain quantities must not be kept in registers across 2805 a call to `setjmp' on such machines. 2806 */ 2807 /* Not defined */ 2808 2809 /* Section: Stack and Calling::Stack Arguments */ 2810 2811 /* 2812 `PROMOTE_PROTOTYPES' 2813 Define this macro if an argument declared in a prototype as an 2814 integral type smaller than `int' should actually be passed as an 2815 `int'. In addition to avoiding errors in certain cases of 2816 mismatch, it also makes for better code on certain machines. 2817 */ 2818 /* Since many parameters take up one register each in any case, this 2819 seems like a good idea. */ 2820 #define PROMOTE_PROTOTYPES 1 2821 2822 2823 /* 2824 `PUSH_ROUNDING (NPUSHED)' 2825 A C expression that is the number of bytes actually pushed onto the 2826 stack when an instruction attempts to push NPUSHED bytes. 2827 2828 If the target machine does not have a push instruction, do not 2829 define this macro. That directs GNU CC to use an alternate 2830 strategy: to allocate the entire argument block and then store the 2831 arguments into it. 2832 2833 On some machines, the definition 2834 2835 #define PUSH_ROUNDING(BYTES) (BYTES) 2836 2837 will suffice. But on other machines, instructions that appear to 2838 push one byte actually push two bytes in an attempt to maintain 2839 alignment. Then the definition should be 2840 2841 #define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1) 2842 */ 2843 /* Not defined */ 2844 2845 2846 /* 2847 `ACCUMULATE_OUTGOING_ARGS' 2848 If defined, the maximum amount of space required for outgoing 2849 arguments will be computed and placed into the variable 2850 `current_function_outgoing_args_size'. No space will be pushed 2851 onto the stack for each call; instead, the function prologue should 2852 increase the stack frame size by this amount. 2853 2854 Defining both `PUSH_ROUNDING' and `ACCUMULATE_OUTGOING_ARGS' is 2855 not proper. 2856 */ 2857 #define ACCUMULATE_OUTGOING_ARGS 1 2858 2859 2860 /* 2861 `REG_PARM_STACK_SPACE (FNDECL)' 2862 Define this macro if functions should assume that stack space has 2863 been allocated for arguments even when their values are passed in 2864 registers. 2865 2866 The value of this macro is the size, in bytes, of the area 2867 reserved for arguments passed in registers for the function 2868 represented by FNDECL. 2869 2870 This space can be allocated by the caller, or be a part of the 2871 machine-dependent stack frame: `OUTGOING_REG_PARM_STACK_SPACE' says 2872 which. 2873 */ 2874 /* Not defined */ 2875 2876 2877 /* 2878 `MAYBE_REG_PARM_STACK_SPACE' 2879 `FINAL_REG_PARM_STACK_SPACE (CONST_SIZE, VAR_SIZE)' 2880 Define these macros in addition to the one above if functions might 2881 allocate stack space for arguments even when their values are 2882 passed in registers. These should be used when the stack space 2883 allocated for arguments in registers is not a simple constant 2884 independent of the function declaration. 2885 2886 The value of the first macro is the size, in bytes, of the area 2887 that we should initially assume would be reserved for arguments 2888 passed in registers. 2889 2890 The value of the second macro is the actual size, in bytes, of the 2891 area that will be reserved for arguments passed in registers. 2892 This takes two arguments: an integer representing the number of 2893 bytes of fixed sized arguments on the stack, and a tree 2894 representing the number of bytes of variable sized arguments on 2895 the stack. 2896 2897 When these macros are defined, `REG_PARM_STACK_SPACE' will only be 2898 called for libcall functions, the current function, or for a 2899 function being called when it is known that such stack space must 2900 be allocated. In each case this value can be easily computed. 2901 2902 When deciding whether a called function needs such stack space, 2903 and how much space to reserve, GNU CC uses these two macros 2904 instead of `REG_PARM_STACK_SPACE'. 2905 */ 2906 /* Not defined */ 2907 2908 2909 /* 2910 `OUTGOING_REG_PARM_STACK_SPACE' 2911 Define this if it is the responsibility of the caller to allocate 2912 the area reserved for arguments passed in registers. 2913 2914 If `ACCUMULATE_OUTGOING_ARGS' is defined, this macro controls 2915 whether the space for these arguments counts in the value of 2916 `current_function_outgoing_args_size'. 2917 */ 2918 /* Not defined */ 2919 2920 2921 /* 2922 `STACK_PARMS_IN_REG_PARM_AREA' 2923 Define this macro if `REG_PARM_STACK_SPACE' is defined, but the 2924 stack parameters don't skip the area specified by it. 2925 2926 Normally, when a parameter is not passed in registers, it is 2927 placed on the stack beyond the `REG_PARM_STACK_SPACE' area. 2928 Defining this macro suppresses this behavior and causes the 2929 parameter to be passed on the stack in its natural location. 2930 */ 2931 /* Not defined */ 2932 2933 2934 /* 2935 `RETURN_POPS_ARGS (FUNDECL, FUNTYPE, STACK-SIZE)' 2936 A C expression that should indicate the number of bytes of its own 2937 arguments that a function pops on returning, or 0 if the function 2938 pops no arguments and the caller must therefore pop them all after 2939 the function returns. 2940 2941 FUNDECL is a C variable whose value is a tree node that describes 2942 the function in question. Normally it is a node of type 2943 `FUNCTION_DECL' that describes the declaration of the function. 2944 From this it is possible to obtain the DECL_MACHINE_ATTRIBUTES of 2945 the function. 2946 2947 FUNTYPE is a C variable whose value is a tree node that describes 2948 the function in question. Normally it is a node of type 2949 `FUNCTION_TYPE' that describes the data type of the function. 2950 From this it is possible to obtain the data types of the value and 2951 arguments (if known). 2952 2953 When a call to a library function is being considered, FUNTYPE 2954 will contain an identifier node for the library function. Thus, if 2955 you need to distinguish among various library functions, you can 2956 do so by their names. Note that "library function" in this 2957 context means a function used to perform arithmetic, whose name is 2958 known specially in the compiler and was not mentioned in the C 2959 code being compiled. 2960 2961 STACK-SIZE is the number of bytes of arguments passed on the 2962 stack. If a variable number of bytes is passed, it is zero, and 2963 argument popping will always be the responsibility of the calling 2964 function. 2965 2966 On the Vax, all functions always pop their arguments, so the 2967 definition of this macro is STACK-SIZE. On the 68000, using the 2968 standard calling convention, no functions pop their arguments, so 2969 the value of the macro is always 0 in this case. But an 2970 alternative calling convention is available in which functions 2971 that take a fixed number of arguments pop them but other functions 2972 (such as `printf') pop nothing (the caller pops all). When this 2973 convention is in use, FUNTYPE is examined to determine whether a 2974 function takes a fixed number of arguments. 2975 */ 2976 /* On Jvm, RET just restores PC */ 2977 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,STACKSIZE) 0 2978 2979 2980 /* Section: Stack and Calling::Register Arguments */ 2981 2982 /* 2983 `FUNCTION_ARG (CUM, MODE, TYPE, NAMED)' 2984 A C expression that controls whether a function argument is passed 2985 in a register, and which register. 2986 2987 The arguments are CUM, which summarizes all the previous 2988 arguments; MODE, the machine mode of the argument; TYPE, the data 2989 type of the argument as a tree node or 0 if that is not known 2990 (which happens for C support library functions); and NAMED, which 2991 is 1 for an ordinary argument and 0 for nameless arguments that 2992 correspond to `...' in the called function's prototype. 2993 2994 The value of the expression should either be a `reg' RTX for the 2995 hard register in which to pass the argument, or zero to pass the 2996 argument on the stack. 2997 2998 For machines like the Vax and 68000, where normally all arguments 2999 are pushed, zero suffices as a definition. 3000 3001 The usual way to make the ANSI library `stdarg.h' work on a machine 3002 where some arguments are usually passed in registers, is to cause 3003 nameless arguments to be passed on the stack instead. This is done 3004 by making `FUNCTION_ARG' return 0 whenever NAMED is 0. 3005 3006 You may use the macro `MUST_PASS_IN_STACK (MODE, TYPE)' in the 3007 definition of this macro to determine if this argument is of a 3008 type that must be passed in the stack. If `REG_PARM_STACK_SPACE' 3009 is not defined and `FUNCTION_ARG' returns non-zero for such an 3010 argument, the compiler will abort. If `REG_PARM_STACK_SPACE' is 3011 defined, the argument will be computed in the stack and then 3012 loaded into a register. 3013 */ 3014 3015 /* --- jds31 --- 3016 * To pass all arguments on the stack, use the following definition ... 3017 * 3018 */ 3019 3020 /* 3021 * #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) 0 3022 */ 3023 3024 /* --- jds31 --- 3025 * To pass first N args in registers, use the following definition ... 3026 * Note that N == MAX_ARGS_IN_REGS, and we can only pass args 3027 * in registers if they are not address-taken. Otherwise, args are 3028 * still passed on the stack. 3029 */ 3030 3031 3032 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \ 3033 ((CUM).regs < MAX_ARGS_IN_REGS \ 3034 ? gen_rtx(REG, MODE, (FIRST_ARG_REG)+(CUM).regs) \ 3035 : ((rtx) 0)) 3036 3037 3038 /* 3039 **** --- jds31 --- this is orig version, from egcs-jvm ... 3040 **** it doesn't work, I think that is because 3041 **** we haven't defined macro 3042 **** MUST_PASS_IN_STACK anywhere. 3043 3044 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \ 3045 ((CUM).regs < MAX_ARGS_IN_REGS && !MUST_PASS_IN_STACK (MODE, TYPE) \ 3046 && (GET_MODE_BITSIZE(MODE) <= 32 || TARGET_LIBFUNC || (CUM).lib) \ 3047 ? gen_rtx(REG, MODE, (FIRST_ARG_REG)+(CUM).regs) \ 3048 : ((rtx) 0)) 3049 */ 3050 3051 /* 3052 `FUNCTION_INCOMING_ARG (CUM, MODE, TYPE, NAMED)' 3053 Define this macro if the target machine has "register windows", so 3054 that the register in which a function sees an arguments is not 3055 necessarily the same as the one in which the caller passed the 3056 argument. 3057 3058 For such machines, `FUNCTION_ARG' computes the register in which 3059 the caller passes the value, and `FUNCTION_INCOMING_ARG' should be 3060 defined in a similar fashion to tell the function being called 3061 where the arguments will arrive. 3062 3063 If `FUNCTION_INCOMING_ARG' is not defined, `FUNCTION_ARG' serves 3064 both purposes. 3065 */ 3066 /* Note that the only difference between this and the previous, is 3067 that this one isnt ignoring the function definition or declaration. */ 3068 #define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) \ 3069 ((NAMED) && (CUM).regs < MAX_ARGS_IN_REGS \ 3070 && !MUST_PASS_IN_STACK (MODE, TYPE)\ 3071 && (GET_MODE_BITSIZE(MODE) <= 32 || TARGET_LIBFUNC || (CUM).lib)\ 3072 ? gen_rtx(REG, MODE, FIRST_ARG_REG_IN+(CUM).regs) \ 3073 : ((rtx) 0)) 3074 3075 /* 3076 `FUNCTION_ARG_PARTIAL_NREGS (CUM, MODE, TYPE, NAMED)' 3077 A C expression for the number of words, at the beginning of an 3078 argument, must be put in registers. The value must be zero for 3079 arguments that are passed entirely in registers or that are 3080 entirely pushed on the stack. 3081 3082 On some machines, certain arguments must be passed partially in 3083 registers and partially in memory. On these machines, typically 3084 the first N words of arguments are passed in registers, and the 3085 rest on the stack. If a multi-word argument (a `double' or a 3086 structure) crosses that boundary, its first few words must be 3087 passed in registers and the rest must be pushed. This macro tells 3088 the compiler when this occurs, and how many of the words should go 3089 in registers. 3090 3091 `FUNCTION_ARG' for these arguments should return the first 3092 register to be used by the caller for this argument; likewise 3093 `FUNCTION_INCOMING_ARG', for the called function. 3094 */ 3095 /* Not defined */ 3096 3097 3098 /* 3099 `FUNCTION_ARG_PASS_BY_REFERENCE (CUM, MODE, TYPE, NAMED)' 3100 A C expression that indicates when an argument must be passed by 3101 reference. If nonzero for an argument, a copy of that argument is 3102 made in memory and a pointer to the argument is passed instead of 3103 the argument itself. The pointer is passed in whatever way is 3104 appropriate for passing a pointer to that type. 3105 3106 On machines where `REG_PARM_STACK_SPACE' is not defined, a suitable 3107 definition of this macro might be 3108 #define FUNCTION_ARG_PASS_BY_REFERENCE\ 3109 (CUM, MODE, TYPE, NAMED) \ 3110 MUST_PASS_IN_STACK (MODE, TYPE) 3111 */ 3112 /* Structs may be passed by value, but they must not be more than 4 3113 bytes long. 3114 Since we support long longs, we must be able to call a libfunc 3115 with an 8-byte entity (i.e. long long). This will be safe if we 3116 know what we're doing when we use -mlibfunc. No long long libfuncs 3117 take more than two parameters in, so it is ok if we have at least 4 3118 argregs. */ 3119 #define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) \ 3120 (MUST_PASS_IN_STACK(MODE, TYPE) /* I'm not sure this one is necessary. */ \ 3121 || (FUNCTION_ARG_SIZE(MODE,TYPE) > 4 && !TARGET_LIBFUNC && !(CUM).lib)) 3122 3123 /* Good to have. Not standard. */ 3124 #define FUNCTION_ARG_SIZE(MODE, TYPE) \ 3125 ((MODE) != BLKmode ? GET_MODE_SIZE (MODE) : int_size_in_bytes (TYPE)) 3126 3127 3128 /* 3129 `FUNCTION_ARG_CALLEE_COPIES (CUM, MODE, TYPE, NAMED)' 3130 If defined, a C expression that indicates when it is the called 3131 function's responsibility to make a copy of arguments passed by 3132 invisible reference. Normally, the caller makes a copy and passes 3133 the address of the copy to the routine being called. When 3134 FUNCTION_ARG_CALLEE_COPIES is defined and is nonzero, the caller 3135 does not make a copy. Instead, it passes a pointer to the "live" 3136 value. The called function must not modify this value. If it can 3137 be determined that the value won't be modified, it need not make a 3138 copy; otherwise a copy must be made. 3139 */ 3140 /* Maybe define this later, when we play with optimizations. */ 3141 3142 3143 /* 3144 `CUMULATIVE_ARGS' 3145 A C type for declaring a variable that is used as the first 3146 argument of `FUNCTION_ARG' and other related values. For some 3147 target machines, the type `int' suffices and can hold the number 3148 of bytes of argument so far. 3149 3150 There is no need to record in `CUMULATIVE_ARGS' anything about the 3151 arguments that have been passed on the stack. The compiler has 3152 other variables to keep track of that. For target machines on 3153 which all arguments are passed on the stack, there is no need to 3154 store anything in `CUMULATIVE_ARGS'; however, the data structure 3155 must exist and should not be empty, so use `int'. 3156 */ 3157 #define CUMULATIVE_ARGS struct cumu_args 3158 3159 struct cumu_args {int regs; int lib;}; 3160 3161 3162 /* 3163 `INIT_CUMULATIVE_ARGS (CUM, FNTYPE, LIBNAME)' 3164 A C statement (sans semicolon) for initializing the variable CUM 3165 for the state at the beginning of the argument list. The variable 3166 has type `CUMULATIVE_ARGS'. The value of FNTYPE is the tree node 3167 for the data type of the function which will receive the args, or 0 3168 if the args are to a compiler support library function. 3169 3170 When processing a call to a compiler support library function, 3171 LIBNAME identifies which one. It is a `symbol_ref' rtx which 3172 contains the name of the function, as a string. LIBNAME is 0 when 3173 an ordinary C function call is being processed. Thus, each time 3174 this macro is called, either LIBNAME or FNTYPE is nonzero, but 3175 never both of them at once. 3176 */ 3177 /* This is an integer, which is the number of arguments got into registers so 3178 far, and if init_cumulative_args was found to generate a call to a 3179 library function. The offset starts at 0. */ 3180 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,unused) \ 3181 ((CUM).regs = 0, (CUM).lib = ((LIBNAME) != 0)) 3182 3183 /* Add another (unused) parameter to the macro above and remove this 3184 macro and declaration, since there *is* a xstrdup() in post-2.7.2(.2) 3185 #define xstrdup strdup 3186 extern char *strdup(); 3187 */ 3188 3189 /* 3190 `INIT_CUMULATIVE_INCOMING_ARGS (CUM, FNTYPE, LIBNAME)' 3191 Like `INIT_CUMULATIVE_ARGS' but overrides it for the purposes of 3192 finding the arguments for the function being compiled. If this 3193 macro is undefined, `INIT_CUMULATIVE_ARGS' is used instead. 3194 3195 The value passed for LIBNAME is always 0, since library routines 3196 with special calling conventions are never compiled with GNU CC. 3197 The argument LIBNAME exists for symmetry with 3198 `INIT_CUMULATIVE_ARGS'. 3199 */ 3200 /* Not defined */ 3201 3202 3203 /* 3204 `FUNCTION_ARG_ADVANCE (CUM, MODE, TYPE, NAMED)' 3205 A C statement (sans semicolon) to update the summarizer variable 3206 CUM to advance past an argument in the argument list. The values 3207 MODE, TYPE and NAMED describe that argument. Once this is done, 3208 the variable CUM is suitable for analyzing the *following* 3209 argument with `FUNCTION_ARG', etc. 3210 3211 This macro need not do anything if the argument in question was 3212 passed on the stack. The compiler knows how to track the amount 3213 of stack space used for arguments without any special help. 3214 */ 3215 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \ 3216 ((CUM).regs = ((MUST_PASS_IN_STACK(MODE,TYPE)) \ 3217 || (FUNCTION_ARG_SIZE(MODE,TYPE) > 4 && !TARGET_LIBFUNC && !(CUM).lib))\ 3218 ? (MAX_ARGS_IN_REGS)+1 : (CUM).regs + (3+(FUNCTION_ARG_SIZE(MODE,TYPE)))/4) 3219 3220 3221 /* 3222 `FUNCTION_ARG_PADDING (MODE, TYPE)' 3223 If defined, a C expression which determines whether, and in which 3224 direction, to pad out an argument with extra space. The value 3225 should be of type `enum direction': either `upward' to pad above 3226 the argument, `downward' to pad below, or `none' to inhibit 3227 padding. 3228 3229 The *amount* of padding is always just enough to reach the next 3230 multiple of `FUNCTION_ARG_BOUNDARY'; this macro does not control 3231 it. 3232 3233 This macro has a default definition which is right for most 3234 systems. For little-endian machines, the default is to pad 3235 upward. For big-endian machines, the default is to pad downward 3236 for an argument of constant size shorter than an `int', and upward 3237 otherwise. 3238 */ 3239 /* Not defined */ 3240 3241 3242 /* 3243 `FUNCTION_ARG_BOUNDARY (MODE, TYPE)' 3244 If defined, a C expression that gives the alignment boundary, in 3245 bits, of an argument with the specified mode and type. If it is 3246 not defined, `PARM_BOUNDARY' is used for all arguments. 3247 */ 3248 /* Not defined */ 3249 3250 3251 /* 3252 `FUNCTION_ARG_REGNO_P (REGNO)' 3253 A C expression that is nonzero if REGNO is the number of a hard 3254 register in which function arguments are sometimes passed. This 3255 does *not* include implicit arguments such as the static chain and 3256 the structure-value address. On many machines, no registers can be 3257 used for this purpose since all function arguments are pushed on 3258 the stack. 3259 */ 3260 #define FUNCTION_ARG_REGNO_P(REGNO) \ 3261 ((REGNO) >= FIRST_ARG_REG && (REGNO) < FIRST_ARG_REG + (MAX_ARGS_IN_REGS)) 3262 3263 3264 /* Section: Stack and Calling::Scalar Return */ 3265 3266 /* 3267 `TRADITIONAL_RETURN_FLOAT' 3268 Define this macro if `-traditional' should not cause functions 3269 declared to return `float' to convert the value to `double'. 3270 */ 3271 /* Not defined */ 3272 3273 3274 /* 3275 `FUNCTION_VALUE (VALTYPE, FUNC)' 3276 A C expression to create an RTX representing the place where a 3277 function returns a value of data type VALTYPE. VALTYPE is a tree 3278 node representing a data type. Write `TYPE_MODE (VALTYPE)' to get 3279 the machine mode used to represent that type. On many machines, 3280 only the mode is relevant. (Actually, on most machines, scalar 3281 values are returned in the same place regardless of mode). 3282 3283 If `PROMOTE_FUNCTION_RETURN' is defined, you must apply the same 3284 promotion rules specified in `PROMOTE_MODE' if VALTYPE is a scalar 3285 type. 3286 3287 If the precise function being called is known, FUNC is a tree node 3288 (`FUNCTION_DECL') for it; otherwise, FUNC is a null pointer. This 3289 makes it possible to use a different value-returning convention 3290 for specific functions when all their calls are known. 3291 3292 `FUNCTION_VALUE' is not used for return vales with aggregate data 3293 types, because these are returned in another way. See 3294 `STRUCT_VALUE_REGNUM' and related macros, below. 3295 */ 3296 /* Let's assume all functions return in r[FIRST_ARG_REG] for the time being */ 3297 /* 3298 * #define FUNCTION_VALUE(VALTYPE, FUNC) \ 3299 * gen_rtx (REG, TYPE_MODE (VALTYPE), FIRST_ARG_REG) 3300 */ 3301 3302 /* --- jds31 --- 3303 * we choose to return values in r0, on the CLR. 3304 */ 3305 3306 #define RETURN_VALUE_REG 0 3307 3308 #define FUNCTION_VALUE(VALTYPE, FUNC) \ 3309 gen_rtx (REG, TYPE_MODE (VALTYPE), RETURN_VALUE_REG) 3310 3311 3312 /* 3313 `FUNCTION_OUTGOING_VALUE (VALTYPE, FUNC)' 3314 Define this macro if the target machine has "register windows" so 3315 that the register in which a function returns its value is not the 3316 same as the one in which the caller sees the value. 3317 3318 For such machines, `FUNCTION_VALUE' computes the register in which 3319 the caller will see the value. `FUNCTION_OUTGOING_VALUE' should be 3320 defined in a similar fashion to tell the function where to put the 3321 value. 3322 3323 If `FUNCTION_OUTGOING_VALUE' is not defined, `FUNCTION_VALUE' 3324 serves both purposes. 3325 3326 `FUNCTION_OUTGOING_VALUE' is not used for return vales with 3327 aggregate data types, because these are returned in another way. 3328 See `STRUCT_VALUE_REGNUM' and related macros, below. 3329 */ 3330 /* Not defined */ 3331 3332 3333 /* 3334 `LIBCALL_VALUE (MODE)' 3335 A C expression to create an RTX representing the place where a 3336 library function returns a value of mode MODE. If the precise 3337 function being called is known, FUNC is a tree node 3338 (`FUNCTION_DECL') for it; otherwise, FUNC is a null pointer. This 3339 makes it possible to use a different value-returning convention 3340 for specific functions when all their calls are known. 3341 3342 Note that "library function" in this context means a compiler 3343 support routine, used to perform arithmetic, whose name is known 3344 specially by the compiler and was not mentioned in the C code being 3345 compiled. 3346 3347 The definition of `LIBRARY_VALUE' need not be concerned aggregate 3348 data types, because none of the library functions returns such 3349 types. 3350 */ 3351 /* Let's assume all lib functions return in r[FIRST_ARG_REG] 3352 for the time being */ 3353 #define LIBCALL_VALUE(MODE) gen_rtx (REG, MODE, FIRST_ARG_REG) 3354 3355 3356 /* 3357 `FUNCTION_VALUE_REGNO_P (REGNO)' 3358 A C expression that is nonzero if REGNO is the number of a hard 3359 register in which the values of called function may come back. 3360 3361 A register whose use for returning values is limited to serving as 3362 the second of a pair (for a value of type `double', say) need not 3363 be recognized by this macro. So for most machines, this definition 3364 suffices: 3365 3366 #define FUNCTION_VALUE_REGNO_P(N) ((N) == 0) 3367 3368 If the machine has register windows, so that the caller and the 3369 called function use different registers for the return value, this 3370 macro should recognize only the caller's register numbers. 3371 */ 3372 #define FUNCTION_VALUE_REGNO_P(N) ((N) == FIRST_ARG_REG) 3373 3374 3375 /* 3376 `APPLY_RESULT_SIZE' 3377 Define this macro if `untyped_call' and `untyped_return' need more 3378 space than is implied by `FUNCTION_VALUE_REGNO_P' for saving and 3379 restoring an arbitrary return value. 3380 */ 3381 /* Not defined */ 3382 3383 3384 /* Section: Stack and Calling::Aggregate Return */ 3385 3386 /* 3387 `RETURN_IN_MEMORY (TYPE)' 3388 A C expression which can inhibit the returning of certain function 3389 values in registers, based on the type of value. A nonzero value 3390 says to return the function value in memory, just as large 3391 structures are always returned. Here TYPE will be a C expression 3392 of type `tree', representing the data type of the value. 3393 3394 Note that values of mode `BLKmode' must be explicitly handled by 3395 this macro. Also, the option `-fpcc-struct-return' takes effect 3396 regardless of this macro. On most systems, it is possible to 3397 leave the macro undefined; this causes a default definition to be 3398 used, whose value is the constant 1 for `BLKmode' values, and 0 3399 otherwise. 3400 3401 Do not use this macro to indicate that structures and unions 3402 should always be returned in memory. You should instead use 3403 `DEFAULT_PCC_STRUCT_RETURN' to indicate this. 3404 */ 3405 #if 0 3406 /* Dont foo around with this -- yet. */ 3407 /* Let's try this. Cast int_size_in_bytes() to unsigned, so we will 3408 get a huge number for "structures" of variable size (-1). */ 3409 #define RETURN_IN_MEMORY(TYPE) \ 3410 ((unsigned) int_size_in_bytes(TYPE) > MAX_ARGS_IN_REGS*UNITS_PER_WORD) 3411 #endif 3412 3413 3414 /* 3415 `DEFAULT_PCC_STRUCT_RETURN' 3416 Define this macro to be 1 if all structure and union return values 3417 must be in memory. Since this results in slower code, this should 3418 be defined only if needed for compatibility with other compilers 3419 or with an ABI. If you define this macro to be 0, then the 3420 conventions used for structure and union return values are decided 3421 by the `RETURN_IN_MEMORY' macro. 3422 3423 If not defined, this defaults to the value 1. 3424 */ 3425 /* Not defined */ 3426 3427 3428 /* 3429 `STRUCT_VALUE_REGNUM' 3430 If the structure value address is passed in a register, then 3431 `STRUCT_VALUE_REGNUM' should be the number of that register. 3432 */ 3433 #define STRUCT_VALUE_REGNUM ((FIRST_ARG_REG) - 1) 3434 3435 3436 /* 3437 `STRUCT_VALUE' 3438 If the structure value address is not passed in a register, define 3439 `STRUCT_VALUE' as an expression returning an RTX for the place 3440 where the address is passed. If it returns 0, the address is 3441 passed as an "invisible" first argument. 3442 */ 3443 /* Not defined */ 3444 3445 3446 /* 3447 `STRUCT_VALUE_INCOMING_REGNUM' 3448 On some architectures the place where the structure value address 3449 is found by the called function is not the same place that the 3450 caller put it. This can be due to register windows, or it could 3451 be because the function prologue moves it to a different place. 3452 3453 If the incoming location of the structure value address is in a 3454 register, define this macro as the register number. 3455 */ 3456 /* Not defined */ 3457 3458 3459 /* 3460 `STRUCT_VALUE_INCOMING' 3461 If the incoming location is not a register, then you should define 3462 `STRUCT_VALUE_INCOMING' as an expression for an RTX for where the 3463 called function should find the value. If it should find the 3464 value on the stack, define this to create a `mem' which refers to 3465 the frame pointer. A definition of 0 means that the address is 3466 passed as an "invisible" first argument. 3467 */ 3468 /* Not defined */ 3469 3470 3471 /* 3472 `PCC_STATIC_STRUCT_RETURN' 3473 Define this macro if the usual system convention on the target 3474 machine for returning structures and unions is for the called 3475 function to return the address of a static variable containing the 3476 value. 3477 3478 Do not define this if the usual system convention is for the 3479 caller to pass an address to the subroutine. 3480 3481 This macro has effect in `-fpcc-struct-return' mode, but it does 3482 nothing when you use `-freg-struct-return' mode. 3483 */ 3484 /* Not defined */ 3485 3486 3487 /* Section: Stack and Calling::Caller Saves */ 3488 /* (no definitions) */ 3489 3490 /* Section: Stack and Calling::Function entry */ 3491 3492 /* 3493 `FUNCTION_PROLOGUE (FILE, SIZE)' 3494 A C compound statement that outputs the assembler code for entry 3495 to a function. The prologue is responsible for setting up the 3496 stack frame, initializing the frame pointer register, saving 3497 registers that must be saved, and allocating SIZE additional bytes 3498 of storage for the local variables. SIZE is an integer. FILE is 3499 a stdio stream to which the assembler code should be output. 3500 3501 The label for the beginning of the function need not be output by 3502 this macro. That has already been done when the macro is run. 3503 3504 To determine which registers to save, the macro can refer to the 3505 array `regs_ever_live': element R is nonzero if hard register R is 3506 used anywhere within the function. This implies the function 3507 prologue should save register R, provided it is not one of the 3508 call-used registers. (`FUNCTION_EPILOGUE' must likewise use 3509 `regs_ever_live'.) 3510 3511 On machines that have "register windows", the function entry code 3512 does not save on the stack the registers that are in the windows, 3513 even if they are supposed to be preserved by function calls; 3514 instead it takes appropriate steps to "push" the register stack, 3515 if any non-call-used registers are used in the function. 3516 3517 On machines where functions may or may not have frame-pointers, the 3518 function entry code must vary accordingly; it must set up the frame 3519 pointer if one is wanted, and not otherwise. To determine whether 3520 a frame pointer is in wanted, the macro can refer to the variable 3521 `frame_pointer_needed'. The variable's value will be 1 at run 3522 time in a function that needs a frame pointer. *Note 3523 Elimination::. 3524 3525 The function entry code is responsible for allocating any stack 3526 space required for the function. This stack space consists of the 3527 regions listed below. In most cases, these regions are allocated 3528 in the order listed, with the last listed region closest to the 3529 top of the stack (the lowest address if `STACK_GROWS_DOWNWARD' is 3530 defined, and the highest address if it is not defined). You can 3531 use a different order for a machine if doing so is more convenient 3532 or required for compatibility reasons. Except in cases where 3533 required by standard or by a debugger, there is no reason why the 3534 stack layout used by GCC need agree with that used by other 3535 compilers for a machine. 3536 3537 * A region of `current_function_pretend_args_size' bytes of 3538 uninitialized space just underneath the first argument 3539 arriving on the stack. (This may not be at the very start of 3540 the allocated stack region if the calling sequence has pushed 3541 anything else since pushing the stack arguments. But 3542 usually, on such machines, nothing else has been pushed yet, 3543 because the function prologue itself does all the pushing.) 3544 This region is used on machines where an argument may be 3545 passed partly in registers and partly in memory, and, in some 3546 cases to support the features in `varargs.h' and `stdargs.h'. 3547 3548 * An area of memory used to save certain registers used by the 3549 function. The size of this area, which may also include 3550 space for such things as the return address and pointers to 3551 previous stack frames, is machine-specific and usually 3552 depends on which registers have been used in the function. 3553 Machines with register windows often do not require a save 3554 area. 3555 3556 * A region of at least SIZE bytes, possibly rounded up to an 3557 allocation boundary, to contain the local variables of the 3558 function. On some machines, this region and the save area 3559 may occur in the opposite order, with the save area closer to 3560 the top of the stack. 3561 3562 * Optionally, when `ACCUMULATE_OUTGOING_ARGS' is defined, a 3563 region of `current_function_outgoing_args_size' bytes to be 3564 used for outgoing argument lists of the function. *Note 3565 Stack Arguments::. 3566 3567 Normally, it is necessary for the macros `FUNCTION_PROLOGUE' and 3568 `FUNCTION_EPILOGUE' to treat leaf functions specially. The C 3569 variable `leaf_function' is nonzero for such a function. 3570 */ 3571 #define FUNCTION_PROLOGUE(FILE, SIZE) function_prologue(FILE, SIZE) 3572 3573 /* moved to protos.h extern void function_prologue(FILE *, int); */ 3574 3575 3576 /* 3577 `EXIT_IGNORE_STACK' 3578 Define this macro as a C expression that is nonzero if the return 3579 instruction or the function epilogue ignores the value of the stack 3580 pointer; in other words, if it is safe to delete an instruction to 3581 adjust the stack pointer before a return from the function. 3582 3583 Note that this macro's value is relevant only for functions for 3584 which frame pointers are maintained. It is never safe to delete a 3585 final stack adjustment in a function that has no frame pointer, 3586 and the compiler knows this regardless of `EXIT_IGNORE_STACK'. 3587 */ 3588 /* Not defined */ 3589 3590 3591 /* 3592 `FUNCTION_EPILOGUE (FILE, SIZE)' 3593 A C compound statement that outputs the assembler code for exit 3594 from a function. The epilogue is responsible for restoring the 3595 saved registers and stack pointer to their values when the 3596 function was called, and returning control to the caller. This 3597 macro takes the same arguments as the macro `FUNCTION_PROLOGUE', 3598 and the registers to restore are determined from `regs_ever_live' 3599 and `CALL_USED_REGISTERS' in the same way. 3600 3601 On some machines, there is a single instruction that does all the 3602 work of returning from the function. On these machines, give that 3603 instruction the name `return' and do not define the macro 3604 `FUNCTION_EPILOGUE' at all. 3605 3606 Do not define a pattern named `return' if you want the 3607 `FUNCTION_EPILOGUE' to be used. If you want the target switches 3608 to control whether return instructions or epilogues are used, 3609 define a `return' pattern with a validity condition that tests the 3610 target switches appropriately. If the `return' pattern's validity 3611 condition is false, epilogues will be used. 3612 3613 On machines where functions may or may not have frame-pointers, the 3614 function exit code must vary accordingly. Sometimes the code for 3615 these two cases is completely different. To determine whether a 3616 frame pointer is wanted, the macro can refer to the variable 3617 `frame_pointer_needed'. The variable's value will be 1 when 3618 compiling a function that needs a frame pointer. 3619 3620 Normally, `FUNCTION_PROLOGUE' and `FUNCTION_EPILOGUE' must treat 3621 leaf functions specially. The C variable `leaf_function' is 3622 nonzero for such a function. *Note Leaf Functions::. 3623 3624 On some machines, some functions pop their arguments on exit while 3625 others leave that for the caller to do. For example, the 68020 3626 when given `-mrtd' pops arguments in functions that take a fixed 3627 number of arguments. 3628 3629 Your definition of the macro `RETURN_POPS_ARGS' decides which 3630 functions pop their own arguments. `FUNCTION_EPILOGUE' needs to 3631 know what was decided. The variable that is called 3632 `current_function_pops_args' is the number of bytes of its 3633 arguments that a function should pop. *Note Scalar Return::. 3634 */ 3635 #define FUNCTION_EPILOGUE(FILE, SIZE) function_epilogue(FILE,SIZE) 3636 3637 /* moved to protos.h extern void function_epilogue(FILE *, int); */ 3638 3639 3640 /* 3641 `DELAY_SLOTS_FOR_EPILOGUE' 3642 Define this macro if the function epilogue contains delay slots to 3643 which instructions from the rest of the function can be "moved". 3644 The definition should be a C expression whose value is an integer 3645 representing the number of delay slots there. 3646 */ 3647 /* If "ret" insns in the epilogue, we need to fill the 3648 delay slot. 3649 #define DELAY_SLOTS_FOR_EPILOGUE delay_slots_for_epilogue() 3650 3651 extern int delay_slots_for_epilogue(); 3652 */ 3653 3654 3655 /* 3656 `ELIGIBLE_FOR_EPILOGUE_DELAY (INSN, N)' 3657 A C expression that returns 1 if INSN can be placed in delay slot 3658 number N of the epilogue. 3659 3660 The argument N is an integer which identifies the delay slot now 3661 being considered (since different slots may have different rules of 3662 eligibility). It is never negative and is always less than the 3663 number of epilogue delay slots (what `DELAY_SLOTS_FOR_EPILOGUE' 3664 returns). If you reject a particular insn for a given delay slot, 3665 in principle, it may be reconsidered for a subsequent delay slot. 3666 Also, other insns may (at least in principle) be considered for 3667 the so far unfilled delay slot. 3668 3669 The insns accepted to fill the epilogue delay slots are put in an 3670 RTL list made with `insn_list' objects, stored in the variable 3671 `current_function_epilogue_delay_list'. The insn for the first 3672 delay slot comes first in the list. Your definition of the macro 3673 `FUNCTION_EPILOGUE' should fill the delay slots by outputting the 3674 insns in this list, usually by calling `final_scan_insn'. 3675 3676 You need not define this macro if you did not define 3677 `DELAY_SLOTS_FOR_EPILOGUE'. 3678 3679 #define ELIGIBLE_FOR_EPILOGUE_DELAY(INSN, N) \ 3680 eligible_for_epilogue_delay(INSN) 3681 3682 extern int eligible_for_epilogue_delay(); 3683 */ 3684 3685 /* Section: Stack and Calling::Profiling */ 3686 3687 /* 3688 `FUNCTION_PROFILER (FILE, LABELNO)' 3689 A C statement or compound statement to output to FILE some 3690 assembler code to call the profiling subroutine `mcount'. Before 3691 calling, the assembler code must load the address of a counter 3692 variable into a register where `mcount' expects to find the 3693 address. The name of this variable is `LP' followed by the number 3694 LABELNO, so you would generate the name using `LP%d' in a 3695 `fprintf'. 3696 3697 The details of how the address should be passed to `mcount' are 3698 determined by your operating system environment, not by GNU CC. To 3699 figure them out, compile a small program for profiling using the 3700 system's installed C compiler and look at the assembler code that 3701 results. 3702 */ 3703 #define FUNCTION_PROFILER(FILE, LABELNO) \ 3704 /* fprintf (FILE, "This should have been mcount(%d)\n", (LABELNO)); */; 3705 3706 3707 /* 3708 `PROFILE_BEFORE_PROLOGUE' 3709 Define this macro if the code for function profiling should come 3710 before the function prologue. Normally, the profiling code comes 3711 after. 3712 */ 3713 /* Not defined */ 3714 3715 3716 /* 3717 `FUNCTION_BLOCK_PROFILER (FILE, LABELNO)' 3718 A C statement or compound statement to output to FILE some 3719 assembler code to initialize basic-block profiling for the current 3720 object module. This code should call the subroutine 3721 `__bb_init_func' once per object module, passing it as its sole 3722 argument the address of a block allocated in the object module. 3723 3724 The name of the block is a local symbol made with this statement: 3725 3726 ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0); 3727 3728 Of course, since you are writing the definition of 3729 `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you 3730 can take a short cut in the definition of this macro and use the 3731 name that you know will result. 3732 3733 The first word of this block is a flag which will be nonzero if the 3734 object module has already been initialized. So test this word 3735 first, and do not call `__bb_init_func' if the flag is nonzero. 3736 */ 3737 /* No profiling for the time being. */ 3738 #define FUNCTION_BLOCK_PROFILER(FILE, LABELNO) \ 3739 /* fprintf (FILE, "\tFunction block profiler %d:\n", \ 3740 LABELNO); \ 3741 */; 3742 3743 3744 /* 3745 `BLOCK_PROFILER (FILE, BLOCKNO)' 3746 A C statement or compound statement to increment the count 3747 associated with the basic block number BLOCKNO. Basic blocks are 3748 numbered separately from zero within each compilation. The count 3749 associated with block number BLOCKNO is at index BLOCKNO in a 3750 vector of words; the name of this array is a local symbol made 3751 with this statement: 3752 3753 ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 2); 3754 3755 Of course, since you are writing the definition of 3756 `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you 3757 can take a short cut in the definition of this macro and use the 3758 name that you know will result. 3759 */ 3760 /* No profiling for the time being. */ 3761 #define BLOCK_PROFILER(FILE, BLOCKNO) \ 3762 /* fprintf (FILE, "\tBlock profiler: %d\n", \ 3763 BLOCKNO) */; 3764 3765 3766 /* 3767 `BLOCK_PROFILER_CODE' 3768 A C function or functions which are needed in the library to 3769 support block profiling. 3770 */ 3771 /* No profiling for the time being. */ 3772 3773 3774 /* Section: Varargs */ 3775 3776 /* 3777 `EXPAND_BUILTIN_SAVEREGS (ARGS)' 3778 If defined, is a C expression that produces the machine-specific 3779 code for a call to `__builtin_saveregs'. This code will be moved 3780 to the very beginning of the function, before any parameter access 3781 are made. The return value of this function should be an RTX that 3782 contains the value to use as the return of `__builtin_saveregs'. 3783 3784 The argument ARGS is a `tree_list' containing the arguments that 3785 were passed to `__builtin_saveregs'. 3786 3787 If this macro is not defined, the compiler will output an ordinary 3788 call to the library function `__builtin_saveregs'. 3789 */ 3790 /* Not defined */ 3791 3792 3793 /* 3794 `SETUP_INCOMING_VARARGS (ARGS_SO_FAR, MODE, TYPE,' 3795 PRETEND_ARGS_SIZE, SECOND_TIME) This macro offers an alternative 3796 to using `__builtin_saveregs' and defining the macro 3797 `EXPAND_BUILTIN_SAVEREGS'. Use it to store the anonymous register 3798 arguments into the stack so that all the arguments appear to have 3799 been passed consecutively on the stack. Once this is done, you 3800 can use the standard implementation of varargs that works for 3801 machines that pass all their arguments on the stack. 3802 3803 The argument ARGS_SO_FAR is the `CUMULATIVE_ARGS' data structure, 3804 containing the values that obtain after processing of the named 3805 arguments. The arguments MODE and TYPE describe the last named 3806 argument--its machine mode and its data type as a tree node. 3807 3808 The macro implementation should do two things: first, push onto the 3809 stack all the argument registers *not* used for the named 3810 arguments, and second, store the size of the data thus pushed into 3811 the `int'-valued variable whose name is supplied as the argument 3812 PRETEND_ARGS_SIZE. The value that you store here will serve as 3813 additional offset for setting up the stack frame. 3814 3815 Because you must generate code to push the anonymous arguments at 3816 compile time without knowing their data types, 3817 `SETUP_INCOMING_VARARGS' is only useful on machines that have just 3818 a single category of argument register and use it uniformly for 3819 all data types. 3820 3821 If the argument SECOND_TIME is nonzero, it means that the 3822 arguments of the function are being analyzed for the second time. 3823 This happens for an inline function, which is not actually 3824 compiled until the end of the source file. The macro 3825 `SETUP_INCOMING_VARARGS' should not generate any instructions in 3826 this case. 3827 */ 3828 /* We save the register number of the first anonymous argument in 3829 first_vararg_reg, and take care of this in the function prologue. 3830 This behaviour is used by at least one more port (the ARM?), but 3831 may be unsafe when compiling nested functions. (With varargs? Hairy.) 3832 Note that nested-functions is a Gnu C extension. 3833 */ 3834 3835 /* FIXME - jds31 - 6/12/01 - Do we need this?? */ 3836 3837 /* #define SETUP_INCOMING_VARARGS(ARGS_SO_FAR, MODE, TYPE, PRETEND_ARGS_SIZE, SECOND_TIME)\ 3838 { \ 3839 if ((ARGS_SO_FAR).regs < (MAX_ARGS_IN_REGS)) \ 3840 { \ 3841 extern int first_vararg_reg; \ 3842 first_vararg_reg = (FIRST_ARG_REG)+(ARGS_SO_FAR).regs; \ 3843 (PRETEND_ARGS_SIZE) = ((MAX_ARGS_IN_REGS) - (ARGS_SO_FAR).regs)*4; \ 3844 } \ 3845 if (TARGET_PDEBUG) \ 3846 { \ 3847 fprintf(stderr,"\n VA:: %s: %d args before, anon @ #%d, %dtime\n", \ 3848 current_function_varargs ? "OLD" : "ANSI", \ 3849 (ARGS_SO_FAR).regs, PRETEND_ARGS_SIZE,SECOND_TIME); \ 3850 } \ 3851 } 3852 */ 3853 3854 /* 3855 `STRICT_ARGUMENT_NAMING' 3856 Define this macro if the location where a function argument is 3857 passed depends on whether or not it is a named argument. 3858 3859 This macro controls how the NAMED argument to `FUNCTION_ARG' is 3860 set for varargs and stdarg functions. With this macro defined, 3861 the NAMED argument is always true for named arguments, and false 3862 for unnamed arguments. If this is not defined, but 3863 `SETUP_INCOMING_VARARGS' is defined, then all arguments are 3864 treated as named. Otherwise, all named arguments except the last 3865 are treated as named. 3866 */ 3867 /* Not defined */ 3868 3869 3870 /* Section: Trampolines */ 3871 3872 /* 3873 `TRAMPOLINE_TEMPLATE (FILE)' 3874 A C statement to output, on the stream FILE, assembler code for a 3875 block of data that contains the constant parts of a trampoline. 3876 This code should not include a label--the label is taken care of 3877 automatically. 3878 */ 3879 /* NOTE THAT TRAMPOLINES ARE NOT TESTED, SINCE WE DONT USE NESTED FUNCTIONS. */ 3880 #define TRAMPOLINE_TEMPLATE(FILE) \ 3881 fprintf(FILE, "\tmove.d 0,r%d\n", STATIC_CHAIN_REGNUM); \ 3882 fprintf(FILE, "\tjump 0\n"); 3883 3884 3885 /* 3886 `TRAMPOLINE_SECTION' 3887 The name of a subroutine to switch to the section in which the 3888 trampoline template is to be placed (*note Sections::.). The 3889 default is a value of `readonly_data_section', which places the 3890 trampoline in the section containing read-only data. 3891 */ 3892 /* Not defined */ 3893 3894 3895 /* 3896 `TRAMPOLINE_SIZE' 3897 A C expression for the size in bytes of the trampoline, as an 3898 integer. 3899 */ 3900 #define TRAMPOLINE_SIZE 12 3901 3902 3903 /* 3904 `TRAMPOLINE_ALIGNMENT' 3905 Alignment required for trampolines, in bits. 3906 3907 If you don't define this macro, the value of `BIGGEST_ALIGNMENT' 3908 is used for aligning trampolines. 3909 */ 3910 /* Jvm wants instructions on word-(16)-boundary. 3911 Note that due to a bug (reported) in 2.7.2 and earlier, this is 3912 actually treated as alignment in _bytes_, not _bits_. (Obviously 3913 this is not fatal, only a slight waste of stack space). */ 3914 #define TRAMPOLINE_ALIGNMENT 16 3915 3916 3917 /* 3918 `INITIALIZE_TRAMPOLINE (ADDR, FNADDR, STATIC_CHAIN)' 3919 A C statement to initialize the variable parts of a trampoline. 3920 aDDR is an RTX for the address of the trampoline; FNADDR is an RTX 3921 for the address of the nested function; STATIC_CHAIN is an RTX for 3922 the static chain value that should be passed to the function when 3923 it is called. 3924 */ 3925 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \ 3926 { \ 3927 emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 2)), CXT); \ 3928 emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 8)), FNADDR); \ 3929 } 3930 3931 3932 /* 3933 `ALLOCATE_TRAMPOLINE (FP)' 3934 A C expression to allocate run-time space for a trampoline. The 3935 expression value should be an RTX representing a memory reference 3936 to the space for the trampoline. 3937 3938 If this macro is not defined, by default the trampoline is 3939 allocated as a stack slot. This default is right for most 3940 machines. The exceptions are machines where it is impossible to 3941 execute instructions in the stack area. On such machines, you may 3942 have to implement a separate stack, using this macro in 3943 conjunction with `FUNCTION_PROLOGUE' and `FUNCTION_EPILOGUE'. 3944 3945 FP points to a data structure, a `struct function', which 3946 describes the compilation status of the immediate containing 3947 function of the function which the trampoline is for. Normally 3948 (when `ALLOCATE_TRAMPOLINE' is not defined), the stack slot for the 3949 trampoline is in the stack frame of this containing function. 3950 Other allocation strategies probably must do something analogous 3951 with this information. 3952 */ 3953 /* Not defined */ 3954 3955 3956 /* 3957 `INSN_CACHE_SIZE' 3958 The total size in bytes of the cache. 3959 */ 3960 /* Not defined */ 3961 3962 3963 /* 3964 `INSN_CACHE_LINE_WIDTH' 3965 The length in bytes of each cache line. The cache is divided into 3966 cache lines which are disjoint slots, each holding a contiguous 3967 chunk of data fetched from memory. Each time data is brought into 3968 the cache, an entire line is read at once. The data loaded into a 3969 cache line is always aligned on a boundary equal to the line size. 3970 */ 3971 /* Not defined */ 3972 3973 3974 /* 3975 `INSN_CACHE_DEPTH' 3976 The number of alternative cache lines that can hold any particular 3977 memory location. 3978 */ 3979 /* Not defined */ 3980 3981 3982 /* 3983 `CLEAR_INSN_CACHE (BEG, END)' 3984 If defined, expands to a C expression clearing the *instruction 3985 cache* in the specified interval. If it is not defined, and the 3986 macro INSN_CACHE_SIZE is defined, some generic code is generated 3987 to clear the cache. The definition of this macro would typically 3988 be a series of `asm' statements. Both BEG and END are both pointer 3989 expressions. 3990 */ 3991 /* Not defined */ 3992 3993 3994 /* 3995 `TRANSFER_FROM_TRAMPOLINE' 3996 Define this macro if trampolines need a special subroutine to do 3997 their work. The macro should expand to a series of `asm' 3998 statements which will be compiled with GNU CC. They go in a 3999 library function named `__transfer_from_trampoline'. 4000 4001 If you need to avoid executing the ordinary prologue code of a 4002 compiled C function when you jump to the subroutine, you can do so 4003 by placing a special label of your own in the assembler code. Use 4004 one `asm' statement to generate an assembler label, and another to 4005 make the label global. Then trampolines can use that label to 4006 jump directly to your special assembler code. 4007 */ 4008 /* Not defined */ 4009 4010 4011 /* Section: Library Calls */ 4012 4013 /* 4014 `MULSI3_LIBCALL' 4015 A C string constant giving the name of the function to call for 4016 multiplication of one signed full-word by another. If you do not 4017 define this macro, the default name is used, which is `__mulsi3', 4018 a function defined in `libgcc.a'. 4019 */ 4020 /* We have no real divsi3 udivsi3 modsi3 umodsi3 mulsi3 so 4021 we must have them in some library. 4022 Gcc makes __xx names for them, with "xx" one of the above, and 4023 defines them in libgcc1. This causes a recursive definition if we 4024 do not have other names for them, and define them elsewhere. 4025 So lets do that. 4026 */ 4027 #define MULSI3_LIBCALL "__Mul" 4028 4029 4030 /* 4031 `DIVSI3_LIBCALL' 4032 A C string constant giving the name of the function to call for 4033 division of one signed full-word by another. If you do not define 4034 this macro, the default name is used, which is `__divsi3', a 4035 function defined in `libgcc.a'. 4036 */ 4037 #define DIVSI3_LIBCALL "__Div" 4038 4039 4040 /* 4041 `UDIVSI3_LIBCALL' 4042 A C string constant giving the name of the function to call for 4043 division of one unsigned full-word by another. If you do not 4044 define this macro, the default name is used, which is `__udivsi3', 4045 a function defined in `libgcc.a'. 4046 */ 4047 #define UDIVSI3_LIBCALL "__Udiv" 4048 4049 4050 /* 4051 `MODSI3_LIBCALL' 4052 A C string constant giving the name of the function to call for the 4053 remainder in division of one signed full-word by another. If you 4054 do not define this macro, the default name is used, which is 4055 `__modsi3', a function defined in `libgcc.a'. 4056 */ 4057 #define MODSI3_LIBCALL "__Mod" 4058 4059 4060 /* 4061 `UMODSI3_LIBCALL' 4062 A C string constant giving the name of the function to call for the 4063 remainder in division of one unsigned full-word by another. If 4064 you do not define this macro, the default name is used, which is 4065 `__umodsi3', a function defined in `libgcc.a'. 4066 */ 4067 #define UMODSI3_LIBCALL "__Umod" 4068 4069 4070 /* 4071 `MULDI3_LIBCALL' 4072 A C string constant giving the name of the function to call for 4073 multiplication of one signed double-word by another. If you do not 4074 define this macro, the default name is used, which is `__muldi3', 4075 a function defined in `libgcc.a'. 4076 */ 4077 /* Not defined */ 4078 4079 4080 /* 4081 `DIVDI3_LIBCALL' 4082 A C string constant giving the name of the function to call for 4083 division of one signed double-word by another. If you do not 4084 define this macro, the default name is used, which is `__divdi3', a 4085 function defined in `libgcc.a'. 4086 */ 4087 /* Not defined */ 4088 4089 4090 /* 4091 `UDIVDI3_LIBCALL' 4092 A C string constant giving the name of the function to call for 4093 division of one unsigned full-word by another. If you do not 4094 define this macro, the default name is used, which is `__udivdi3', 4095 a function defined in `libgcc.a'. 4096 */ 4097 /* Not defined */ 4098 4099 4100 /* 4101 `MODDI3_LIBCALL' 4102 A C string constant giving the name of the function to call for the 4103 remainder in division of one signed double-word by another. If 4104 you do not define this macro, the default name is used, which is 4105 `__moddi3', a function defined in `libgcc.a'. 4106 */ 4107 /* Not defined */ 4108 4109 4110 /* 4111 `UMODDI3_LIBCALL' 4112 A C string constant giving the name of the function to call for the 4113 remainder in division of one unsigned full-word by another. If 4114 you do not define this macro, the default name is used, which is 4115 `__umoddi3', a function defined in `libgcc.a'. 4116 */ 4117 /* Not defined */ 4118 4119 4120 /* 4121 `INIT_TARGET_OPTABS' 4122 Define this macro as a C statement that declares additional library 4123 routines renames existing ones. `init_optabs' calls this macro 4124 after initializing all the normal library routines. 4125 */ 4126 /* Not defined */ 4127 4128 4129 /* 4130 `TARGET_EDOM' 4131 The value of `EDOM' on the target machine, as a C integer constant 4132 expression. If you don't define this macro, GNU CC does not 4133 attempt to deposit the value of `EDOM' into `errno' directly. 4134 Look in `/usr/include/errno.h' to find the value of `EDOM' on your 4135 system. 4136 4137 If you do not define `TARGET_EDOM', then compiled code reports 4138 domain errors by calling the library function and letting it 4139 report the error. If mathematical functions on your system use 4140 `matherr' when there is an error, then you should leave 4141 `TARGET_EDOM' undefined so that `matherr' is used normally. 4142 */ 4143 #define TARGET_EDOM 33 /* Dont go change the include files now! */ 4144 4145 4146 /* 4147 `GEN_ERRNO_RTX' 4148 Define this macro as a C expression to create an rtl expression 4149 that refers to the global "variable" `errno'. (On certain systems, 4150 `errno' may not actually be a variable.) If you don't define this 4151 macro, a reasonable default is used. 4152 */ 4153 /* Not defined */ 4154 4155 4156 /* 4157 `TARGET_MEM_FUNCTIONS' 4158 Define this macro if GNU CC should generate calls to the System V 4159 (and ANSI C) library functions `memcpy' and `memset' rather than 4160 the BSD functions `bcopy' and `bzero'. 4161 */ 4162 #define TARGET_MEM_FUNCTIONS 4163 4164 4165 /* 4166 `LIBGCC_NEEDS_DOUBLE' 4167 Define this macro if only `float' arguments cannot be passed to 4168 library routines (so they must be converted to `double'). This 4169 macro affects both how library calls are generated and how the 4170 library routines in `libgcc1.c' accept their arguments. It is 4171 useful on machines where floating and fixed point arguments are 4172 passed differently, such as the i860. 4173 */ 4174 /* Not defined */ 4175 4176 4177 /* 4178 `FLOAT_ARG_TYPE' 4179 Define this macro to override the type used by the library 4180 routines to pick up arguments of type `float'. (By default, they 4181 use a union of `float' and `int'.) 4182 4183 The obvious choice would be `float'--but that won't work with 4184 traditional C compilers that expect all arguments declared as 4185 `float' to arrive as `double'. To avoid this conversion, the 4186 library routines ask for the value as some other type and then 4187 treat it as a `float'. 4188 4189 On some systems, no other type will work for this. For these 4190 systems, you must use `LIBGCC_NEEDS_DOUBLE' instead, to force 4191 conversion of the values `double' before they are passed. 4192 */ 4193 /* Not defined */ 4194 4195 4196 /* 4197 `FLOATIFY (PASSED-VALUE)' 4198 Define this macro to override the way library routines redesignate 4199 a `float' argument as a `float' instead of the type it was passed 4200 as. The default is an expression which takes the `float' field of 4201 the union. 4202 */ 4203 /* Not defined */ 4204 4205 4206 /* 4207 `FLOAT_VALUE_TYPE' 4208 Define this macro to override the type used by the library 4209 routines to return values that ought to have type `float'. (By 4210 default, they use `int'.) 4211 4212 The obvious choice would be `float'--but that won't work with 4213 traditional C compilers gratuitously convert values declared as 4214 `float' into `double'. 4215 */ 4216 /* Only used in libgcc1.c which we do not use, but we let it in here 4217 to keep a complete description. */ 4218 #define FLOAT_VALUE_TYPE float 4219 4220 4221 /* 4222 `INTIFY (FLOAT-VALUE)' 4223 Define this macro to override the way the value of a 4224 `float'-returning library routine should be packaged in order to 4225 return it. These functions are actually declared to return type 4226 `FLOAT_VALUE_TYPE' (normally `int'). 4227 4228 These values can't be returned as type `float' because traditional 4229 C compilers would gratuitously convert the value to a `double'. 4230 4231 A local variable named `intify' is always available when the macro 4232 `INTIFY' is used. It is a union of a `float' field named `f' and 4233 a field named `i' whose type is `FLOAT_VALUE_TYPE' or `int'. 4234 4235 If you don't define this macro, the default definition works by 4236 copying the value through that union. 4237 */ 4238 /* See comment for FLOAT_VALUE_TYPE */ 4239 #define INTIFY(x) (x) 4240 4241 4242 /* 4243 `nongcc_SI_type' 4244 Define this macro as the name of the data type corresponding to 4245 `SImode' in the system's own C compiler. 4246 4247 You need not define this macro if that type is `long int', as it 4248 usually is. 4249 */ 4250 /* Not defined */ 4251 4252 4253 /* 4254 `nongcc_word_type' 4255 Define this macro as the name of the data type corresponding to the 4256 word_mode in the system's own C compiler. 4257 4258 You need not define this macro if that type is `long int', as it 4259 usually is. 4260 */ 4261 /* Not defined */ 4262 4263 4264 /* 4265 `perform_...' 4266 Define these macros to supply explicit C statements to carry out 4267 various arithmetic operations on types `float' and `double' in the 4268 library routines in `libgcc1.c'. See that file for a full list of 4269 these macros and their arguments. 4270 4271 On most machines, you don't need to define any of these macros, 4272 because the C compiler that comes with the system takes care of 4273 doing them. 4274 */ 4275 /* Not defined */ 4276 4277 4278 /* 4279 `NEXT_OBJC_RUNTIME' 4280 Define this macro to generate code for Objective C message sending 4281 using the calling convention of the NeXT system. This calling 4282 convention involves passing the object, the selector and the 4283 method arguments all at once to the method-lookup library function. 4284 4285 The default calling convention passes just the object and the 4286 selector to the lookup function, which returns a pointer to the 4287 method. 4288 */ 4289 /* Not defined */ 4290 4291 4292 /* Section: Addressing Modes */ 4293 4294 /* 4295 `HAVE_POST_INCREMENT' 4296 Define this macro if the machine supports post-increment 4297 addressing. 4298 4299 #define HAVE_POST_INCREMENT 4300 */ 4301 4302 /* 4303 `HAVE_PRE_INCREMENT' 4304 `HAVE_POST_DECREMENT' 4305 `HAVE_PRE_DECREMENT' 4306 Similar for other kinds of addressing. 4307 */ 4308 /* Not defined */ 4309 4310 4311 /* 4312 `CONSTANT_ADDRESS_P (X)' 4313 A C expression that is 1 if the RTX X is a constant which is a 4314 valid address. On most machines, this can be defined as 4315 `CONSTANT_P (X)', but a few machines are more restrictive in which 4316 constant addresses are supported. 4317 4318 `CONSTANT_P' accepts integer-values expressions whose values are 4319 not explicitly known, such as `symbol_ref', `label_ref', and 4320 `high' expressions and `const' arithmetic expressions, in addition 4321 to `const_int' and `const_double' expressions. 4322 */ 4323 #define CONSTANT_ADDRESS_P(X) CONSTANT_P (X) 4324 /* Not defined */ 4325 4326 4327 /* 4328 `MAX_REGS_PER_ADDRESS' 4329 A number, the maximum number of registers that can appear in a 4330 valid memory address. Note that it is up to you to specify a 4331 value equal to the maximum number that `GO_IF_LEGITIMATE_ADDRESS' 4332 would ever accept. 4333 */ 4334 #define MAX_REGS_PER_ADDRESS 2 4335 4336 4337 /* 4338 `GO_IF_LEGITIMATE_ADDRESS (MODE, X, LABEL)' 4339 A C compound statement with a conditional `goto LABEL;' executed 4340 if X (an RTX) is a legitimate memory address on the target machine 4341 for a memory operand of mode MODE. 4342 4343 It usually pays to define several simpler macros to serve as 4344 subroutines for this one. Otherwise it may be too complicated to 4345 understand. 4346 4347 This macro must exist in two variants: a strict variant and a 4348 non-strict one. The strict variant is used in the reload pass. It 4349 must be defined so that any pseudo-register that has not been 4350 allocated a hard register is considered a memory reference. In 4351 contexts where some kind of register is required, a pseudo-register 4352 with no hard register must be rejected. 4353 4354 The non-strict variant is used in other passes. It must be 4355 defined to accept all pseudo-registers in every context where some 4356 kind of register is required. 4357 4358 Compiler source files that want to use the strict variant of this 4359 macro define the macro `REG_OK_STRICT'. You should use an `#ifdef 4360 REG_OK_STRICT' conditional to define the strict variant in that 4361 case and the non-strict variant otherwise. 4362 4363 Subroutines to check for acceptable registers for various purposes 4364 (one for base registers, one for index registers, and so on) are 4365 typically among the subroutines used to define 4366 `GO_IF_LEGITIMATE_ADDRESS'. Then only these subroutine macros 4367 need have two variants; the higher levels of macros may be the 4368 same whether strict or not. 4369 4370 Normally, constant addresses which are the sum of a `symbol_ref' 4371 and an integer are stored inside a `const' RTX to mark them as 4372 constant. Therefore, there is no need to recognize such sums 4373 specifically as legitimate addresses. Normally you would simply 4374 recognize any `const' as legitimate. 4375 4376 Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle constant 4377 sums that are not marked with `const'. It assumes that a naked 4378 `plus' indicates indexing. If so, then you *must* reject such 4379 naked constant sums as illegitimate addresses, so that none of 4380 them will be given to `PRINT_OPERAND_ADDRESS'. 4381 4382 On some machines, whether a symbolic address is legitimate depends 4383 on the section that the address refers to. On these machines, 4384 define the macro `ENCODE_SECTION_INFO' to store the information 4385 into the `symbol_ref', and then check for it here. When you see a 4386 `const', you will have to look inside it to find the `symbol_ref' 4387 in order to determine the section. *Note Assembler Format::. 4388 4389 The best way to modify the name string is by adding text to the 4390 beginning, with suitable punctuation to prevent any ambiguity. 4391 Allocate the new name in `saveable_obstack'. You will have to 4392 modify `ASM_OUTPUT_LABELREF' to remove and decode the added text 4393 and output the name accordingly, and define `STRIP_NAME_ENCODING' 4394 to access the original name string. 4395 4396 You can check the information stored here into the `symbol_ref' in 4397 the definitions of the macros `GO_IF_LEGITIMATE_ADDRESS' and 4398 `PRINT_OPERAND_ADDRESS'. 4399 */ 4400 /* 4401 The other macros defined here are used only in GO_IF_LEGITIMATE_ADDRESS, 4402 except for CONSTANT_ADDRESS_P which is actually machine-independent. 4403 4404 Note that you HAVE TO reject illegal addressing modes for mode 4405 MODE, even if it is legal for normal addressing modes. You cannot 4406 rely on the constraints to do this work. They can only be used to 4407 doublecheck your intentions. One example is that you HAVE TO reject 4408 (mem:DI (plus:SI (reg:SI x) (reg:SI y))) because for some reason 4409 this cannot be reloaded. (Which of course you can argue that gcc 4410 should have done.) 4411 */ 4412 #define GO_PRINTF(foo) if (TARGET_GO_DEBUG) printf(foo) /* was debug_printf*/ 4413 #define GO_RTX(foo) if (TARGET_GO_DEBUG) debug_rtx(foo) 4414 4415 #define CONSTANT_INDEX_P(X) CONSTANT_P(X) 4416 4417 /* True if X is a valid base register */ 4418 #define BASE_P(X) \ 4419 (REG_P(X) && REG_OK_FOR_BASE_P(X)) 4420 4421 /* True if X is a valid base register with or without autoincrement */ 4422 #define BASE_OR_AUTOINCR_P(X) \ 4423 (BASE_P(X) || (GET_CODE(X) == POST_INC && BASE_P(XEXP(X, 0)))) 4424 4425 /* True if X is a valid (register) index for BDAP, i.e. (Rs) or (Rs+) */ 4426 /* Now 8 and 16 bit sign extend + 32bit! HP 930428. */ 4427 #define BDAP_INDEX_P(X) \ 4428 (TARGET_BDAP \ 4429 && ((GET_CODE(X) == MEM && GET_MODE(X) == SImode \ 4430 && BASE_OR_AUTOINCR_P(XEXP(X,0))) \ 4431 || (GET_CODE(X) == SIGN_EXTEND \ 4432 && GET_CODE(XEXP(X, 0)) == MEM \ 4433 && (GET_MODE(XEXP(X, 0)) == HImode \ 4434 || GET_MODE(XEXP(X, 0)) == QImode) \ 4435 && BASE_OR_AUTOINCR_P(XEXP(XEXP(X,0), 0))))) 4436 4437 /* True if X is a valid (register) index for BIAP, i.e. Rd.m */ 4438 #define BIAP_INDEX_P(X) \ 4439 ((BASE_P(X) && REG_OK_FOR_INDEX_P(X)) || \ 4440 (GET_CODE(X) == MULT && \ 4441 BASE_P(XEXP(X, 0)) && REG_OK_FOR_INDEX_P(XEXP(X, 0)) && \ 4442 GET_CODE(XEXP(X, 1)) == CONST_INT && \ 4443 (INTVAL(XEXP(X, 1)) == 2 || INTVAL(XEXP(X, 1)) == 4))) 4444 4445 /* True if X is an address that doesn't need a prefix i.e. 4446 (reg), (reg+). */ 4447 #define SIMPLE_ADDRESS_P(X) \ 4448 (BASE_P(X) || /* earlier versions used REG_P. Not strict enough! */ \ 4449 (GET_CODE(X) == POST_INC && \ 4450 BASE_P(XEXP(X, 0)))) 4451 4452 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ 4453 { \ 4454 register rtx foo, foo1, foo2; \ 4455 GO_PRINTF("GO_IF_LEGIT_ADDR:\n"); \ 4456 GO_RTX(X); \ 4457 if (SIMPLE_ADDRESS_P(X)) \ 4458 goto ADDR; \ 4459 if (CONSTANT_P(X)) \ 4460 goto ADDR; \ 4461 if (GET_CODE(X) == PLUS) /* indexed */ \ 4462 { \ 4463 GO_PRINTF("Indexed..."); \ 4464 foo1 = XEXP(X, 0); \ 4465 foo2 = XEXP(X, 1); \ 4466 if ((BASE_P(foo1) && CONSTANT_INDEX_P(foo2)) || /* BDAP o, Rd */ \ 4467 (BASE_P(foo2) && CONSTANT_INDEX_P(foo1)) || \ 4468 (GET_MODE_SIZE(MODE) <= UNITS_PER_WORD \ 4469 && ((BASE_P(foo1) && BDAP_INDEX_P(foo2)) /* BDAP (Rs[+]), Rd */ \ 4470 || (BASE_P(foo2) && BDAP_INDEX_P(foo1)) \ 4471 || (BASE_P(foo1) && BIAP_INDEX_P(foo2)) /* BIAP.m Rs, Rd */ \ 4472 || (BASE_P(foo2) && BIAP_INDEX_P(foo1))))) \ 4473 goto ADDR; \ 4474 } \ 4475 else if (GET_CODE(X) == MEM) /* DIP (Rs) */ \ 4476 { /* Reject [[reg+]] and [[reg]] for long long */ \ 4477 if (GET_MODE_SIZE(MODE) <= UNITS_PER_WORD \ 4478 && (BASE_P(XEXP(X,0)) /* [[reg+]] not implemented in jvm 1.0. */ \ 4479 || TARGET_DIPINC && BASE_OR_AUTOINCR_P(XEXP(X, 0)))) \ 4480 goto ADDR; \ 4481 } \ 4482 else \ 4483 GO_PRINTF("Bad address\n"); \ 4484 } 4485 4486 4487 /* 4488 `REG_OK_FOR_BASE_P (X)' 4489 A C expression that is nonzero if X (assumed to be a `reg' RTX) is 4490 valid for use as a base register. For hard registers, it should 4491 always accept those which the hardware permits and reject the 4492 others. Whether the macro accepts or rejects pseudo registers 4493 must be controlled by `REG_OK_STRICT' as described above. This 4494 usually requires two variant definitions, of which `REG_OK_STRICT' 4495 controls the one actually used. 4496 */ 4497 #ifndef REG_OK_STRICT 4498 4499 /* Nonzero if X is a hard reg that can be used as a base reg 4500 or if it is a pseudo reg. */ 4501 # define REG_OK_FOR_BASE_P(X) \ 4502 (REGNO(X) <= LAST_GENERAL_REGISTER || REGNO(X) >= FIRST_PSEUDO_REGISTER) 4503 4504 #else 4505 4506 /* Nonzero if X is a hard reg that can be used as a base reg. */ 4507 # define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X)) 4508 4509 #endif 4510 4511 4512 /* 4513 `REG_OK_FOR_INDEX_P (X)' 4514 A C expression that is nonzero if X (assumed to be a `reg' RTX) is 4515 valid for use as an index register. 4516 4517 The difference between an index register and a base register is 4518 that the index register may be scaled. If an address involves the 4519 sum of two registers, neither one of them scaled, then either one 4520 may be labeled the "base" and the other the "index"; but whichever 4521 labeling is used must fit the machine's constraints of which 4522 registers may serve in each capacity. The compiler will try both 4523 labelings, looking for one that is valid, and will reload one or 4524 both registers only if neither labeling works. 4525 */ 4526 #ifndef REG_OK_STRICT 4527 4528 /* Nonzero if X is a hard reg that can be used as an index 4529 or if it is a pseudo reg. */ 4530 # define REG_OK_FOR_INDEX_P(X) \ 4531 (REGNO(X) <= LAST_GENERAL_REGISTER || REGNO(X) >= FIRST_PSEUDO_REGISTER) 4532 4533 #else 4534 4535 /* Nonzero if X is a hard reg that can be used as an index. */ 4536 # define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X)) 4537 4538 #endif 4539 4540 4541 /* 4542 `LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN)' 4543 A C compound statement that attempts to replace X with a valid 4544 memory address for an operand of mode MODE. WIN will be a C 4545 statement label elsewhere in the code; the macro definition may use 4546 4547 GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN); 4548 4549 to avoid further processing if the address has become legitimate. 4550 4551 X will always be the result of a call to `break_out_memory_refs', 4552 and OLDX will be the operand that was given to that function to 4553 produce X. 4554 4555 The code generated by this macro should not alter the substructure 4556 of X. If it transforms X into a more legitimate form, it should 4557 assign X (which will always be a C variable) a new value. 4558 4559 It is not necessary for this macro to come up with a legitimate 4560 address. The compiler has standard ways of doing so in all cases. 4561 In fact, it is safe for this macro to do nothing. But often a 4562 machine-dependent strategy can generate better code. 4563 */ 4564 /* 4565 For now, don't do anything. Gcc does quite a good job most often. 4566 4567 Maybe we could do something about gcc:s misbahaviour when it 4568 recalculates frame offsets for local variables, from fp+offs to 4569 sp+offs. The resulting address expression gets screwed up 4570 sometimes, but I'm not sure that it may be fixed here, since it is 4571 already split up in several instructions (Is this still true?) */ 4572 #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) {} 4573 4574 4575 /* 4576 `GO_IF_MODE_DEPENDENT_ADDRESS (ADDR, LABEL)' 4577 A C statement or compound statement with a conditional `goto 4578 LABEL;' executed if memory address X (an RTX) can have different 4579 meanings depending on the machine mode of the memory reference it 4580 is used for or if the address is valid for some modes but not 4581 others. 4582 4583 Autoincrement and autodecrement addresses typically have 4584 mode-dependent effects because the amount of the increment or 4585 decrement is the size of the operand being addressed. Some 4586 machines have other mode-dependent addresses. Many RISC machines 4587 have no mode-dependent addresses. 4588 4589 You may assume that ADDR is a valid address for the machine. 4590 */ 4591 /* In Jvm, only the postincrement address mode depends thus, 4592 since the increment depends on the size of the operand. */ 4593 4594 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \ 4595 { if (GET_CODE (ADDR) == POST_INC) \ 4596 goto LABEL; } 4597 4598 4599 /* 4600 `LEGITIMATE_CONSTANT_P (X)' 4601 A C expression that is nonzero if X is a legitimate constant for 4602 an immediate operand on the target machine. You can assume that X 4603 satisfies `CONSTANT_P', so you need not check this. In fact, `1' 4604 is a suitable definition for this macro on machines where anything 4605 `CONSTANT_P' is valid. 4606 */ 4607 #define LEGITIMATE_CONSTANT_P(X) 1 4608 4609 4610 /* Section: Condition Code */ 4611 4612 /* 4613 `CC_STATUS_MDEP' 4614 C code for a data type which is used for declaring the `mdep' 4615 component of `cc_status'. It defaults to `int'. 4616 4617 This macro is not used on machines that do not use `cc0'. 4618 */ 4619 /* Not defined */ 4620 4621 4622 /* 4623 `CC_STATUS_MDEP_INIT' 4624 A C expression to initialize the `mdep' field to "empty". The 4625 default definition does nothing, since most machines don't use the 4626 field anyway. If you want to use the field, you should probably 4627 define this macro to initialize it. 4628 4629 This macro is not used on machines that do not use `cc0'. 4630 */ 4631 /* Not defined */ 4632 4633 4634 /* 4635 `NOTICE_UPDATE_CC (EXP, INSN)' 4636 A C compound statement to set the components of `cc_status' 4637 appropriately for an insn INSN whose body is EXP. It is this 4638 macro's responsibility to recognize insns that set the condition 4639 code as a byproduct of other activity as well as those that 4640 explicitly set `(cc0)'. 4641 4642 This macro is not used on machines that do not use `cc0'. 4643 4644 If there are insns that do not set the condition code but do alter 4645 other machine registers, this macro must check to see whether they 4646 invalidate the expressions that the condition code is recorded as 4647 reflecting. For example, on the 68000, insns that store in address 4648 registers do not set the condition code, which means that usually 4649 `NOTICE_UPDATE_CC' can leave `cc_status' unaltered for such insns. 4650 But suppose that the previous insn set the condition code based 4651 on location `a4@(102)' and the current insn stores a new value in 4652 `a4'. Although the condition code is not changed by this, it will 4653 no longer be true that it reflects the contents of `a4@(102)'. 4654 Therefore, `NOTICE_UPDATE_CC' must alter `cc_status' in this case 4655 to say that nothing is known about the condition code value. 4656 4657 The definition of `NOTICE_UPDATE_CC' must be prepared to deal with 4658 the results of peephole optimization: insns whose patterns are 4659 `parallel' RTXs containing various `reg', `mem' or constants which 4660 are just the operands. The RTL structure of these insns is not 4661 sufficient to indicate what the insns actually do. What 4662 `NOTICE_UPDATE_CC' should do when it sees one is just to run 4663 `CC_STATUS_INIT'. 4664 4665 A possible definition of `NOTICE_UPDATE_CC' is to call a function 4666 that looks at an attribute (*note Insn Attributes::.) named, for 4667 example, `cc'. This avoids having detailed information about 4668 patterns in two places, the `md' file and in `NOTICE_UPDATE_CC'. 4669 */ 4670 #define NOTICE_UPDATE_CC(EXP, INSN) notice_update_cc(EXP, INSN) 4671 4672 /* moved to protos.h extern void notice_update_cc(rtx, rtx); */ 4673 4674 4675 /* 4676 `EXTRA_CC_MODES' 4677 A list of names to be used for additional modes for condition code 4678 values in registers (*note Jump Patterns::.). These names are 4679 added to `enum machine_mode' and all have class `MODE_CC'. By 4680 convention, they should start with `CC' and end with `mode'. 4681 4682 You should only define this macro if your machine does not use 4683 `cc0' and only if additional modes are required. 4684 */ 4685 /* Not defined */ 4686 4687 4688 /* 4689 `EXTRA_CC_NAMES' 4690 A list of C strings giving the names for the modes listed in 4691 `EXTRA_CC_MODES'. For example, the Sparc defines this macro and 4692 `EXTRA_CC_MODES' as 4693 4694 #define EXTRA_CC_MODES CC_NOOVmode, CCFPmode, CCFPEmode 4695 #define EXTRA_CC_NAMES "CC_NOOV", "CCFP", "CCFPE" 4696 4697 This macro is not required if `EXTRA_CC_MODES' is not defined. 4698 */ 4699 /* Not defined */ 4700 4701 4702 /* 4703 `SELECT_CC_MODE (OP, X, Y)' 4704 Returns a mode from class `MODE_CC' to be used when comparison 4705 operation code OP is applied to rtx X and Y. For example, on the 4706 Sparc, `SELECT_CC_MODE' is defined as (see *note Jump Patterns::. 4707 for a description of the reason for this definition) 4708 4709 #define SELECT_CC_MODE(OP,X,Y) \ 4710 (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT \ 4711 ? ((OP == EQ || OP == NE) ? CCFPmode : CCFPEmode) \ 4712 : ((GET_CODE (X) == PLUS || GET_CODE (X) == MINUS \ 4713 || GET_CODE (X) == NEG) \ 4714 ? CC_NOOVmode : CCmode)) 4715 4716 You need not define this macro if `EXTRA_CC_MODES' is not defined. 4717 */ 4718 /* Not defined */ 4719 4720 4721 /* 4722 `CANONICALIZE_COMPARISON (CODE, OP0, OP1)' 4723 One some machines not all possible comparisons are defined, but 4724 you can convert an invalid comparison into a valid one. For 4725 example, the Alpha does not have a `GT' comparison, but you can 4726 use an `LT' comparison instead and swap the order of the operands. 4727 4728 On such machines, define this macro to be a C statement to do any 4729 required conversions. CODE is the initial comparison code and OP0 4730 and OP1 are the left and right operands of the comparison, 4731 respectively. You should modify CODE, OP0, and OP1 as required. 4732 4733 GNU CC will not assume that the comparison resulting from this 4734 macro is valid but will see if the resulting insn matches a 4735 pattern in the `md' file. 4736 4737 You need not define this macro if it would never change the 4738 comparison code or operands. 4739 */ 4740 /* Maybe define this later, when we play with optimizations. 4741 It is needed; currently we do this with instruction patterns and 4742 NOTICE_UPDATE_CC() */ 4743 4744 4745 /* 4746 `REVERSIBLE_CC_MODE (MODE)' 4747 A C expression whose value is one if it is always safe to reverse a 4748 comparison whose mode is MODE. If `SELECT_CC_MODE' can ever 4749 return MODE for a floating-point inequality comparison, then 4750 `REVERSIBLE_CC_MODE (MODE)' must be zero. 4751 4752 You need not define this macro if it would always returns zero or 4753 if the floating-point format is anything other than 4754 `IEEE_FLOAT_FORMAT'. For example, here is the definition used on 4755 the Sparc, where floating-point inequality comparisons are always 4756 given `CCFPEmode': 4757 4758 #define REVERSIBLE_CC_MODE(MODE) ((MODE) != CCFPEmode) 4759 */ 4760 /* Not defined */ 4761 4762 4763 /* Section: Costs */ 4764 4765 /* 4766 `CONST_COSTS (X, CODE, OUTER_CODE)' 4767 A part of a C `switch' statement that describes the relative costs 4768 of constant RTL expressions. It must contain `case' labels for 4769 expression codes `const_int', `const', `symbol_ref', `label_ref' 4770 and `const_double'. Each case must ultimately reach a `return' 4771 statement to return the relative cost of the use of that kind of 4772 constant value in an expression. The cost may depend on the 4773 precise value of the constant, which is available for examination 4774 in X, and the rtx code of the expression in which it is contained, 4775 found in OUTER_CODE. 4776 4777 CODE is the expression code--redundant, since it can be obtained 4778 with `GET_CODE (X)'. 4779 */ 4780 #define CONST_COSTS(RTX,CODE, OUTER_CODE) \ 4781 case CONST_INT: \ 4782 if (INTVAL(RTX) == 0) return 0; \ 4783 if (INTVAL (RTX) < 32 && INTVAL(RTX) >= -32) return 1; \ 4784 /* 8 or 16 bits */ \ 4785 if (INTVAL (RTX) <= 32767 && INTVAL (RTX) >= -32768) return 2; \ 4786 return 4; /* 32 bits (or very seldom, unsigned 16 bits) */ \ 4787 case CONST: \ 4788 case LABEL_REF: \ 4789 case SYMBOL_REF: \ 4790 return 6; \ 4791 case CONST_DOUBLE: \ 4792 if (RTX != CONST0_RTX(GET_MODE(RTX) == VOIDmode ? DImode : \ 4793 GET_MODE(RTX))) \ 4794 return 12; \ 4795 return 0; /* Make 0 cheap, else test-insns will not be used. */ 4796 4797 4798 /* 4799 `RTX_COSTS (X, CODE, OUTER_CODE)' 4800 Like `CONST_COSTS' but applies to nonconstant RTL expressions. 4801 This can be used, for example, to indicate how costly a multiply 4802 instruction is. In writing this macro, you can use the construct 4803 `COSTS_N_INSNS (N)' to specify a cost equal to N fast 4804 instructions. OUTER_CODE is the code of the expression in which X 4805 is contained. 4806 4807 This macro is optional; do not define it if the default cost 4808 assumptions are adequate for the target machine. 4809 */ 4810 /* In 2.1, 2.7.2 you may return rtx_cost(X) for operands. If you use 4811 a later version, check first that this is ok. Used in cse.c 4812 ONLY. (2.1, 2.7.2) */ 4813 #define RTX_COSTS(X,CODE, OUTER_CODE) \ 4814 case MULT: \ 4815 /* Identify values that are no powers of two. Powers of 2 */ \ 4816 /* are taken care of already. */ \ 4817 if (GET_CODE(XEXP(X,1)) != CONST_INT \ 4818 || exact_log2(INTVAL(XEXP(X,1)) < 0)) \ 4819 return COSTS_N_INSNS(132); /* Estimate as 4+4*#ofbits */ \ 4820 break; \ 4821 case UDIV: \ 4822 case MOD: \ 4823 case UMOD: \ 4824 case DIV: \ 4825 if (GET_CODE(XEXP(X,1)) != CONST_INT \ 4826 || exact_log2(INTVAL(XEXP(X,1)) < 0)) \ 4827 return COSTS_N_INSNS(260); /* Estimate as 4+8*#ofbits */ \ 4828 case AND: \ 4829 if (GET_CODE(XEXP(X,1)) == CONST_INT \ 4830 /* Two constants may actually happen before optimization */ \ 4831 && GET_CODE(XEXP(X,0)) != CONST_INT \ 4832 && !CONST_OK_FOR_LETTER_P(INTVAL(XEXP(X,1)),'I')) \ 4833 return rtx_cost(XEXP(X,0),SET) \ 4834 + 2 + 2*GET_MODE_NUNITS(GET_MODE(XEXP(X,0))); \ 4835 case ZERO_EXTEND: case SIGN_EXTEND: \ 4836 /* Same as move. If embedded in other insn, cost is 0. */ \ 4837 return rtx_cost(XEXP(X,0),SET); 4838 4839 4840 /* 4841 `ADDRESS_COST (ADDRESS)' 4842 An expression giving the cost of an addressing mode that contains 4843 ADDRESS. If not defined, the cost is computed from the ADDRESS 4844 expression and the `CONST_COSTS' values. 4845 4846 For most CISC machines, the default cost is a good approximation 4847 of the true cost of the addressing mode. However, on RISC 4848 machines, all instructions normally have the same length and 4849 execution time. Hence all addresses will have equal costs. 4850 4851 In cases where more than one form of an address is known, the form 4852 with the lowest cost will be used. If multiple forms have the 4853 same, lowest, cost, the one that is the most complex will be used. 4854 4855 For example, suppose an address that is equal to the sum of a 4856 register and a constant is used twice in the same basic block. 4857 When this macro is not defined, the address will be computed in a 4858 register and memory references will be indirect through that 4859 register. On machines where the cost of the addressing mode 4860 containing the sum is no higher than that of a simple indirect 4861 reference, this will produce an additional instruction and 4862 possibly require an additional register. Proper specification of 4863 this macro eliminates this overhead for such machines. 4864 4865 Similar use of this macro is made in strength reduction of loops. 4866 4867 ADDRESS need not be valid as an address. In such a case, the cost 4868 is not relevant and can be any value; invalid addresses need not be 4869 assigned a different cost. 4870 4871 On machines where an address involving more than one register is as 4872 cheap as an address computation involving only one register, 4873 defining `ADDRESS_COST' to reflect this can cause two registers to 4874 be live over a region of code where only one would have been if 4875 `ADDRESS_COST' were not defined in that manner. This effect should 4876 be considered in the definition of this macro. Equivalent costs 4877 should probably only be given to addresses with different numbers 4878 of registers on machines with lots of registers. 4879 4880 This macro will normally either not be defined or be defined as a 4881 constant. 4882 */ 4883 /* Not defined */ 4884 4885 4886 /* 4887 `REGISTER_MOVE_COST (FROM, TO)' 4888 A C expression for the cost of moving data from a register in class 4889 FROM to one in class TO. The classes are expressed using the 4890 enumeration values such as `GENERAL_REGS'. A value of 4 is the 4891 default; other values are interpreted relative to that. 4892 4893 It is not required that the cost always equal 2 when FROM is the 4894 same as TO; on some machines it is expensive to move between 4895 registers if they are not general registers. 4896 4897 If reload sees an insn consisting of a single `set' between two 4898 hard registers, and if `REGISTER_MOVE_COST' applied to their 4899 classes returns a value of 2, reload does not check to ensure that 4900 the constraints of the insn are met. Setting a cost of other than 4901 2 will allow reload to verify that the constraints are met. You 4902 should do this if the `movM' pattern's constraints do not allow 4903 such copying. 4904 */ 4905 /* Not defined */ 4906 4907 4908 /* 4909 `MEMORY_MOVE_COST (M)' 4910 A C expression for the cost of moving data of mode M between a 4911 register and memory. A value of 2 is the default; this cost is 4912 relative to those in `REGISTER_MOVE_COST'. 4913 4914 If moving between registers and memory is more expensive than 4915 between two registers, you should define this macro to express the 4916 relative cost. 4917 */ 4918 /* Not defined */ 4919 4920 4921 4922 /* 4923 `BRANCH_COST' 4924 A C expression for the cost of a branch instruction. A value of 1 4925 is the default; other values are interpreted relative to that. 4926 */ 4927 /* Since we get a delay slot to fill, a branch may be considered expensive. 4928 #define BRANCH_COST 3 4929 */ 4930 4931 /* 4932 `SLOW_BYTE_ACCESS' 4933 Define this macro as a C expression which is nonzero if accessing 4934 less than a word of memory (i.e. a `char' or a `short') is no 4935 faster than accessing a word of memory, i.e., if such access 4936 require more than one instruction or if there is no difference in 4937 cost between byte and (aligned) word loads. 4938 4939 When this macro is not defined, the compiler will access a field by 4940 finding the smallest containing object; when it is defined, a 4941 fullword load will be used if alignment permits. Unless bytes 4942 accesses are faster than word accesses, using word accesses is 4943 preferable since it may eliminate subsequent memory access if 4944 subsequent accesses occur to other fields in the same word of the 4945 structure, but to different bytes. 4946 */ 4947 #define SLOW_BYTE_ACCESS 0 4948 4949 4950 /* 4951 `SLOW_ZERO_EXTEND' 4952 Define this macro if zero-extension (of a `char' or `short' to an 4953 `int') can be done faster if the destination is a register that is 4954 known to be zero. 4955 4956 If you define this macro, you must have instruction patterns that 4957 recognize RTL structures like this: 4958 4959 (set (strict_low_part (subreg:QI (reg:SI ...) 0)) ...) 4960 4961 and likewise for `HImode'. 4962 */ 4963 /* Not defined */ 4964 4965 4966 /* 4967 `SLOW_UNALIGNED_ACCESS' 4968 Define this macro to be the value 1 if unaligned accesses have a 4969 cost many times greater than aligned accesses, for example if they 4970 are emulated in a trap handler. 4971 4972 When this macro is non-zero, the compiler will act as if 4973 `STRICT_ALIGNMENT' were non-zero when generating code for block 4974 moves. This can cause significantly more instructions to be 4975 produced. Therefore, do not set this macro non-zero if unaligned 4976 accesses only add a cycle or two to the time for a memory access. 4977 4978 If the value of this macro is always zero, it need not be defined. 4979 */ 4980 /* Not defined */ 4981 4982 4983 /* 4984 `DONT_REDUCE_ADDR' 4985 Define this macro to inhibit strength reduction of memory 4986 addresses. (On some machines, such strength reduction seems to do 4987 harm rather than good.) 4988 */ 4989 /* Not defined */ 4990 4991 4992 /* 4993 `MOVE_RATIO' 4994 The number of scalar move insns which should be generated instead 4995 of a string move insn or a library call. Increasing the value 4996 will always make code faster, but eventually incurs high cost in 4997 increased code size. 4998 4999 If you don't define this, a reasonable default is used. 5000 */ 5001 /* Must be something to make gcc refrain from using blkmove insns. 5002 Due to a bug in gcc, it cannot see that a machine lacks "move mem,mem" 5003 instructions. */ 5004 /* ??? Define if code breaks (not defined in 2.6.3) */ 5005 #if 0 5006 #define MOVE_RATIO -1 5007 #endif 5008 5009 5010 /* 5011 `NO_FUNCTION_CSE' 5012 Define this macro if it is as good or better to call a constant 5013 function address than to call an address kept in a register. 5014 */ 5015 /* Not defined */ 5016 5017 5018 /* 5019 `NO_RECURSIVE_FUNCTION_CSE' 5020 Define this macro if it is as good or better for a function to call 5021 itself with an explicit address than to call an address kept in a 5022 register. 5023 */ 5024 /* Not defined */ 5025 5026 5027 /* 5028 `ADJUST_COST (INSN, LINK, DEP_INSN, COST)' 5029 A C statement (sans semicolon) to update the integer variable COST 5030 based on the relationship between INSN that is dependent on 5031 DEP_INSN through the dependence LINK. The default is to make no 5032 adjustment to COST. This can be used for example to specify to 5033 the scheduler that an output- or anti-dependence does not incur 5034 the same cost as a data-dependence. 5035 */ 5036 /* Maybe define this later, when we play with optimizations. */ 5037 5038 5039 /* Section: Sections */ 5040 5041 /* 5042 `TEXT_SECTION_ASM_OP' 5043 A C expression whose value is a string containing the assembler 5044 operation that should precede instructions and read-only data. 5045 Normally `".text"' is right. 5046 */ 5047 #define TEXT_SECTION_ASM_OP "//\t.text" 5048 5049 5050 /* 5051 `DATA_SECTION_ASM_OP' 5052 A C expression whose value is a string containing the assembler 5053 operation to identify the following data as writable initialized 5054 data. Normally `".data"' is right. 5055 5056 */ 5057 #define DATA_SECTION_ASM_OP "//\t.data" 5058 5059 5060 /* 5061 `SHARED_SECTION_ASM_OP' 5062 if defined, a C expression whose value is a string containing the 5063 assembler operation to identify the following data as shared data. 5064 If not defined, `DATA_SECTION_ASM_OP' will be used. 5065 */ 5066 /* Not defined */ 5067 5068 5069 /* 5070 `INIT_SECTION_ASM_OP' 5071 if defined, a C expression whose value is a string containing the 5072 assembler operation to identify the following data as 5073 initialization code. If not defined, GNU CC will assume such a 5074 section does not exist. 5075 */ 5076 /* Not defined */ 5077 5078 5079 /* 5080 `EXTRA_SECTIONS' 5081 A list of names for sections other than the standard two, which are 5082 `in_text' and `in_data'. You need not define this macro on a 5083 system with no other sections (that GCC needs to use). 5084 */ 5085 /* Not defined */ 5086 5087 5088 /* 5089 `EXTRA_SECTION_FUNCTIONS' 5090 One or more functions to be defined in `varasm.c'. These 5091 functions should do jobs analogous to those of `text_section' and 5092 `data_section', for your additional sections. Do not define this 5093 macro if you do not define `EXTRA_SECTIONS'. 5094 */ 5095 /* Not defined */ 5096 5097 5098 /* 5099 `READONLY_DATA_SECTION' 5100 On most machines, read-only variables, constants, and jump tables 5101 are placed in the text section. If this is not the case on your 5102 machine, this macro should be defined to be the name of a function 5103 (either `data_section' or a function defined in `EXTRA_SECTIONS') 5104 that switches to the section to be used for read-only items. 5105 5106 If these items should be placed in the text section, this macro 5107 should not be defined. 5108 */ 5109 /*#define READONLY_DATA_SECTION data_section*/ 5110 /* Not defined */ 5111 5112 5113 /* 5114 `SELECT_SECTION (EXP, RELOC)' 5115 A C statement or statements to switch to the appropriate section 5116 for output of EXP. You can assume that EXP is either a `VAR_DECL' 5117 node or a constant of some sort. RELOC indicates whether the 5118 initial value of EXP requires link-time relocations. Select the 5119 section by calling `text_section' or one of the alternatives for 5120 other sections. 5121 5122 Do not define this macro if you put all read-only variables and 5123 constants in the read-only data section (usually the text section). 5124 */ 5125 /*#define SELECT_SECTION(EXP, RELOC) data_section()*/ 5126 /* Not defined */ 5127 5128 5129 /* 5130 `SELECT_RTX_SECTION (MODE, RTX)' 5131 A C statement or statements to switch to the appropriate section 5132 for output of RTX in mode MODE. You can assume that RTX is some 5133 kind of constant in RTL. The argument MODE is redundant except in 5134 the case of a `const_int' rtx. Select the section by calling 5135 `text_section' or one of the alternatives for other sections. 5136 5137 Do not define this macro if you put all constants in the read-only 5138 data section. 5139 */ 5140 /* Not defined */ 5141 5142 5143 /* This was an attempt to deal with case statements.. real pain on JVM 5144 - tw */ 5145 #undef HAVE_tablejump 5146 5147 5148 /* 5149 `JUMP_TABLES_IN_TEXT_SECTION' 5150 Define this macro if jump tables (for `tablejump' insns) should be 5151 output in the text section, along with the assembler instructions. 5152 Otherwise, the readonly data section is used. 5153 5154 This macro is irrelevant if there is no separate readonly data 5155 section. 5156 */ 5157 /* Not defined */ 5158 5159 5160 /* 5161 `ENCODE_SECTION_INFO (DECL)' 5162 Define this macro if references to a symbol must be treated 5163 differently depending on something about the variable or function 5164 named by the symbol (such as what section it is in). 5165 5166 The macro definition, if any, is executed immediately after the 5167 rtl for DECL has been created and stored in `DECL_RTL (DECL)'. 5168 The value of the rtl will be a `mem' whose address is a 5169 `symbol_ref'. 5170 5171 The usual thing for this macro to do is to record a flag in the 5172 `symbol_ref' (such as `SYMBOL_REF_FLAG') or to store a modified 5173 name string in the `symbol_ref' (if one bit is not enough 5174 information). 5175 */ 5176 /* Not defined */ 5177 5178 /* 5179 `STRIP_NAME_ENCODING (VAR, SYM_NAME)' 5180 Decode SYM_NAME and store the real name part in VAR, sans the 5181 characters that encode section info. Define this macro if 5182 `ENCODE_SECTION_INFO' alters the symbol's name string. 5183 */ 5184 /* Unused-string-removal support for the JVM port (not in gcc-2.7.2) 5185 handled here. No real name un-encoding done. Name changed to "0" 5186 (the local multiple-definable macro) if string should not be 5187 output. Default stripping done ('*' removed). 5188 Do not inhibit string output in *uses* of the label, only when the 5189 label (and the string) is to be output. */ 5190 /* Not defined */ 5191 5192 /* Section: PIC */ 5193 /* (no definitions) */ 5194 5195 /* Section: Assembler Format::File Framework */ 5196 5197 /* 5198 `ASM_FILE_START (STREAM)' 5199 A C expression which outputs to the stdio stream STREAM some 5200 appropriate text to go at the start of an assembler file. 5201 5202 Normally this macro is defined to output a line containing 5203 `#NO_APP', which is a comment that has no effect on most 5204 assemblers but tells the GNU assembler that it can save time by not 5205 checking for certain assembler constructs. 5206 5207 On systems that use SDB, it is necessary to output certain 5208 commands; see `attasm.h'. 5209 */ 5210 /* 5211 NO_APP means faster assembly. 5212 It also means comments are not allowed. 5213 In some cases comments will be output for debugging purposes. 5214 Make sure they are allowed then. */ 5215 #define ASM_FILE_START(FILE) \ 5216 fprintf(FILE, "// gcc .net generated il asm code\n\n") 5217 5218 /* 5219 `ASM_FILE_END (STREAM)' 5220 A C expression which outputs to the stdio stream STREAM some 5221 appropriate text to go at the end of an assembler file. 5222 5223 If this macro is not defined, the default is to output nothing 5224 special at the end of the file. Most systems don't require any 5225 definition. 5226 5227 On systems that use SDB, it is necessary to output certain 5228 commands; see `attasm.h'. 5229 */ 5230 /* Unused-string-removal support for the JVM port (not in gcc-2.7.2) 5231 Strings output here. */ 5232 /* Not defined */ 5233 5234 /* 5235 `ASM_IDENTIFY_GCC (FILE)' 5236 A C statement to output assembler commands which will identify the 5237 object file as having been compiled with GNU CC (or another GNU 5238 compiler). 5239 5240 If you don't define this macro, the string `gcc_compiled.:' is 5241 output. This string is calculated to define a symbol which, on 5242 BSD systems, will never be defined for any other reason. GDB 5243 checks for the presence of this symbol when reading the symbol 5244 table of an executable. 5245 5246 On non-BSD systems, you must arrange communication with GDB in 5247 some other fashion. If GDB is not used on your system, you can 5248 define this macro with an empty body. 5249 */ 5250 #define ASM_IDENTIFY_GCC(FILE) ; 5251 /* Not defined */ 5252 5253 5254 /* 5255 `ASM_COMMENT_START' 5256 A C string constant describing how to begin a comment in the target 5257 assembler language. The compiler assumes that the comment will 5258 end at the end of the line. 5259 */ 5260 /* Not defined */ 5261 5262 5263 /* 5264 `ASM_APP_ON' 5265 A C string constant for text to be output before each `asm' 5266 statement or group of consecutive ones. Normally this is 5267 `"#APP"', which is a comment that has no effect on most assemblers 5268 but tells the GNU assembler that it must check the lines that 5269 follow for all valid assembler constructs. 5270 */ 5271 #define ASM_APP_ON "#APP\n" 5272 5273 5274 /* 5275 `ASM_APP_OFF' 5276 A C string constant for text to be output after each `asm' 5277 statement or group of consecutive ones. Normally this is 5278 `"#NO_APP"', which tells the GNU assembler to resume making the 5279 time-saving assumptions that are valid for ordinary compiler 5280 output. 5281 */ 5282 #define ASM_APP_OFF "" 5283 /*"#NO_APP\n"*/ 5284 5285 5286 /* 5287 `ASM_OUTPUT_SOURCE_FILENAME (STREAM, NAME)' 5288 A C statement to output COFF information or DWARF debugging 5289 information which indicates that filename NAME is the current 5290 source file to the stdio stream STREAM. 5291 5292 This macro need not be defined if the standard form of output for 5293 the file format in use is appropriate. 5294 */ 5295 /* Not defined */ 5296 5297 5298 /* 5299 `ASM_OUTPUT_SOURCE_LINE (STREAM, LINE)' 5300 A C statement to output DBX or SDB debugging information before 5301 code for line number LINE of the current source file to the stdio 5302 stream STREAM. 5303 5304 This macro need not be defined if the standard form of debugging 5305 information for the debugger in use is appropriate. 5306 */ 5307 /* Not defined */ 5308 5309 5310 /* 5311 `ASM_OUTPUT_IDENT (STREAM, STRING)' 5312 A C statement to output something to the assembler file to handle a 5313 `#ident' directive containing the text STRING. If this macro is 5314 not defined, nothing is output for a `#ident' directive. 5315 */ 5316 /* Not defined */ 5317 5318 5319 /* 5320 `ASM_OUTPUT_SECTION_NAME (STREAM, DECL, NAME)' 5321 A C statement to output something to the assembler file to switch 5322 to section NAME for object DECL which is either a `FUNCTION_DECL', 5323 a `VAR_DECL' or `NULL_TREE'. Some target formats do not support 5324 arbitrary sections. Do not define this macro in such cases. 5325 5326 At present this macro is only used to support section attributes. 5327 When this macro is undefined, section attributes are disabled. 5328 */ 5329 /* Not defined */ 5330 5331 5332 /* 5333 `OBJC_PROLOGUE' 5334 A C statement to output any assembler statements which are 5335 required to precede any Objective C object definitions or message 5336 sending. The statement is executed only when compiling an 5337 Objective C program. 5338 */ 5339 /* Not defined */ 5340 5341 5342 /* Section: Assembler Format::Data Output */ 5343 5344 /* 5345 `ASM_OUTPUT_LONG_DOUBLE (STREAM, VALUE)' 5346 `ASM_OUTPUT_DOUBLE (STREAM, VALUE)' 5347 `ASM_OUTPUT_FLOAT (STREAM, VALUE)' 5348 `ASM_OUTPUT_THREE_QUARTER_FLOAT (STREAM, VALUE)' 5349 `ASM_OUTPUT_SHORT_FLOAT (STREAM, VALUE)' 5350 `ASM_OUTPUT_BYTE_FLOAT (STREAM, VALUE)' 5351 A C statement to output to the stdio stream STREAM an assembler 5352 instruction to assemble a floating-point constant of `TFmode', 5353 `DFmode', `SFmode', `TQFmode', `HFmode', or `QFmode', 5354 respectively, whose value is VALUE. VALUE will be a C expression 5355 of type `REAL_VALUE_TYPE'. Macros such as 5356 `REAL_VALUE_TO_TARGET_DOUBLE' are useful for writing these 5357 definitions. 5358 */ 5359 /* 5360 * The GNU assembler, which we use, really should behave when doing 5361 * float numbers. Unfortunalely it seems broken. 5362 * There does not seem to be any use in fixing it, since 5363 * printing/parsing a float is much more expensize (takes time) than 5364 * to print/parse a hexnumber. We may have to do it anyway, if we use 5365 * a host that does not have IEEE floating point. 5366 */ 5367 5368 /* Note: Floats have _not_ been implimented - tw */ /* Hurrah! I'm not going 5369 * to bother either! 5370 */ 5371 5372 #ifndef JVM_FLOAT_NOT_BROKEN_ANY_MORE 5373 5374 # define ASM_OUTPUT_DOUBLE(FILE,VALUE) \ 5375 do { union { float f; long l;} tem; \ 5376 tem.f = (VALUE); \ 5377 fprintf (FILE, "\t.uaword 0x%x ; BOGUS double?\n", tem.l); \ 5378 } while (0) 5379 5380 # define ASM_OUTPUT_FLOAT(FILE,VALUE) \ 5381 do { union { float f; long l;} tem; \ 5382 tem.f = (VALUE); \ 5383 fprintf (FILE, "\t.dword 0x%x\n", tem.l); \ 5384 } while (0) 5385 5386 #else /* i.e. ! JVM_FLOAT_BROKEN... */ 5387 5388 # define ASM_OUTPUT_DOUBLE(FILE,VALUE) \ 5389 fprintf (FILE, "\t.float 0s%.10g ; BOGUS double?\n", (VALUE)) 5390 5391 # define ASM_OUTPUT_FLOAT(FILE,VALUE) \ 5392 fprintf (FILE, "\t.float 0s%.10g\n", (VALUE)) 5393 5394 #endif /* JVM_FLOAT_NOT_BROKEN_ANY_MORE */ 5395 5396 /* The oters are not deined, since they are not used. */ 5397 5398 5399 /* 5400 `ASM_OUTPUT_QUADRUPLE_INT (STREAM, EXP)' 5401 `ASM_OUTPUT_DOUBLE_INT (STREAM, EXP)' 5402 `ASM_OUTPUT_INT (STREAM, EXP)' 5403 `ASM_OUTPUT_SHORT (STREAM, EXP)' 5404 `ASM_OUTPUT_CHAR (STREAM, EXP)' 5405 A C statement to output to the stdio stream STREAM an assembler 5406 instruction to assemble an integer of 16, 8, 4, 2 or 1 bytes, 5407 respectively, whose value is VALUE. The argument EXP will be an 5408 RTL expression which represents a constant value. Use 5409 `output_addr_const (STREAM, EXP)' to output this value as an 5410 assembler expression. 5411 5412 For sizes larger than `UNITS_PER_WORD', if the action of a macro 5413 would be identical to repeatedly calling the macro corresponding to 5414 a size of `UNITS_PER_WORD', once for each word, you need not define 5415 the macro. 5416 */ 5417 5418 /* Very important. When we are compiling C programs with global data the 5419 data definitions do not go into the jasmin file. The definitions are 5420 dumped into a "global.s" file which is linked during the build process 5421 to an object file and then objdump'd to resolve symbol references to 5422 integers. The object file is then objcopy'd and loaded into memory at 5423 run time. - tw */ 5424 extern FILE *datasection; 5425 5426 /* output the integer to the global.s file, regardless of what FILE is. 5427 All references to symbols are preceded with "symref" and proceded with 5428 "end" to make them easy to find in the jasmin output. - tw 5429 */ 5430 /* jds31 - undo all of tw's work - get back to simple data sections */ 5431 5432 #define ASM_OUTPUT_INT(FILE,VALUE) \ 5433 fprintf(FILE, "\t.int32 "); \ 5434 output_addr_const(FILE, VALUE); \ 5435 fprintf(FILE, "\n") 5436 5437 /* 5438 #define ASM_OUTPUT_INT(FILE,VALUE) \ 5439 ( (my_string_label_referenced = 1), \ 5440 setup_datasection_now(), \ 5441 fprintf (datasection, "\t.uaword "), \ 5442 output_addr_const (datasection, (VALUE)), \ 5443 (my_string_label_referenced = 0), \ 5444 fprintf (datasection, "\n")) 5445 */ 5446 5447 #define ASM_OUTPUT_SHORT(FILE,VALUE) \ 5448 fprintf(FILE, "<SHORT OUTPUT - %d>", VALUE); 5449 5450 #define ASM_OUTPUT_CHAR(FILE,VALUE) \ 5451 fprintf(FILE, "<CHAR OUTPUT - %d>", VALUE); 5452 5453 5454 /* 5455 `ASM_OUTPUT_BYTE (STREAM, VALUE)' 5456 A C statement to output to the stdio stream STREAM an assembler 5457 instruction to assemble a single byte containing the number VALUE. 5458 */ 5459 #define ASM_OUTPUT_BYTE(FILE,VALUE) \ 5460 fprintf (FILE, "\t.byte 0x%x\n", (VALUE)) 5461 5462 /* 5463 `ASM_BYTE_OP' 5464 A C string constant giving the pseudo-op to use for a sequence of 5465 single-byte constants. If this macro is not defined, the default 5466 is `"byte"'. 5467 */ 5468 /* Not defined */ 5469 5470 5471 /* 5472 `ASM_OUTPUT_ASCII (STREAM, PTR, LEN)' 5473 A C statement to output to the stdio stream STREAM an assembler 5474 instruction to assemble a string constant containing the LEN bytes 5475 at PTR. PTR will be a C expression of type `char *' and LEN a C 5476 expression of type `int'. 5477 5478 If the assembler has a `.ascii' pseudo-op as found in the Berkeley 5479 Unix assembler, do not define the macro `ASM_OUTPUT_ASCII'. 5480 */ 5481 /* Used to defer output of local constant strings until we know they 5482 are used. The rest is copied from the defaults.h in gcc 2.7.2 */ 5483 /*#define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) { \ 5484 data_section(); \ 5485 fprintf(MYFILE,".ascii \"%s\"\n",MYSTRING); \ 5486 }*/ 5487 /* Not defined */ 5488 5489 /* 5490 `ASM_OUTPUT_POOL_PROLOGUE (FILE FUNNAME FUNDECL SIZE)' 5491 A C statement to output assembler commands to define the start of 5492 the constant pool for a function. FUNNAME is a string giving the 5493 name of the function. Should the return type of the function be 5494 required, it can be obtained via FUNDECL. SIZE is the size, in 5495 bytes, of the constant pool that will be written immediately after 5496 this call. 5497 5498 If no constant-pool prefix is required, the usual case, this macro 5499 need not be defined. 5500 */ 5501 /* 2.6.3 (and 2.7.2) has some bug causing it to create a constant pool 5502 when failing to match certain operand constraints. This is a way to 5503 assert that our fix is valid. */ 5504 #define ASM_OUTPUT_POOL_PROLOGUE(FILE, FUNNAME, FUNDECL, SIZE) \ 5505 do \ 5506 { \ 5507 if (current_function_uses_const_pool) \ 5508 { \ 5509 fprintf(stderr, "FATAL! %s ``%s''\n", \ 5510 "Constant pool unsupported; used in function",\ 5511 FUNNAME); \ 5512 abort(); \ 5513 } \ 5514 } \ 5515 while (0) 5516 5517 /* 5518 `ASM_OUTPUT_SPECIAL_POOL_ENTRY (FILE, X, MODE, ALIGN, LABELNO, JUMPTO)' 5519 A C statement (with or without semicolon) to output a constant in 5520 the constant pool, if it needs special treatment. (This macro 5521 need not do anything for RTL expressions that can be output 5522 normally.) 5523 5524 The argument FILE is the standard I/O stream to output the 5525 assembler code on. X is the RTL expression for the constant to 5526 output, and MODE is the machine mode (in case X is a `const_int'). 5527 ALIGN is the required alignment for the value X; you should 5528 output an assembler directive to force this much alignment. 5529 5530 The argument LABELNO is a number to use in an internal label for 5531 the address of this pool entry. The definition of this macro is 5532 responsible for outputting the label definition at the proper 5533 place. Here is how to do this: 5534 5535 ASM_OUTPUT_INTERNAL_LABEL (FILE, "LC", LABELNO); 5536 5537 When you output a pool entry specially, you should end with a 5538 `goto' to the label JUMPTO. This will prevent the same pool entry 5539 from being output a second time in the usual manner. 5540 5541 You need not define this macro if it would do nothing. 5542 */ 5543 /* Not defined */ 5544 5545 5546 /* 5547 `IS_ASM_LOGICAL_LINE_SEPARATOR (C)' 5548 Define this macro as a C expression which is nonzero if C is used 5549 as a logical line separator by the assembler. 5550 5551 If you do not define this macro, the default is that only the 5552 character `;' is treated as a logical line separator. 5553 */ 5554 /* Not defined */ 5555 5556 5557 /* 5558 `ASM_OPEN_PAREN' 5559 `ASM_CLOSE_PAREN' 5560 These macros are defined as C string constant, describing the 5561 syntax in the assembler for grouping arithmetic expressions. The 5562 following definitions are correct for most assemblers: 5563 5564 #define ASM_OPEN_PAREN "(" 5565 #define ASM_CLOSE_PAREN ")" 5566 */ 5567 #define ASM_OPEN_PAREN "(" 5568 #define ASM_CLOSE_PAREN ")" 5569 5570 5571 /* 5572 `REAL_VALUE_TO_TARGET_SINGLE (X, L)' 5573 `REAL_VALUE_TO_TARGET_DOUBLE (X, L)' 5574 `REAL_VALUE_TO_TARGET_LONG_DOUBLE (X, L)' 5575 These translate X, of type `REAL_VALUE_TYPE', to the target's 5576 floating point representation, and store its bit pattern in the 5577 array of `long int' whose address is L. The number of elements in 5578 the output array is determined by the size of the desired target 5579 floating point data type: 32 bits of it go in each `long int' array 5580 element. Each array element holds 32 bits of the result, even if 5581 `long int' is wider than 32 bits on the host machine. 5582 5583 The array element values are designed so that you can print them 5584 out using `fprintf' in the order they should appear in the target 5585 machine's memory. 5586 */ 5587 /* Not defined */ 5588 5589 5590 /* 5591 `REAL_VALUE_TO_DECIMAL (X, FORMAT, STRING)' 5592 This macro converts X, of type `REAL_VALUE_TYPE', to a decimal 5593 number and stores it as a string into STRING. You must pass, as 5594 STRING, the address of a long enough block of space to hold the 5595 result. 5596 5597 The argument FORMAT is a `printf'-specification that serves as a 5598 suggestion for how to format the output string. 5599 */ 5600 /* Not defined */ 5601 5602 5603 /* Section: Assembler Format::Uninitialized Data */ 5604 5605 /* 5606 `ASM_OUTPUT_COMMON (STREAM, NAME, SIZE, ROUNDED)' 5607 A C statement (sans semicolon) to output to the stdio stream 5608 STREAM the assembler definition of a common-label named NAME whose 5609 size is SIZE bytes. The variable ROUNDED is the size rounded up 5610 to whatever alignment the caller wants. 5611 5612 Use the expression `assemble_name (STREAM, NAME)' to output the 5613 name itself; before and after that, output the additional 5614 assembler syntax for defining the name, and a newline. 5615 5616 This macro controls how the assembler definitions of uninitialized 5617 global variables are output. 5618 */ 5619 #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \ 5620 ( fputs ("\t.field public static valuetype vt_", (FILE)), \ 5621 assemble_name ((FILE), (NAME)), \ 5622 fputs(" ", (FILE)), \ 5623 assemble_name((FILE), (NAME)), \ 5624 fputs (" at d_", (FILE)), \ 5625 assemble_name ((FILE), (NAME)), \ 5626 fputs("\n\t.data d_", (FILE)), \ 5627 assemble_name ((FILE), (NAME)), \ 5628 fprintf((FILE), " = int32(0)[%d]\n", \ 5629 (TARGET_DATA_ALIGN ? ((ROUNDED)+1)&~1 : (ROUNDED))/4), \ 5630 fputs("\t.class public explicit sealed serializable ansi vt_", (FILE)), \ 5631 assemble_name ((FILE), (NAME)), \ 5632 fputs(" extends [mscorlib]System.ValueType\n", (FILE)), \ 5633 fputs("\t{\n", (FILE)), \ 5634 fputs("\t\t.pack 4\n", (FILE)), \ 5635 fprintf((FILE), "\t\t.size %d\n", \ 5636 (TARGET_DATA_ALIGN ? ((ROUNDED)+1)&~1 : (ROUNDED))), \ 5637 fputs("\t\t.field [0] public specialname int32 elem__\n", (FILE)), \ 5638 fputs("\t}\n\n", (FILE))) 5639 5640 5641 /* 5642 `ASM_OUTPUT_ALIGNED_COMMON (STREAM, NAME, SIZE, ALIGNMENT)' 5643 Like `ASM_OUTPUT_COMMON' except takes the required alignment as a 5644 separate, explicit argument. If you define this macro, it is used 5645 in place of `ASM_OUTPUT_COMMON', and gives you more flexibility in 5646 handling the required alignment of the variable. The alignment is 5647 specified as the number of bits. 5648 */ 5649 /* Not defined */ 5650 5651 5652 /* 5653 `ASM_OUTPUT_SHARED_COMMON (STREAM, NAME, SIZE, ROUNDED)' 5654 If defined, it is similar to `ASM_OUTPUT_COMMON', except that it 5655 is used when NAME is shared. If not defined, `ASM_OUTPUT_COMMON' 5656 will be used. 5657 */ 5658 /* Not defined */ 5659 5660 5661 /* 5662 `ASM_OUTPUT_LOCAL (STREAM, NAME, SIZE, ROUNDED)' 5663 A C statement (sans semicolon) to output to the stdio stream 5664 STREAM the assembler definition of a local-common-label named NAME 5665 whose size is SIZE bytes. The variable ROUNDED is the size 5666 rounded up to whatever alignment the caller wants. 5667 5668 Use the expression `assemble_name (STREAM, NAME)' to output the 5669 name itself; before and after that, output the additional 5670 assembler syntax for defining the name, and a newline. 5671 5672 This macro controls how the assembler definitions of uninitialized 5673 static variables are output. 5674 */ 5675 /* jds31 - we can get away with making these the same (local and 5676 * common, on the CLR. 5677 */ 5678 #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \ 5679 ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) 5680 5681 /* 5682 `ASM_OUTPUT_ALIGNED_LOCAL (STREAM, NAME, SIZE, ALIGNMENT)' 5683 Like `ASM_OUTPUT_LOCAL' except takes the required alignment as a 5684 separate, explicit argument. If you define this macro, it is used 5685 in place of `ASM_OUTPUT_LOCAL', and gives you more flexibility in 5686 handling the required alignment of the variable. The alignment is 5687 specified as the number of bits. 5688 */ 5689 /* Not defined */ 5690 5691 5692 /* 5693 `ASM_OUTPUT_SHARED_LOCAL (STREAM, NAME, SIZE, ROUNDED)' 5694 If defined, it is similar to `ASM_OUTPUT_LOCAL', except that it is 5695 used when NAME is shared. If not defined, `ASM_OUTPUT_LOCAL' will 5696 be used. 5697 */ 5698 /* Not defined */ 5699 5700 5701 /* Section: Assembler Format::Label Output */ 5702 5703 /* 5704 `ASM_OUTPUT_LABEL (STREAM, NAME)' 5705 A C statement (sans semicolon) to output to the stdio stream 5706 STREAM the assembler definition of a label named NAME. Use the 5707 expression `assemble_name (STREAM, NAME)' to output the name 5708 itself; before and after that, output the additional assembler 5709 syntax for defining the name, and a newline. 5710 */ 5711 #define ASM_OUTPUT_LABEL(FILE,NAME) \ 5712 assemble_name(FILE, NAME); \ 5713 fprintf(FILE, ":\n") 5714 5715 5716 /* 5717 `ASM_DECLARE_FUNCTION_NAME (STREAM, NAME, DECL)' 5718 A C statement (sans semicolon) to output to the stdio stream 5719 STREAM any text necessary for declaring the name NAME of a 5720 function which is being defined. This macro is responsible for 5721 outputting the label definition (perhaps using 5722 `ASM_OUTPUT_LABEL'). The argument DECL is the `FUNCTION_DECL' 5723 tree node representing the function. 5724 5725 If this macro is not defined, then the function name is defined in 5726 the usual manner as a label (by means of `ASM_OUTPUT_LABEL'). 5727 */ 5728 /* It seems like this is the only valid place to get the name of the current 5729 function; current_function_name is not valid during assembly output. */ 5730 #define ASM_DECLARE_FUNCTION_NAME(STREAM, NAME, DECL) \ 5731 fprintf(STREAM, "// <function decl - %s>\n.method public static int32 %s(", NAME, NAME) 5732 5733 5734 /* 5735 `ASM_DECLARE_FUNCTION_SIZE (STREAM, NAME, DECL)' 5736 A C statement (sans semicolon) to output to the stdio stream 5737 STREAM any text necessary for declaring the size of a function 5738 which is being defined. The argument NAME is the name of the 5739 function. The argument DECL is the `FUNCTION_DECL' tree node 5740 representing the function. 5741 5742 If this macro is not defined, then the function size is not 5743 defined. 5744 */ 5745 /* Not defined */ 5746 5747 5748 /* 5749 `ASM_DECLARE_OBJECT_NAME (STREAM, NAME, DECL)' 5750 A C statement (sans semicolon) to output to the stdio stream 5751 STREAM any text necessary for declaring the name NAME of an 5752 initialized variable which is being defined. This macro must 5753 output the label definition (perhaps using `ASM_OUTPUT_LABEL'). 5754 The argument DECL is the `VAR_DECL' tree node representing the 5755 variable. 5756 5757 If this macro is not defined, then the variable name is defined in 5758 the usual manner as a label (by means of `ASM_OUTPUT_LABEL'). 5759 */ 5760 /* Not defined */ 5761 5762 5763 /* 5764 `ASM_FINISH_DECLARE_OBJECT (STREAM, DECL, TOPLEVEL, ATEND)' 5765 A C statement (sans semicolon) to finish up declaring a variable 5766 name once the compiler has processed its initializer fully and 5767 thus has had a chance to determine the size of an array when 5768 controlled by an initializer. This is used on systems where it's 5769 necessary to declare something about the size of the object. 5770 5771 If you don't define this macro, that is equivalent to defining it 5772 to do nothing. 5773 */ 5774 /* Not defined */ 5775 5776 5777 /* 5778 `ASM_GLOBALIZE_LABEL (STREAM, NAME)' 5779 A C statement (sans semicolon) to output to the stdio stream 5780 STREAM some commands that will make the label NAME global; that 5781 is, available for reference from other files. Use the expression 5782 `assemble_name (STREAM, NAME)' to output the name itself; before 5783 and after that, output the additional assembler syntax for making 5784 that name global, and a newline. 5785 */ 5786 #define ASM_GLOBALIZE_LABEL(FILE,NAME) ; 5787 /* do { fputs ("\t.global ", FILE); assemble_name (FILE, NAME); \ 5788 fputs ("\n", FILE);} while (0)*/ 5789 5790 5791 /* 5792 `ASM_WEAKEN_LABEL' 5793 A C statement (sans semicolon) to output to the stdio stream 5794 STREAM some commands that will make the label NAME weak; that is, 5795 available for reference from other files but only used if no other 5796 definition is available. Use the expression `assemble_name 5797 (STREAM, NAME)' to output the name itself; before and after that, 5798 output the additional assembler syntax for making that name weak, 5799 and a newline. 5800 5801 If you don't define this macro, GNU CC will not support weak 5802 symbols and you should not define the `SUPPORTS_WEAK' macro. 5803 */ 5804 /* Not defined */ 5805 5806 5807 /* 5808 `SUPPORTS_WEAK' 5809 A C expression which evaluates to true if the target supports weak 5810 symbols. 5811 5812 If you don't define this macro, `defaults.h' provides a default 5813 definition. If `ASM_WEAKEN_LABEL' is defined, the default 5814 definition is `1'; otherwise, it is `0'. Define this macro if you 5815 want to control weak symbol support with a compiler flag such as 5816 `-melf'. 5817 */ 5818 /* Not defined */ 5819 5820 5821 /* 5822 `ASM_OUTPUT_EXTERNAL (STREAM, DECL, NAME)' 5823 A C statement (sans semicolon) to output to the stdio stream 5824 STREAM any text necessary for declaring the name of an external 5825 symbol named NAME which is referenced in this compilation but not 5826 defined. The value of DECL is the tree node for the declaration. 5827 5828 This macro need not be defined if it does not need to output 5829 anything. The GNU assembler and most Unix assemblers don't 5830 require anything. 5831 */ 5832 /* Not defined */ 5833 5834 5835 /* 5836 `ASM_OUTPUT_EXTERNAL_LIBCALL (STREAM, SYMREF)' 5837 A C statement (sans semicolon) to output on STREAM an assembler 5838 pseudo-op to declare a library function name external. The name 5839 of the library function is given by SYMREF, which has type `rtx' 5840 and is a `symbol_ref'. 5841 5842 This macro need not be defined if it does not need to output 5843 anything. The GNU assembler and most Unix assemblers don't 5844 require anything. 5845 */ 5846 /* Not defined */ 5847 5848 5849 /* 5850 `ASM_OUTPUT_LABELREF (STREAM, NAME)' 5851 A C statement (sans semicolon) to output to the stdio stream 5852 STREAM a reference in assembler syntax to a label named NAME. 5853 This should add `_' to the front of the name, if that is customary 5854 on your operating system, as it is in most Berkeley Unix systems. 5855 This macro is used in `assemble_name'. 5856 */ 5857 /* jds31 - on CLR, we don't want a leading _ */ 5858 /* #define ASM_OUTPUT_LABELREF(FILE,NAME) \ 5859 fprintf (FILE, "_%s", NAME) 5860 */ 5861 #define ASM_OUTPUT_LABELREF(FILE,NAME) \ 5862 fprintf (FILE, "%s", NAME) 5863 5864 5865 /* 5866 `ASM_OUTPUT_INTERNAL_LABEL (STREAM, PREFIX, NUM)' 5867 A C statement to output to the stdio stream STREAM a label whose 5868 name is made from the string PREFIX and the number NUM. 5869 5870 It is absolutely essential that these labels be distinct from the 5871 labels used for user-level functions and variables. Otherwise, 5872 certain programs will have name conflicts with internal labels. 5873 5874 It is desirable to exclude internal labels from the symbol table 5875 of the object file. Most assemblers have a naming convention for 5876 labels that should be excluded; on many systems, the letter `L' at 5877 the beginning of a label has this effect. You should find out what 5878 convention your system uses, and follow it. 5879 5880 The usual definition of this macro is as follows: 5881 5882 fprintf (STREAM, "L%s%d:\n", PREFIX, NUM) 5883 */ 5884 /* Unused-string-removal support for the JVM port (not in gcc-2.7.2) 5885 Do not output the label if it is in the list. All strings *seem* to 5886 be defined before used, so if this label is *not* in the table, 5887 then no string has been defined (it might be a struct or vector). */ 5888 #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \ 5889 fprintf (FILE, "%s%d:\n", PREFIX, NUM) 5890 5891 /*#define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \ 5892 do \ 5893 { int _num = (NUM); char *_prefix = (PREFIX); \ 5894 data_section(); \ 5895 if (!TARGET_USED_STRINGS \ 5896 || _prefix[0] != 'L' || _prefix[1] != 'C' || _prefix[2] != 0 \ 5897 || !my_deferred_string_added(_num,NULL,0,0,0)) \ 5898 fprintf (FILE, "%s%d:\n", _prefix, _num); \ 5899 else \ 5900 { \ 5901 my_deferred_string_added(_num,NULL,0,0,1); \ 5902 my_inhibit_stringout = 1; \ 5903 if (TARGET_PDEBUG || flag_print_asm_name) \ 5904 fprintf (FILE, "; Not outputting %s%d:\n", _prefix, _num); \ 5905 } \ 5906 } while (0) 5907 */ 5908 5909 /* 5910 `ASM_GENERATE_INTERNAL_LABEL (STRING, PREFIX, NUM)' 5911 A C statement to store into the string STRING a label whose name 5912 is made from the string PREFIX and the number NUM. 5913 5914 This string, when output subsequently by `assemble_name', should 5915 produce the output that `ASM_OUTPUT_INTERNAL_LABEL' would produce 5916 with the same PREFIX and NUM. 5917 5918 If the string begins with `*', then `assemble_name' will output 5919 the rest of the string unchanged. It is often convenient for 5920 `ASM_GENERATE_INTERNAL_LABEL' to use `*' in this way. If the 5921 string doesn't start with `*', then `ASM_OUTPUT_LABELREF' gets to 5922 output the string, and may change it. (Of course, 5923 `ASM_OUTPUT_LABELREF' is also part of your machine description, so 5924 you should know what it does on your machine.) 5925 */ 5926 #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \ 5927 sprintf (LABEL, "*%s%d", PREFIX, NUM) 5928 5929 5930 /* 5931 `ASM_FORMAT_PRIVATE_NAME (OUTVAR, NAME, NUMBER)' 5932 A C expression to assign to OUTVAR (which is a variable of type 5933 `char *') a newly allocated string made from the string NAME and 5934 the number NUMBER, with some suitable punctuation added. Use 5935 `alloca' to get space for the string. 5936 5937 The string will be used as an argument to `ASM_OUTPUT_LABELREF' to 5938 produce an assembler label for an internal static variable whose 5939 name is NAME. Therefore, the string must be such as to result in 5940 valid assembler code. The argument NUMBER is different each time 5941 this macro is executed; it prevents conflicts between 5942 similarly-named internal static variables in different scopes. 5943 5944 Ideally this string should not be a valid C identifier, to prevent 5945 any conflict with the user's own symbols. Most assemblers allow 5946 periods or percent signs in assembler symbols; putting at least 5947 one of these between the name and the number will suffice. 5948 */ 5949 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \ 5950 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10), \ 5951 sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO))) 5952 5953 5954 /* 5955 `ASM_OUTPUT_DEF (STREAM, NAME, VALUE)' 5956 A C statement to output to the stdio stream STREAM assembler code 5957 which defines (equates) the symbol NAME to have the value VALUE. 5958 5959 If SET_ASM_OP is defined, a default definition is provided which is 5960 correct for most systems. 5961 */ 5962 /* Maybe define this later, to support "alias" definitions. */ 5963 5964 5965 /* 5966 `OBJC_GEN_METHOD_LABEL (BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME)' 5967 Define this macro to override the default assembler names used for 5968 Objective C methods. 5969 5970 The default name is a unique method number followed by the name of 5971 the class (e.g. `_1_Foo'). For methods in categories, the name of 5972 the category is also included in the assembler name (e.g. 5973 `_1_Foo_Bar'). 5974 5975 These names are safe on most systems, but make debugging difficult 5976 since the method's selector is not present in the name. 5977 Therefore, particular systems define other ways of computing names. 5978 5979 BUF is an expression of type `char *' which gives you a buffer in 5980 which to store the name; its length is as long as CLASS_NAME, 5981 CAT_NAME and SEL_NAME put together, plus 50 characters extra. 5982 5983 The argument IS_INST specifies whether the method is an instance 5984 method or a class method; CLASS_NAME is the name of the class; 5985 CAT_NAME is the name of the category (or NULL if the method is not 5986 in a category); and SEL_NAME is the name of the selector. 5987 5988 On systems where the assembler can handle quoted names, you can 5989 use this macro to provide more human-readable names. 5990 */ 5991 /* Not defined */ 5992 5993 5994 /* Section: Assembler Format::Initialization */ 5995 /* (no definitions) */ 5996 5997 /* Section: Assembler Format::Macros for Initialization */ 5998 /* (no definitions since the defaults work; the gnu linker will 5999 understand the default magic) */ 6000 6001 /* Section: Assembler Format::Instruction Output */ 6002 6003 /* 6004 `REGISTER_NAMES' 6005 A C initializer containing the assembler's names for the machine 6006 registers, each one as a C string constant. This is what 6007 translates register numbers in the compiler into assembler 6008 language. 6009 */ 6010 /* --- jds31 --- undefine this --- 6011 * #define REGISTER_NAMES \ 6012 * {"16", "1", "2", "3", "4", "5", "6", "7", "8", \ 6013 * "9", "10", "11", "12", "13", "14", "pc", "srp"} 6014 */ 6015 6016 /* 6017 `ADDITIONAL_REGISTER_NAMES' 6018 If defined, a C initializer for an array of structures containing 6019 a name and a register number. This macro defines additional names 6020 for hard registers, thus allowing the `asm' option in declarations 6021 to refer to registers using alternate names. 6022 */ 6023 /* Not defined */ 6024 6025 6026 /* 6027 `ASM_OUTPUT_OPCODE (STREAM, PTR)' 6028 Define this macro if you are using an unusual assembler that 6029 requires different names for the machine instructions. 6030 6031 The definition is a C statement or statements which output an 6032 assembler instruction opcode to the stdio stream STREAM. The 6033 macro-operand PTR is a variable of type `char *' which points to 6034 the opcode name in its "internal" form--the form that is written 6035 in the machine description. The definition should output the 6036 opcode name to STREAM, performing any translation you desire, and 6037 increment the variable PTR to point at the end of the opcode so 6038 that it will not be output twice. 6039 6040 In fact, your macro definition may process less than the entire 6041 opcode name, or more than the opcode name; but if you want to 6042 process text that includes `%'-sequences to substitute operands, 6043 you must take care of the substitution yourself. Just be sure to 6044 increment PTR over whatever text should not be output normally. 6045 6046 If you need to look at the operand values, they can be found as the 6047 elements of `recog_operand'. 6048 6049 If the macro definition does nothing, the instruction is output in 6050 the usual way. 6051 */ 6052 /* Not defined */ 6053 6054 6055 /* 6056 `FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)' 6057 If defined, a C statement to be executed just prior to the output 6058 of assembler code for INSN, to modify the extracted operands so 6059 they will be output differently. 6060 6061 Here the argument OPVEC is the vector containing the operands 6062 extracted from INSN, and NOPERANDS is the number of elements of 6063 the vector which contain meaningful data for this insn. The 6064 contents of this vector are what will be used to convert the insn 6065 template into assembler code, so you can change the assembler 6066 output by changing the contents of the vector. 6067 6068 This macro is useful when various assembler syntaxes share a single 6069 file of instruction patterns; by defining this macro differently, 6070 you can cause a large class of instructions to be output 6071 differently (such as with rearranged operands). Naturally, 6072 variations in assembler syntax affecting individual insn patterns 6073 ought to be handled by writing conditional output routines in 6074 those patterns. 6075 6076 If this macro is not defined, it is equivalent to a null statement. 6077 */ 6078 /* Not defined */ 6079 6080 6081 /* 6082 `PRINT_OPERAND (STREAM, X, CODE)' 6083 A C compound statement to output to stdio stream STREAM the 6084 assembler syntax for an instruction operand X. X is an RTL 6085 expression. 6086 6087 CODE is a value that can be used to specify one of several ways of 6088 printing the operand. It is used when identical operands must be 6089 printed differently depending on the context. CODE comes from the 6090 `%' specification that was used to request printing of the 6091 operand. If the specification was just `%DIGIT' then CODE is 0; 6092 if the specification was `%LTR DIGIT' then CODE is the ASCII code 6093 for LTR. 6094 6095 If X is a register, this macro should print the register's name. 6096 The names can be found in an array `reg_names' whose type is `char 6097 *[]'. `reg_names' is initialized from `REGISTER_NAMES'. 6098 6099 When the machine description has a specification `%PUNCT' (a `%' 6100 followed by a punctuation character), this macro is called with a 6101 null pointer for X and the punctuation character for CODE. 6102 */ 6103 #define PRINT_OPERAND(FILE, X, CODE) \ 6104 print_operand(FILE, X, CODE) 6105 6106 /* moved to protos.h extern void print_operand(FILE *, rtx, int); */ 6107 6108 6109 /* 6110 `PRINT_OPERAND_PUNCT_VALID_P (CODE)' 6111 A C expression which evaluates to true if CODE is a valid 6112 punctuation character for use in the `PRINT_OPERAND' macro. If 6113 `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no 6114 punctuation characters (except for the standard one, `%') are used 6115 in this way. 6116 */ 6117 #define PRINT_OPERAND_PUNCT_VALID_P(CODE) (CODE == '#') /* for "nop" in slot */ 6118 6119 6120 /* 6121 `PRINT_OPERAND_ADDRESS (STREAM, X)' 6122 A C compound statement to output to stdio stream STREAM the 6123 assembler syntax for an instruction operand that is a memory 6124 reference whose address is X. X is an RTL expression. 6125 6126 On some machines, the syntax for a symbolic address depends on the 6127 section that the address refers to. On these machines, define the 6128 macro `ENCODE_SECTION_INFO' to store the information into the 6129 `symbol_ref', and then check for it here. *Note Assembler 6130 Format::. 6131 */ 6132 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) \ 6133 print_operand_address(FILE, ADDR) 6134 6135 6136 /* moved to protos.h extern void print_operand_address(FILE *, rtx); */ 6137 6138 6139 /* 6140 `DBR_OUTPUT_SEQEND(FILE)' 6141 A C statement, to be executed after all slot-filler instructions 6142 have been output. If necessary, call `dbr_sequence_length' to 6143 determine the number of slots filled in a sequence (zero if not 6144 currently outputting a sequence), to decide how many no-ops to 6145 output, or whatever. 6146 6147 Don't define this macro if it has nothing to do, but it is helpful 6148 in reading assembly output if the extent of the delay sequence is 6149 made explicit (e.g. with white space). 6150 6151 Note that output routines for instructions with delay slots must be 6152 prepared to deal with not being output as part of a sequence (i.e. 6153 when the scheduling pass is not run, or when no slot fillers could 6154 be found.) The variable `final_sequence' is null when not 6155 processing a sequence, otherwise it contains the `sequence' rtx 6156 being output. 6157 */ 6158 #define DBR_OUTPUT_SEQEND(FILE) \ 6159 fprintf(FILE,"\n") /* Empty line to illustrate. */ 6160 6161 6162 /* 6163 `REGISTER_PREFIX' 6164 `LOCAL_LABEL_PREFIX' 6165 `USER_LABEL_PREFIX' 6166 `IMMEDIATE_PREFIX' 6167 If defined, C string expressions to be used for the `%R', `%L', 6168 `%U', and `%I' options of `asm_fprintf' (see `final.c'). These 6169 are useful when a single `md' file must support multiple assembler 6170 formats. In that case, the various `tm.h' files can define these 6171 macros differently. 6172 */ 6173 /* Not defined */ 6174 6175 6176 /* 6177 `ASSEMBLER_DIALECT' 6178 If your target supports multiple dialects of assembler language 6179 (such as different opcodes), define this macro as a C expression 6180 that gives the numeric index of the assembler language dialect to 6181 use, with zero as the first variant. 6182 6183 If this macro is defined, you may use 6184 `{option0|option1|option2...}' constructs in the output templates 6185 of patterns (*note Output Template::.) or in the first argument of 6186 `asm_fprintf'. This construct outputs `option0', `option1' or 6187 `option2', etc., if the value of `ASSEMBLER_DIALECT' is zero, one 6188 or two, etc. Any special characters within these strings retain 6189 their usual meaning. 6190 6191 If you do not define this macro, the characters `{', `|' and `}' 6192 do not have any special meaning when used in templates or operands 6193 to `asm_fprintf'. 6194 6195 Define the macros `REGISTER_PREFIX', `LOCAL_LABEL_PREFIX', 6196 `USER_LABEL_PREFIX' and `IMMEDIATE_PREFIX' if you can express the 6197 variations in assemble language syntax with that mechanism. Define 6198 `ASSEMBLER_DIALECT' and use the `{option0|option1}' syntax if the 6199 syntax variant are larger and involve such things as different 6200 opcodes or operand order. 6201 */ 6202 /* Not defined */ 6203 6204 6205 /* 6206 `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)' 6207 A C expression to output to STREAM some assembler code which will 6208 push hard register number REGNO onto the stack. The code need not 6209 be optimal, since this macro is used only when profiling. 6210 */ 6211 #define ASM_OUTPUT_REG_PUSH(FILE,REGNO) \ 6212 fprintf (FILE, "\tpush %s\n", reg_names[REGNO]) 6213 6214 6215 /* 6216 `ASM_OUTPUT_REG_POP (STREAM, REGNO)' 6217 A C expression to output to STREAM some assembler code which will 6218 pop hard register number REGNO off of the stack. The code need 6219 not be optimal, since this macro is used only when profiling. 6220 */ 6221 #define ASM_OUTPUT_REG_POP(FILE,REGNO) \ 6222 fprintf (FILE, "\tpop %s\n", reg_names[REGNO]) 6223 6224 6225 /* Section: Assembler Format::Dispatch Tables */ 6226 6227 /* 6228 `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)' 6229 This macro should be provided on machines where the addresses in a 6230 dispatch table are relative to the table's own address. 6231 6232 The definition should be a C statement to output to the stdio 6233 stream STREAM an assembler pseudo-instruction to generate a 6234 difference between two labels. VALUE and REL are the numbers of 6235 two internal labels. The definitions of these labels are output 6236 using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the 6237 same way here. For example, 6238 6239 fprintf (STREAM, "\t.word L%d-L%d\n", 6240 VALUE, REL) 6241 */ 6242 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL,unused) \ 6243 fprintf (FILE, "\t.word L%d-L%d\n", VALUE, REL) 6244 6245 6246 /* 6247 `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)' 6248 This macro should be provided on machines where the addresses in a 6249 dispatch table are absolute. 6250 6251 The definition should be a C statement to output to the stdio 6252 stream STREAM an assembler pseudo-instruction to generate a 6253 reference to a label. VALUE is the number of an internal label 6254 whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. For 6255 example, 6256 6257 fprintf (STREAM, "\t.word L%d\n", VALUE) 6258 */ 6259 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ 6260 fprintf (FILE, "\t.dword L%d\n", VALUE) 6261 6262 6263 /* 6264 `ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)' 6265 Define this if the label before a jump-table needs to be output 6266 specially. The first three arguments are the same as for 6267 `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the jump-table 6268 which follows (a `jump_insn' containing an `addr_vec' or 6269 `addr_diff_vec'). 6270 6271 This feature is used on system V to output a `swbeg' statement for 6272 the table. 6273 6274 If this macro is not defined, these labels are output with 6275 `ASM_OUTPUT_INTERNAL_LABEL'. 6276 */ 6277 /* Not defined */ 6278 6279 6280 /* 6281 `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)' 6282 Define this if something special must be output at the end of a 6283 jump-table. The definition should be a C statement to be executed 6284 after the assembler code for the table is written. It should write 6285 the appropriate code to stdio stream STREAM. The argument TABLE 6286 is the jump-table insn, and NUM is the label-number of the 6287 preceding label. 6288 6289 If this macro is not defined, nothing special is output at the end 6290 of the jump-table. 6291 */ 6292 /* Since the "bound" insn loads the comparison value if the compared 6293 value (register) is out of bounds (0..comparison value-1), we need 6294 to output another case to catch it. 6295 The way to find it is to look after the "use" note inside the 6296 dummy-jump. (It could be stored somewhere by the casesi expand, 6297 but that storage-position would have to be in a list, it cannot be 6298 stored in a scalar.) 6299 Check this construct when changing to new version of gcc. 6300 *//* 6301 #define ASM_OUTPUT_CASE_END(STREAM, NUM, TABLE) \ 6302 { \ 6303 fprintf(STREAM,"\t.word L%d-L%d%s\n", \ 6304 CODE_LABEL_NUMBER( \ 6305 XEXP(XEXP(XVECEXP(PATTERN(PREV_INSN(PREV_INSN(TABLE))), \ 6306 0,2),0),0)), NUM, \ 6307 (TARGET_PDEBUG ? "; default" : "")); \ 6308 } 6309 */ 6310 6311 /* Section: Assembler Format::Alignment Output */ 6312 6313 /* 6314 `ASM_OUTPUT_ALIGN_CODE (FILE)' 6315 A C expression to output text to align the location counter in the 6316 way that is desirable at a point in the code that is reached only 6317 by jumping. 6318 6319 This macro need not be defined if you don't want any special 6320 alignment to be done at such a time. Most machine descriptions do 6321 not currently define the macro. 6322 */ 6323 /* Not defined */ 6324 6325 6326 /* 6327 `ASM_OUTPUT_LOOP_ALIGN (FILE)' 6328 A C expression to output text to align the location counter in the 6329 way that is desirable at the beginning of a loop. 6330 6331 This macro need not be defined if you don't want any special 6332 alignment to be done at such a time. Most machine descriptions do 6333 not currently define the macro. 6334 */ 6335 /* Not defined */ 6336 6337 6338 /* 6339 `ASM_OUTPUT_SKIP (STREAM, NBYTES)' 6340 A C statement to output to the stdio stream STREAM an assembler 6341 instruction to advance the location counter by NBYTES bytes. 6342 Those bytes should be zero when loaded. NBYTES will be a C 6343 expression of type `int'. 6344 */ 6345 #define ASM_OUTPUT_SKIP(FILE,SIZE) ; 6346 /* \ 6347 fprintf (FILE, "\t.space %u\n", (SIZE)) 6348 */ 6349 6350 /* 6351 `ASM_NO_SKIP_IN_TEXT' 6352 Define this macro if `ASM_OUTPUT_SKIP' should not be used in the 6353 text section because it fails put zeros in the bytes that are 6354 skipped. This is true on many Unix systems, where the pseudo-op 6355 to skip bytes produces no-op instructions rather than zeros when 6356 used in the text section. 6357 */ 6358 /* Not defined */ 6359 6360 6361 /* 6362 `ASM_OUTPUT_ALIGN (STREAM, POWER)' 6363 A C statement to output to the stdio stream STREAM an assembler 6364 command to advance the location counter to a multiple of 2 to the 6365 POWER bytes. POWER will be a C expression of type `int'. 6366 */ 6367 #define ASM_OUTPUT_ALIGN(FILE,LOG) \ 6368 fprintf (FILE, "// \t.align %d\n", (LOG)) 6369 6370 6371 /* Section: Debugging Info::All Debuggers */ 6372 6373 /* 6374 `DBX_REGISTER_NUMBER (REGNO)' 6375 A C expression that returns the DBX register number for the 6376 compiler register number REGNO. In simple cases, the value of this 6377 expression may be REGNO itself. But sometimes there are some 6378 registers that the compiler knows about and DBX does not, or vice 6379 versa. In such cases, some register may need to have one number in 6380 the compiler and another for DBX. 6381 6382 If two registers have consecutive numbers inside GNU CC, and they 6383 can be used as a pair to hold a multiword value, then they *must* 6384 have consecutive numbers after renumbering with 6385 `DBX_REGISTER_NUMBER'. Otherwise, debuggers will be unable to 6386 access such a pair, because they expect register pairs to be 6387 consecutive in their own numbering scheme. 6388 6389 If you find yourself defining `DBX_REGISTER_NUMBER' in way that 6390 does not preserve register pairs, then what you must do instead is 6391 redefine the actual register numbering scheme. 6392 */ 6393 /* Jvm needs no change in the numeration, I guess. */ 6394 #define DBX_REGISTER_NUMBER(REGNO) (REGNO) 6395 6396 6397 /* 6398 `DEBUGGER_AUTO_OFFSET (X)' 6399 A C expression that returns the integer offset value for an 6400 automatic variable having address X (an RTL expression). The 6401 default computation assumes that X is based on the frame-pointer 6402 and gives the offset from the frame-pointer. This is required for 6403 targets that produce debugging output for DBX or COFF-style 6404 debugging output for SDB and allow the frame-pointer to be 6405 eliminated when the `-g' options is used. 6406 */ 6407 /* Not defined */ 6408 6409 6410 /* 6411 `DEBUGGER_ARG_OFFSET (OFFSET, X)' 6412 A C expression that returns the integer offset value for an 6413 argument having address X (an RTL expression). The nominal offset 6414 is OFFSET. 6415 */ 6416 /* Not defined */ 6417 6418 6419 /* 6420 `PREFERRED_DEBUGGING_TYPE' 6421 A C expression that returns the type of debugging output GNU CC 6422 produces when the user specifies `-g' or `-ggdb'. Define this if 6423 you have arranged for GNU CC to support more than one format of 6424 debugging output. Currently, the allowable values are `DBX_DEBUG', 6425 `SDB_DEBUG', `DWARF_DEBUG', and `XCOFF_DEBUG'. 6426 6427 The value of this macro only affects the default debugging output; 6428 the user can always get a specific type of output by using 6429 `-gstabs', `-gcoff', `-gdwarf', or `-gxcoff'. 6430 */ 6431 /* Not defined */ 6432 6433 6434 /* Section: Debugging Info::DBX Options */ 6435 6436 /* 6437 `DBX_DEBUGGING_INFO' 6438 Define this macro if GNU CC should produce debugging output for DBX 6439 in response to the `-g' option. 6440 */ 6441 /* Well, it seems to work nicely; the default stuff for the assembler 6442 and linker is to look like a BSD system, which uses DBX format. */ 6443 #define DBX_DEBUGGING_INFO 6444 6445 6446 /* 6447 `XCOFF_DEBUGGING_INFO' 6448 Define this macro if GNU CC should produce XCOFF format debugging 6449 output in response to the `-g' option. This is a variant of DBX 6450 format. 6451 */ 6452 /* Not defined */ 6453 6454 6455 /* 6456 `DEFAULT_GDB_EXTENSIONS' 6457 Define this macro to control whether GNU CC should by default 6458 generate GDB's extended version of DBX debugging information 6459 (assuming DBX-format debugging information is enabled at all). If 6460 you don't define the macro, the default is 1: always generate the 6461 extended information if there is any occasion to. 6462 */ 6463 /* Not defined */ 6464 6465 6466 /* 6467 `DEBUG_SYMS_TEXT' 6468 Define this macro if all `.stabs' commands should be output while 6469 in the text section. 6470 */ 6471 /* Not defined */ 6472 6473 6474 /* 6475 `ASM_STABS_OP' 6476 A C string constant naming the assembler pseudo op to use instead 6477 of `.stabs' to define an ordinary debugging symbol. If you don't 6478 define this macro, `.stabs' is used. This macro applies only to 6479 DBX debugging information format. 6480 */ 6481 /* Not defined */ 6482 6483 6484 /* 6485 `ASM_STABD_OP' 6486 A C string constant naming the assembler pseudo op to use instead 6487 of `.stabd' to define a debugging symbol whose value is the current 6488 location. If you don't define this macro, `.stabd' is used. This 6489 macro applies only to DBX debugging information format. 6490 */ 6491 /* Not defined */ 6492 6493 6494 /* 6495 `ASM_STABN_OP' 6496 A C string constant naming the assembler pseudo op to use instead 6497 of `.stabn' to define a debugging symbol with no name. If you 6498 don't define this macro, `.stabn' is used. This macro applies 6499 only to DBX debugging information format. 6500 */ 6501 /* Not defined */ 6502 6503 6504 /* 6505 `DBX_NO_XREFS' 6506 Define this macro if DBX on your system does not support the 6507 construct `xsTAGNAME'. On some systems, this construct is used to 6508 describe a forward reference to a structure named TAGNAME. On 6509 other systems, this construct is not supported at all. 6510 */ 6511 /* Is this correct? Check later. */ 6512 #define DBX_NO_XREFS 6513 6514 6515 /* 6516 `DBX_CONTIN_LENGTH' 6517 A symbol name in DBX-format debugging information is normally 6518 continued (split into two separate `.stabs' directives) when it 6519 exceeds a certain length (by default, 80 characters). On some 6520 operating systems, DBX requires this splitting; on others, 6521 splitting must not be done. You can inhibit splitting by defining 6522 this macro with the value zero. You can override the default 6523 splitting-length by defining this macro as an expression for the 6524 length you desire. 6525 */ 6526 #define DBX_CONTIN_LENGTH 0 6527 6528 6529 /* 6530 `DBX_CONTIN_CHAR' 6531 Normally continuation is indicated by adding a `\' character to 6532 the end of a `.stabs' string when a continuation follows. To use 6533 a different character instead, define this macro as a character 6534 constant for the character you want to use. Do not define this 6535 macro if backslash is correct for your system. 6536 */ 6537 #define DBX_CONTIN_CHAR '?' 6538 6539 6540 /* 6541 `DBX_STATIC_STAB_DATA_SECTION' 6542 Define this macro if it is necessary to go to the data section 6543 before outputting the `.stabs' pseudo-op for a non-global static 6544 variable. 6545 */ 6546 #define DBX_STATIC_STAB_DATA_SECTION 6547 6548 6549 /* 6550 `DBX_TYPE_DECL_STABS_CODE' 6551 The value to use in the "code" field of the `.stabs' directive for 6552 a typedef. The default is `N_LSYM'. 6553 */ 6554 /* Not defined */ 6555 6556 6557 /* 6558 `DBX_STATIC_CONST_VAR_CODE' 6559 The value to use in the "code" field of the `.stabs' directive for 6560 a static variable located in the text section. DBX format does not 6561 provide any "right" way to do this. The default is `N_FUN'. 6562 */ 6563 /* Not defined */ 6564 6565 6566 /* 6567 `DBX_REGPARM_STABS_CODE' 6568 The value to use in the "code" field of the `.stabs' directive for 6569 a parameter passed in registers. DBX format does not provide any 6570 "right" way to do this. The default is `N_RSYM'. 6571 */ 6572 /* Not defined */ 6573 6574 6575 /* 6576 `DBX_REGPARM_STABS_LETTER' 6577 The letter to use in DBX symbol data to identify a symbol as a 6578 parameter passed in registers. DBX format does not customarily 6579 provide any way to do this. The default is `'P''. 6580 */ 6581 /* Not defined */ 6582 6583 6584 /* 6585 `DBX_MEMPARM_STABS_LETTER' 6586 The letter to use in DBX symbol data to identify a symbol as a 6587 stack parameter. The default is `'p''. 6588 */ 6589 /* Not defined */ 6590 6591 6592 /* 6593 `DBX_FUNCTION_FIRST' 6594 Define this macro if the DBX information for a function and its 6595 arguments should precede the assembler code for the function. 6596 Normally, in DBX format, the debugging information entirely 6597 follows the assembler code. 6598 */ 6599 /* Not defined */ 6600 6601 6602 /* 6603 `DBX_LBRAC_FIRST' 6604 Define this macro if the `N_LBRAC' symbol for a block should 6605 precede the debugging information for variables and functions 6606 defined in that block. Normally, in DBX format, the `N_LBRAC' 6607 symbol comes first. 6608 */ 6609 /* Not defined */ 6610 6611 6612 /* 6613 `DBX_BLOCKS_FUNCTION_RELATIVE' 6614 Define this macro if the value of a symbol describing the scope of 6615 a block (`N_LBRAC' or `N_RBRAC') should be relative to the start 6616 of the enclosing function. Normally, GNU C uses an absolute 6617 address. 6618 */ 6619 /* Not defined */ 6620 6621 6622 /* Section: Debugging Info::DBX Hooks */ 6623 /* (no definitions) */ 6624 6625 /* Section: Debugging Info::File names and DBX */ 6626 /* (no definitions) */ 6627 6628 /* Section: Debugging Info::SDB and DWARF */ 6629 /* (no definitions) */ 6630 6631 /* Section: Cross-compilation */ 6632 /* (no definitions) */ 6633 6634 /* Section: Misc */ 6635 6636 /* 6637 `PREDICATE_CODES' 6638 Define this if you have defined special-purpose predicates in the 6639 file `MACHINE.c'. This macro is called within an initializer of an 6640 array of structures. The first field in the structure is the name 6641 of a predicate and the second field is an array of rtl codes. For 6642 each predicate, list all rtl codes that can be in expressions 6643 matched by the predicate. The list should have a trailing comma. 6644 Here is an example of two entries in the list for a typical RISC 6645 machine: 6646 6647 #define PREDICATE_CODES \ 6648 {"gen_reg_rtx_operand", {SUBREG, REG}}, \ 6649 {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}}, 6650 6651 Defining this macro does not affect the generated code (however, 6652 incorrect definitions that omit an rtl code that may be matched by 6653 the predicate can cause the compiler to malfunction). Instead, it 6654 allows the table built by `genrecog' to be more compact and 6655 efficient, thus speeding up the compiler. The most important 6656 predicates to include in the list specified by this macro are 6657 thoses used in the most insn patterns. 6658 */ 6659 #if 0 6660 /* DONT define this if there is ANY 6661 possibility that you will change them */ 6662 # define PREDICATE_CODES \ 6663 { "index_operand", { CONST_INT, REG, MULT, /* LSHIFT, ASHIFT */ }},\ 6664 { "shift_operand", { REG, MULT, /*LSHIFT, ASHIFT*/ }}, \ 6665 { "orthogonal_operator", { PLUS, MINUS, IOR, AND, UMIN }}, \ 6666 { "commutative_orth_op", { PLUS, IOR, AND, UMIN }}, \ 6667 { "extend_operator", { ZERO_EXTEND, SIGN_EXTEND }}, \ 6668 { "add_sub_operator", { PLUS, MINUS }}, \ 6669 { "zero_extend_op", { ZERO_EXTEND }}, \ 6670 { "const_ref_operand", { CONST, LABEL_REF, SYMBOL_REF }}, 6671 #endif 6672 6673 6674 /* 6675 `CASE_VECTOR_MODE' 6676 An alias for a machine mode name. This is the machine mode that 6677 elements of a jump-table should have. 6678 */ 6679 /* A combination of the bound (umin) insn together with a 6680 sign-extended add via the table to PC seems optimal. If the 6681 table overflows, the assembler will take care of it. */ 6682 #define CASE_VECTOR_MODE HImode 6683 6684 6685 /* 6686 `CASE_VECTOR_PC_RELATIVE' 6687 Define this macro if jump-tables should contain relative addresses. 6688 */ 6689 /*#define CASE_VECTOR_PC_RELATIVE*/ 6690 6691 6692 /* 6693 `CASE_DROPS_THROUGH' 6694 Define this if control falls through a `case' insn when the index 6695 value is out of range. This means the specified default-label is 6696 actually ignored by the `case' insn proper. 6697 */ 6698 /* Not defined */ 6699 6700 6701 /* 6702 `CASE_VALUES_THRESHOLD' 6703 Define this to be the smallest number of different values for 6704 which it is best to use a jump-table instead of a tree of 6705 conditional branches. The default is four for machines with a 6706 `casesi' instruction and five otherwise. This is best for most 6707 machines. 6708 */ 6709 /* set this to some high value so we don't try to generate case/jump tables */ 6710 #define CASE_VALUES_THRESHOLD 1024 6711 /* Not defined */ 6712 6713 6714 /* 6715 `WORD_REGISTER_OPERATIONS' 6716 Define this macro if operations between registers with integral 6717 mode smaller than a word are always performed on the entire 6718 register. Most RISC machines have this property and most CISC 6719 machines do not. 6720 */ 6721 /* Maybe define this later, when we play with optimizations. */ 6722 6723 6724 /* 6725 `LOAD_EXTEND_OP (MODE)' 6726 Define this macro to be a C expression indicating when insns that 6727 read memory in MODE, an integral mode narrower than a word, set the 6728 bits outside of MODE to be either the sign-extension or the 6729 zero-extension of the data read. Return `SIGN_EXTEND' for values 6730 of MODE for which the insn sign-extends, `ZERO_EXTEND' for which 6731 it zero-extends, and `NIL' for other modes. 6732 6733 This macro is not called with MODE non-integral or with a width 6734 greater than or equal to `BITS_PER_WORD', so you may return any 6735 value in this case. Do not define this macro if it would always 6736 return `NIL'. On machines where this macro is defined, you will 6737 normally define it as the constant `SIGN_EXTEND' or `ZERO_EXTEND'. 6738 */ 6739 /* Maybe define this later, when we play with optimizations. */ 6740 6741 6742 /* 6743 `IMPLICIT_FIX_EXPR' 6744 An alias for a tree code that should be used by default for 6745 conversion of floating point values to fixed point. Normally, 6746 `FIX_ROUND_EXPR' is used. 6747 */ 6748 #define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR 6749 6750 6751 /* 6752 `FIXUNS_TRUNC_LIKE_FIX_TRUNC' 6753 Define this macro if the same instructions that convert a floating 6754 point number to a signed fixed point number also convert validly 6755 to an unsigned one. 6756 */ 6757 #define FIXUNS_TRUNC_LIKE_FIX_TRUNC 6758 6759 6760 /* 6761 `EASY_DIV_EXPR' 6762 An alias for a tree code that is the easiest kind of division to 6763 compile code for in the general case. It may be `TRUNC_DIV_EXPR', 6764 `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'. These four 6765 division operators differ in how they round the result to an 6766 integer. `EASY_DIV_EXPR' is used when it is permissible to use 6767 any of those kinds of division and the choice should be made on 6768 the basis of efficiency. 6769 */ 6770 #define EASY_DIV_EXPR TRUNC_DIV_EXPR 6771 6772 6773 /* 6774 `MOVE_MAX' 6775 The maximum number of bytes that a single instruction can move 6776 quickly from memory to memory. 6777 */ 6778 /* Conversation between UA (Ulf Andersson) and Richard Kenner (?) 6779 indicates that "one reasonably fast instruction" actually is "one 6780 reasonably fast instruction SEQUENCE" (that is, two instructions -- 6781 mem => reg, reg => mem -- for jvm). */ 6782 /* ??? Change back to 0 if code breaks. */ 6783 #define MOVE_MAX 4 6784 6785 6786 /* 6787 `MAX_MOVE_MAX' 6788 The maximum number of bytes that a single instruction can move 6789 quickly from memory to memory. If this is undefined, the default 6790 is `MOVE_MAX'. Otherwise, it is the constant value that is the 6791 largest value that `MOVE_MAX' can have at run-time. 6792 */ 6793 /* Not defined */ 6794 6795 6796 /* 6797 `SHIFT_COUNT_TRUNCATED' 6798 A C expression that is nonzero if on this machine the number of 6799 bits actually used for the count of a shift operation is equal to 6800 the number of bits needed to represent the size of the object 6801 being shifted. When this macro is non-zero, the compiler will 6802 assume that it is safe to omit a sign-extend, zero-extend, and 6803 certain bitwise `and' instructions that truncates the count of a 6804 shift operation. On machines that have instructions that act on 6805 bitfields at variable positions, which may include `bit test' 6806 instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables 6807 deletion of truncations of the values that serve as arguments to 6808 bitfield instructions. 6809 6810 If both types of instructions truncate the count (for shifts) and 6811 position (for bitfield operations), or if no variable-position 6812 bitfield instructions exist, you should define this macro. 6813 6814 However, on some machines, such as the 80386 and the 680x0, 6815 truncation only applies to shift operations and not the (real or 6816 pretended) bitfield operations. Define `SHIFT_COUNT_TRUNCATED' to 6817 be zero on such machines. Instead, add patterns to the `md' file 6818 that include the implied truncation of the shift instructions. 6819 6820 You need not define this macro if it would always have the value 6821 of zero. 6822 */ 6823 /* Maybe this should be defined? Check later. */ 6824 6825 6826 /* 6827 `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)' 6828 A C expression which is nonzero if on this machine it is safe to 6829 "convert" an integer of INPREC bits to one of OUTPREC bits (where 6830 OUTPREC is smaller than INPREC) by merely operating on it as if it 6831 had only OUTPREC bits. 6832 6833 On many machines, this expression can be 1. 6834 6835 When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for 6836 modes for which `MODES_TIEABLE_P' is 0, suboptimal code can result. 6837 If this is the case, making `TRULY_NOOP_TRUNCATION' return 0 in 6838 such cases may improve things. 6839 */ 6840 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 6841 6842 6843 /* 6844 `STORE_FLAG_VALUE' 6845 A C expression describing the value returned by a comparison 6846 operator with an integral mode and stored by a store-flag 6847 instruction (`sCOND') when the condition is true. This 6848 description must apply to *all* the `sCOND' patterns and all the 6849 comparison operators whose results have a `MODE_INT' mode. 6850 6851 A value of 1 or -1 means that the instruction implementing the 6852 comparison operator returns exactly 1 or -1 when the comparison is 6853 true and 0 when the comparison is false. Otherwise, the value 6854 indicates which bits of the result are guaranteed to be 1 when the 6855 comparison is true. This value is interpreted in the mode of the 6856 comparison operation, which is given by the mode of the first 6857 operand in the `sCOND' pattern. Either the low bit or the sign 6858 bit of `STORE_FLAG_VALUE' be on. Presently, only those bits are 6859 used by the compiler. 6860 6861 If `STORE_FLAG_VALUE' is neither 1 or -1, the compiler will 6862 generate code that depends only on the specified bits. It can also 6863 replace comparison operators with equivalent operations if they 6864 cause the required bits to be set, even if the remaining bits are 6865 undefined. For example, on a machine whose comparison operators 6866 return an `SImode' value and where `STORE_FLAG_VALUE' is defined as 6867 `0x80000000', saying that just the sign bit is relevant, the 6868 expression 6869 6870 (ne:SI (and:SI X (const_int POWER-OF-2)) (const_int 0)) 6871 6872 can be converted to 6873 6874 (ashift:SI X (const_int N)) 6875 6876 where N is the appropriate shift count to move the bit being 6877 tested into the sign bit. 6878 6879 There is no way to describe a machine that always sets the 6880 low-order bit for a true value, but does not guarantee the value 6881 of any other bits, but we do not know of any machine that has such 6882 an instruction. If you are trying to port GNU CC to such a 6883 machine, include an instruction to perform a logical-and of the 6884 result with 1 in the pattern for the comparison operators and let 6885 us know (*note How to Report Bugs: Bug Reporting.). 6886 6887 Often, a machine will have multiple instructions that obtain a 6888 value from a comparison (or the condition codes). Here are rules 6889 to guide the choice of value for `STORE_FLAG_VALUE', and hence the 6890 instructions to be used: 6891 6892 * Use the shortest sequence that yields a valid definition for 6893 `STORE_FLAG_VALUE'. It is more efficient for the compiler to 6894 "normalize" the value (convert it to, e.g., 1 or 0) than for 6895 the comparison operators to do so because there may be 6896 opportunities to combine the normalization with other 6897 operations. 6898 6899 * For equal-length sequences, use a value of 1 or -1, with -1 6900 being slightly preferred on machines with expensive jumps and 6901 1 preferred on other machines. 6902 6903 * As a second choice, choose a value of `0x80000001' if 6904 instructions exist that set both the sign and low-order bits 6905 but do not define the others. 6906 6907 * Otherwise, use a value of `0x80000000'. 6908 6909 Many machines can produce both the value chosen for 6910 `STORE_FLAG_VALUE' and its negation in the same number of 6911 instructions. On those machines, you should also define a pattern 6912 for those cases, e.g., one matching 6913 6914 (set A (neg:M (ne:M B C))) 6915 6916 Some machines can also perform `and' or `plus' operations on 6917 condition code values with less instructions than the corresponding 6918 `sCOND' insn followed by `and' or `plus'. On those machines, 6919 define the appropriate patterns. Use the names `incscc' and 6920 `decscc', respectively, for the the patterns which perform `plus' 6921 or `minus' operations on condition code values. See `rs6000.md' 6922 for some examples. The GNU Superoptizer can be used to find such 6923 instruction sequences on other machines. 6924 6925 You need not define `STORE_FLAG_VALUE' if the machine has no 6926 store-flag instructions. 6927 */ 6928 #define STORE_FLAG_VALUE 1 6929 6930 6931 /* 6932 `FLOAT_STORE_FLAG_VALUE' 6933 A C expression that gives a non-zero floating point value that is 6934 returned when comparison operators with floating-point results are 6935 true. Define this macro on machine that have comparison 6936 operations that return floating-point values. If there are no 6937 such operations, do not define this macro. 6938 */ 6939 /* Not defined */ 6940 6941 6942 /* 6943 `Pmode' 6944 An alias for the machine mode for pointers. On most machines, 6945 define this to be the integer mode corresponding to the width of a 6946 hardware pointer; `SImode' on 32-bit machine or `DImode' on 64-bit 6947 machines. On some machines you must define this to be one of the 6948 partial integer modes, such as `PSImode'. 6949 6950 The width of `Pmode' must be at least as large as the value of 6951 `POINTER_SIZE'. If it is not equal, you must define the macro 6952 `POINTERS_EXTEND_UNSIGNED' to specify how pointers are extended to 6953 `Pmode'. 6954 */ 6955 #define Pmode SImode 6956 6957 6958 /* 6959 `FUNCTION_MODE' 6960 An alias for the machine mode used for memory references to 6961 functions being called, in `call' RTL expressions. On most 6962 machines this should be `QImode'. 6963 */ 6964 #define FUNCTION_MODE QImode 6965 6966 6967 /* 6968 `INTEGRATE_THRESHOLD (DECL)' 6969 A C expression for the maximum number of instructions above which 6970 the function DECL should not be inlined. DECL is a 6971 `FUNCTION_DECL' node. 6972 6973 The default definition of this macro is 64 plus 8 times the number 6974 of arguments that the function accepts. Some people think a larger 6975 threshold should be used on RISC machines. 6976 */ 6977 /* Maybe define this later, when we play with optimizations. */ 6978 6979 6980 /* 6981 `SCCS_DIRECTIVE' 6982 Define this if the preprocessor should ignore `#sccs' directives 6983 and print no error message. 6984 */ 6985 /* Not defined */ 6986 6987 6988 /* 6989 `NO_IMPLICIT_EXTERN_C' 6990 Define this macro if the system header files support C++ as well 6991 as C. This macro inhibits the usual method of using system header 6992 files in C++, which is to pretend that the file's contents are 6993 enclosed in `extern "C" {...}'. 6994 */ 6995 /* Not defined */ 6996 6997 6998 /* 6999 `HANDLE_PRAGMA (STREAM)' 7000 Define this macro if you want to implement any pragmas. If 7001 defined, it should be a C statement to be executed when `#pragma' 7002 is seen. The argument STREAM is the stdio input stream from which 7003 the source text can be read. 7004 7005 It is generally a bad idea to implement new uses of `#pragma'. The 7006 only reason to define this macro is for compatibility with other 7007 compilers that do support `#pragma' for the sake of any user 7008 programs which already use it. 7009 */ 7010 /* Not defined */ 7011 7012 7013 /* 7014 `VALID_MACHINE_DECL_ATTRIBUTE (DECL, ATTRIBUTES, IDENTIFIER, ARGS)' 7015 If defined, a C expression whose value is nonzero if IDENTIFIER 7016 with arguments ARGS is a valid machine specific attribute for DECL. 7017 The attributes in ATTRIBUTES have previously been assigned to DECL. 7018 */ 7019 /* Not defined */ 7020 7021 7022 /* 7023 `VALID_MACHINE_TYPE_ATTRIBUTE (TYPE, ATTRIBUTES, IDENTIFIER, ARGS)' 7024 If defined, a C expression whose value is nonzero if IDENTIFIER 7025 with arguments ARGS is a valid machine specific attribute for TYPE. 7026 The attributes in ATTRIBUTES have previously been assigned to TYPE. 7027 */ 7028 /* Not defined */ 7029 7030 7031 /* 7032 `COMP_TYPE_ATTRIBUTES (TYPE1, TYPE2)' 7033 If defined, a C expression whose value is zero if the attributes on 7034 TYPE1 and TYPE2 are incompatible, one if they are compatible, and 7035 two if they are nearly compatible (which causes a warning to be 7036 generated). 7037 */ 7038 /* Not defined */ 7039 7040 7041 /* 7042 `SET_DEFAULT_TYPE_ATTRIBUTES (TYPE)' 7043 If defined, a C statement that assigns default attributes to newly 7044 defined TYPE. 7045 */ 7046 /* Not defined */ 7047 7048 7049 /* 7050 `DOLLARS_IN_IDENTIFIERS' 7051 Define this macro to control use of the character `$' in identifier 7052 names. The value should be 0, 1, or 2. 0 means `$' is not allowed 7053 by default; 1 means it is allowed by default if `-traditional' is 7054 used; 2 means it is allowed by default provided `-ansi' is not 7055 used. 1 is the default; there is no need to define this macro in 7056 that case. 7057 */ 7058 /* Not defined */ 7059 7060 7061 /* 7062 `NO_DOLLAR_IN_LABEL' 7063 Define this macro if the assembler does not accept the character 7064 `$' in label names. By default constructors and destructors in 7065 G++ have `$' in the identifiers. If this macro is defined, `.' is 7066 used instead. 7067 */ 7068 /* Not defined */ 7069 7070 7071 /* 7072 `NO_DOT_IN_LABEL' 7073 Define this macro if the assembler does not accept the character 7074 `.' in label names. By default constructors and destructors in G++ 7075 have names that use `.'. If this macro is defined, these names 7076 are rewritten to avoid `.'. 7077 */ 7078 /* Not defined */ 7079 7080 7081 /* 7082 `DEFAULT_MAIN_RETURN' 7083 Define this macro if the target system expects every program's 7084 `main' function to return a standard "success" value by default 7085 (if no other value is explicitly returned). 7086 7087 The definition should be a C statement (sans semicolon) to 7088 generate the appropriate rtl instructions. It is used only when 7089 compiling the end of `main'. 7090 */ 7091 /* Not defined */ 7092 7093 7094 /* 7095 `HAVE_ATEXIT' 7096 Define this if the target system supports the function `atexit' 7097 from the ANSI C standard. If this is not defined, and 7098 `INIT_SECTION_ASM_OP' is not defined, a default `exit' function 7099 will be provided to support C++. 7100 */ 7101 /* Not defined */ 7102 7103 7104 /* 7105 `EXIT_BODY' 7106 Define this if your `exit' function needs to do something besides 7107 calling an external function `_cleanup' before terminating with 7108 `_exit'. The `EXIT_BODY' macro is only needed if netiher 7109 `HAVE_ATEXIT' nor `INIT_SECTION_ASM_OP' are defined. 7110 */ 7111 /* Not defined */ 7112 7113 7114 /* 7115 `INSN_SETS_ARE_DELAYED (INSN)' 7116 Define this macro as a C expression that is nonzero if it is safe 7117 for the delay slot scheduler to place instructions in the delay 7118 slot of INSN, even if they appear to use a resource set or 7119 clobbered in INSN. INSN is always a `jump_insn' or an `insn'; GNU 7120 CC knows that every `call_insn' has this behavior. On machines 7121 where some `insn' or `jump_insn' is really a function call and 7122 hence has this behavior, you should define this macro. 7123 7124 You need not define this macro if it would always return zero. 7125 */ 7126 /* Not defined */ 7127 7128 7129 /* 7130 `INSN_REFERENCES_ARE_DELAYED (INSN)' 7131 Define this macro as a C expression that is nonzero if it is safe 7132 for the delay slot scheduler to place instructions in the delay 7133 slot of INSN, even if they appear to set or clobber a resource 7134 referenced in INSN. INSN is always a `jump_insn' or an `insn'. 7135 On machines where some `insn' or `jump_insn' is really a function 7136 call and its operands are registers whose use is actually in the 7137 subroutine it calls, you should define this macro. Doing so 7138 allows the delay slot scheduler to move instructions which copy 7139 arguments into the argument registers into the delay slot of INSN. 7140 7141 You need not define this macro if it would always return zero. 7142 */ 7143 /* Not defined */ 7144 7145 7146 /* 7147 `MACHINE_DEPENDENT_REORG (INSN)' 7148 In rare cases, correct code generation requires extra machine 7149 dependent processing between the second jump optimization pass and 7150 delayed branch scheduling. On those machines, define this macro 7151 as a C statement to act on the code starting at INSN. 7152 */ 7153 /* Not defined */ 7154 7155 /* END of tm.h */ 7156 7157 7158 /* end of clr.h */ 7159