linux64.h revision 146895
1/* Definitions of target machine for GNU compiler, 2 for 64 bit PowerPC linux. 3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 4 Free Software Foundation, Inc. 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it 9 under the terms of the GNU General Public License as published 10 by the Free Software Foundation; either version 2, or (at your 11 option) any later version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 16 License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING. If not, write to the 20 Free Software Foundation, 59 Temple Place - Suite 330, Boston, 21 MA 02111-1307, USA. */ 22 23#ifndef RS6000_BI_ARCH 24 25#undef DEFAULT_ABI 26#define DEFAULT_ABI ABI_AIX 27 28#undef TARGET_64BIT 29#define TARGET_64BIT 1 30 31#define DEFAULT_ARCH64_P 1 32#define RS6000_BI_ARCH_P 0 33 34#else 35 36#define DEFAULT_ARCH64_P (TARGET_DEFAULT & MASK_64BIT) 37#define RS6000_BI_ARCH_P 1 38 39#endif 40 41#ifdef IN_LIBGCC2 42#undef TARGET_64BIT 43#ifdef __powerpc64__ 44#define TARGET_64BIT 1 45#else 46#define TARGET_64BIT 0 47#endif 48#endif 49 50#undef TARGET_AIX 51#define TARGET_AIX TARGET_64BIT 52 53#undef PROCESSOR_DEFAULT64 54#define PROCESSOR_DEFAULT64 PROCESSOR_PPC630 55 56/* We don't need to generate entries in .fixup, except when 57 -mrelocatable or -mrelocatable-lib is given. */ 58#undef RELOCATABLE_NEEDS_FIXUP 59#define RELOCATABLE_NEEDS_FIXUP \ 60 (target_flags & target_flags_explicit & MASK_RELOCATABLE) 61 62#undef RS6000_ABI_NAME 63#define RS6000_ABI_NAME (TARGET_64BIT ? "aixdesc" : "sysv") 64 65#define INVALID_64BIT "-m%s not supported in this configuration" 66#define INVALID_32BIT INVALID_64BIT 67 68#undef SUBSUBTARGET_OVERRIDE_OPTIONS 69#define SUBSUBTARGET_OVERRIDE_OPTIONS \ 70 do \ 71 { \ 72 if (rs6000_alignment_string == 0) \ 73 rs6000_alignment_flags = MASK_ALIGN_NATURAL; \ 74 if (TARGET_64BIT) \ 75 { \ 76 if (DEFAULT_ABI != ABI_AIX) \ 77 { \ 78 rs6000_current_abi = ABI_AIX; \ 79 error (INVALID_64BIT, "call"); \ 80 } \ 81 if (target_flags & MASK_RELOCATABLE) \ 82 { \ 83 target_flags &= ~MASK_RELOCATABLE; \ 84 error (INVALID_64BIT, "relocatable"); \ 85 } \ 86 if (target_flags & MASK_EABI) \ 87 { \ 88 target_flags &= ~MASK_EABI; \ 89 error (INVALID_64BIT, "eabi"); \ 90 } \ 91 if (target_flags & MASK_PROTOTYPE) \ 92 { \ 93 target_flags &= ~MASK_PROTOTYPE; \ 94 error (INVALID_64BIT, "prototype"); \ 95 } \ 96 if ((target_flags & MASK_POWERPC64) == 0) \ 97 { \ 98 target_flags |= MASK_POWERPC64; \ 99 error ("-m64 requires a PowerPC64 cpu"); \ 100 } \ 101 } \ 102 else \ 103 { \ 104 if (!RS6000_BI_ARCH_P) \ 105 error (INVALID_32BIT, "32"); \ 106 if (TARGET_PROFILE_KERNEL) \ 107 { \ 108 target_flags &= ~MASK_PROFILE_KERNEL; \ 109 error (INVALID_32BIT, "profile-kernel"); \ 110 } \ 111 } \ 112 } \ 113 while (0) 114 115#ifdef RS6000_BI_ARCH 116 117#undef OVERRIDE_OPTIONS 118#define OVERRIDE_OPTIONS \ 119 rs6000_override_options (((TARGET_DEFAULT ^ target_flags) & MASK_64BIT) \ 120 ? (char *) 0 : TARGET_CPU_DEFAULT) 121 122#endif 123 124#undef ASM_DEFAULT_SPEC 125#undef ASM_SPEC 126#undef LINK_OS_LINUX_SPEC 127 128#ifndef RS6000_BI_ARCH 129#define ASM_DEFAULT_SPEC "-mppc64" 130#define ASM_SPEC "%(asm_spec64) %(asm_spec_common)" 131#define LINK_OS_LINUX_SPEC "%(link_os_linux_spec64)" 132#else 133#if DEFAULT_ARCH64_P 134#define ASM_DEFAULT_SPEC "-mppc%{!m32:64}" 135#define ASM_SPEC "%{m32:%(asm_spec32)}%{!m32:%(asm_spec64)} %(asm_spec_common)" 136#define LINK_OS_LINUX_SPEC "%{m32:%(link_os_linux_spec32)}%{!m32:%(link_os_linux_spec64)}" 137#else 138#define ASM_DEFAULT_SPEC "-mppc%{m64:64}" 139#define ASM_SPEC "%{!m64:%(asm_spec32)}%{m64:%(asm_spec64)} %(asm_spec_common)" 140#define LINK_OS_LINUX_SPEC "%{!m64:%(link_os_linux_spec32)}%{m64:%(link_os_linux_spec64)}" 141#endif 142#endif 143 144#define ASM_SPEC32 "-a32 %{n} %{T} %{Ym,*} %{Yd,*} \ 145%{mrelocatable} %{mrelocatable-lib} %{fpic:-K PIC} %{fPIC:-K PIC} \ 146%{memb} %{!memb: %{msdata: -memb} %{msdata=eabi: -memb}} \ 147%{!mlittle: %{!mlittle-endian: %{!mbig: %{!mbig-endian: \ 148 %{mcall-freebsd: -mbig} \ 149 %{mcall-i960-old: -mlittle} \ 150 %{mcall-linux: -mbig} \ 151 %{mcall-gnu: -mbig} \ 152 %{mcall-netbsd: -mbig} \ 153}}}}" 154 155#define ASM_SPEC64 "-a64" 156 157#define ASM_SPEC_COMMON "%(asm_cpu) \ 158%{.s: %{mregnames} %{mno-regnames}} %{.S: %{mregnames} %{mno-regnames}} \ 159%{v:-V} %{Qy:} %{!Qn:-Qy} %{Wa,*:%*} \ 160%{mlittle} %{mlittle-endian} %{mbig} %{mbig-endian}" 161 162#undef SUBSUBTARGET_EXTRA_SPECS 163#define SUBSUBTARGET_EXTRA_SPECS \ 164 { "asm_spec_common", ASM_SPEC_COMMON }, \ 165 { "asm_spec32", ASM_SPEC32 }, \ 166 { "asm_spec64", ASM_SPEC64 }, \ 167 { "link_os_linux_spec32", LINK_OS_LINUX_SPEC32 }, \ 168 { "link_os_linux_spec64", LINK_OS_LINUX_SPEC64 }, 169 170#undef MULTILIB_DEFAULTS 171#if DEFAULT_ARCH64_P 172#define MULTILIB_DEFAULTS { "m64" } 173#else 174#define MULTILIB_DEFAULTS { "m32" } 175#endif 176 177#ifndef RS6000_BI_ARCH 178 179/* 64-bit PowerPC Linux is always big-endian. */ 180#undef TARGET_LITTLE_ENDIAN 181#define TARGET_LITTLE_ENDIAN 0 182 183/* 64-bit PowerPC Linux always has a TOC. */ 184#undef TARGET_TOC 185#define TARGET_TOC 1 186 187/* Some things from sysv4.h we don't do when 64 bit. */ 188#undef TARGET_RELOCATABLE 189#define TARGET_RELOCATABLE 0 190#undef TARGET_EABI 191#define TARGET_EABI 0 192#undef TARGET_PROTOTYPE 193#define TARGET_PROTOTYPE 0 194#undef RELOCATABLE_NEEDS_FIXUP 195#define RELOCATABLE_NEEDS_FIXUP 0 196 197#endif 198 199#define MASK_PROFILE_KERNEL 0x00100000 200 201/* Non-standard profiling for kernels, which just saves LR then calls 202 _mcount without worrying about arg saves. The idea is to change 203 the function prologue as little as possible as it isn't easy to 204 account for arg save/restore code added just for _mcount. */ 205#define TARGET_PROFILE_KERNEL (target_flags & MASK_PROFILE_KERNEL) 206 207/* Override sysv4.h. */ 208#undef EXTRA_SUBTARGET_SWITCHES 209#define EXTRA_SUBTARGET_SWITCHES \ 210 {"profile-kernel", MASK_PROFILE_KERNEL, \ 211 N_("Call mcount for profiling before a function prologue") }, \ 212 {"no-profile-kernel", -MASK_PROFILE_KERNEL, \ 213 N_("Call mcount for profiling after a function prologue") }, 214 215/* We use glibc _mcount for profiling. */ 216#define NO_PROFILE_COUNTERS TARGET_64BIT 217#define PROFILE_HOOK(LABEL) \ 218 do { if (TARGET_64BIT) output_profile_hook (LABEL); } while (0) 219 220/* PowerPC64 Linux word-aligns FP doubles when -malign-power is given. */ 221#undef ADJUST_FIELD_ALIGN 222#define ADJUST_FIELD_ALIGN(FIELD, COMPUTED) \ 223 ((TARGET_ALTIVEC && TREE_CODE (TREE_TYPE (FIELD)) == VECTOR_TYPE) \ 224 ? 128 \ 225 : (TARGET_64BIT \ 226 && TARGET_ALIGN_NATURAL == 0 \ 227 && TYPE_MODE (TREE_CODE (TREE_TYPE (FIELD)) == ARRAY_TYPE \ 228 ? get_inner_array_type (FIELD) \ 229 : TREE_TYPE (FIELD)) == DFmode) \ 230 ? MIN ((COMPUTED), 32) \ 231 : (COMPUTED)) 232 233/* PowerPC64 Linux increases natural record alignment to doubleword if 234 the first field is an FP double, only if in power alignment mode. */ 235#undef ROUND_TYPE_ALIGN 236#define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED) \ 237 ((TARGET_ALTIVEC && TREE_CODE (STRUCT) == VECTOR_TYPE) \ 238 ? MAX (MAX ((COMPUTED), (SPECIFIED)), 128) \ 239 : (TARGET_64BIT \ 240 && (TREE_CODE (STRUCT) == RECORD_TYPE \ 241 || TREE_CODE (STRUCT) == UNION_TYPE \ 242 || TREE_CODE (STRUCT) == QUAL_UNION_TYPE) \ 243 && TARGET_ALIGN_NATURAL == 0) \ 244 ? rs6000_special_round_type_align (STRUCT, COMPUTED, SPECIFIED) \ 245 : MAX ((COMPUTED), (SPECIFIED))) 246 247/* Indicate that jump tables go in the text section. */ 248#undef JUMP_TABLES_IN_TEXT_SECTION 249#define JUMP_TABLES_IN_TEXT_SECTION TARGET_64BIT 250 251/* The linux ppc64 ABI isn't explicit on whether aggregates smaller 252 than a doubleword should be padded upward or downward. You could 253 reasonably assume that they follow the normal rules for structure 254 layout treating the parameter area as any other block of memory, 255 then map the reg param area to registers. ie. pad updard. 256 Setting both of the following defines results in this behavior. 257 Setting just the first one will result in aggregates that fit in a 258 doubleword being padded downward, and others being padded upward. 259 Not a bad idea as this results in struct { int x; } being passed 260 the same way as an int. */ 261#define AGGREGATE_PADDING_FIXED TARGET_64BIT 262#define AGGREGATES_PAD_UPWARD_ALWAYS 0 263 264/* We don't want anything in the reg parm area being passed on the 265 stack. */ 266#define MUST_PASS_IN_STACK(MODE, TYPE) \ 267 ((TARGET_64BIT \ 268 && (TYPE) != 0 \ 269 && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST \ 270 || TREE_ADDRESSABLE (TYPE))) \ 271 || (!TARGET_64BIT \ 272 && default_must_pass_in_stack ((MODE), (TYPE)))) 273 274/* Specify padding for the last element of a block move between 275 registers and memory. FIRST is nonzero if this is the only 276 element. */ 277#define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ 278 (!(FIRST) ? upward : FUNCTION_ARG_PADDING (MODE, TYPE)) 279 280/* __throw will restore its own return address to be the same as the 281 return address of the function that the throw is being made to. 282 This is unfortunate, because we want to check the original 283 return address to see if we need to restore the TOC. 284 So we have to squirrel it away with this. */ 285#define SETUP_FRAME_ADDRESSES() \ 286 do { if (TARGET_64BIT) rs6000_aix_emit_builtin_unwind_init (); } while (0) 287 288/* Override svr4.h */ 289#undef MD_EXEC_PREFIX 290#undef MD_STARTFILE_PREFIX 291 292/* Linux doesn't support saving and restoring 64-bit regs in a 32-bit 293 process. */ 294#define OS_MISSING_POWERPC64 !TARGET_64BIT 295 296/* glibc has float and long double forms of math functions. */ 297#undef TARGET_C99_FUNCTIONS 298#define TARGET_C99_FUNCTIONS 1 299 300#undef TARGET_OS_CPP_BUILTINS 301#define TARGET_OS_CPP_BUILTINS() \ 302 do \ 303 { \ 304 if (TARGET_64BIT) \ 305 { \ 306 builtin_define ("__PPC__"); \ 307 builtin_define ("__PPC64__"); \ 308 builtin_define ("__powerpc__"); \ 309 builtin_define ("__powerpc64__"); \ 310 builtin_define ("__PIC__"); \ 311 builtin_assert ("cpu=powerpc64"); \ 312 builtin_assert ("machine=powerpc64"); \ 313 } \ 314 else \ 315 { \ 316 builtin_define_std ("PPC"); \ 317 builtin_define_std ("powerpc"); \ 318 builtin_assert ("cpu=powerpc"); \ 319 builtin_assert ("machine=powerpc"); \ 320 TARGET_OS_SYSV_CPP_BUILTINS (); \ 321 } \ 322 } \ 323 while (0) 324 325#undef CPP_OS_DEFAULT_SPEC 326#define CPP_OS_DEFAULT_SPEC "%(cpp_os_linux)" 327 328/* The GNU C++ standard library currently requires _GNU_SOURCE being 329 defined on glibc-based systems. This temporary hack accomplishes this, 330 it should go away as soon as libstdc++-v3 has a real fix. */ 331#undef CPLUSPLUS_CPP_SPEC 332#define CPLUSPLUS_CPP_SPEC "-D_GNU_SOURCE %(cpp)" 333 334#undef LINK_SHLIB_SPEC 335#define LINK_SHLIB_SPEC "%{shared:-shared} %{!shared: %{static:-static}}" 336 337#undef LIB_DEFAULT_SPEC 338#define LIB_DEFAULT_SPEC "%(lib_linux)" 339 340#undef STARTFILE_DEFAULT_SPEC 341#define STARTFILE_DEFAULT_SPEC "%(startfile_linux)" 342 343#undef ENDFILE_DEFAULT_SPEC 344#define ENDFILE_DEFAULT_SPEC "%(endfile_linux)" 345 346#undef LINK_START_DEFAULT_SPEC 347#define LINK_START_DEFAULT_SPEC "%(link_start_linux)" 348 349#undef LINK_OS_DEFAULT_SPEC 350#define LINK_OS_DEFAULT_SPEC "%(link_os_linux)" 351 352#define LINK_OS_LINUX_SPEC32 "-m elf32ppclinux %{!shared: %{!static: \ 353 %{rdynamic:-export-dynamic} \ 354 %{!dynamic-linker:-dynamic-linker /lib/ld.so.1}}}" 355 356#define LINK_OS_LINUX_SPEC64 "-m elf64ppc %{!shared: %{!static: \ 357 %{rdynamic:-export-dynamic} \ 358 %{!dynamic-linker:-dynamic-linker /lib64/ld64.so.1}}}" 359 360#undef TOC_SECTION_ASM_OP 361#define TOC_SECTION_ASM_OP \ 362 (TARGET_64BIT \ 363 ? "\t.section\t\".toc\",\"aw\"" \ 364 : "\t.section\t\".got\",\"aw\"") 365 366#undef MINIMAL_TOC_SECTION_ASM_OP 367#define MINIMAL_TOC_SECTION_ASM_OP \ 368 (TARGET_64BIT \ 369 ? "\t.section\t\".toc1\",\"aw\"" \ 370 : ((TARGET_RELOCATABLE || flag_pic) \ 371 ? "\t.section\t\".got2\",\"aw\"" \ 372 : "\t.section\t\".got1\",\"aw\"")) 373 374#undef TARGET_VERSION 375#define TARGET_VERSION fprintf (stderr, " (PowerPC64 GNU/Linux)"); 376 377/* Must be at least as big as our pointer type. */ 378#undef SIZE_TYPE 379#define SIZE_TYPE (TARGET_64BIT ? "long unsigned int" : "unsigned int") 380 381#undef PTRDIFF_TYPE 382#define PTRDIFF_TYPE (TARGET_64BIT ? "long int" : "int") 383 384#undef WCHAR_TYPE 385#define WCHAR_TYPE (TARGET_64BIT ? "int" : "long int") 386#undef WCHAR_TYPE_SIZE 387#define WCHAR_TYPE_SIZE 32 388 389/* Override rs6000.h definition. */ 390#undef ASM_APP_ON 391#define ASM_APP_ON "#APP\n" 392 393/* Override rs6000.h definition. */ 394#undef ASM_APP_OFF 395#define ASM_APP_OFF "#NO_APP\n" 396 397/* PowerPC no-op instruction. */ 398#undef RS6000_CALL_GLUE 399#define RS6000_CALL_GLUE (TARGET_64BIT ? "nop" : "cror 31,31,31") 400 401#undef RS6000_MCOUNT 402#define RS6000_MCOUNT "_mcount" 403 404#ifdef __powerpc64__ 405/* _init and _fini functions are built from bits spread across many 406 object files, each potentially with a different TOC pointer. For 407 that reason, place a nop after the call so that the linker can 408 restore the TOC pointer if a TOC adjusting call stub is needed. */ 409#define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC) \ 410 asm (SECTION_OP "\n" \ 411" bl ." #FUNC "\n" \ 412" nop\n" \ 413" .previous"); 414#endif 415 416/* FP save and restore routines. */ 417#undef SAVE_FP_PREFIX 418#define SAVE_FP_PREFIX (TARGET_64BIT ? "._savef" : "_savefpr_") 419#undef SAVE_FP_SUFFIX 420#define SAVE_FP_SUFFIX (TARGET_64BIT ? "" : "_l") 421#undef RESTORE_FP_PREFIX 422#define RESTORE_FP_PREFIX (TARGET_64BIT ? "._restf" : "_restfpr_") 423#undef RESTORE_FP_SUFFIX 424#define RESTORE_FP_SUFFIX (TARGET_64BIT ? "" : "_l") 425 426/* Dwarf2 debugging. */ 427#undef PREFERRED_DEBUGGING_TYPE 428#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG 429 430/* This is how to declare the size of a function. */ 431#undef ASM_DECLARE_FUNCTION_SIZE 432#define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \ 433 do \ 434 { \ 435 if (!flag_inhibit_size_directive) \ 436 { \ 437 fputs ("\t.size\t", (FILE)); \ 438 if (TARGET_64BIT) \ 439 putc ('.', (FILE)); \ 440 assemble_name ((FILE), (FNAME)); \ 441 fputs (",.-", (FILE)); \ 442 if (TARGET_64BIT) \ 443 putc ('.', (FILE)); \ 444 assemble_name ((FILE), (FNAME)); \ 445 putc ('\n', (FILE)); \ 446 } \ 447 } \ 448 while (0) 449 450/* Return nonzero if this entry is to be written into the constant 451 pool in a special way. We do so if this is a SYMBOL_REF, LABEL_REF 452 or a CONST containing one of them. If -mfp-in-toc (the default), 453 we also do this for floating-point constants. We actually can only 454 do this if the FP formats of the target and host machines are the 455 same, but we can't check that since not every file that uses 456 GO_IF_LEGITIMATE_ADDRESS_P includes real.h. We also do this when 457 we can write the entry into the TOC and the entry is not larger 458 than a TOC entry. */ 459 460#undef ASM_OUTPUT_SPECIAL_POOL_ENTRY_P 461#define ASM_OUTPUT_SPECIAL_POOL_ENTRY_P(X, MODE) \ 462 (TARGET_TOC \ 463 && (GET_CODE (X) == SYMBOL_REF \ 464 || (GET_CODE (X) == CONST && GET_CODE (XEXP (X, 0)) == PLUS \ 465 && GET_CODE (XEXP (XEXP (X, 0), 0)) == SYMBOL_REF) \ 466 || GET_CODE (X) == LABEL_REF \ 467 || (GET_CODE (X) == CONST_INT \ 468 && GET_MODE_BITSIZE (MODE) <= GET_MODE_BITSIZE (Pmode)) \ 469 || (GET_CODE (X) == CONST_DOUBLE \ 470 && ((TARGET_64BIT \ 471 && (TARGET_POWERPC64 \ 472 || TARGET_MINIMAL_TOC \ 473 || (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT \ 474 && ! TARGET_NO_FP_IN_TOC))) \ 475 || (!TARGET_64BIT \ 476 && !TARGET_NO_FP_IN_TOC \ 477 && !TARGET_RELOCATABLE \ 478 && GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT \ 479 && BITS_PER_WORD == HOST_BITS_PER_INT))))) 480 481/* This is the same as the dbxelf.h version, except that we need to 482 use the function code label, not the function descriptor. */ 483#undef ASM_OUTPUT_SOURCE_LINE 484#define ASM_OUTPUT_SOURCE_LINE(FILE, LINE, COUNTER) \ 485do \ 486 { \ 487 char temp[256]; \ 488 ASM_GENERATE_INTERNAL_LABEL (temp, "LM", COUNTER); \ 489 fprintf (FILE, "\t.stabn 68,0,%d,", LINE); \ 490 assemble_name (FILE, temp); \ 491 putc ('-', FILE); \ 492 if (TARGET_64BIT) \ 493 putc ('.', FILE); \ 494 assemble_name (FILE, \ 495 XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));\ 496 putc ('\n', FILE); \ 497 (*targetm.asm_out.internal_label) (FILE, "LM", COUNTER); \ 498 } \ 499while (0) 500 501/* Similarly, we want the function code label here. */ 502#define DBX_OUTPUT_BRAC(FILE, NAME, BRAC) \ 503 do \ 504 { \ 505 const char *flab; \ 506 fprintf (FILE, "%s%d,0,0,", ASM_STABN_OP, BRAC); \ 507 assemble_name (FILE, NAME); \ 508 putc ('-', FILE); \ 509 if (current_function_func_begin_label != NULL_TREE) \ 510 flab = IDENTIFIER_POINTER (current_function_func_begin_label); \ 511 else \ 512 { \ 513 if (TARGET_64BIT) \ 514 putc ('.', FILE); \ 515 flab = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); \ 516 } \ 517 assemble_name (FILE, flab); \ 518 putc ('\n', FILE); \ 519 } \ 520 while (0) 521 522#define DBX_OUTPUT_LBRAC(FILE, NAME) DBX_OUTPUT_BRAC (FILE, NAME, N_LBRAC) 523#define DBX_OUTPUT_RBRAC(FILE, NAME) DBX_OUTPUT_BRAC (FILE, NAME, N_RBRAC) 524 525/* Another case where we want the dot name. */ 526#define DBX_OUTPUT_NFUN(FILE, LSCOPE, DECL) \ 527 do \ 528 { \ 529 fprintf (FILE, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN); \ 530 assemble_name (FILE, LSCOPE); \ 531 putc ('-', FILE); \ 532 if (TARGET_64BIT) \ 533 putc ('.', FILE); \ 534 assemble_name (FILE, XSTR (XEXP (DECL_RTL (DECL), 0), 0)); \ 535 putc ('\n', FILE); \ 536 } \ 537 while (0) 538 539/* Select a format to encode pointers in exception handling data. CODE 540 is 0 for data, 1 for code labels, 2 for function pointers. GLOBAL is 541 true if the symbol may be affected by dynamic relocations. */ 542#undef ASM_PREFERRED_EH_DATA_FORMAT 543#define ASM_PREFERRED_EH_DATA_FORMAT(CODE, GLOBAL) \ 544 ((TARGET_64BIT || flag_pic || TARGET_RELOCATABLE) \ 545 ? (((GLOBAL) ? DW_EH_PE_indirect : 0) | DW_EH_PE_pcrel \ 546 | (TARGET_64BIT ? DW_EH_PE_udata8 : DW_EH_PE_sdata4)) \ 547 : DW_EH_PE_absptr) 548 549/* For backward compatibility, we must continue to use the AIX 550 structure return convention. */ 551#undef DRAFT_V4_STRUCT_RET 552#define DRAFT_V4_STRUCT_RET (!TARGET_64BIT) 553 554#define TARGET_ASM_FILE_END rs6000_elf_end_indicate_exec_stack 555 556#define TARGET_HAS_F_SETLKW 557 558#define LINK_GCC_C_SEQUENCE_SPEC \ 559 "%{static:--start-group} %G %L %{static:--end-group}%{!static:%G}" 560 561#ifdef IN_LIBGCC2 562#include "config/rs6000/linux-unwind.h" 563#endif 564