summaryrefslogtreecommitdiffstats
path: root/contrib/gcc/config/alpha/unicosmk.h
blob: 9d966d6e27c622a0d9ce751dc978c9baf0c8c312 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
/* 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 GCC.

GCC 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.

GCC 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 GCC; 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)

/* 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, N_NAMED_ARGS) \
  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)

/* 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 */

/* 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 ()

/* 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 (void)		\
{				\
  in_section = in_common;	\
}

extern void ssib_section (void);
#define SSIB_SECTION		\
void				\
ssib_section (void)		\
{				\
  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)

#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 DWARF2_DEBUGGING_INFO
#undef DWARF2_UNWIND_INFO
#undef INCOMING_RETURN_ADDR_RTX
#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 EXPAND_BUILTIN_VA_START
#undef EXPAND_BUILTIN_VA_ARG

#define EH_FRAME_IN_DATA_SECTION 1
OpenPOWER on IntegriCloud