1/* Definitions of target machine for GNU compiler, 2 for 64 bit PowerPC linux. 3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, 51 Franklin Street, Fifth Floor, Boston, 21 MA 02110-1301, 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#ifdef HAVE_LD_NO_DOT_SYMS 54/* New ABI uses a local sym for the function entry point. */ 55extern int dot_symbols; 56#undef DOT_SYMBOLS 57#define DOT_SYMBOLS dot_symbols 58#endif 59 60#undef PROCESSOR_DEFAULT 61#define PROCESSOR_DEFAULT PROCESSOR_POWER4 62#undef PROCESSOR_DEFAULT64 63#define PROCESSOR_DEFAULT64 PROCESSOR_POWER4 64 65/* We don't need to generate entries in .fixup, except when 66 -mrelocatable or -mrelocatable-lib is given. */ 67#undef RELOCATABLE_NEEDS_FIXUP 68#define RELOCATABLE_NEEDS_FIXUP \ 69 (target_flags & target_flags_explicit & MASK_RELOCATABLE) 70 71#undef RS6000_ABI_NAME 72#define RS6000_ABI_NAME "linux" 73 74#define INVALID_64BIT "-m%s not supported in this configuration" 75#define INVALID_32BIT INVALID_64BIT 76 77#undef SUBSUBTARGET_OVERRIDE_OPTIONS 78#define SUBSUBTARGET_OVERRIDE_OPTIONS \ 79 do \ 80 { \ 81 if (!rs6000_explicit_options.alignment) \ 82 rs6000_alignment_flags = MASK_ALIGN_NATURAL; \ 83 if (TARGET_64BIT) \ 84 { \ 85 if (DEFAULT_ABI != ABI_AIX) \ 86 { \ 87 rs6000_current_abi = ABI_AIX; \ 88 error (INVALID_64BIT, "call"); \ 89 } \ 90 dot_symbols = !strcmp (rs6000_abi_name, "aixdesc"); \ 91 if (target_flags & MASK_RELOCATABLE) \ 92 { \ 93 target_flags &= ~MASK_RELOCATABLE; \ 94 error (INVALID_64BIT, "relocatable"); \ 95 } \ 96 if (target_flags & MASK_EABI) \ 97 { \ 98 target_flags &= ~MASK_EABI; \ 99 error (INVALID_64BIT, "eabi"); \ 100 } \ 101 if (target_flags & MASK_PROTOTYPE) \ 102 { \ 103 target_flags &= ~MASK_PROTOTYPE; \ 104 error (INVALID_64BIT, "prototype"); \ 105 } \ 106 if ((target_flags & MASK_POWERPC64) == 0) \ 107 { \ 108 target_flags |= MASK_POWERPC64; \ 109 error ("-m64 requires a PowerPC64 cpu"); \ 110 } \ 111 } \ 112 else \ 113 { \ 114 if (!RS6000_BI_ARCH_P) \ 115 error (INVALID_32BIT, "32"); \ 116 if (TARGET_PROFILE_KERNEL) \ 117 { \ 118 target_flags &= ~MASK_PROFILE_KERNEL; \ 119 error (INVALID_32BIT, "profile-kernel"); \ 120 } \ 121 } \ 122 } \ 123 while (0) 124 125#ifdef RS6000_BI_ARCH 126 127#undef OVERRIDE_OPTIONS 128#define OVERRIDE_OPTIONS \ 129 rs6000_override_options (((TARGET_DEFAULT ^ target_flags) & MASK_64BIT) \ 130 ? (char *) 0 : TARGET_CPU_DEFAULT) 131 132#endif 133 134#undef ASM_DEFAULT_SPEC 135#undef ASM_SPEC 136#undef LINK_OS_LINUX_SPEC 137 138#ifndef RS6000_BI_ARCH 139#define ASM_DEFAULT_SPEC "-mppc64" 140#define ASM_SPEC "%(asm_spec64) %(asm_spec_common)" 141#define LINK_OS_LINUX_SPEC "%(link_os_linux_spec64)" 142#else 143#if DEFAULT_ARCH64_P 144#define ASM_DEFAULT_SPEC "-mppc%{!m32:64}" 145#define ASM_SPEC "%{m32:%(asm_spec32)}%{!m32:%(asm_spec64)} %(asm_spec_common)" 146#define LINK_OS_LINUX_SPEC "%{m32:%(link_os_linux_spec32)}%{!m32:%(link_os_linux_spec64)}" 147#else 148#define ASM_DEFAULT_SPEC "-mppc%{m64:64}" 149#define ASM_SPEC "%{!m64:%(asm_spec32)}%{m64:%(asm_spec64)} %(asm_spec_common)" 150#define LINK_OS_LINUX_SPEC "%{!m64:%(link_os_linux_spec32)}%{m64:%(link_os_linux_spec64)}" 151#endif 152#endif 153 154#define ASM_SPEC32 "-a32 %{n} %{T} %{Ym,*} %{Yd,*} \ 155%{mrelocatable} %{mrelocatable-lib} %{fpic:-K PIC} %{fPIC:-K PIC} \ 156%{memb} %{!memb: %{msdata: -memb} %{msdata=eabi: -memb}} \ 157%{!mlittle: %{!mlittle-endian: %{!mbig: %{!mbig-endian: \ 158 %{mcall-freebsd: -mbig} \ 159 %{mcall-i960-old: -mlittle} \ 160 %{mcall-linux: -mbig} \ 161 %{mcall-gnu: -mbig} \ 162 %{mcall-netbsd: -mbig} \ 163}}}}" 164 165#define ASM_SPEC64 "-a64" 166 167#define ASM_SPEC_COMMON "%(asm_cpu) \ 168%{.s: %{mregnames} %{mno-regnames}} %{.S: %{mregnames} %{mno-regnames}} \ 169%{v:-V} %{Qy:} %{!Qn:-Qy} %{Wa,*:%*} \ 170%{mlittle} %{mlittle-endian} %{mbig} %{mbig-endian}" 171 172#undef SUBSUBTARGET_EXTRA_SPECS 173#define SUBSUBTARGET_EXTRA_SPECS \ 174 { "asm_spec_common", ASM_SPEC_COMMON }, \ 175 { "asm_spec32", ASM_SPEC32 }, \ 176 { "asm_spec64", ASM_SPEC64 }, \ 177 { "link_os_linux_spec32", LINK_OS_LINUX_SPEC32 }, \ 178 { "link_os_linux_spec64", LINK_OS_LINUX_SPEC64 }, 179 180#undef MULTILIB_DEFAULTS 181#if DEFAULT_ARCH64_P 182#define MULTILIB_DEFAULTS { "m64" } 183#else 184#define MULTILIB_DEFAULTS { "m32" } 185#endif 186 187#ifndef RS6000_BI_ARCH 188 189/* 64-bit PowerPC Linux is always big-endian. */ 190#undef TARGET_LITTLE_ENDIAN 191#define TARGET_LITTLE_ENDIAN 0 192 193/* 64-bit PowerPC Linux always has a TOC. */ 194#undef TARGET_TOC 195#define TARGET_TOC 1 196 197/* Some things from sysv4.h we don't do when 64 bit. */ 198#undef TARGET_RELOCATABLE 199#define TARGET_RELOCATABLE 0 200#undef TARGET_EABI 201#define TARGET_EABI 0 202#undef TARGET_PROTOTYPE 203#define TARGET_PROTOTYPE 0 204#undef RELOCATABLE_NEEDS_FIXUP 205#define RELOCATABLE_NEEDS_FIXUP 0 206 207#endif 208 209/* We use glibc _mcount for profiling. */ 210#define NO_PROFILE_COUNTERS 1 211#define PROFILE_HOOK(LABEL) \ 212 do { if (TARGET_64BIT) output_profile_hook (LABEL); } while (0) 213 214/* PowerPC64 Linux word-aligns FP doubles when -malign-power is given. */ 215#undef ADJUST_FIELD_ALIGN 216#define ADJUST_FIELD_ALIGN(FIELD, COMPUTED) \ 217 ((TARGET_ALTIVEC && TREE_CODE (TREE_TYPE (FIELD)) == VECTOR_TYPE) \ 218 ? 128 \ 219 : (TARGET_64BIT \ 220 && TARGET_ALIGN_NATURAL == 0 \ 221 && TYPE_MODE (TREE_CODE (TREE_TYPE (FIELD)) == ARRAY_TYPE \ 222 ? get_inner_array_type (FIELD) \ 223 : TREE_TYPE (FIELD)) == DFmode) \ 224 ? MIN ((COMPUTED), 32) \ 225 : (COMPUTED)) 226 227/* PowerPC64 Linux increases natural record alignment to doubleword if 228 the first field is an FP double, only if in power alignment mode. */ 229#undef ROUND_TYPE_ALIGN 230#define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED) \ 231 ((TARGET_64BIT \ 232 && (TREE_CODE (STRUCT) == RECORD_TYPE \ 233 || TREE_CODE (STRUCT) == UNION_TYPE \ 234 || TREE_CODE (STRUCT) == QUAL_UNION_TYPE) \ 235 && TARGET_ALIGN_NATURAL == 0) \ 236 ? rs6000_special_round_type_align (STRUCT, COMPUTED, SPECIFIED) \ 237 : MAX ((COMPUTED), (SPECIFIED))) 238 239/* Use the default for compiling target libs. */ 240#ifdef IN_TARGET_LIBS 241#undef TARGET_ALIGN_NATURAL 242#define TARGET_ALIGN_NATURAL 1 243#endif 244 245/* Indicate that jump tables go in the text section. */ 246#undef JUMP_TABLES_IN_TEXT_SECTION 247#define JUMP_TABLES_IN_TEXT_SECTION TARGET_64BIT 248 249/* The linux ppc64 ABI isn't explicit on whether aggregates smaller 250 than a doubleword should be padded upward or downward. You could 251 reasonably assume that they follow the normal rules for structure 252 layout treating the parameter area as any other block of memory, 253 then map the reg param area to registers. i.e. pad upward. 254 Setting both of the following defines results in this behavior. 255 Setting just the first one will result in aggregates that fit in a 256 doubleword being padded downward, and others being padded upward. 257 Not a bad idea as this results in struct { int x; } being passed 258 the same way as an int. */ 259#define AGGREGATE_PADDING_FIXED TARGET_64BIT 260#define AGGREGATES_PAD_UPWARD_ALWAYS 0 261 262/* Specify padding for the last element of a block move between 263 registers and memory. FIRST is nonzero if this is the only 264 element. */ 265#define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ 266 (!(FIRST) ? upward : FUNCTION_ARG_PADDING (MODE, TYPE)) 267 268/* __throw will restore its own return address to be the same as the 269 return address of the function that the throw is being made to. 270 This is unfortunate, because we want to check the original 271 return address to see if we need to restore the TOC. 272 So we have to squirrel it away with this. */ 273#define SETUP_FRAME_ADDRESSES() \ 274 do { if (TARGET_64BIT) rs6000_aix_emit_builtin_unwind_init (); } while (0) 275 276/* Override svr4.h */ 277#undef MD_EXEC_PREFIX 278#undef MD_STARTFILE_PREFIX 279 280/* Linux doesn't support saving and restoring 64-bit regs in a 32-bit 281 process. */ 282#define OS_MISSING_POWERPC64 !TARGET_64BIT 283 284/* glibc has float and long double forms of math functions. */ 285#undef TARGET_C99_FUNCTIONS 286#define TARGET_C99_FUNCTIONS (OPTION_GLIBC) 287 288#undef TARGET_OS_CPP_BUILTINS 289#define TARGET_OS_CPP_BUILTINS() \ 290 do \ 291 { \ 292 if (TARGET_64BIT) \ 293 { \ 294 builtin_define ("__PPC__"); \ 295 builtin_define ("__PPC64__"); \ 296 builtin_define ("__powerpc__"); \ 297 builtin_define ("__powerpc64__"); \ 298 builtin_assert ("cpu=powerpc64"); \ 299 builtin_assert ("machine=powerpc64"); \ 300 } \ 301 else \ 302 { \ 303 builtin_define_std ("PPC"); \ 304 builtin_define_std ("powerpc"); \ 305 builtin_assert ("cpu=powerpc"); \ 306 builtin_assert ("machine=powerpc"); \ 307 TARGET_OS_SYSV_CPP_BUILTINS (); \ 308 } \ 309 } \ 310 while (0) 311 312#undef CPP_OS_DEFAULT_SPEC 313#define CPP_OS_DEFAULT_SPEC "%(cpp_os_linux)" 314 315/* The GNU C++ standard library currently requires _GNU_SOURCE being 316 defined on glibc-based systems. This temporary hack accomplishes this, 317 it should go away as soon as libstdc++-v3 has a real fix. */ 318#undef CPLUSPLUS_CPP_SPEC 319#define CPLUSPLUS_CPP_SPEC "-D_GNU_SOURCE %(cpp)" 320 321#undef LINK_SHLIB_SPEC 322#define LINK_SHLIB_SPEC "%{shared:-shared} %{!shared: %{static:-static}}" 323 324#undef LIB_DEFAULT_SPEC 325#define LIB_DEFAULT_SPEC "%(lib_linux)" 326 327#undef STARTFILE_DEFAULT_SPEC 328#define STARTFILE_DEFAULT_SPEC "%(startfile_linux)" 329 330#undef ENDFILE_DEFAULT_SPEC 331#define ENDFILE_DEFAULT_SPEC "%(endfile_linux)" 332 333#undef LINK_START_DEFAULT_SPEC 334#define LINK_START_DEFAULT_SPEC "%(link_start_linux)" 335 336#undef LINK_OS_DEFAULT_SPEC 337#define LINK_OS_DEFAULT_SPEC "%(link_os_linux)" 338 339#define GLIBC_DYNAMIC_LINKER32 "/lib/ld.so.1" 340#define GLIBC_DYNAMIC_LINKER64 "/lib64/ld64.so.1" 341#define UCLIBC_DYNAMIC_LINKER32 "/lib/ld-uClibc.so.0" 342#define UCLIBC_DYNAMIC_LINKER64 "/lib/ld64-uClibc.so.0" 343#if UCLIBC_DEFAULT 344#define CHOOSE_DYNAMIC_LINKER(G, U) "%{mglibc:%{muclibc:%e-mglibc and -muclibc used together}" G ";:" U "}" 345#else 346#define CHOOSE_DYNAMIC_LINKER(G, U) "%{muclibc:%{mglibc:%e-mglibc and -muclibc used together}" U ";:" G "}" 347#endif 348#define LINUX_DYNAMIC_LINKER32 \ 349 CHOOSE_DYNAMIC_LINKER (GLIBC_DYNAMIC_LINKER32, UCLIBC_DYNAMIC_LINKER32) 350#define LINUX_DYNAMIC_LINKER64 \ 351 CHOOSE_DYNAMIC_LINKER (GLIBC_DYNAMIC_LINKER64, UCLIBC_DYNAMIC_LINKER64) 352 353 354#define LINK_OS_LINUX_SPEC32 "-m elf32ppclinux %{!shared: %{!static: \ 355 %{rdynamic:-export-dynamic} \ 356 %{!dynamic-linker:-dynamic-linker " LINUX_DYNAMIC_LINKER32 "}}}" 357 358#define LINK_OS_LINUX_SPEC64 "-m elf64ppc %{!shared: %{!static: \ 359 %{rdynamic:-export-dynamic} \ 360 %{!dynamic-linker:-dynamic-linker " LINUX_DYNAMIC_LINKER64 "}}}" 361 362#undef TOC_SECTION_ASM_OP 363#define TOC_SECTION_ASM_OP \ 364 (TARGET_64BIT \ 365 ? "\t.section\t\".toc\",\"aw\"" \ 366 : "\t.section\t\".got\",\"aw\"") 367 368#undef MINIMAL_TOC_SECTION_ASM_OP 369#define MINIMAL_TOC_SECTION_ASM_OP \ 370 (TARGET_64BIT \ 371 ? "\t.section\t\".toc1\",\"aw\"" \ 372 : ((TARGET_RELOCATABLE || flag_pic) \ 373 ? "\t.section\t\".got2\",\"aw\"" \ 374 : "\t.section\t\".got1\",\"aw\"")) 375 376#undef TARGET_VERSION 377#define TARGET_VERSION fprintf (stderr, " (PowerPC64 GNU/Linux)"); 378 379/* Must be at least as big as our pointer type. */ 380#undef SIZE_TYPE 381#define SIZE_TYPE (TARGET_64BIT ? "long unsigned int" : "unsigned int") 382 383#undef PTRDIFF_TYPE 384#define PTRDIFF_TYPE (TARGET_64BIT ? "long int" : "int") 385 386#undef WCHAR_TYPE 387#define WCHAR_TYPE (TARGET_64BIT ? "int" : "long int") 388#undef WCHAR_TYPE_SIZE 389#define WCHAR_TYPE_SIZE 32 390 391/* Override rs6000.h definition. */ 392#undef ASM_APP_ON 393#define ASM_APP_ON "#APP\n" 394 395/* Override rs6000.h definition. */ 396#undef ASM_APP_OFF 397#define ASM_APP_OFF "#NO_APP\n" 398 399/* PowerPC no-op instruction. */ 400#undef RS6000_CALL_GLUE 401#define RS6000_CALL_GLUE (TARGET_64BIT ? "nop" : "cror 31,31,31") 402 403#undef RS6000_MCOUNT 404#define RS6000_MCOUNT "_mcount" 405 406#ifdef __powerpc64__ 407/* _init and _fini functions are built from bits spread across many 408 object files, each potentially with a different TOC pointer. For 409 that reason, place a nop after the call so that the linker can 410 restore the TOC pointer if a TOC adjusting call stub is needed. */ 411#if DOT_SYMBOLS 412#define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC) \ 413 asm (SECTION_OP "\n" \ 414" bl ." #FUNC "\n" \ 415" nop\n" \ 416" .previous"); 417#else 418#define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC) \ 419 asm (SECTION_OP "\n" \ 420" bl " #FUNC "\n" \ 421" nop\n" \ 422" .previous"); 423#endif 424#endif 425 426/* FP save and restore routines. */ 427#undef SAVE_FP_PREFIX 428#define SAVE_FP_PREFIX (TARGET_64BIT ? "._savef" : "_savefpr_") 429#undef SAVE_FP_SUFFIX 430#define SAVE_FP_SUFFIX (TARGET_64BIT ? "" : "_l") 431#undef RESTORE_FP_PREFIX 432#define RESTORE_FP_PREFIX (TARGET_64BIT ? "._restf" : "_restfpr_") 433#undef RESTORE_FP_SUFFIX 434#define RESTORE_FP_SUFFIX (TARGET_64BIT ? "" : "_l") 435 436/* Dwarf2 debugging. */ 437#undef PREFERRED_DEBUGGING_TYPE 438#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG 439 440/* This is how to declare the size of a function. */ 441#undef ASM_DECLARE_FUNCTION_SIZE 442#define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \ 443 do \ 444 { \ 445 if (!flag_inhibit_size_directive) \ 446 { \ 447 fputs ("\t.size\t", (FILE)); \ 448 if (TARGET_64BIT && DOT_SYMBOLS) \ 449 putc ('.', (FILE)); \ 450 assemble_name ((FILE), (FNAME)); \ 451 fputs (",.-", (FILE)); \ 452 rs6000_output_function_entry (FILE, FNAME); \ 453 putc ('\n', (FILE)); \ 454 } \ 455 } \ 456 while (0) 457 458/* Return nonzero if this entry is to be written into the constant 459 pool in a special way. We do so if this is a SYMBOL_REF, LABEL_REF 460 or a CONST containing one of them. If -mfp-in-toc (the default), 461 we also do this for floating-point constants. We actually can only 462 do this if the FP formats of the target and host machines are the 463 same, but we can't check that since not every file that uses 464 GO_IF_LEGITIMATE_ADDRESS_P includes real.h. We also do this when 465 we can write the entry into the TOC and the entry is not larger 466 than a TOC entry. */ 467 468#undef ASM_OUTPUT_SPECIAL_POOL_ENTRY_P 469#define ASM_OUTPUT_SPECIAL_POOL_ENTRY_P(X, MODE) \ 470 (TARGET_TOC \ 471 && (GET_CODE (X) == SYMBOL_REF \ 472 || (GET_CODE (X) == CONST && GET_CODE (XEXP (X, 0)) == PLUS \ 473 && GET_CODE (XEXP (XEXP (X, 0), 0)) == SYMBOL_REF) \ 474 || GET_CODE (X) == LABEL_REF \ 475 || (GET_CODE (X) == CONST_INT \ 476 && GET_MODE_BITSIZE (MODE) <= GET_MODE_BITSIZE (Pmode)) \ 477 || (GET_CODE (X) == CONST_DOUBLE \ 478 && ((TARGET_64BIT \ 479 && (TARGET_POWERPC64 \ 480 || TARGET_MINIMAL_TOC \ 481 || (SCALAR_FLOAT_MODE_P (GET_MODE (X)) \ 482 && ! TARGET_NO_FP_IN_TOC))) \ 483 || (!TARGET_64BIT \ 484 && !TARGET_NO_FP_IN_TOC \ 485 && !TARGET_RELOCATABLE \ 486 && SCALAR_FLOAT_MODE_P (GET_MODE (X)) \ 487 && BITS_PER_WORD == HOST_BITS_PER_INT))))) 488 489/* Select a format to encode pointers in exception handling data. CODE 490 is 0 for data, 1 for code labels, 2 for function pointers. GLOBAL is 491 true if the symbol may be affected by dynamic relocations. */ 492#undef ASM_PREFERRED_EH_DATA_FORMAT 493#define ASM_PREFERRED_EH_DATA_FORMAT(CODE, GLOBAL) \ 494 ((TARGET_64BIT || flag_pic || TARGET_RELOCATABLE) \ 495 ? (((GLOBAL) ? DW_EH_PE_indirect : 0) | DW_EH_PE_pcrel \ 496 | (TARGET_64BIT ? DW_EH_PE_udata8 : DW_EH_PE_sdata4)) \ 497 : DW_EH_PE_absptr) 498 499/* For backward compatibility, we must continue to use the AIX 500 structure return convention. */ 501#undef DRAFT_V4_STRUCT_RET 502#define DRAFT_V4_STRUCT_RET (!TARGET_64BIT) 503 504#define TARGET_ASM_FILE_END rs6000_elf_end_indicate_exec_stack 505 506#define TARGET_POSIX_IO 507 508#define LINK_GCC_C_SEQUENCE_SPEC \ 509 "%{static:--start-group} %G %L %{static:--end-group}%{!static:%G}" 510 511/* Use --as-needed -lgcc_s for eh support. */ 512#ifdef HAVE_LD_AS_NEEDED 513#define USE_LD_AS_NEEDED 1 514#endif 515 516#define MD_UNWIND_SUPPORT "config/rs6000/linux-unwind.h" 517 518#ifdef TARGET_LIBC_PROVIDES_SSP 519/* ppc32 glibc provides __stack_chk_guard in -0x7008(2), 520 ppc64 glibc provides it at -0x7010(13). */ 521#define TARGET_THREAD_SSP_OFFSET (TARGET_64BIT ? -0x7010 : -0x7008) 522#endif 523 524#define POWERPC_LINUX 525 526/* ppc{32,64} linux has 128-bit long double support in glibc 2.4 and later. */ 527#ifdef TARGET_DEFAULT_LONG_DOUBLE_128 528#define RS6000_DEFAULT_LONG_DOUBLE_SIZE 128 529#endif 530