OSDN Git Service

moxie EH fixes
[pf3gnuchains/gcc-fork.git] / gcc / config / moxie / moxie.h
1 /* Target Definitions for moxie.
2    Copyright (C) 2008, 2009, 2010  Free Software Foundation, Inc.
3    Contributed by Anthony Green.
4
5    This file is part of GCC.
6
7    GCC is free software; you can redistribute it and/or modify it
8    under the terms of the GNU General Public License as published
9    by the Free Software Foundation; either version 3, or (at your
10    option) any later version.
11
12    GCC is distributed in the hope that it will be useful, but WITHOUT
13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15    License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GCC; see the file COPYING3.  If not see
19    <http://www.gnu.org/licenses/>.  */
20
21 #ifndef GCC_MOXIE_H
22 #define GCC_MOXIE_H
23
24 /* This is defined by svr4.h, which is included prior to this file.
25    However, we should undefine it for moxie-elf, since we don't provide
26    functions like access() and mkdir() in newlib.  This will have to
27    be defined again for a Linux port.  */
28 #undef TARGET_POSIX_IO
29
30 /* Another C string constant used much like `LINK_SPEC'.  The difference
31    between the two is that `STARTFILE_SPEC' is used at the very beginning of
32    the command given to the linker.
33
34    If this macro is not defined, a default is provided that loads the standard
35    C startup file from the usual place.  See `gcc.c'.
36
37    Defined in svr4.h.  */
38 #undef  STARTFILE_SPEC
39 #define STARTFILE_SPEC "crt0%O%s crti.o%s crtbegin.o%s"
40
41 /* Provide an ENDFILE_SPEC appropriate for svr4.  Here we tack on our own
42    magical crtend.o file (see crtstuff.c) which provides part of the
43    support for getting C++ file-scope static object constructed before
44    entering `main', followed by the normal svr3/svr4 "finalizer" file,
45    which is either `gcrtn.o' or `crtn.o'.  */
46
47 #undef  ENDFILE_SPEC
48 #define ENDFILE_SPEC "crtend.o%s crtn.o%s"
49
50 /* Provide a LIB_SPEC appropriate for svr4.  Here we tack on the default
51    standard C library (unless we are building a shared library) and
52    the simulator BSP code.  */
53
54 #undef LIB_SPEC
55 #define LIB_SPEC "%{!shared:%{!symbolic:-lc}}"
56
57 /* Layout of Source Language Data Types */
58
59 #define INT_TYPE_SIZE 32
60 #define SHORT_TYPE_SIZE 16
61 #define LONG_TYPE_SIZE 32
62 #define LONG_LONG_TYPE_SIZE 64
63
64 #define FLOAT_TYPE_SIZE 32
65 #define DOUBLE_TYPE_SIZE 64
66 #define LONG_DOUBLE_TYPE_SIZE 64
67
68 #define DEFAULT_SIGNED_CHAR 1
69
70 /* Registers...
71
72    $fp  - frame pointer
73    $sp  - stack pointer
74    $r0  - general purpose 32-bit register.
75    $r1  - general purpose 32-bit register.
76    $r2  - general purpose 32-bit register.
77    $r3  - general purpose 32-bit register.
78    $r4  - general purpose 32-bit register.
79    $r5  - general purpose 32-bit register.
80    $r6  - general purpose 32-bit register.
81    $r7  - general purpose 32-bit register.
82    $r8  - general purpose 32-bit register.
83    $r9  - general purpose 32-bit register.
84    $r10 - general purpose 32-bit register.
85    $r11 - general purpose 32-bit register.
86    $r12 - general purpose 32-bit register.
87    $r13 - reserved for execution environment.
88
89    Special Registers...
90
91    $pc - 32-bit program counter.
92    
93 */
94
95 #define REGISTER_NAMES {        \
96   "$fp", "$sp", "$r0", "$r1",   \
97   "$r2", "$r3", "$r4", "$r5",   \
98   "$r6", "$r7", "$r8", "$r9",   \
99   "$r10", "$r11", "$r12", "$r13",   \
100   "?fp", "?ap", "$pc", "?cc" }
101
102 #define MOXIE_FP     0
103 #define MOXIE_SP     1
104 #define MOXIE_R0     2
105 #define MOXIE_R1     3 
106 #define MOXIE_R2     4
107 #define MOXIE_R3     5
108 #define MOXIE_R4     6
109 #define MOXIE_R5     7
110 #define MOXIE_R6     8
111 #define MOXIE_R7     9
112 #define MOXIE_R8     10
113 #define MOXIE_R9     11
114 #define MOXIE_R10    12
115 #define MOXIE_R11    13
116 #define MOXIE_R12    14
117 #define MOXIE_R13    15
118 #define MOXIE_QFP    16
119 #define MOXIE_QAP    17
120 #define MOXIE_PC     18
121 #define MOXIE_CC     19
122
123 #define FIRST_PSEUDO_REGISTER 20
124
125 enum reg_class
126 {
127   NO_REGS,
128   GENERAL_REGS,
129   SPECIAL_REGS,
130   CC_REGS,
131   ALL_REGS,
132   LIM_REG_CLASSES
133 };
134
135
136 /* The following macro defines cover classes for Integrated Register
137    Allocator.  Cover classes is a set of non-intersected register
138    classes covering all hard registers used for register allocation
139    purpose.  Any move between two registers of a cover class should be
140    cheaper than load or store of the registers.  The macro value is
141    array of register classes with LIM_REG_CLASSES used as the end
142    marker.  */
143 #define IRA_COVER_CLASSES { GENERAL_REGS, LIM_REG_CLASSES }
144
145 #define REG_CLASS_CONTENTS \
146 { { 0x00000000 }, /* Empty */                      \
147   { 0x0003FFFF }, /* $fp, $sp, $r0 to $r13, ?fp */ \
148   { 0x00040000 }, /* $pc */                        \
149   { 0x00080000 }, /* ?cc */                        \
150   { 0x000FFFFF }  /* All registers */              \
151 }
152
153 #define N_REG_CLASSES LIM_REG_CLASSES
154
155 #define REG_CLASS_NAMES {\
156     "NO_REGS", \
157     "GENERAL_REGS", \
158     "SPECIAL_REGS", \
159     "CC_REGS", \
160     "ALL_REGS" }
161
162 #define FIXED_REGISTERS     { 1, 1, 0, 0, \
163                               0, 0, 0, 0, \
164                               0, 0, 0, 0, \
165                               0, 0, 0, 1, \
166                               1, 1, 1, 1 }
167
168 #define CALL_USED_REGISTERS { 1, 1, 1, 1, \
169                               1, 1, 1, 1, \
170                               0, 0, 0, 0, \
171                               0, 0, 1, 1, \
172                               1, 1, 1, 1 }
173
174 /* We can't copy to or from our CC register. */
175 #define AVOID_CCMODE_COPIES 1
176
177 /* A C expression that is nonzero if it is permissible to store a
178    value of mode MODE in hard register number REGNO (or in several
179    registers starting with that one).  All gstore registers are 
180    equivalent, so we can set this to 1.  */
181 #define HARD_REGNO_MODE_OK(R,M) 1
182
183 /* A C expression whose value is a register class containing hard
184    register REGNO.  */
185 #define REGNO_REG_CLASS(R) ((R < MOXIE_PC) ? GENERAL_REGS :             \
186                             (R == MOXIE_CC ? CC_REGS : SPECIAL_REGS))
187
188 /* A C expression for the number of consecutive hard registers,
189    starting at register number REGNO, required to hold a value of mode
190    MODE.  */
191 #define HARD_REGNO_NREGS(REGNO, MODE)                      \
192   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1)             \
193    / UNITS_PER_WORD)
194
195 /* A C expression that is nonzero if a value of mode MODE1 is
196    accessible in mode MODE2 without copying.  */
197 #define MODES_TIEABLE_P(MODE1, MODE2) 1
198
199 /* A C expression for the maximum number of consecutive registers of
200    class CLASS needed to hold a value of mode MODE.  */
201 #define CLASS_MAX_NREGS(CLASS, MODE) \
202   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
203
204 /* The Overall Framework of an Assembler File */
205
206 #undef  ASM_SPEC
207 #define ASM_COMMENT_START "#"
208 #define ASM_APP_ON ""
209 #define ASM_APP_OFF ""
210
211 #define FILE_ASM_OP     "\t.file\n"
212
213 /* Switch to the text or data segment.  */
214 #define TEXT_SECTION_ASM_OP  "\t.text"
215 #define DATA_SECTION_ASM_OP  "\t.data"
216
217 /* Assembler Commands for Alignment */
218
219 #define ASM_OUTPUT_ALIGN(STREAM,POWER) \
220         fprintf (STREAM, "\t.p2align\t%d\n", POWER);
221
222 /* A C compound statement to output to stdio stream STREAM the
223    assembler syntax for an instruction operand X.  */
224 #define PRINT_OPERAND(STREAM, X, CODE) moxie_print_operand (STREAM, X, CODE)
225
226 #define PRINT_OPERAND_ADDRESS(STREAM ,X) moxie_print_operand_address (STREAM, X)
227
228 /* Output and Generation of Labels */
229
230 #define GLOBAL_ASM_OP "\t.global\t"
231
232 /* Passing Arguments in Registers */
233
234 /* A C type for declaring a variable that is used as the first
235    argument of `FUNCTION_ARG' and other related values.  */
236 #define CUMULATIVE_ARGS unsigned int
237
238 /* If defined, the maximum amount of space required for outgoing arguments
239    will be computed and placed into the variable
240    `current_function_outgoing_args_size'.  No space will be pushed
241    onto the stack for each call; instead, the function prologue should
242    increase the stack frame size by this amount.  */
243 #define ACCUMULATE_OUTGOING_ARGS 1
244
245 /* A C statement (sans semicolon) for initializing the variable CUM
246    for the state at the beginning of the argument list.  
247    For moxie, the first arg is passed in register 2 (aka $r0).  */
248 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,FNDECL,N_NAMED_ARGS) \
249   (CUM = MOXIE_R0)
250
251 /* How Scalar Function Values Are Returned */
252
253 /* STACK AND CALLING */
254
255 /* Define this macro if pushing a word onto the stack moves the stack
256    pointer to a smaller address.  */
257 #define STACK_GROWS_DOWNWARD
258
259 #define INITIAL_FRAME_POINTER_OFFSET(DEPTH) (DEPTH) = 0
260
261 /* Offset from the frame pointer to the first local variable slot to
262    be allocated.  */
263 #define STARTING_FRAME_OFFSET 0
264
265 /* Define this if the above stack space is to be considered part of the
266    space allocated by the caller.  */
267 #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1
268 #define STACK_PARMS_IN_REG_PARM_AREA
269
270 /* Define this if it is the responsibility of the caller to allocate
271    the area reserved for arguments passed in registers.  */
272 #define REG_PARM_STACK_SPACE(FNDECL) (6 * UNITS_PER_WORD)
273
274 /* Offset from the argument pointer register to the first argument's
275    address.  On some machines it may depend on the data type of the
276    function.  */
277 #define FIRST_PARM_OFFSET(F) 12
278
279 /* Define this macro to nonzero value if the addresses of local variable slots
280    are at negative offsets from the frame pointer.  */
281 #define FRAME_GROWS_DOWNWARD 1
282
283 /* Define this macro as a C expression that is nonzero for registers that are
284    used by the epilogue or the return pattern.  The stack and frame
285    pointer registers are already assumed to be used as needed.  */
286 #define EPILOGUE_USES(R) (R == MOXIE_R5)
287
288 /* A C expression whose value is RTL representing the location of the
289    incoming return address at the beginning of any function, before
290    the prologue.  */
291 #define INCOMING_RETURN_ADDR_RTX                                        \
292   gen_frame_mem (Pmode,                                                 \
293                  plus_constant (stack_pointer_rtx, UNITS_PER_WORD))
294
295 /* Describe how we implement __builtin_eh_return.  */
296 #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N+2) : INVALID_REGNUM)
297
298 /* Store the return handler into the call frame.  */
299 #define EH_RETURN_HANDLER_RTX                                           \
300   gen_frame_mem (Pmode,                                                 \
301                  plus_constant (frame_pointer_rtx, UNITS_PER_WORD))
302
303 /* Storage Layout */
304
305 #define BITS_BIG_ENDIAN 0
306 #define BYTES_BIG_ENDIAN 1
307 #define WORDS_BIG_ENDIAN 1
308
309 /* Alignment required for a function entry point, in bits.  */
310 #define FUNCTION_BOUNDARY 16
311
312 /* Define this macro as a C expression which is nonzero if accessing
313    less than a word of memory (i.e. a `char' or a `short') is no
314    faster than accessing a word of memory.  */
315 #define SLOW_BYTE_ACCESS 1
316
317 /* Number of storage units in a word; normally the size of a
318    general-purpose register, a power of two from 1 or 8.  */
319 #define UNITS_PER_WORD 4
320
321 /* Define this macro to the minimum alignment enforced by hardware
322    for the stack pointer on this machine.  The definition is a C
323    expression for the desired alignment (measured in bits).  */
324 #define STACK_BOUNDARY 32
325
326 /* Normal alignment required for function parameters on the stack, in
327    bits.  All stack parameters receive at least this much alignment
328    regardless of data type.  */
329 #define PARM_BOUNDARY 32
330
331 /* Alignment of field after `int : 0' in a structure.  */
332 #define EMPTY_FIELD_BOUNDARY  32
333
334 /* No data type wants to be aligned rounder than this.  */
335 #define BIGGEST_ALIGNMENT 32
336
337 /* The best alignment to use in cases where we have a choice.  */
338 #define FASTEST_ALIGNMENT 32
339
340 /* Every structures size must be a multiple of 8 bits.  */
341 #define STRUCTURE_SIZE_BOUNDARY 8
342
343 /* Look at the fundamental type that is used for a bit-field and use 
344    that to impose alignment on the enclosing structure.
345    struct s {int a:8}; should have same alignment as "int", not "char".  */
346 #define PCC_BITFIELD_TYPE_MATTERS       1
347
348 /* Largest integer machine mode for structures.  If undefined, the default
349    is GET_MODE_SIZE(DImode).  */
350 #define MAX_FIXED_MODE_SIZE 32
351
352 /* Make strings word-aligned so strcpy from constants will be faster.  */
353 #define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
354   ((TREE_CODE (EXP) == STRING_CST       \
355     && (ALIGN) < FASTEST_ALIGNMENT)     \
356    ? FASTEST_ALIGNMENT : (ALIGN))
357
358 /* Make arrays of chars word-aligned for the same reasons.  */
359 #define DATA_ALIGNMENT(TYPE, ALIGN)             \
360   (TREE_CODE (TYPE) == ARRAY_TYPE               \
361    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \
362    && (ALIGN) < FASTEST_ALIGNMENT ? FASTEST_ALIGNMENT : (ALIGN))
363      
364 /* Set this nonzero if move instructions will actually fail to work
365    when given unaligned data.  */
366 #define STRICT_ALIGNMENT 1
367
368 /* Generating Code for Profiling */
369 #define FUNCTION_PROFILER(FILE,LABELNO) (abort (), 0)
370
371 /* Trampolines for Nested Functions.  */
372 #define TRAMPOLINE_SIZE (2 + 6 + 6 + 2 + 2 + 6)
373
374 /* Alignment required for trampolines, in bits.  */
375 #define TRAMPOLINE_ALIGNMENT 32
376
377 /* An alias for the machine mode for pointers.  */
378 #define Pmode         SImode
379
380 /* An alias for the machine mode used for memory references to
381    functions being called, in `call' RTL expressions.  */
382 #define FUNCTION_MODE QImode
383
384 /* The register number of the stack pointer register, which must also
385    be a fixed register according to `FIXED_REGISTERS'.  */
386 #define STACK_POINTER_REGNUM MOXIE_SP
387
388 /* The register number of the frame pointer register, which is used to
389    access automatic variables in the stack frame.  */
390 #define FRAME_POINTER_REGNUM MOXIE_QFP
391
392 /* The register number of the arg pointer register, which is used to
393    access the function's argument list.  */
394 #define ARG_POINTER_REGNUM MOXIE_QAP
395
396 #define HARD_FRAME_POINTER_REGNUM MOXIE_FP
397
398 #define ELIMINABLE_REGS                                                 \
399 {{ FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM },                   \
400  { ARG_POINTER_REGNUM,   HARD_FRAME_POINTER_REGNUM }}                   
401
402 /* This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'.  It
403    specifies the initial difference between the specified pair of
404    registers.  This macro must be defined if `ELIMINABLE_REGS' is
405    defined.  */
406 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)                    \
407   do {                                                                  \
408     (OFFSET) = moxie_initial_elimination_offset ((FROM), (TO));         \
409   } while (0)
410
411 /* A C expression that is nonzero if REGNO is the number of a hard
412    register in which function arguments are sometimes passed.  */
413 #define FUNCTION_ARG_REGNO_P(r) (r >= MOXIE_R0 && r <= MOXIE_R5)
414
415 /* A macro whose definition is the name of the class to which a valid
416    base register must belong.  A base register is one used in an
417    address which is the register value plus a displacement.  */
418 #define BASE_REG_CLASS GENERAL_REGS
419
420 #define INDEX_REG_CLASS NO_REGS
421
422 #define HARD_REGNO_OK_FOR_BASE_P(NUM) \
423   ((unsigned) (NUM) < FIRST_PSEUDO_REGISTER \
424    && (REGNO_REG_CLASS(NUM) == GENERAL_REGS \
425        || (NUM) == HARD_FRAME_POINTER_REGNUM))
426
427 /* A C expression which is nonzero if register number NUM is suitable
428    for use as a base register in operand addresses.  */
429 #ifdef REG_OK_STRICT
430 #define REGNO_OK_FOR_BASE_P(NUM)                 \
431   (HARD_REGNO_OK_FOR_BASE_P(NUM)                 \
432    || HARD_REGNO_OK_FOR_BASE_P(reg_renumber[(NUM)]))
433 #else
434 #define REGNO_OK_FOR_BASE_P(NUM)                 \
435   ((NUM) >= FIRST_PSEUDO_REGISTER || HARD_REGNO_OK_FOR_BASE_P(NUM))
436 #endif
437
438 /* A C expression which is nonzero if register number NUM is suitable
439    for use as an index register in operand addresses.  */
440 #define REGNO_OK_FOR_INDEX_P(NUM) MOXIE_FP
441
442 /* The maximum number of bytes that a single instruction can move
443    quickly between memory and registers or between two memory
444    locations.  */
445 #define MOVE_MAX 4
446 #define TRULY_NOOP_TRUNCATION(op,ip) 1
447
448 /* All load operations zero extend.  */
449 #define LOAD_EXTEND_OP(MEM) ZERO_EXTEND
450
451 /* A C expression that is nonzero if X is a legitimate constant for
452    an immediate operand on the target machine.  */
453 #define LEGITIMATE_CONSTANT_P(X) 1
454
455 /* A number, the maximum number of registers that can appear in a
456    valid memory address.  */
457 #define MAX_REGS_PER_ADDRESS 1
458
459 #define TRULY_NOOP_TRUNCATION(op,ip) 1
460
461 /* An alias for a machine mode name.  This is the machine mode that
462    elements of a jump-table should have.  */
463 #define CASE_VECTOR_MODE SImode
464
465 /* A C compound statement with a conditional `goto LABEL;' executed
466    if X (an RTX) is a legitimate memory address on the target machine
467    for a memory operand of mode MODE.  */
468 #define GO_IF_LEGITIMATE_ADDRESS(MODE,X,LABEL)          \
469   do {                                                  \
470     if (GET_CODE(X) == PLUS)                            \
471       {                                                 \
472         rtx op1,op2;                                    \
473         op1 = XEXP(X,0);                                \
474         op2 = XEXP(X,1);                                \
475         if (GET_CODE(op1) == REG                        \
476             && CONSTANT_ADDRESS_P(op2)                  \
477             && REGNO_OK_FOR_BASE_P(REGNO(op1)))         \
478           goto LABEL;                                   \
479       }                                                 \
480     if (REG_P (X) && REGNO_OK_FOR_BASE_P (REGNO (X)))   \
481       goto LABEL;                                       \
482     if (GET_CODE (X) == SYMBOL_REF                      \
483         || GET_CODE (X) == LABEL_REF                    \
484         || GET_CODE (X) == CONST)                       \
485       goto LABEL;                                       \
486   } while (0)
487
488 /* Run-time Target Specification */
489
490 #define TARGET_CPU_CPP_BUILTINS() \
491   { \
492     builtin_define_std ("moxie");               \
493     builtin_define_std ("MOXIE");               \
494   }
495
496 #define HAS_LONG_UNCOND_BRANCH true
497
498 #endif /* GCC_MOXIE_H */