OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [config/] [v850/] [v850.h] - Blame information for rev 709

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 709 jeremybenn
/* Definitions of target machine for GNU compiler. NEC V850 series
2
   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3
   2007, 2008, 2009, 2010, 2011  Free Software Foundation, Inc.
4
   Contributed by Jeff Law (law@cygnus.com).
5
 
6
   This file is part of GCC.
7
 
8
   GCC is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3, or (at your option)
11
   any later version.
12
 
13
   GCC is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public 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 COPYING3.  If not see
20
   <http://www.gnu.org/licenses/>.  */
21
 
22
#ifndef GCC_V850_H
23
#define GCC_V850_H
24
 
25
extern GTY(()) rtx v850_compare_op0;
26
extern GTY(()) rtx v850_compare_op1;
27
 
28
#undef LIB_SPEC
29
#define LIB_SPEC "%{!shared:%{!symbolic:--start-group -lc -lgcc --end-group}}"
30
 
31
#undef ENDFILE_SPEC
32
#undef LINK_SPEC
33
#undef STARTFILE_SPEC
34
#undef ASM_SPEC
35
 
36
#define TARGET_CPU_generic      1
37
#define TARGET_CPU_v850e        2
38
#define TARGET_CPU_v850e1       3
39
#define TARGET_CPU_v850e2       4
40
#define TARGET_CPU_v850e2v3     5
41
 
42
 
43
#ifndef TARGET_CPU_DEFAULT
44
#define TARGET_CPU_DEFAULT      TARGET_CPU_generic
45
#endif
46
 
47
#define MASK_DEFAULT            MASK_V850
48
#define SUBTARGET_ASM_SPEC      "%{!mv*:-mv850}"
49
#define SUBTARGET_CPP_SPEC      "%{!mv*:-D__v850__}"
50
 
51
/* Choose which processor will be the default.
52
   We must pass a -mv850xx option to the assembler if no explicit -mv* option
53
   is given, because the assembler's processor default may not be correct.  */
54
#if TARGET_CPU_DEFAULT == TARGET_CPU_v850e
55
#undef  MASK_DEFAULT
56
#define MASK_DEFAULT            MASK_V850E
57
#undef  SUBTARGET_ASM_SPEC
58
#define SUBTARGET_ASM_SPEC      "%{!mv*:-mv850e}"
59
#undef  SUBTARGET_CPP_SPEC
60
#define SUBTARGET_CPP_SPEC      "%{!mv*:-D__v850e__}"
61
#endif
62
 
63
#if TARGET_CPU_DEFAULT == TARGET_CPU_v850e1
64
#undef  MASK_DEFAULT
65
#define MASK_DEFAULT            MASK_V850E     /* No practical difference.  */     
66
#undef  SUBTARGET_ASM_SPEC
67
#define SUBTARGET_ASM_SPEC      "%{!mv*:-mv850e1}"
68
#undef  SUBTARGET_CPP_SPEC
69
#define SUBTARGET_CPP_SPEC      "%{!mv*:-D__v850e1__} %{mv850e1:-D__v850e1__}"
70
#endif
71
 
72
#if TARGET_CPU_DEFAULT == TARGET_CPU_v850e2
73
#undef  MASK_DEFAULT
74
#define MASK_DEFAULT            MASK_V850E2     
75
#undef  SUBTARGET_ASM_SPEC
76
#define SUBTARGET_ASM_SPEC      "%{!mv*:-mv850e2}"
77
#undef  SUBTARGET_CPP_SPEC
78
#define SUBTARGET_CPP_SPEC      "%{!mv*:-D__v850e2__} %{mv850e2:-D__v850e2__}"
79
#endif
80
 
81
#if TARGET_CPU_DEFAULT == TARGET_CPU_v850e2v3
82
#undef  MASK_DEFAULT
83
#define MASK_DEFAULT            MASK_V850E2V3
84
#undef  SUBTARGET_ASM_SPEC
85
#define SUBTARGET_ASM_SPEC      "%{!mv*:-mv850e2v3}"
86
#undef  SUBTARGET_CPP_SPEC
87
#define SUBTARGET_CPP_SPEC      "%{!mv*:-D__v850e2v3__} %{mv850e2v3:-D__v850e2v3__}"
88
#endif
89
 
90
#define TARGET_V850E2_ALL      (TARGET_V850E2 || TARGET_V850E2V3) 
91
 
92
#define ASM_SPEC "%{mv850es:-mv850e1}%{!mv850es:%{mv*:-mv%*}}"
93
#define CPP_SPEC "\
94
  %{mv850e2v3:-D__v850e2v3__} \
95
  %{mv850e2:-D__v850e2__} \
96
  %{mv850es:-D__v850e1__} \
97
  %{mv850e1:-D__v850e1__} \
98
  %{mv850e:-D__v850e__} \
99
  %{mv850:-D__v850__} \
100
  %(subtarget_cpp_spec)" \
101
  " %{mep:-D__EP__}"
102
 
103
#define EXTRA_SPECS \
104
 { "subtarget_asm_spec", SUBTARGET_ASM_SPEC }, \
105
 { "subtarget_cpp_spec", SUBTARGET_CPP_SPEC }
106
 
107
/* Names to predefine in the preprocessor for this target machine.  */
108
#define TARGET_CPU_CPP_BUILTINS() do {          \
109
  builtin_define( "__v851__" );                        \
110
  builtin_define( "__v850" );                   \
111
  builtin_assert( "machine=v850" );             \
112
  builtin_assert( "cpu=v850" );                 \
113
  if (TARGET_EP)                                \
114
    builtin_define ("__EP__");                  \
115
} while(0)
116
 
117
#define MASK_CPU (MASK_V850 | MASK_V850E | MASK_V850E1 | MASK_V850E2 | MASK_V850E2V3)
118
 
119
/* Target machine storage layout */
120
 
121
/* Define this if most significant bit is lowest numbered
122
   in instructions that operate on numbered bit-fields.
123
   This is not true on the NEC V850.  */
124
#define BITS_BIG_ENDIAN 0
125
 
126
/* Define this if most significant byte of a word is the lowest numbered.  */
127
/* This is not true on the NEC V850.  */
128
#define BYTES_BIG_ENDIAN 0
129
 
130
/* Define this if most significant word of a multiword number is lowest
131
   numbered.
132
   This is not true on the NEC V850.  */
133
#define WORDS_BIG_ENDIAN 0
134
 
135
/* Width of a word, in units (bytes).  */
136
#define UNITS_PER_WORD          4
137
 
138
/* Define this macro if it is advisable to hold scalars in registers
139
   in a wider mode than that declared by the program.  In such cases,
140
   the value is constrained to be within the bounds of the declared
141
   type, but kept valid in the wider mode.  The signedness of the
142
   extension may differ from that of the type.
143
 
144
   Some simple experiments have shown that leaving UNSIGNEDP alone
145
   generates the best overall code.  */
146
 
147
#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)  \
148
  if (GET_MODE_CLASS (MODE) == MODE_INT \
149
      && GET_MODE_SIZE (MODE) < 4)      \
150
    { (MODE) = SImode; }
151
 
152
/* Allocation boundary (in *bits*) for storing arguments in argument list.  */
153
#define PARM_BOUNDARY           32
154
 
155
/* The stack goes in 32-bit lumps.  */
156
#define STACK_BOUNDARY          32
157
 
158
/* Allocation boundary (in *bits*) for the code of a function.
159
   16 is the minimum boundary; 32 would give better performance.  */
160
#define FUNCTION_BOUNDARY (optimize_size ? 16 : 32)
161
 
162
/* No data type wants to be aligned rounder than this.  */
163
#define BIGGEST_ALIGNMENT       32
164
 
165
/* Alignment of field after `int : 0' in a structure.  */
166
#define EMPTY_FIELD_BOUNDARY 32
167
 
168
/* No structure field wants to be aligned rounder than this.  */
169
#define BIGGEST_FIELD_ALIGNMENT 32
170
 
171
/* Define this if move instructions will actually fail to work
172
   when given unaligned data.  */
173
#define STRICT_ALIGNMENT  (!TARGET_NO_STRICT_ALIGN)
174
 
175
/* Define this as 1 if `char' should by default be signed; else as 0.
176
 
177
   On the NEC V850, loads do sign extension, so make this default.  */
178
#define DEFAULT_SIGNED_CHAR 1
179
 
180
#undef  SIZE_TYPE
181
#define SIZE_TYPE "unsigned int"
182
 
183
#undef  PTRDIFF_TYPE
184
#define PTRDIFF_TYPE "int"
185
 
186
#undef  WCHAR_TYPE
187
#define WCHAR_TYPE "long int"
188
 
189
#undef  WCHAR_TYPE_SIZE
190
#define WCHAR_TYPE_SIZE BITS_PER_WORD
191
 
192
/* Standard register usage.  */
193
 
194
/* Number of actual hardware registers.
195
   The hardware registers are assigned numbers for the compiler
196
   from 0 to just below FIRST_PSEUDO_REGISTER.
197
 
198
   All registers that the compiler knows about must be given numbers,
199
   even those that are not normally considered general registers.  */
200
 
201
#define FIRST_PSEUDO_REGISTER 36
202
 
203
/* 1 for registers that have pervasive standard uses
204
   and are not available for the register allocator.  */
205
 
206
#define FIXED_REGISTERS \
207
  { 1, 1, 1, 1, 1, 1, 0, 0, \
208
    0, 0, 0, 0, 0, 0, 0, 0, \
209
    0, 0, 0, 0, 0, 0, 0, 0, \
210
    0, 0, 0, 0, 0, 0, 1, 0, \
211
    1, 1,       \
212
    1, 1}
213
 
214
/* 1 for registers not available across function calls.
215
   These must include the FIXED_REGISTERS and also any
216
   registers that can be used without being saved.
217
   The latter must include the registers where values are returned
218
   and the register where structure-value addresses are passed.
219
   Aside from that, you can include as many other registers as you
220
   like.  */
221
 
222
#define CALL_USED_REGISTERS \
223
  { 1, 1, 1, 1, 1, 1, 1, 1, \
224
    1, 1, 1, 1, 1, 1, 1, 1, \
225
    1, 1, 1, 1, 0, 0, 0, 0, \
226
    0, 0, 0, 0, 0, 0, 1, 1, \
227
    1, 1,       \
228
    1, 1}
229
 
230
/* List the order in which to allocate registers.  Each register must be
231
   listed once, even those in FIXED_REGISTERS.
232
 
233
   On the 850, we make the return registers first, then all of the volatile
234
   registers, then the saved registers in reverse order to better save the
235
   registers with an out of line function, and finally the fixed
236
   registers.  */
237
 
238
#define REG_ALLOC_ORDER                                                 \
239
{                                                                       \
240
  10, 11,                               /* return registers */          \
241
  12, 13, 14, 15, 16, 17, 18, 19,       /* scratch registers */         \
242
   6,  7,  8,  9, 31,                   /* argument registers */        \
243
  29, 28, 27, 26, 25, 24, 23, 22,       /* saved registers */           \
244
  21, 20,  2,                                                           \
245
   0,  1,  3,  4,  5, 30, 32, 33,      /* fixed registers */           \
246
  34, 35                                                                \
247
}
248
 
249
/* Return number of consecutive hard regs needed starting at reg REGNO
250
   to hold something of mode MODE.
251
 
252
   This is ordinarily the length in words of a value of mode MODE
253
   but can be less for certain modes in special long registers.  */
254
 
255
#define HARD_REGNO_NREGS(REGNO, MODE)   \
256
  ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
257
 
258
/* Value is 1 if hard register REGNO can hold a value of machine-mode
259
   MODE.  */
260
 
261
#define HARD_REGNO_MODE_OK(REGNO, MODE) \
262
 ((GET_MODE_SIZE (MODE) <= 4) || (((REGNO) & 1) == 0 && (REGNO) != 0))
263
 
264
/* Value is 1 if it is a good idea to tie two pseudo registers
265
   when one has mode MODE1 and one has mode MODE2.
266
   If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
267
   for any hard reg, then this must be 0 for correct output.  */
268
#define MODES_TIEABLE_P(MODE1, MODE2) \
269
  (MODE1 == MODE2 || (GET_MODE_SIZE (MODE1) <= 4 && GET_MODE_SIZE (MODE2) <= 4))
270
 
271
 
272
/* Define the classes of registers for register constraints in the
273
   machine description.  Also define ranges of constants.
274
 
275
   One of the classes must always be named ALL_REGS and include all hard regs.
276
   If there is more than one class, another class must be named NO_REGS
277
   and contain no registers.
278
 
279
   The name GENERAL_REGS must be the name of a class (or an alias for
280
   another name such as ALL_REGS).  This is the class of registers
281
   that is allowed by "g" or "r" in a register constraint.
282
   Also, registers outside this class are allocated only when
283
   instructions express preferences for them.
284
 
285
   The classes must be numbered in nondecreasing order; that is,
286
   a larger-numbered class must never be contained completely
287
   in a smaller-numbered class.
288
 
289
   For any two classes, it is very desirable that there be another
290
   class that represents their union.  */
291
 
292
enum reg_class
293
{
294
  NO_REGS, GENERAL_REGS, EVEN_REGS, ALL_REGS, LIM_REG_CLASSES
295
};
296
 
297
#define N_REG_CLASSES (int) LIM_REG_CLASSES
298
 
299
/* Give names of register classes as strings for dump file.  */
300
 
301
#define REG_CLASS_NAMES \
302
{ "NO_REGS", "GENERAL_REGS", "EVEN_REGS", "ALL_REGS", "LIM_REGS" }
303
 
304
/* Define which registers fit in which classes.
305
   This is an initializer for a vector of HARD_REG_SET
306
   of length N_REG_CLASSES.  */
307
 
308
#define REG_CLASS_CONTENTS                     \
309
{                                              \
310
  { 0x00000000,0x0 }, /* NO_REGS      */       \
311
  { 0xffffffff,0x0 }, /* GENERAL_REGS */       \
312
  { 0x55555554,0x0 }, /* EVEN_REGS */          \
313
  { 0xffffffff,0x0 }, /* ALL_REGS      */      \
314
}
315
 
316
/* The same information, inverted:
317
   Return the class number of the smallest class containing
318
   reg number REGNO.  This could be a conditional expression
319
   or could index an array.  */
320
 
321
#define REGNO_REG_CLASS(REGNO)  ((REGNO == CC_REGNUM || REGNO == FCC_REGNUM) ? NO_REGS : GENERAL_REGS)
322
 
323
/* The class value for index registers, and the one for base regs.  */
324
 
325
#define INDEX_REG_CLASS NO_REGS
326
#define BASE_REG_CLASS  GENERAL_REGS
327
 
328
/* Macros to check register numbers against specific register classes.  */
329
 
330
/* These assume that REGNO is a hard or pseudo reg number.
331
   They give nonzero only if REGNO is a hard reg of the suitable class
332
   or a pseudo reg currently allocated to a suitable hard reg.
333
   Since they use reg_renumber, they are safe only once reg_renumber
334
   has been allocated, which happens in local-alloc.c.  */
335
 
336
#define REGNO_OK_FOR_BASE_P(regno)             \
337
  (((regno) < FIRST_PSEUDO_REGISTER            \
338
    && (regno) != CC_REGNUM                    \
339
    && (regno) != FCC_REGNUM)                  \
340
   || reg_renumber[regno] >= 0)
341
 
342
#define REGNO_OK_FOR_INDEX_P(regno) 0
343
 
344
/* Convenience wrappers around insn_const_int_ok_for_constraint.  */
345
 
346
#define CONST_OK_FOR_I(VALUE) \
347
  insn_const_int_ok_for_constraint (VALUE, CONSTRAINT_I)
348
#define CONST_OK_FOR_J(VALUE) \
349
  insn_const_int_ok_for_constraint (VALUE, CONSTRAINT_J)
350
#define CONST_OK_FOR_K(VALUE) \
351
  insn_const_int_ok_for_constraint (VALUE, CONSTRAINT_K)
352
#define CONST_OK_FOR_L(VALUE) \
353
  insn_const_int_ok_for_constraint (VALUE, CONSTRAINT_L)
354
#define CONST_OK_FOR_M(VALUE) \
355
  insn_const_int_ok_for_constraint (VALUE, CONSTRAINT_M)
356
#define CONST_OK_FOR_N(VALUE) \
357
  insn_const_int_ok_for_constraint (VALUE, CONSTRAINT_N)
358
#define CONST_OK_FOR_O(VALUE) \
359
  insn_const_int_ok_for_constraint (VALUE, CONSTRAINT_O)
360
 
361
 
362
/* Stack layout; function entry, exit and calling.  */
363
 
364
/* Define this if pushing a word on the stack
365
   makes the stack pointer a smaller address.  */
366
 
367
#define STACK_GROWS_DOWNWARD
368
 
369
/* Define this to nonzero if the nominal address of the stack frame
370
   is at the high-address end of the local variables;
371
   that is, each additional local variable allocated
372
   goes at a more negative offset in the frame.  */
373
 
374
#define FRAME_GROWS_DOWNWARD 1
375
 
376
/* Offset within stack frame to start allocating local variables at.
377
   If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
378
   first local allocated.  Otherwise, it is the offset to the BEGINNING
379
   of the first local allocated.  */
380
 
381
#define STARTING_FRAME_OFFSET 0
382
 
383
/* Offset of first parameter from the argument pointer register value.  */
384
/* Is equal to the size of the saved fp + pc, even if an fp isn't
385
   saved since the value is used before we know.  */
386
 
387
#define FIRST_PARM_OFFSET(FNDECL) 0
388
 
389
/* Specify the registers used for certain standard purposes.
390
   The values of these macros are register numbers.  */
391
 
392
/* Register to use for pushing function arguments.  */
393
#define STACK_POINTER_REGNUM SP_REGNUM
394
 
395
/* Base register for access to local variables of the function.  */
396
#define FRAME_POINTER_REGNUM 34
397
 
398
/* Register containing return address from latest function call.  */
399
#define LINK_POINTER_REGNUM LP_REGNUM
400
 
401
/* On some machines the offset between the frame pointer and starting
402
   offset of the automatic variables is not known until after register
403
   allocation has been done (for example, because the saved registers
404
   are between these two locations).  On those machines, define
405
   `FRAME_POINTER_REGNUM' the number of a special, fixed register to
406
   be used internally until the offset is known, and define
407
   `HARD_FRAME_POINTER_REGNUM' to be actual the hard register number
408
   used for the frame pointer.
409
 
410
   You should define this macro only in the very rare circumstances
411
   when it is not possible to calculate the offset between the frame
412
   pointer and the automatic variables until after register
413
   allocation has been completed.  When this macro is defined, you
414
   must also indicate in your definition of `ELIMINABLE_REGS' how to
415
   eliminate `FRAME_POINTER_REGNUM' into either
416
   `HARD_FRAME_POINTER_REGNUM' or `STACK_POINTER_REGNUM'.
417
 
418
   Do not define this macro if it would be the same as
419
   `FRAME_POINTER_REGNUM'.  */
420
#undef  HARD_FRAME_POINTER_REGNUM
421
#define HARD_FRAME_POINTER_REGNUM 29
422
 
423
/* Base register for access to arguments of the function.  */
424
#define ARG_POINTER_REGNUM 35
425
 
426
/* Register in which static-chain is passed to a function.  */
427
#define STATIC_CHAIN_REGNUM 20
428
 
429
/* If defined, this macro specifies a table of register pairs used to
430
   eliminate unneeded registers that point into the stack frame.  If
431
   it is not defined, the only elimination attempted by the compiler
432
   is to replace references to the frame pointer with references to
433
   the stack pointer.
434
 
435
   The definition of this macro is a list of structure
436
   initializations, each of which specifies an original and
437
   replacement register.
438
 
439
   On some machines, the position of the argument pointer is not
440
   known until the compilation is completed.  In such a case, a
441
   separate hard register must be used for the argument pointer.
442
   This register can be eliminated by replacing it with either the
443
   frame pointer or the argument pointer, depending on whether or not
444
   the frame pointer has been eliminated.
445
 
446
   In this case, you might specify:
447
        #define ELIMINABLE_REGS  \
448
        {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
449
         {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \
450
         {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}}
451
 
452
   Note that the elimination of the argument pointer with the stack
453
   pointer is specified first since that is the preferred elimination.  */
454
 
455
#define ELIMINABLE_REGS                                                 \
456
{{ FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM },                        \
457
 { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM },                   \
458
 { ARG_POINTER_REGNUM,   STACK_POINTER_REGNUM },                        \
459
 { ARG_POINTER_REGNUM,   HARD_FRAME_POINTER_REGNUM }}                   \
460
 
461
/* This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'.  It
462
   specifies the initial difference between the specified pair of
463
   registers.  This macro must be defined if `ELIMINABLE_REGS' is
464
   defined.  */
465
 
466
#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)                    \
467
{                                                                       \
468
  if ((FROM) == FRAME_POINTER_REGNUM)                                   \
469
    (OFFSET) = get_frame_size () + crtl->outgoing_args_size;    \
470
  else if ((FROM) == ARG_POINTER_REGNUM)                                \
471
   (OFFSET) = compute_frame_size (get_frame_size (), (long *)0);        \
472
  else                                                                  \
473
    gcc_unreachable ();                                                 \
474
}
475
 
476
/* Keep the stack pointer constant throughout the function.  */
477
#define ACCUMULATE_OUTGOING_ARGS 1
478
 
479
#define RETURN_ADDR_RTX(COUNT, FP) v850_return_addr (COUNT)
480
 
481
/* Define a data type for recording info about an argument list
482
   during the scan of that argument list.  This data type should
483
   hold all necessary information about the function itself
484
   and about the args processed so far, enough to enable macros
485
   such as FUNCTION_ARG to determine where the next arg should go.  */
486
 
487
#define CUMULATIVE_ARGS struct cum_arg
488
struct cum_arg { int nbytes; int anonymous_args; };
489
 
490
/* Initialize a variable CUM of type CUMULATIVE_ARGS
491
   for a call to a function whose data type is FNTYPE.
492
   For a library call, FNTYPE is 0.  */
493
 
494
#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
495
 ((CUM).nbytes = 0, (CUM).anonymous_args = 0)
496
 
497
/* When a parameter is passed in a register, stack space is still
498
   allocated for it.  */
499
#define REG_PARM_STACK_SPACE(DECL) 0
500
 
501
/* 1 if N is a possible register number for function argument passing.  */
502
 
503
#define FUNCTION_ARG_REGNO_P(N) (N >= 6 && N <= 9)
504
 
505
/* Define how to find the value returned by a library function
506
   assuming the value has mode MODE.  */
507
 
508
#define LIBCALL_VALUE(MODE) \
509
  gen_rtx_REG (MODE, 10)
510
 
511
#define DEFAULT_PCC_STRUCT_RETURN 0
512
 
513
/* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
514
   the stack pointer does not matter.  The value is tested only in
515
   functions that have frame pointers.
516
   No definition is equivalent to always zero.  */
517
 
518
#define EXIT_IGNORE_STACK 1
519
 
520
/* Define this macro as a C expression that is nonzero for registers
521
   used by the epilogue or the `return' pattern.  */
522
 
523
#define EPILOGUE_USES(REGNO) \
524
  (reload_completed && (REGNO) == LINK_POINTER_REGNUM)
525
 
526
/* Output assembler code to FILE to increment profiler label # LABELNO
527
   for profiling a function entry.  */
528
 
529
#define FUNCTION_PROFILER(FILE, LABELNO) ;
530
 
531
/* Length in units of the trampoline for entering a nested function.  */
532
 
533
#define TRAMPOLINE_SIZE 24
534
 
535
/* Addressing modes, and classification of registers for them.  */
536
 
537
 
538
/* 1 if X is an rtx for a constant that is a valid address.  */
539
 
540
/* ??? This seems too exclusive.  May get better code by accepting more
541
   possibilities here, in particular, should accept ZDA_NAME SYMBOL_REFs.  */
542
 
543
#define CONSTANT_ADDRESS_P(X) constraint_satisfied_p (X, CONSTRAINT_K)
544
 
545
/* Maximum number of registers that can appear in a valid memory address.  */
546
 
547
#define MAX_REGS_PER_ADDRESS 1
548
 
549
/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
550
   and check its validity for a certain class.
551
   We have two alternate definitions for each of them.
552
   The usual definition accepts all pseudo regs; the other rejects
553
   them unless they have been allocated suitable hard regs.
554
   The symbol REG_OK_STRICT causes the latter definition to be used.
555
 
556
   Most source files want to accept pseudo regs in the hope that
557
   they will get allocated to the class that the insn wants them to be in.
558
   Source files for reload pass need to be strict.
559
   After reload, it makes no difference, since pseudo regs have
560
   been eliminated by then.  */
561
 
562
#ifndef REG_OK_STRICT
563
 
564
/* Nonzero if X is a hard reg that can be used as an index
565
   or if it is a pseudo reg.  */
566
#define REG_OK_FOR_INDEX_P(X) 0
567
/* Nonzero if X is a hard reg that can be used as a base reg
568
   or if it is a pseudo reg.  */
569
#define REG_OK_FOR_BASE_P(X) 1
570
#define REG_OK_FOR_INDEX_P_STRICT(X) 0
571
#define REG_OK_FOR_BASE_P_STRICT(X) REGNO_OK_FOR_BASE_P (REGNO (X))
572
#define STRICT 0
573
 
574
#else
575
 
576
/* Nonzero if X is a hard reg that can be used as an index.  */
577
#define REG_OK_FOR_INDEX_P(X) 0
578
/* Nonzero if X is a hard reg that can be used as a base reg.  */
579
#define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
580
#define STRICT 1
581
 
582
#endif
583
 
584
 
585
/* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
586
   that is a valid memory address for an instruction.
587
   The MODE argument is the machine mode for the MEM expression
588
   that wants to use this address.
589
 
590
   The other macros defined here are used only in GO_IF_LEGITIMATE_ADDRESS,
591
   except for CONSTANT_ADDRESS_P which is actually
592
   machine-independent.  */
593
 
594
/* Accept either REG or SUBREG where a register is valid.  */
595
 
596
#define RTX_OK_FOR_BASE_P(X)                                            \
597
  ((REG_P (X) && REG_OK_FOR_BASE_P (X))                                 \
598
   || (GET_CODE (X) == SUBREG && REG_P (SUBREG_REG (X))                 \
599
       && REG_OK_FOR_BASE_P (SUBREG_REG (X))))
600
 
601
#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR)                         \
602
do {                                                                    \
603
  if (RTX_OK_FOR_BASE_P (X))                                            \
604
    goto ADDR;                                                          \
605
  if (CONSTANT_ADDRESS_P (X)                                            \
606
      && (MODE == QImode || INTVAL (X) % 2 == 0)                        \
607
      && (GET_MODE_SIZE (MODE) <= 4 || INTVAL (X) % 4 == 0))            \
608
    goto ADDR;                                                          \
609
  if (GET_CODE (X) == LO_SUM                                            \
610
      && REG_P (XEXP (X, 0))                                            \
611
      && REG_OK_FOR_BASE_P (XEXP (X, 0))                                \
612
      && CONSTANT_P (XEXP (X, 1))                                       \
613
      && (GET_CODE (XEXP (X, 1)) != CONST_INT                           \
614
          || ((MODE == QImode || INTVAL (XEXP (X, 1)) % 2 == 0)         \
615
              && CONST_OK_FOR_K (INTVAL (XEXP (X, 1)))))                \
616
      && GET_MODE_SIZE (MODE) <= GET_MODE_SIZE (word_mode))             \
617
    goto ADDR;                                                          \
618
  if (special_symbolref_operand (X, MODE)                               \
619
      && (GET_MODE_SIZE (MODE) <= GET_MODE_SIZE (word_mode)))           \
620
     goto ADDR;                                                         \
621
  if (GET_CODE (X) == PLUS                                              \
622
      && RTX_OK_FOR_BASE_P (XEXP (X, 0))                                \
623
      && constraint_satisfied_p (XEXP (X,1), CONSTRAINT_K)              \
624
      && ((MODE == QImode || INTVAL (XEXP (X, 1)) % 2 == 0)             \
625
           && CONST_OK_FOR_K (INTVAL (XEXP (X, 1))                      \
626
                              + (GET_MODE_NUNITS (MODE) * UNITS_PER_WORD)))) \
627
    goto ADDR;                  \
628
} while (0)
629
 
630
 
631
/* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
632
   return the mode to be used for the comparison.
633
 
634
   For floating-point equality comparisons, CCFPEQmode should be used.
635
   VOIDmode should be used in all other cases.
636
 
637
   For integer comparisons against zero, reduce to CCNOmode or CCZmode if
638
   possible, to allow for more combinations.  */
639
 
640
#define SELECT_CC_MODE(OP, X, Y)       v850_select_cc_mode (OP, X, Y)
641
 
642
/* Tell final.c how to eliminate redundant test instructions.  */
643
 
644
/* Here we define machine-dependent flags and fields in cc_status
645
   (see `conditions.h').  No extra ones are needed for the VAX.  */
646
 
647
/* Store in cc_status the expressions
648
   that the condition codes will describe
649
   after execution of an instruction whose pattern is EXP.
650
   Do not alter them if the instruction would not alter the cc's.  */
651
 
652
#define CC_OVERFLOW_UNUSABLE 0x200
653
#define CC_NO_CARRY CC_NO_OVERFLOW
654
#define NOTICE_UPDATE_CC(EXP, INSN) notice_update_cc(EXP, INSN)
655
 
656
/* Nonzero if access to memory by bytes or half words is no faster
657
   than accessing full words.  */
658
#define SLOW_BYTE_ACCESS 1
659
 
660
/* According expr.c, a value of around 6 should minimize code size, and
661
   for the V850 series, that's our primary concern.  */
662
#define MOVE_RATIO(speed) 6
663
 
664
/* Indirect calls are expensive, never turn a direct call
665
   into an indirect call.  */
666
#define NO_FUNCTION_CSE
667
 
668
/* The four different data regions on the v850.  */
669
typedef enum
670
{
671
  DATA_AREA_NORMAL,
672
  DATA_AREA_SDA,
673
  DATA_AREA_TDA,
674
  DATA_AREA_ZDA
675
} v850_data_area;
676
 
677
#define TEXT_SECTION_ASM_OP  "\t.section .text"
678
#define DATA_SECTION_ASM_OP  "\t.section .data"
679
#define BSS_SECTION_ASM_OP   "\t.section .bss"
680
#define SDATA_SECTION_ASM_OP "\t.section .sdata,\"aw\""
681
#define SBSS_SECTION_ASM_OP  "\t.section .sbss,\"aw\""
682
 
683
#define SCOMMON_ASM_OP         "\t.scomm\t"
684
#define ZCOMMON_ASM_OP         "\t.zcomm\t"
685
#define TCOMMON_ASM_OP         "\t.tcomm\t"
686
 
687
#define ASM_COMMENT_START "#"
688
 
689
/* Output to assembler file text saying following lines
690
   may contain character constants, extra white space, comments, etc.  */
691
 
692
#define ASM_APP_ON "#APP\n"
693
 
694
/* Output to assembler file text saying following lines
695
   no longer contain unusual constructs.  */
696
 
697
#define ASM_APP_OFF "#NO_APP\n"
698
 
699
#undef  USER_LABEL_PREFIX
700
#define USER_LABEL_PREFIX "_"
701
 
702
/* This says how to output the assembler to define a global
703
   uninitialized but not common symbol.  */
704
 
705
#define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN) \
706
  asm_output_aligned_bss ((FILE), (DECL), (NAME), (SIZE), (ALIGN))
707
 
708
#undef  ASM_OUTPUT_ALIGNED_BSS 
709
#define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN) \
710
  v850_output_aligned_bss (FILE, DECL, NAME, SIZE, ALIGN)
711
 
712
/* This says how to output the assembler to define a global
713
   uninitialized, common symbol.  */
714
#undef  ASM_OUTPUT_ALIGNED_COMMON
715
#undef  ASM_OUTPUT_COMMON
716
#define ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN) \
717
     v850_output_common (FILE, DECL, NAME, SIZE, ALIGN)
718
 
719
/* This says how to output the assembler to define a local
720
   uninitialized symbol.  */
721
#undef  ASM_OUTPUT_ALIGNED_LOCAL
722
#undef  ASM_OUTPUT_LOCAL
723
#define ASM_OUTPUT_ALIGNED_DECL_LOCAL(FILE, DECL, NAME, SIZE, ALIGN) \
724
     v850_output_local (FILE, DECL, NAME, SIZE, ALIGN)
725
 
726
/* Globalizing directive for a label.  */
727
#define GLOBAL_ASM_OP "\t.global "
728
 
729
#define ASM_PN_FORMAT "%s___%lu"
730
 
731
/* This is how we tell the assembler that two symbols have the same value.  */
732
 
733
#define ASM_OUTPUT_DEF(FILE,NAME1,NAME2) \
734
  do { assemble_name(FILE, NAME1);       \
735
       fputs(" = ", FILE);               \
736
       assemble_name(FILE, NAME2);       \
737
       fputc('\n', FILE); } while (0)
738
 
739
 
740
/* How to refer to registers in assembler output.
741
   This sequence is indexed by compiler's hard-register-number (see above).  */
742
 
743
#define REGISTER_NAMES                                         \
744
{  "r0",  "r1",  "r2",  "sp",  "gp",  "r5",  "r6" , "r7",      \
745
   "r8",  "r9", "r10", "r11", "r12", "r13", "r14", "r15",      \
746
  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",      \
747
  "r24", "r25", "r26", "r27", "r28", "r29",  "ep", "r31",      \
748
  "psw", "fcc",      \
749
  ".fp", ".ap"}
750
 
751
/* Register numbers */
752
 
753
#define ADDITIONAL_REGISTER_NAMES              \
754
{ { "zero",    ZERO_REGNUM },                  \
755
  { "hp",      2 },                            \
756
  { "r3",      3 },                            \
757
  { "r4",      4 },                            \
758
  { "tp",      5 },                            \
759
  { "fp",      29 },                           \
760
  { "r30",     30 },                           \
761
  { "lp",      LP_REGNUM} }
762
 
763
/* This is how to output an element of a case-vector that is absolute.  */
764
 
765
#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
766
  fprintf (FILE, "\t%s .L%d\n",                                 \
767
           (TARGET_BIG_SWITCH ? ".long" : ".short"), VALUE)
768
 
769
/* This is how to output an element of a case-vector that is relative.  */
770
 
771
/* Disable the shift, which is for the currently disabled "switch"
772
   opcode.  Se casesi in v850.md.  */
773
 
774
#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL)                \
775
  fprintf (FILE, "\t%s %s.L%d-.L%d%s\n",                                \
776
           (TARGET_BIG_SWITCH ? ".long" : ".short"),                    \
777
           (0 && ! TARGET_BIG_SWITCH && (TARGET_V850E || TARGET_V850E2_ALL) ? "(" : ""),             \
778
           VALUE, REL,                                                  \
779
           (0 && ! TARGET_BIG_SWITCH && (TARGET_V850E || TARGET_V850E2_ALL) ? ")>>1" : ""))
780
 
781
#define ASM_OUTPUT_ALIGN(FILE, LOG)     \
782
  if ((LOG) != 0)                        \
783
    fprintf (FILE, "\t.align %d\n", (LOG))
784
 
785
/* We don't have to worry about dbx compatibility for the v850.  */
786
#define DEFAULT_GDB_EXTENSIONS 1
787
 
788
/* Use stabs debugging info by default.  */
789
#undef PREFERRED_DEBUGGING_TYPE
790
#define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
791
 
792
/* Specify the machine mode that this machine uses
793
   for the index in the tablejump instruction.  */
794
#define CASE_VECTOR_MODE (TARGET_BIG_SWITCH ? SImode : HImode)
795
 
796
/* Define as C expression which evaluates to nonzero if the tablejump
797
   instruction expects the table to contain offsets from the address of the
798
   table.
799
   Do not define this if the table should contain absolute addresses.  */
800
#define CASE_VECTOR_PC_RELATIVE 1
801
 
802
/* The switch instruction requires that the jump table immediately follow
803
   it.  */
804
#define JUMP_TABLES_IN_TEXT_SECTION (!TARGET_JUMP_TABLES_IN_DATA_SECTION)
805
 
806
#undef ASM_OUTPUT_BEFORE_CASE_LABEL
807
#define ASM_OUTPUT_BEFORE_CASE_LABEL(FILE,PREFIX,NUM,TABLE) \
808
  ASM_OUTPUT_ALIGN ((FILE), (TARGET_BIG_SWITCH ? 2 : 1));
809
 
810
#define WORD_REGISTER_OPERATIONS
811
 
812
/* Byte and short loads sign extend the value to a word.  */
813
#define LOAD_EXTEND_OP(MODE) SIGN_EXTEND
814
 
815
/* This flag, if defined, says the same insns that convert to a signed fixnum
816
   also convert validly to an unsigned one.  */
817
#define FIXUNS_TRUNC_LIKE_FIX_TRUNC
818
 
819
/* Max number of bytes we can move from memory to memory
820
   in one reasonably fast instruction.  */
821
#define MOVE_MAX        4
822
 
823
/* Define if shifts truncate the shift count
824
   which implies one can omit a sign-extension or zero-extension
825
   of a shift count.  */
826
#define SHIFT_COUNT_TRUNCATED 1
827
 
828
/* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
829
   is done just by pretending it is already truncated.  */
830
#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
831
 
832
/* Specify the machine mode that pointers have.
833
   After generation of rtl, the compiler makes no further distinction
834
   between pointers and any other objects of this machine mode.  */
835
#define Pmode SImode
836
 
837
/* A function address in a call instruction
838
   is a byte address (for indexing purposes)
839
   so give the MEM rtx a byte's mode.  */
840
#define FUNCTION_MODE QImode
841
 
842
/* Tell compiler we want to support GHS pragmas */
843
#define REGISTER_TARGET_PRAGMAS() do {                          \
844
  c_register_pragma ("ghs", "interrupt", ghs_pragma_interrupt); \
845
  c_register_pragma ("ghs", "section",   ghs_pragma_section);   \
846
  c_register_pragma ("ghs", "starttda",  ghs_pragma_starttda);  \
847
  c_register_pragma ("ghs", "startsda",  ghs_pragma_startsda);  \
848
  c_register_pragma ("ghs", "startzda",  ghs_pragma_startzda);  \
849
  c_register_pragma ("ghs", "endtda",    ghs_pragma_endtda);    \
850
  c_register_pragma ("ghs", "endsda",    ghs_pragma_endsda);    \
851
  c_register_pragma ("ghs", "endzda",    ghs_pragma_endzda);    \
852
} while (0)
853
 
854
/* enum GHS_SECTION_KIND is an enumeration of the kinds of sections that
855
   can appear in the "ghs section" pragma.  These names are used to index
856
   into the GHS_default_section_names[] and GHS_current_section_names[]
857
   that are defined in v850.c, and so the ordering of each must remain
858
   consistent.
859
 
860
   These arrays give the default and current names for each kind of
861
   section defined by the GHS pragmas.  The current names can be changed
862
   by the "ghs section" pragma.  If the current names are null, use
863
   the default names.  Note that the two arrays have different types.
864
 
865
   For the *normal* section kinds (like .data, .text, etc.) we do not
866
   want to explicitly force the name of these sections, but would rather
867
   let the linker (or at least the back end) choose the name of the
868
   section, UNLESS the user has force a specific name for these section
869
   kinds.  To accomplish this set the name in ghs_default_section_names
870
   to null.  */
871
 
872
enum GHS_section_kind
873
{
874
  GHS_SECTION_KIND_DEFAULT,
875
 
876
  GHS_SECTION_KIND_TEXT,
877
  GHS_SECTION_KIND_DATA,
878
  GHS_SECTION_KIND_RODATA,
879
  GHS_SECTION_KIND_BSS,
880
  GHS_SECTION_KIND_SDATA,
881
  GHS_SECTION_KIND_ROSDATA,
882
  GHS_SECTION_KIND_TDATA,
883
  GHS_SECTION_KIND_ZDATA,
884
  GHS_SECTION_KIND_ROZDATA,
885
 
886
  COUNT_OF_GHS_SECTION_KINDS  /* must be last */
887
};
888
 
889
/* The following code is for handling pragmas supported by the
890
   v850 compiler produced by Green Hills Software.  This is at
891
   the specific request of a customer.  */
892
 
893
typedef struct data_area_stack_element
894
{
895
  struct data_area_stack_element * prev;
896
  v850_data_area                   data_area; /* Current default data area.  */
897
} data_area_stack_element;
898
 
899
/* Track the current data area set by the
900
   data area pragma (which can be nested).  */
901
extern data_area_stack_element * data_area_stack;
902
 
903
/* Names of the various data areas used on the v850.  */
904
extern tree GHS_default_section_names [(int) COUNT_OF_GHS_SECTION_KINDS];
905
extern tree GHS_current_section_names [(int) COUNT_OF_GHS_SECTION_KINDS];
906
 
907
/* The assembler op to start the file.  */
908
 
909
#define FILE_ASM_OP "\t.file\n"
910
 
911
/* Enable the register move pass to improve code.  */
912
#define ENABLE_REGMOVE_PASS
913
 
914
 
915
/* Implement ZDA, TDA, and SDA */
916
 
917
#define EP_REGNUM 30    /* ep register number */
918
 
919
#define SYMBOL_FLAG_ZDA         (SYMBOL_FLAG_MACH_DEP << 0)
920
#define SYMBOL_FLAG_TDA         (SYMBOL_FLAG_MACH_DEP << 1)
921
#define SYMBOL_FLAG_SDA         (SYMBOL_FLAG_MACH_DEP << 2)
922
#define SYMBOL_REF_ZDA_P(X)     ((SYMBOL_REF_FLAGS (X) & SYMBOL_FLAG_ZDA) != 0)
923
#define SYMBOL_REF_TDA_P(X)     ((SYMBOL_REF_FLAGS (X) & SYMBOL_FLAG_TDA) != 0)
924
#define SYMBOL_REF_SDA_P(X)     ((SYMBOL_REF_FLAGS (X) & SYMBOL_FLAG_SDA) != 0)
925
 
926
#define TARGET_ASM_INIT_SECTIONS v850_asm_init_sections
927
 
928
/* Define this so that the cc1plus will not think that system header files
929
   need an implicit 'extern "C" { ... }' assumed.  This breaks testing C++
930
   in a build directory where the libstdc++ header files are found via a
931
   -isystem <path-to-build-dir>.  */
932
#define NO_IMPLICIT_EXTERN_C
933
 
934
#endif /* ! GCC_V850_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.