gcc/config/rs6000/linux64.h

   1 /* Definitions of target machine for GNU compiler,
   2    for 64 bit PowerPC linux.
   3    Copyright (C) 2000, 2001, 2002, 2003, 2004
   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 #undef  TARGET_RELOCATABLE
  57 #define TARGET_RELOCATABLE (!TARGET_64BIT && (target_flags & MASK_RELOCATABLE))
  58
  59 #undef  RS6000_ABI_NAME
  60 #define RS6000_ABI_NAME (TARGET_64BIT ? "aixdesc" : "sysv")
  61
  62 #define INVALID_64BIT "-m%s not supported in this configuration"
  63 #define INVALID_32BIT INVALID_64BIT
  64
  65 #undef  SUBSUBTARGET_OVERRIDE_OPTIONS
  66 #define SUBSUBTARGET_OVERRIDE_OPTIONS                           \
  67   do                                                            \
  68     {                                                           \
  69       if (rs6000_alignment_string == 0)                         \
  70         rs6000_alignment_flags = MASK_ALIGN_NATURAL;            \
  71       if (TARGET_64BIT)                                         \
  72         {                                                       \
  73           if (DEFAULT_ABI != ABI_AIX)                           \
  74             {                                                   \
  75               rs6000_current_abi = ABI_AIX;                     \
  76               error (INVALID_64BIT, "call");                    \
  77             }                                                   \
  78           if (target_flags & MASK_RELOCATABLE)                  \
  79             {                                                   \
  80               target_flags &= ~MASK_RELOCATABLE;                \
  81               error (INVALID_64BIT, "relocatable");             \
  82             }                                                   \
  83           if (target_flags & MASK_EABI)                         \
  84             {                                                   \
  85               target_flags &= ~MASK_EABI;                       \
  86               error (INVALID_64BIT, "eabi");                    \
  87             }                                                   \
  88           if (target_flags & MASK_PROTOTYPE)                    \
  89             {                                                   \
  90               target_flags &= ~MASK_PROTOTYPE;                  \
  91               error (INVALID_64BIT, "prototype");               \
  92             }                                                   \
  93           if ((target_flags & MASK_POWERPC64) == 0)             \
  94             {                                                   \
  95               target_flags |= MASK_POWERPC64;                   \
  96               error ("-m64 requires a PowerPC64 cpu");          \
  97             }                                                   \
  98         }                                                       \
  99       else                                                      \
 100         {                                                       \
 101           if (!RS6000_BI_ARCH_P)                                \
 102             error (INVALID_32BIT, "32");                        \
 103           if (TARGET_PROFILE_KERNEL)                            \
 104             {                                                   \
 105               target_flags &= ~MASK_PROFILE_KERNEL;             \
 106               error (INVALID_32BIT, "profile-kernel");          \
 107             }                                                   \
 108         }                                                       \
 109     }                                                           \
 110   while (0)
 111
 112 #ifdef  RS6000_BI_ARCH
 113
 114 #undef  OVERRIDE_OPTIONS
 115 #define OVERRIDE_OPTIONS \
 116   rs6000_override_options (((TARGET_DEFAULT ^ target_flags) & MASK_64BIT) \
 117                            ? (char *) 0 : TARGET_CPU_DEFAULT)
 118
 119 #endif
 120
 121 #undef  ASM_DEFAULT_SPEC
 122 #undef  ASM_SPEC
 123 #undef  LINK_OS_LINUX_SPEC
 124
 125 #ifndef RS6000_BI_ARCH
 126 #define ASM_DEFAULT_SPEC "-mppc64"
 127 #define ASM_SPEC         "%(asm_spec64) %(asm_spec_common)"
 128 #define LINK_OS_LINUX_SPEC "%(link_os_linux_spec64)"
 129 #else
 130 #if DEFAULT_ARCH64_P
 131 #define ASM_DEFAULT_SPEC "-mppc%{!m32:64}"
 132 #define ASM_SPEC         "%{m32:%(asm_spec32)}%{!m32:%(asm_spec64)} %(asm_spec_common)"
 133 #define LINK_OS_LINUX_SPEC "%{m32:%(link_os_linux_spec32)}%{!m32:%(link_os_linux_spec64)}"
 134 #else
 135 #define ASM_DEFAULT_SPEC "-mppc%{m64:64}"
 136 #define ASM_SPEC         "%{!m64:%(asm_spec32)}%{m64:%(asm_spec64)} %(asm_spec_common)"
 137 #define LINK_OS_LINUX_SPEC "%{!m64:%(link_os_linux_spec32)}%{m64:%(link_os_linux_spec64)}"
 138 #endif
 139 #endif
 140
 141 #define ASM_SPEC32 "-a32 %{n} %{T} %{Ym,*} %{Yd,*} \
 142 %{mrelocatable} %{mrelocatable-lib} %{fpic:-K PIC} %{fPIC:-K PIC} \
 143 %{memb} %{!memb: %{msdata: -memb} %{msdata=eabi: -memb}} \
 144 %{!mlittle: %{!mlittle-endian: %{!mbig: %{!mbig-endian: \
 145     %{mcall-freebsd: -mbig} \
 146     %{mcall-i960-old: -mlittle} \
 147     %{mcall-linux: -mbig} \
 148     %{mcall-gnu: -mbig} \
 149     %{mcall-netbsd: -mbig} \
 150 }}}}"
 151
 152 #define ASM_SPEC64 "-a64"
 153
 154 #define ASM_SPEC_COMMON "%(asm_cpu) \
 155 %{.s: %{mregnames} %{mno-regnames}} %{.S: %{mregnames} %{mno-regnames}} \
 156 %{v:-V} %{Qy:} %{!Qn:-Qy} %{Wa,*:%*} \
 157 %{mlittle} %{mlittle-endian} %{mbig} %{mbig-endian}"
 158
 159 #undef  SUBSUBTARGET_EXTRA_SPECS
 160 #define SUBSUBTARGET_EXTRA_SPECS \
 161   { "asm_spec_common",          ASM_SPEC_COMMON },                      \
 162   { "asm_spec32",               ASM_SPEC32 },                           \
 163   { "asm_spec64",               ASM_SPEC64 },                           \
 164   { "link_os_linux_spec32",     LINK_OS_LINUX_SPEC32 },                 \
 165   { "link_os_linux_spec64",     LINK_OS_LINUX_SPEC64 },
 166
 167 #undef  MULTILIB_DEFAULTS
 168 #if DEFAULT_ARCH64_P
 169 #define MULTILIB_DEFAULTS { "m64" }
 170 #else
 171 #define MULTILIB_DEFAULTS { "m32" }
 172 #endif
 173
 174 #ifndef RS6000_BI_ARCH
 175
 176 /* 64-bit PowerPC Linux is always big-endian.  */
 177 #undef  TARGET_LITTLE_ENDIAN
 178 #define TARGET_LITTLE_ENDIAN    0
 179
 180 /* 64-bit PowerPC Linux always has a TOC.  */
 181 #undef  TARGET_TOC
 182 #define TARGET_TOC              1
 183
 184 /* Some things from sysv4.h we don't do when 64 bit.  */
 185 #undef  TARGET_RELOCATABLE
 186 #define TARGET_RELOCATABLE      0
 187 #undef  TARGET_EABI
 188 #define TARGET_EABI             0
 189 #undef  TARGET_PROTOTYPE
 190 #define TARGET_PROTOTYPE        0
 191
 192 #endif
 193
 194 #define MASK_PROFILE_KERNEL     0x00100000
 195
 196 /* Non-standard profiling for kernels, which just saves LR then calls
 197    _mcount without worrying about arg saves.  The idea is to change
 198    the function prologue as little as possible as it isn't easy to
 199    account for arg save/restore code added just for _mcount.  */
 200 #define TARGET_PROFILE_KERNEL   (target_flags & MASK_PROFILE_KERNEL)
 201
 202 /* Override sysv4.h.  */
 203 #undef  EXTRA_SUBTARGET_SWITCHES
 204 #define EXTRA_SUBTARGET_SWITCHES                                        \
 205   {"profile-kernel",     MASK_PROFILE_KERNEL,                           \
 206    N_("Call mcount for profiling before a function prologue") },        \
 207   {"no-profile-kernel", -MASK_PROFILE_KERNEL,                           \
 208    N_("Call mcount for profiling after a function prologue") },
 209
 210 /* We use glibc _mcount for profiling.  */
 211 #define NO_PROFILE_COUNTERS TARGET_64BIT
 212 #define PROFILE_HOOK(LABEL) \
 213   do { if (TARGET_64BIT) output_profile_hook (LABEL); } while (0)
 214
 215 /* We don't need to generate entries in .fixup.  */
 216 #undef RELOCATABLE_NEEDS_FIXUP
 217
 218 /* PowerPC64 Linux word-aligns FP doubles when -malign-power is given.  */
 219 #undef  ADJUST_FIELD_ALIGN
 220 #define ADJUST_FIELD_ALIGN(FIELD, COMPUTED) \
 221   ((TARGET_ALTIVEC && TREE_CODE (TREE_TYPE (FIELD)) == VECTOR_TYPE)     \
 222    ? 128                                                                \
 223    : (TARGET_64BIT                                                      \
 224       && TARGET_ALIGN_NATURAL == 0                                      \
 225       && TYPE_MODE (TREE_CODE (TREE_TYPE (FIELD)) == ARRAY_TYPE         \
 226                     ? get_inner_array_type (FIELD)                      \
 227                     : TREE_TYPE (FIELD)) == DFmode)                     \
 228    ? MIN ((COMPUTED), 32)                                               \
 229    : (COMPUTED))
 230
 231 /* PowerPC64 Linux increases natural record alignment to doubleword if
 232    the first field is an FP double, only if in power alignment mode.  */
 233 #undef  ROUND_TYPE_ALIGN
 234 #define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED)                   \
 235   ((TARGET_ALTIVEC && TREE_CODE (STRUCT) == VECTOR_TYPE)                \
 236    ? MAX (MAX ((COMPUTED), (SPECIFIED)), 128)                           \
 237    : (TARGET_64BIT                                                      \
 238       && (TREE_CODE (STRUCT) == RECORD_TYPE                             \
 239           || TREE_CODE (STRUCT) == UNION_TYPE                           \
 240           || TREE_CODE (STRUCT) == QUAL_UNION_TYPE)                     \
 241       && TARGET_ALIGN_NATURAL == 0)                                     \
 242    ? rs6000_special_round_type_align (STRUCT, COMPUTED, SPECIFIED)      \
 243    : MAX ((COMPUTED), (SPECIFIED)))
 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.  ie. pad updard.
 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 /* We don't want anything in the reg parm area being passed on the
 263    stack.  */
 264 #define MUST_PASS_IN_STACK(MODE, TYPE)                          \
 265   ((TARGET_64BIT                                                \
 266     && (TYPE) != 0                                              \
 267     && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST             \
 268         || TREE_ADDRESSABLE (TYPE)))                            \
 269    || (!TARGET_64BIT                                            \
 270        && default_must_pass_in_stack ((MODE), (TYPE))))
 271
 272 /* Specify padding for the last element of a block move between
 273    registers and memory.  FIRST is nonzero if this is the only
 274    element.  */
 275 #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \
 276   (!(FIRST) ? upward : FUNCTION_ARG_PADDING (MODE, TYPE))
 277
 278 /* __throw will restore its own return address to be the same as the
 279    return address of the function that the throw is being made to.
 280    This is unfortunate, because we want to check the original
 281    return address to see if we need to restore the TOC.
 282    So we have to squirrel it away with this.  */
 283 #define SETUP_FRAME_ADDRESSES() \
 284   do { if (TARGET_64BIT) rs6000_aix_emit_builtin_unwind_init (); } while (0)
 285
 286 /* Override svr4.h  */
 287 #undef MD_EXEC_PREFIX
 288 #undef MD_STARTFILE_PREFIX
 289
 290 #undef  TARGET_OS_CPP_BUILTINS
 291 #define TARGET_OS_CPP_BUILTINS()                        \
 292   do                                                    \
 293     {                                                   \
 294       if (TARGET_64BIT)                                 \
 295         {                                               \
 296           builtin_define ("__PPC__");                   \
 297           builtin_define ("__PPC64__");                 \
 298           builtin_define ("__powerpc__");               \
 299           builtin_define ("__powerpc64__");             \
 300           builtin_define ("__PIC__");                   \
 301           builtin_assert ("cpu=powerpc64");             \
 302           builtin_assert ("machine=powerpc64");         \
 303         }                                               \
 304       else                                              \
 305         {                                               \
 306           builtin_define_std ("PPC");                   \
 307           builtin_define_std ("powerpc");               \
 308           builtin_assert ("cpu=powerpc");               \
 309           builtin_assert ("machine=powerpc");           \
 310           TARGET_OS_SYSV_CPP_BUILTINS ();               \
 311         }                                               \
 312     }                                                   \
 313   while (0)
 314
 315 #undef  CPP_OS_DEFAULT_SPEC
 316 #define CPP_OS_DEFAULT_SPEC "%(cpp_os_linux)"
 317
 318 /* The GNU C++ standard library currently requires _GNU_SOURCE being
 319    defined on glibc-based systems. This temporary hack accomplishes this,
 320    it should go away as soon as libstdc++-v3 has a real fix.  */
 321 #undef  CPLUSPLUS_CPP_SPEC
 322 #define CPLUSPLUS_CPP_SPEC "-D_GNU_SOURCE %(cpp)"
 323
 324 #undef  LINK_SHLIB_SPEC
 325 #define LINK_SHLIB_SPEC "%{shared:-shared} %{!shared: %{static:-static}}"
 326
 327 #undef  LIB_DEFAULT_SPEC
 328 #define LIB_DEFAULT_SPEC "%(lib_linux)"
 329
 330 #undef  STARTFILE_DEFAULT_SPEC
 331 #define STARTFILE_DEFAULT_SPEC "%(startfile_linux)"
 332
 333 #undef  ENDFILE_DEFAULT_SPEC
 334 #define ENDFILE_DEFAULT_SPEC "%(endfile_linux)"
 335
 336 #undef  LINK_START_DEFAULT_SPEC
 337 #define LINK_START_DEFAULT_SPEC "%(link_start_linux)"
 338
 339 #undef  LINK_OS_DEFAULT_SPEC
 340 #define LINK_OS_DEFAULT_SPEC "%(link_os_linux)"
 341
 342 #define LINK_OS_LINUX_SPEC32 "-m elf32ppclinux %{!shared: %{!static: \
 343   %{rdynamic:-export-dynamic} \
 344   %{!dynamic-linker:-dynamic-linker /lib/ld.so.1}}}"
 345
 346 #define LINK_OS_LINUX_SPEC64 "-m elf64ppc %{!shared: %{!static: \
 347   %{rdynamic:-export-dynamic} \
 348   %{!dynamic-linker:-dynamic-linker /lib64/ld64.so.1}}}"
 349
 350 #undef  TOC_SECTION_ASM_OP
 351 #define TOC_SECTION_ASM_OP \
 352   (TARGET_64BIT                                         \
 353    ? "\t.section\t\".toc\",\"aw\""                      \
 354    : "\t.section\t\".got\",\"aw\"")
 355
 356 #undef  MINIMAL_TOC_SECTION_ASM_OP
 357 #define MINIMAL_TOC_SECTION_ASM_OP \
 358   (TARGET_64BIT                                         \
 359    ? "\t.section\t\".toc1\",\"aw\""                     \
 360    : ((TARGET_RELOCATABLE || flag_pic)                  \
 361       ? "\t.section\t\".got2\",\"aw\""                  \
 362       : "\t.section\t\".got1\",\"aw\""))
 363
 364 #undef  TARGET_VERSION
 365 #define TARGET_VERSION fprintf (stderr, " (PowerPC64 GNU/Linux)");
 366
 367 /* Must be at least as big as our pointer type.  */
 368 #undef  SIZE_TYPE
 369 #define SIZE_TYPE (TARGET_64BIT ? "long unsigned int" : "unsigned int")
 370
 371 #undef  PTRDIFF_TYPE
 372 #define PTRDIFF_TYPE (TARGET_64BIT ? "long int" : "int")
 373
 374 #undef  WCHAR_TYPE
 375 #define WCHAR_TYPE (TARGET_64BIT ? "int" : "long int")
 376 #undef  WCHAR_TYPE_SIZE
 377 #define WCHAR_TYPE_SIZE 32
 378
 379 /* Override rs6000.h definition.  */
 380 #undef  ASM_APP_ON
 381 #define ASM_APP_ON "#APP\n"
 382
 383 /* Override rs6000.h definition.  */
 384 #undef  ASM_APP_OFF
 385 #define ASM_APP_OFF "#NO_APP\n"
 386
 387 /* PowerPC no-op instruction.  */
 388 #undef  RS6000_CALL_GLUE
 389 #define RS6000_CALL_GLUE (TARGET_64BIT ? "nop" : "cror 31,31,31")
 390
 391 #undef  RS6000_MCOUNT
 392 #define RS6000_MCOUNT "_mcount"
 393
 394 #ifdef __powerpc64__
 395 /* _init and _fini functions are built from bits spread across many
 396    object files, each potentially with a different TOC pointer.  For
 397    that reason, place a nop after the call so that the linker can
 398    restore the TOC pointer if a TOC adjusting call stub is needed.  */
 399 #define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC)      \
 400   asm (SECTION_OP "\n"                                  \
 401 "       bl ." #FUNC "\n"                                \
 402 "       nop\n"                                          \
 403 "       .previous");
 404 #endif
 405
 406 /* FP save and restore routines.  */
 407 #undef  SAVE_FP_PREFIX
 408 #define SAVE_FP_PREFIX (TARGET_64BIT ? "._savef" : "_savefpr_")
 409 #undef  SAVE_FP_SUFFIX
 410 #define SAVE_FP_SUFFIX (TARGET_64BIT ? "" : "_l")
 411 #undef  RESTORE_FP_PREFIX
 412 #define RESTORE_FP_PREFIX (TARGET_64BIT ? "._restf" : "_restfpr_")
 413 #undef  RESTORE_FP_SUFFIX
 414 #define RESTORE_FP_SUFFIX (TARGET_64BIT ? "" : "_l")
 415
 416 /* Dwarf2 debugging.  */
 417 #undef  PREFERRED_DEBUGGING_TYPE
 418 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
 419
 420 /* This is how to declare the size of a function.  */
 421 #undef  ASM_DECLARE_FUNCTION_SIZE
 422 #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL)                    \
 423   do                                                                    \
 424     {                                                                   \
 425       if (!flag_inhibit_size_directive)                                 \
 426         {                                                               \
 427           fputs ("\t.size\t", (FILE));                                  \
 428           if (TARGET_64BIT)                                             \
 429             putc ('.', (FILE));                                         \
 430           assemble_name ((FILE), (FNAME));                              \
 431           fputs (",.-", (FILE));                                        \
 432           if (TARGET_64BIT)                                             \
 433             putc ('.', (FILE));                                         \
 434           assemble_name ((FILE), (FNAME));                              \
 435           putc ('\n', (FILE));                                          \
 436         }                                                               \
 437     }                                                                   \
 438   while (0)
 439
 440 /* Return nonzero if this entry is to be written into the constant
 441    pool in a special way.  We do so if this is a SYMBOL_REF, LABEL_REF
 442    or a CONST containing one of them.  If -mfp-in-toc (the default),
 443    we also do this for floating-point constants.  We actually can only
 444    do this if the FP formats of the target and host machines are the
 445    same, but we can't check that since not every file that uses
 446    GO_IF_LEGITIMATE_ADDRESS_P includes real.h.  We also do this when
 447    we can write the entry into the TOC and the entry is not larger
 448    than a TOC entry.  */
 449
 450 #undef  ASM_OUTPUT_SPECIAL_POOL_ENTRY_P
 451 #define ASM_OUTPUT_SPECIAL_POOL_ENTRY_P(X, MODE)                        \
 452   (TARGET_TOC                                                           \
 453    && (GET_CODE (X) == SYMBOL_REF                                       \
 454        || (GET_CODE (X) == CONST && GET_CODE (XEXP (X, 0)) == PLUS      \
 455            && GET_CODE (XEXP (XEXP (X, 0), 0)) == SYMBOL_REF)           \
 456        || GET_CODE (X) == LABEL_REF                                     \
 457        || (GET_CODE (X) == CONST_INT                                    \
 458            && GET_MODE_BITSIZE (MODE) <= GET_MODE_BITSIZE (Pmode))      \
 459        || (GET_CODE (X) == CONST_DOUBLE                                 \
 460            && ((TARGET_64BIT                                            \
 461                 && (TARGET_POWERPC64                                    \
 462                     || TARGET_MINIMAL_TOC                               \
 463                     || (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT     \
 464                         && ! TARGET_NO_FP_IN_TOC)))                     \
 465                || (!TARGET_64BIT                                        \
 466                    && !TARGET_NO_FP_IN_TOC                              \
 467                    && !TARGET_RELOCATABLE                               \
 468                    && GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT       \
 469                    && BITS_PER_WORD == HOST_BITS_PER_INT)))))
 470
 471 /* This is the same as the dbxelf.h version, except that we need to
 472    use the function code label, not the function descriptor.  */
 473 #undef  ASM_OUTPUT_SOURCE_LINE
 474 #define ASM_OUTPUT_SOURCE_LINE(FILE, LINE, COUNTER)                     \
 475 do                                                                      \
 476   {                                                                     \
 477     char temp[256];                                                     \
 478     ASM_GENERATE_INTERNAL_LABEL (temp, "LM", COUNTER);                  \
 479     fprintf (FILE, "\t.stabn 68,0,%d,", LINE);                          \
 480     assemble_name (FILE, temp);                                         \
 481     putc ('-', FILE);                                                   \
 482     if (TARGET_64BIT)                                                   \
 483       putc ('.', FILE);                                                 \
 484     assemble_name (FILE,                                                \
 485                    XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));\
 486     putc ('\n', FILE);                                                  \
 487     (*targetm.asm_out.internal_label) (FILE, "LM", COUNTER);            \
 488   }                                                                     \
 489 while (0)
 490
 491 /* Similarly, we want the function code label here.  */
 492 #define DBX_OUTPUT_BRAC(FILE, NAME, BRAC) \
 493   do                                                                    \
 494     {                                                                   \
 495       const char *flab;                                                 \
 496       fprintf (FILE, "%s%d,0,0,", ASM_STABN_OP, BRAC);                  \
 497       assemble_name (FILE, NAME);                                       \
 498       putc ('-', FILE);                                                 \
 499       if (current_function_func_begin_label != NULL_TREE)               \
 500         flab = IDENTIFIER_POINTER (current_function_func_begin_label);  \
 501       else                                                              \
 502         {                                                               \
 503           if (TARGET_64BIT)                                             \
 504             putc ('.', FILE);                                           \
 505           flab = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);  \
 506         }                                                               \
 507       assemble_name (FILE, flab);                                       \
 508       putc ('\n', FILE);                                                \
 509     }                                                                   \
 510   while (0)
 511
 512 #define DBX_OUTPUT_LBRAC(FILE, NAME) DBX_OUTPUT_BRAC (FILE, NAME, N_LBRAC)
 513 #define DBX_OUTPUT_RBRAC(FILE, NAME) DBX_OUTPUT_BRAC (FILE, NAME, N_RBRAC)
 514
 515 /* Another case where we want the dot name.  */
 516 #define DBX_OUTPUT_NFUN(FILE, LSCOPE, DECL)                             \
 517   do                                                                    \
 518     {                                                                   \
 519       fprintf (FILE, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);            \
 520       assemble_name (FILE, LSCOPE);                                     \
 521       putc ('-', FILE);                                                 \
 522       if (TARGET_64BIT)                                                 \
 523         putc ('.', FILE);                                               \
 524       assemble_name (FILE, XSTR (XEXP (DECL_RTL (DECL), 0), 0));        \
 525       putc ('\n', FILE);                                                \
 526     }                                                                   \
 527   while (0)
 528
 529 /* Select a format to encode pointers in exception handling data.  CODE
 530    is 0 for data, 1 for code labels, 2 for function pointers.  GLOBAL is
 531    true if the symbol may be affected by dynamic relocations.  */
 532 #undef  ASM_PREFERRED_EH_DATA_FORMAT
 533 #define ASM_PREFERRED_EH_DATA_FORMAT(CODE, GLOBAL) \
 534   ((TARGET_64BIT || flag_pic || TARGET_RELOCATABLE)                     \
 535    ? (((GLOBAL) ? DW_EH_PE_indirect : 0) | DW_EH_PE_pcrel               \
 536       | (TARGET_64BIT ? DW_EH_PE_udata8 : DW_EH_PE_sdata4))             \
 537    : DW_EH_PE_absptr)
 538
 539 /* For backward compatibility, we must continue to use the AIX
 540    structure return convention.  */
 541 #undef DRAFT_V4_STRUCT_RET
 542 #define DRAFT_V4_STRUCT_RET (!TARGET_64BIT)
 543
 544 #define TARGET_ASM_FILE_END file_end_indicate_exec_stack
 545
 546 #define LINK_GCC_C_SEQUENCE_SPEC \
 547   "%{static:--start-group} %G %L %{static:--end-group}%{!static:%G}"
 548
 549 /* Do code reading to identify a signal frame, and set the frame
 550    state data appropriately.  See unwind-dw2.c for the structs.  */
 551
 552 #ifdef IN_LIBGCC2
 553 #include <signal.h>
 554 #ifdef __powerpc64__
 555 #include <sys/ucontext.h>
 556
 557 enum { SIGNAL_FRAMESIZE = 128 };
 558
 559 #else
 560
 561 /* During the 2.5 kernel series the kernel ucontext was changed, but
 562    the new layout is compatible with the old one, so we just define
 563    and use the old one here for simplicity and compatibility.  */
 564
 565 struct kernel_old_ucontext {
 566   unsigned long     uc_flags;
 567   struct ucontext  *uc_link;
 568   stack_t           uc_stack;
 569   struct sigcontext_struct uc_mcontext;
 570   sigset_t          uc_sigmask;
 571 };
 572 enum { SIGNAL_FRAMESIZE = 64 };
 573 #endif
 574
 575 #endif
 576
 577 #ifdef __powerpc64__
 578
 579 /* If the current unwind info (FS) does not contain explicit info
 580    saving R2, then we have to do a minor amount of code reading to
 581    figure out if it was saved.  The big problem here is that the
 582    code that does the save/restore is generated by the linker, so
 583    we have no good way to determine at compile time what to do.  */
 584
 585 #define MD_FROB_UPDATE_CONTEXT(CTX, FS)                                 \
 586   do {                                                                  \
 587     if ((FS)->regs.reg[2].how == REG_UNSAVED)                           \
 588       {                                                                 \
 589         unsigned int *insn                                              \
 590           = (unsigned int *)                                            \
 591             _Unwind_GetGR ((CTX), LINK_REGISTER_REGNUM);                \
 592         if (*insn == 0xE8410028)                                        \
 593           _Unwind_SetGRPtr ((CTX), 2, (CTX)->cfa + 40);                 \
 594       }                                                                 \
 595   } while (0)
 596
 597 #define MD_FALLBACK_FRAME_STATE_FOR(CONTEXT, FS, SUCCESS)               \
 598   do {                                                                  \
 599     unsigned char *pc_ = (CONTEXT)->ra;                                 \
 600     struct sigcontext *sc_;                                             \
 601     long new_cfa_;                                                      \
 602     int i_;                                                             \
 603                                                                         \
 604     /* addi r1, r1, 128; li r0, 0x0077; sc  (sigreturn) */              \
 605     /* addi r1, r1, 128; li r0, 0x00AC; sc  (rt_sigreturn) */           \
 606     if (*(unsigned int *) (pc_+0) != 0x38210000 + SIGNAL_FRAMESIZE      \
 607         || *(unsigned int *) (pc_+8) != 0x44000002)                     \
 608       break;                                                            \
 609     if (*(unsigned int *) (pc_+4) == 0x38000077)                        \
 610       {                                                                 \
 611         struct sigframe {                                               \
 612           char gap[SIGNAL_FRAMESIZE];                                   \
 613           struct sigcontext sigctx;                                     \
 614         } *rt_ = (CONTEXT)->cfa;                                        \
 615         sc_ = &rt_->sigctx;                                             \
 616       }                                                                 \
 617     else if (*(unsigned int *) (pc_+4) == 0x380000AC)                   \
 618       {                                                                 \
 619         struct rt_sigframe {                                            \
 620           int tramp[6];                                                 \
 621           struct siginfo *pinfo;                                        \
 622           struct ucontext *puc;                                         \
 623         } *rt_ = (struct rt_sigframe *) pc_;                            \
 624         sc_ = &rt_->puc->uc_mcontext;                                   \
 625       }                                                                 \
 626     else                                                                \
 627       break;                                                            \
 628                                                                         \
 629     new_cfa_ = sc_->regs->gpr[STACK_POINTER_REGNUM];                    \
 630     (FS)->cfa_how = CFA_REG_OFFSET;                                     \
 631     (FS)->cfa_reg = STACK_POINTER_REGNUM;                               \
 632     (FS)->cfa_offset = new_cfa_ - (long) (CONTEXT)->cfa;                \
 633                                                                         \
 634     for (i_ = 0; i_ < 32; i_++)                                         \
 635       if (i_ != STACK_POINTER_REGNUM)                                   \
 636         {                                                               \
 637           (FS)->regs.reg[i_].how = REG_SAVED_OFFSET;                    \
 638           (FS)->regs.reg[i_].loc.offset                                 \
 639             = (long)&(sc_->regs->gpr[i_]) - new_cfa_;                   \
 640         }                                                               \
 641                                                                         \
 642     (FS)->regs.reg[LINK_REGISTER_REGNUM].how = REG_SAVED_OFFSET;        \
 643     (FS)->regs.reg[LINK_REGISTER_REGNUM].loc.offset                     \
 644       = (long)&(sc_->regs->link) - new_cfa_;                            \
 645                                                                         \
 646     (FS)->regs.reg[ARG_POINTER_REGNUM].how = REG_SAVED_OFFSET;          \
 647     (FS)->regs.reg[ARG_POINTER_REGNUM].loc.offset                       \
 648       = (long)&(sc_->regs->nip) - new_cfa_;                             \
 649     (FS)->retaddr_column = ARG_POINTER_REGNUM;                          \
 650     goto SUCCESS;                                                       \
 651   } while (0)
 652
 653 #else
 654
 655 #define MD_FALLBACK_FRAME_STATE_FOR(CONTEXT, FS, SUCCESS)               \
 656   do {                                                                  \
 657     unsigned char *pc_ = (CONTEXT)->ra;                                 \
 658     struct sigcontext *sc_;                                             \
 659     long new_cfa_;                                                      \
 660     int i_;                                                             \
 661                                                                         \
 662     /* li r0, 0x7777; sc  (sigreturn old)  */                           \
 663     /* li r0, 0x0077; sc  (sigreturn new)  */                           \
 664     /* li r0, 0x6666; sc  (rt_sigreturn old)  */                        \
 665     /* li r0, 0x00AC; sc  (rt_sigreturn new)  */                        \
 666     if (*(unsigned int *) (pc_+4) != 0x44000002)                        \
 667       break;                                                            \
 668     if (*(unsigned int *) (pc_+0) == 0x38007777                         \
 669         || *(unsigned int *) (pc_+0) == 0x38000077)                     \
 670       {                                                                 \
 671         struct sigframe {                                               \
 672           char gap[SIGNAL_FRAMESIZE];                                   \
 673           struct sigcontext sigctx;                                     \
 674         } *rt_ = (CONTEXT)->cfa;                                        \
 675         sc_ = &rt_->sigctx;                                             \
 676       }                                                                 \
 677     else if (*(unsigned int *) (pc_+0) == 0x38006666                    \
 678              || *(unsigned int *) (pc_+0) == 0x380000AC)                \
 679       {                                                                 \
 680         struct rt_sigframe {                                            \
 681           char gap[SIGNAL_FRAMESIZE];                                   \
 682           unsigned long _unused[2];                                     \
 683           struct siginfo *pinfo;                                        \
 684           void *puc;                                                    \
 685           struct siginfo info;                                          \
 686           struct kernel_old_ucontext uc;                                \
 687         } *rt_ = (CONTEXT)->cfa;                                        \
 688         sc_ = &rt_->uc.uc_mcontext;                                     \
 689       }                                                                 \
 690     else                                                                \
 691       break;                                                            \
 692                                                                         \
 693     new_cfa_ = sc_->regs->gpr[STACK_POINTER_REGNUM];                    \
 694     (FS)->cfa_how = CFA_REG_OFFSET;                                     \
 695     (FS)->cfa_reg = STACK_POINTER_REGNUM;                               \
 696     (FS)->cfa_offset = new_cfa_ - (long) (CONTEXT)->cfa;                \
 697                                                                         \
 698     for (i_ = 0; i_ < 32; i_++)                                         \
 699       if (i_ != STACK_POINTER_REGNUM)                                   \
 700         {                                                               \
 701           (FS)->regs.reg[i_].how = REG_SAVED_OFFSET;                    \
 702           (FS)->regs.reg[i_].loc.offset                                 \
 703             = (long)&(sc_->regs->gpr[i_]) - new_cfa_;                   \
 704         }                                                               \
 705                                                                         \
 706     (FS)->regs.reg[LINK_REGISTER_REGNUM].how = REG_SAVED_OFFSET;        \
 707     (FS)->regs.reg[LINK_REGISTER_REGNUM].loc.offset                     \
 708       = (long)&(sc_->regs->link) - new_cfa_;                            \
 709                                                                         \
 710     (FS)->regs.reg[CR0_REGNO].how = REG_SAVED_OFFSET;                   \
 711     (FS)->regs.reg[CR0_REGNO].loc.offset                                \
 712       = (long)&(sc_->regs->nip) - new_cfa_;                             \
 713     (FS)->retaddr_column = CR0_REGNO;                                   \
 714     goto SUCCESS;                                                       \
 715   } while (0)
 716
 717 #endif