* target.h (asm_out.file_start, file_start_app_off,

[official-gcc.git] / gcc / config / alpha / unicosmk.h

/* Definitions of target machine for GNU compiler, for DEC Alpha on Cray
   T3E running Unicos/Mk.
   Copyright (C) 2001, 2002
   Free Software Foundation, Inc.
   Contributed by Roman Lechtchinsky (rl@cs.tu-berlin.de)

This file is part of GNU CC.

GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

#undef TARGET_ABI_UNICOSMK
#define TARGET_ABI_UNICOSMK 1

/* CAM requires a slash before floating-pointing instruction suffixes.  */

#undef TARGET_AS_SLASH_BEFORE_SUFFIX
#define TARGET_AS_SLASH_BEFORE_SUFFIX 1

/* The following defines are necessary for the standard headers to work
   correctly.  */

#define TARGET_OS_CPP_BUILTINS()                                \
    do {                                                        \
        builtin_define ("__unix");                              \
        builtin_define ("_UNICOS=205");                         \
        builtin_define ("_CRAY");                               \
        builtin_define ("_CRAYT3E");                            \
        builtin_define ("_CRAYMPP");                            \
        builtin_define ("_CRAYIEEE");                           \
        builtin_define ("_ADDR64");                             \
        builtin_define ("_LD64");                               \
        builtin_define ("__UNICOSMK__");                        \
    } while (0)

#define SHORT_TYPE_SIZE 32

#undef INT_TYPE_SIZE
#define INT_TYPE_SIZE 64

/* This is consistent with the definition Cray CC uses.  */
#undef WCHAR_TYPE
#define WCHAR_TYPE "int"
#undef WCHAR_TYPE_SIZE
#define WCHAR_TYPE_SIZE 64

/*
#define SIZE_TYPE "unsigned int"
#define PTRDIFF_TYPE "int"
*/

/* Alphas are operated in big endian mode on the Cray T3E.  */

#undef BITS_BIG_ENDIAN
#undef BYTES_BIG_ENDIAN
#undef WORDS_BIG_ENDIAN
#define BITS_BIG_ENDIAN 0
#define BYTES_BIG_ENDIAN 1
#define WORDS_BIG_ENDIAN 1


/* Every structure's size must be a multiple of this.  */

#undef STRUCTURE_SIZE_BOUNDARY
#define STRUCTURE_SIZE_BOUNDARY 64

/* No data type wants to be aligned rounder than this.  */

#undef BIGGEST_ALIGNMENT
#define BIGGEST_ALIGNMENT 256

/* Include the frame pointer in fixed_regs and call_used_regs as it can't be 
   used as a general-purpose register even in frameless functions.
   ??? The global_regs hack is needed for now because -O2 sometimes tries to 
   eliminate $15 increments/decrements in frameless functions.  */

#undef CONDITIONAL_REGISTER_USAGE
#define CONDITIONAL_REGISTER_USAGE      \
  do {                                  \
    fixed_regs[15] = 1;                 \
    call_used_regs[15] = 1;             \
    global_regs[15] = 1;                \
  } while(0)
\f
/* The stack frame grows downward.  */

#define FRAME_GROWS_DOWNWARD

/* Define the offset between two registers, one to be eliminated, and the
   other its replacement, at the start of a routine. This is somewhat
   complicated on the T3E which is why we use a function.  */

#undef INITIAL_ELIMINATION_OFFSET
#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)                    \
  do {                                                                  \
    (OFFSET) = unicosmk_initial_elimination_offset ((FROM), (TO));      \
  } while (0)


/* Define this if stack space is still allocated for a parameter passed
   in a register. On the T3E, stack space is preallocated for all outgoing
   arguments, including those passed in registers. To avoid problems, we
   assume that at least 48 bytes (i.e. enough space for all arguments passed
   in registers) are allocated.  */

#define REG_PARM_STACK_SPACE(DECL) 48
#define OUTGOING_REG_PARM_STACK_SPACE

/* If an argument can't be passed in registers even though not all argument
   registers have been used yet, it is passed on the stack in the space 
   preallocated for these registers.  */

#define STACK_PARMS_IN_REG_PARM_AREA

/* This evaluates to nonzero if we do not know how to pass TYPE solely in
   registers. This is the case for all arguments that do not fit in two
   registers.  */

#define MUST_PASS_IN_STACK(MODE,TYPE)                                   \
  ((TYPE) != 0                                                          \
   && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST                      \
       || (TREE_ADDRESSABLE (TYPE) || ALPHA_ARG_SIZE (MODE, TYPE, 0) > 2)))

/* Define a data type for recording info about an argument list
   during the scan of that argument list.  This data type should
   hold all necessary information about the function itself
   and about the args processed so far, enough to enable macros
   such as FUNCTION_ARG to determine where the next arg should go.

   On Unicos/Mk, this is a structure that contains various information for
   the static subroutine information block (SSIB) and the call information
   word (CIW).  */

typedef struct {

  /* The overall number of arguments.  */
  int num_args;

  /* The overall size of the arguments in words.  */
  int num_arg_words;

  /* The number of words passed in registers.  */
  int num_reg_words;

  /* If an argument must be passed in the stack, all subsequent arguments
     must be passed there, too. This flag indicates whether this is the
     case.  */
  int force_stack;

  /* This array indicates whether a word is passed in an integer register or
     a floating point one.  */

  /* For each of the 6 register arguments, the corresponding flag in this
     array indicates whether the argument is passed in an integer or a
     floating point register.  */
  int reg_args_type[6];

} unicosmk_arg_info;

#undef CUMULATIVE_ARGS
#define CUMULATIVE_ARGS unicosmk_arg_info

/* Initialize a variable CUM of type CUMULATIVE_ARGS for a call to a
   function whose data type is FNTYPE.  For a library call, FNTYPE is 0.  */

#undef INIT_CUMULATIVE_ARGS
#define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT)       \
  do { (CUM).num_args = 0;                                      \
       (CUM).num_arg_words = 0;                                 \
       (CUM).num_reg_words = 0;                                 \
       (CUM).force_stack = 0;                                   \
  } while(0)

/* Update the data in CUM to advance over an argument of mode MODE and data
   type TYPE. (TYPE is null for libcalls where that information may not be
   available.)

   On Unicos/Mk, at most 6 words can be passed in registers. Structures
   which fit in two words are passed in registers, larger structures are
   passed on stack.  */

#undef FUNCTION_ARG_ADVANCE
#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)            \
do {                                                            \
  int size;                                                     \
                                                                \
  size = ALPHA_ARG_SIZE (MODE, TYPE, NAMED);                    \
                                                                \
  if (size > 2 || MUST_PASS_IN_STACK (MODE, TYPE)               \
      || (CUM).num_reg_words + size > 6)                        \
    (CUM).force_stack = 1;                                      \
                                                                \
  if (! (CUM).force_stack)                                      \
    {                                                           \
      int i;                                                    \
      int isfloat;                                              \
      isfloat = (GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT    \
              || GET_MODE_CLASS (MODE) == MODE_FLOAT);          \
      for (i = 0; i < size; i++)                                \
        {                                                       \
          (CUM).reg_args_type[(CUM).num_reg_words] = isfloat;   \
          ++(CUM).num_reg_words;                                \
        }                                                       \
    }                                                           \
  (CUM).num_arg_words += size;                                  \
  ++(CUM).num_args;                                             \
} while(0)

/* We want the default definition for this.
   ??? In fact, we should delete the definition from alpha.h as it
   corresponds to the default definition for little-endian machines.  */

#undef FUNCTION_ARG_PADDING

/* An argument is passed either entirely in registers or entirely on stack.  */
 
#undef FUNCTION_ARG_PARTIAL_NREGS
/* #define FUNCTION_ARG_PARTIAL_NREGS(CUM,MODE,TYPE,NAMED) 0 */

/* Perform any needed actions needed for a function that is receiving a
   variable number of arguments.

   On Unicos/Mk, the standard subroutine __T3E_MISMATCH stores all register
   arguments on the stack. Unfortunately, it doesn't always store the first
   one (i.e. the one that arrives in $16 or $f16). This is not a problem
   with stdargs as we always have at least one named argument there.  */

#undef SETUP_INCOMING_VARARGS
#define SETUP_INCOMING_VARARGS(CUM,MODE,TYPE,PRETEND_SIZE,NO_RTL)       \
{ if ((CUM).num_reg_words < 6)                                          \
    {                                                                   \
      if (! (NO_RTL))                                                   \
        {                                                               \
          int start = (CUM).num_reg_words + 1;                          \
                                                                        \
          emit_insn (gen_umk_mismatch_args (GEN_INT (start)));          \
          emit_insn (gen_arg_home_umk ());                              \
        }                                                               \
                                                                        \
      PRETEND_SIZE = 0;                                                 \
    }                                                                   \
}

/* This ensures that $15 increments/decrements in leaf functions won't get
   eliminated.  */

#undef EPILOGUE_USES
#define EPILOGUE_USES(REGNO)  ((REGNO) == 26 || (REGNO) == 15)

/* Would have worked, only the stack doesn't seem to be executable
#undef TRAMPOLINE_TEMPLATE
#define TRAMPOLINE_TEMPLATE(FILE)                       \
do { fprintf (FILE, "\tbr $1,0\n");                     \
     fprintf (FILE, "\tldq $0,12($1)\n");               \
     fprintf (FILE, "\tldq $1,20($1)\n");               \
     fprintf (FILE, "\tjmp $31,(r0)\n");                \
     fprintf (FILE, "\tbis $31,$31,$31\n");             \
     fprintf (FILE, "\tbis $31,$31,$31\n");             \
} while (0) */

/* We don't support nested functions (yet).  */

#undef TRAMPOLINE_TEMPLATE
#define TRAMPOLINE_TEMPLATE(FILE) abort ()
\f
/* Specify the machine mode that this machine uses for the index in the
   tablejump instruction. On Unicos/Mk, we don't support relative case
   vectors yet, thus the entries should be absolute addresses.  */ 

#undef CASE_VECTOR_MODE
#define CASE_VECTOR_MODE DImode

#undef CASE_VECTOR_PC_RELATIVE

/* Define this as 1 if `char' should by default be signed; else as 0.  */
/* #define DEFAULT_SIGNED_CHAR 1 */

/* The Cray assembler is really weird with respect to sections. It has only
   named sections and you can't reopen a section once it has been closed.
   This means that we have to generate unique names whenever we want to
   reenter the text or the data section. The following is a rather bad hack
   as TEXT_SECTION_ASM_OP and DATA_SECTION_ASM_OP are supposed to be
   constants.  */

#undef TEXT_SECTION_ASM_OP
#define TEXT_SECTION_ASM_OP unicosmk_text_section ()

#undef DATA_SECTION_ASM_OP
#define DATA_SECTION_ASM_OP unicosmk_data_section ()

/* There are no read-only sections on Unicos/Mk.  */

#undef READONLY_DATA_SECTION_ASM_OP
#define READONLY_DATA_SECTION data_section

/* Define extra sections for common data and SSIBs (static subroutine
   information blocks). The actual section header is output by the callers
   of these functions.  */

#undef EXTRA_SECTIONS
#undef EXTRA_SECTION_FUNCTIONS

#define EXTRA_SECTIONS in_common, in_ssib
#define EXTRA_SECTION_FUNCTIONS \
COMMON_SECTION                  \
SSIB_SECTION    

extern void common_section (void);
#define COMMON_SECTION          \
void                            \
common_section ()               \
{                               \
  in_section = in_common;       \
}

extern void ssib_section (void);
#define SSIB_SECTION            \
void                            \
ssib_section ()                 \
{                               \
  in_section = in_ssib;         \
}

/* We take care of this in unicosmk_file_start.  */

#undef ASM_OUTPUT_SOURCE_FILENAME

/* This is how to output a label for a jump table.  Arguments are the same as
   for (*targetm.asm_out.internal_label), except the insn for the jump table is
   passed.  */

#undef ASM_OUTPUT_CASE_LABEL
#define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,TABLEINSN)        \
  (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM)

/* CAM has some restrictions with respect to string literals. It won't
   accept lines with more that 256 characters which means that we have
   to split long strings. Moreover, it only accepts escape sequences of
   the form \nnn in the range 0 to 127. We generate .byte directives for
   escapes characters greater than 127. And finally, ` must be escaped.  */

#undef ASM_OUTPUT_ASCII
#define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \
  do {                                                                        \
    FILE *_hide_asm_out_file = (MYFILE);                                      \
    const unsigned char *_hide_p = (const unsigned char *) (MYSTRING);        \
    int _hide_thissize = (MYLENGTH);                                          \
    int _size_so_far = 0;                                                     \
    {                                                                         \
      FILE *asm_out_file = _hide_asm_out_file;                                \
      const unsigned char *p = _hide_p;                                       \
      int thissize = _hide_thissize;                                          \
      int in_ascii = 0;                                                       \
      int i;                                                                  \
                                                                              \
      for (i = 0; i < thissize; i++)                                          \
        {                                                                     \
          register int c = p[i];                                              \
                                                                              \
          if (c > 127)                                                        \
            {                                                                 \
              if (in_ascii)                                                   \
                {                                                             \
                  fprintf (asm_out_file, "\"\n");                             \
                  in_ascii = 0;                                               \
                }                                                             \
                                                                              \
              fprintf (asm_out_file, "\t.byte\t%d\n", c);                     \
            }                                                                 \
          else                                                                \
            {                                                                 \
              if (! in_ascii)                                                 \
                {                                                             \
                  fprintf (asm_out_file, "\t.ascii\t\"");                     \
                  in_ascii = 1;                                               \
                  _size_so_far = 0;                                           \
                }                                                             \
              else if (_size_so_far >= 64)                                    \
                {                                                             \
                  fprintf (asm_out_file, "\"\n\t.ascii\t\"");                 \
                  _size_so_far = 0;                                           \
                }                                                             \
                                                                              \
              if (c == '\"' || c == '\\' || c == '`')                         \
                putc ('\\', asm_out_file);                                    \
              if (c >= ' ')                                                   \
                putc (c, asm_out_file);                                       \
              else                                                            \
                fprintf (asm_out_file, "\\%.3o", c);                          \
              ++ _size_so_far;                                                \
            }                                                                 \
        }                                                                     \
      if (in_ascii)                                                           \
        fprintf (asm_out_file, "\"\n");                                       \
    }                                                                         \
  } while(0)

/* This is how to output an element of a case-vector that is absolute.  */

#undef ASM_OUTPUT_ADDR_VEC_ELT
#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)    \
  fprintf (FILE, "\t.quad $L%d\n", (VALUE))

/* This is how to output an element of a case-vector that is relative.
   (Unicos/Mk does not use such vectors yet).  */

#undef ASM_OUTPUT_ADDR_DIFF_ELT
#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) abort ()

/* We can't output case vectors in the same section as the function code
   because CAM doesn't allow data definitions in code sections. Thus, we
   simply record the case vectors and put them in a separate section after
   the function.  */

#define ASM_OUTPUT_ADDR_VEC(LAB,VEC) \
  unicosmk_defer_case_vector ((LAB),(VEC))

#define ASM_OUTPUT_ADDR_DIFF_VEC(LAB,VEC) abort ()

/* This is how to output an assembler line that says to advance the location
   counter to a multiple of 2**LOG bytes. Annoyingly, CAM always uses zeroes
   to fill the unused space which does not work in code sections. We have to 
   be careful not to use the .align directive in code sections.  */

#undef ASM_OUTPUT_ALIGN
#define ASM_OUTPUT_ALIGN(STREAM,LOG) unicosmk_output_align (STREAM, LOG)

/* This is how to advance the location counter by SIZE bytes.  */

#undef ASM_OUTPUT_SKIP
#define ASM_OUTPUT_SKIP(STREAM,SIZE)                    \
  fprintf ((STREAM), "\t.byte\t0:"HOST_WIDE_INT_PRINT_UNSIGNED"\n",\
           (SIZE));

/* This says how to output an assembler line to define a global common
   symbol. We need the alignment information because it has to be supplied
   in the section header.  */ 

#undef ASM_OUTPUT_COMMON
#define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)      \
  unicosmk_output_common ((FILE), (NAME), (SIZE), (ALIGN))

/* This says how to output an assembler line to define a local symbol.  */

#undef ASM_OUTPUT_LOCAL
#define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN) \
  do { data_section ();                                 \
       fprintf (FILE, "\t.align\t%d\n", floor_log2 ((ALIGN) / BITS_PER_UNIT));\
       ASM_OUTPUT_LABEL ((FILE), (NAME));               \
       fprintf (FILE, "\t.byte 0:"HOST_WIDE_INT_PRINT_UNSIGNED"\n",(SIZE));\
  } while (0)

/* CAM does not allow us to declare a symbol as external first and then
   define it in the same file later. Thus, we keep a list of all external
   references, remove all symbols defined locally from it and output it at
   the end of the asm file.  */
   
#define ASM_OUTPUT_EXTERNAL(FILE,DECL,NAME) \
  unicosmk_add_extern ((NAME))

#define ASM_OUTPUT_EXTERNAL_LIBCALL(STREAM,SYMREF)      \
  unicosmk_add_extern (XSTR ((SYMREF), 0))

/* This is how to declare an object. We don't have to output anything if
   it is a global variable because those go into unique `common' sections
   and the section name is globally visible. For local variables, we simply
   output the label. In any case, we have to record that no extern
   declaration should be generated for the symbol.  */

#define ASM_DECLARE_OBJECT_NAME(STREAM,NAME,DECL)       \
  do { tree name_tree;                                  \
       name_tree = get_identifier ((NAME));             \
       TREE_ASM_WRITTEN (name_tree) = 1;                \
       if (!TREE_PUBLIC (DECL))                         \
         {                                              \
           assemble_name (STREAM, NAME);                \
           fputs (":\n", STREAM);                       \
         }                                              \
  } while(0)

/*
#define ASM_OUTPUT_SECTION_NAME(STREAM, DECL, NAME, RELOC)      \
  unicosmk_output_section_name ((STREAM), (DECL), (NAME), (RELOC))
*/

/* Switch into a generic section.  */
#define TARGET_ASM_NAMED_SECTION unicosmk_asm_named_section

#undef ASM_OUTPUT_MAX_SKIP_ALIGN
#define ASM_OUTPUT_MAX_SKIP_ALIGN(STREAM,POWER,MAXSKIP)
\f
#undef NM_FLAGS

#undef OBJECT_FORMAT_COFF

/* We cannot generate debugging information on Unicos/Mk.  */

#undef SDB_DEBUGGING_INFO
#undef MIPS_DEBUGGING_INFO
#undef DBX_DEBUGGING_INFO
#undef DWARF_DEBUGGING_INFO
#undef DWARF2_DEBUGGING_INFO
#undef DWARF2_UNWIND_INFO
#undef INCOMING_RETURN_ADDR_RTX


/* We use the functions provided by the system library for integer
   division.  */

#undef UDIVDI3_LIBCALL
#undef DIVDI3_LIBCALL
#define UDIVDI3_LIBCALL "$uldiv"
#define DIVDI3_LIBCALL "$sldiv"

/* This is necessary to prevent gcc from generating calls to __divsi3.  */

#define INIT_TARGET_OPTABS                                      \
  do {                                                          \
    sdiv_optab->handlers[(int) SImode].libfunc = NULL_RTX;      \
    udiv_optab->handlers[(int) SImode].libfunc = NULL_RTX;      \
  } while (0)

#undef ASM_OUTPUT_SOURCE_LINE

/* We don't need a start file.  */

#undef STARTFILE_SPEC
#define STARTFILE_SPEC ""

/* These are the libraries we have to link with.
   ??? The Craylibs directory should be autoconfed.  */
#undef LIB_SPEC
#define LIB_SPEC "-L/opt/ctl/craylibs/craylibs -lu -lm -lc -lsma"

#undef BUILD_VA_LIST_TYPE
#undef EXPAND_BUILTIN_VA_START
#undef EXPAND_BUILTIN_VA_ARG

#define EH_FRAME_IN_DATA_SECTION 1