OSDN Git Service

* config/bfin/bfin.h (enum reg_class, REG_CLASS_CONTENTS,
[pf3gnuchains/gcc-fork.git] / gcc / config / bfin / bfin.h
1 /* Definitions for the Blackfin port.
2    Copyright (C) 2005, 2007 Free Software Foundation, Inc.
3    Contributed by Analog Devices.
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 _BFIN_CONFIG
22 #define _BFIN_CONFIG
23
24 #define OBJECT_FORMAT_ELF
25
26 #define BRT 1
27 #define BRF 0
28
29 /* Print subsidiary information on the compiler version in use.  */
30 #define TARGET_VERSION fprintf (stderr, " (BlackFin bfin)")
31
32 /* Run-time compilation parameters selecting different hardware subsets.  */
33
34 extern int target_flags;
35
36 #ifndef DEFAULT_CPU_TYPE
37 #define DEFAULT_CPU_TYPE BFIN_CPU_BF532
38 #endif
39
40 /* Predefinition in the preprocessor for this target machine */
41 #ifndef TARGET_CPU_CPP_BUILTINS
42 #define TARGET_CPU_CPP_BUILTINS()               \
43   do                                            \
44     {                                           \
45       builtin_define_std ("bfin");              \
46       builtin_define_std ("BFIN");              \
47       builtin_define ("__ADSPBLACKFIN__");      \
48       builtin_define ("__ADSPLPBLACKFIN__");    \
49                                                 \
50       switch (bfin_cpu_type)                    \
51         {                                       \
52         case BFIN_CPU_BF531:                    \
53           builtin_define ("__ADSPBF531__");     \
54           break;                                \
55         case BFIN_CPU_BF532:                    \
56           builtin_define ("__ADSPBF532__");     \
57           break;                                \
58         case BFIN_CPU_BF533:                    \
59           builtin_define ("__ADSPBF533__");     \
60           break;                                \
61         case BFIN_CPU_BF534:                    \
62           builtin_define ("__ADSPBF534__");     \
63           break;                                \
64         case BFIN_CPU_BF536:                    \
65           builtin_define ("__ADSPBF536__");     \
66           break;                                \
67         case BFIN_CPU_BF537:                    \
68           builtin_define ("__ADSPBF537__");     \
69           break;                                \
70         case BFIN_CPU_BF561:                    \
71           builtin_define ("__ADSPBF561__");     \
72           break;                                \
73         }                                       \
74                                                 \
75       if (TARGET_FDPIC)                         \
76         builtin_define ("__BFIN_FDPIC__");      \
77       if (TARGET_ID_SHARED_LIBRARY)             \
78         builtin_define ("__ID_SHARED_LIB__");   \
79       if (flag_no_builtin)                      \
80         builtin_define ("__NO_BUILTIN");        \
81     }                                           \
82   while (0)
83 #endif
84
85 #define DRIVER_SELF_SPECS SUBTARGET_DRIVER_SELF_SPECS   "\
86  %{mleaf-id-shared-library:%{!mid-shared-library:-mid-shared-library}} \
87  %{mfdpic:%{!fpic:%{!fpie:%{!fPIC:%{!fPIE:\
88             %{!fno-pic:%{!fno-pie:%{!fno-PIC:%{!fno-PIE:-fpie}}}}}}}}} \
89 "
90 #ifndef SUBTARGET_DRIVER_SELF_SPECS
91 # define SUBTARGET_DRIVER_SELF_SPECS
92 #endif
93
94 #define LINK_GCC_C_SEQUENCE_SPEC "\
95   %{mfast-fp:-lbffastfp} %G %L %{mfast-fp:-lbffastfp} %G \
96 "
97
98 /* A C string constant that tells the GCC driver program options to pass to
99    the assembler.  It can also specify how to translate options you give to GNU
100    CC into options for GCC to pass to the assembler.  See the file `sun3.h'
101    for an example of this.
102
103    Do not define this macro if it does not need to do anything.
104
105    Defined in svr4.h.  */
106 #undef  ASM_SPEC
107 #define ASM_SPEC "\
108 %{G*} %{v} %{n} %{T} %{Ym,*} %{Yd,*} %{Wa,*:%*} \
109     %{mno-fdpic:-mnopic} %{mfdpic}"
110
111 #define LINK_SPEC "\
112 %{h*} %{v:-V} \
113 %{b} \
114 %{mfdpic:-melf32bfinfd -z text} \
115 %{static:-dn -Bstatic} \
116 %{shared:-G -Bdynamic} \
117 %{symbolic:-Bsymbolic} \
118 %{G*} \
119 %{YP,*} \
120 %{Qy:} %{!Qn:-Qy} \
121 -init __init -fini __fini "
122
123 /* Generate DSP instructions, like DSP halfword loads */
124 #define TARGET_DSP                      (1)
125
126 #define TARGET_DEFAULT (MASK_SPECLD_ANOMALY | MASK_CSYNC_ANOMALY)
127
128 /* Maximum number of library ids we permit */
129 #define MAX_LIBRARY_ID 255
130
131 extern const char *bfin_library_id_string;
132
133 /* Sometimes certain combinations of command options do not make
134    sense on a particular target machine.  You can define a macro
135    `OVERRIDE_OPTIONS' to take account of this.  This macro, if
136    defined, is executed once just after all the command options have
137    been parsed.
138  
139    Don't use this macro to turn on various extra optimizations for
140    `-O'.  That is what `OPTIMIZATION_OPTIONS' is for.  */
141  
142 #define OVERRIDE_OPTIONS override_options ()
143
144 #define FUNCTION_MODE    SImode
145 #define Pmode            SImode
146
147 /* store-condition-codes instructions store 0 for false
148    This is the value stored for true.  */
149 #define STORE_FLAG_VALUE 1
150
151 /* Define this if pushing a word on the stack
152    makes the stack pointer a smaller address.  */
153 #define STACK_GROWS_DOWNWARD
154
155 #define STACK_PUSH_CODE PRE_DEC
156
157 /* Define this to nonzero if the nominal address of the stack frame
158    is at the high-address end of the local variables;
159    that is, each additional local variable allocated
160    goes at a more negative offset in the frame.  */
161 #define FRAME_GROWS_DOWNWARD 1
162
163 /* We define a dummy ARGP register; the parameters start at offset 0 from
164    it. */
165 #define FIRST_PARM_OFFSET(DECL) 0
166
167 /* Offset within stack frame to start allocating local variables at.
168    If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
169    first local allocated.  Otherwise, it is the offset to the BEGINNING
170    of the first local allocated.  */
171 #define STARTING_FRAME_OFFSET 0
172
173 /* Register to use for pushing function arguments.  */
174 #define STACK_POINTER_REGNUM REG_P6
175
176 /* Base register for access to local variables of the function.  */
177 #define FRAME_POINTER_REGNUM REG_P7
178
179 /* A dummy register that will be eliminated to either FP or SP.  */
180 #define ARG_POINTER_REGNUM REG_ARGP
181
182 /* `PIC_OFFSET_TABLE_REGNUM'
183      The register number of the register used to address a table of
184      static data addresses in memory.  In some cases this register is
185      defined by a processor's "application binary interface" (ABI).
186      When this macro is defined, RTL is generated for this register
187      once, as with the stack pointer and frame pointer registers.  If
188      this macro is not defined, it is up to the machine-dependent files
189      to allocate such a register (if necessary). */
190 #define PIC_OFFSET_TABLE_REGNUM (REG_P5)
191
192 #define FDPIC_FPTR_REGNO REG_P1
193 #define FDPIC_REGNO REG_P3
194 #define OUR_FDPIC_REG   get_hard_reg_initial_val (SImode, FDPIC_REGNO)
195
196 /* A static chain register for nested functions.  We need to use a
197    call-clobbered register for this.  */
198 #define STATIC_CHAIN_REGNUM REG_P2
199
200 /* Define this if functions should assume that stack space has been
201    allocated for arguments even when their values are passed in
202    registers.
203
204    The value of this macro is the size, in bytes, of the area reserved for
205    arguments passed in registers.
206
207    This space can either be allocated by the caller or be a part of the
208    machine-dependent stack frame: `OUTGOING_REG_PARM_STACK_SPACE'
209    says which.  */
210 #define FIXED_STACK_AREA 12
211 #define REG_PARM_STACK_SPACE(FNDECL) FIXED_STACK_AREA
212
213 /* Define this if the above stack space is to be considered part of the
214  * space allocated by the caller.  */
215 #define OUTGOING_REG_PARM_STACK_SPACE 1
216           
217 /* Define this if the maximum size of all the outgoing args is to be
218    accumulated and pushed during the prologue.  The amount can be
219    found in the variable current_function_outgoing_args_size. */ 
220 #define ACCUMULATE_OUTGOING_ARGS 1
221
222 /* Value should be nonzero if functions must have frame pointers.
223    Zero means the frame pointer need not be set up (and parms
224    may be accessed via the stack pointer) in functions that seem suitable.
225    This is computed in `reload', in reload1.c.  
226 */
227 #define FRAME_POINTER_REQUIRED (bfin_frame_pointer_required ())
228
229 /*#define DATA_ALIGNMENT(TYPE, BASIC-ALIGN) for arrays.. */
230
231 /* If defined, a C expression to compute the alignment for a local
232    variable.  TYPE is the data type, and ALIGN is the alignment that
233    the object would ordinarily have.  The value of this macro is used
234    instead of that alignment to align the object.
235
236    If this macro is not defined, then ALIGN is used.
237
238    One use of this macro is to increase alignment of medium-size
239    data to make it all fit in fewer cache lines.  */
240
241 #define LOCAL_ALIGNMENT(TYPE, ALIGN) bfin_local_alignment ((TYPE), (ALIGN))
242
243 /* Make strings word-aligned so strcpy from constants will be faster.  */
244 #define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
245   (TREE_CODE (EXP) == STRING_CST        \
246    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))    
247
248 #define TRAMPOLINE_SIZE (TARGET_FDPIC ? 30 : 18)
249 #define TRAMPOLINE_TEMPLATE(FILE)                                       \
250   if (TARGET_FDPIC)                                                     \
251     {                                                                   \
252       fprintf(FILE, "\t.dd\t0x00000000\n"); /* 0 */                     \
253       fprintf(FILE, "\t.dd\t0x00000000\n"); /* 0 */                     \
254       fprintf(FILE, "\t.dd\t0x0000e109\n"); /* p1.l = fn low */         \
255       fprintf(FILE, "\t.dd\t0x0000e149\n"); /* p1.h = fn high */        \
256       fprintf(FILE, "\t.dd\t0x0000e10a\n"); /* p2.l = sc low */         \
257       fprintf(FILE, "\t.dd\t0x0000e14a\n"); /* p2.h = sc high */        \
258       fprintf(FILE, "\t.dw\t0xac4b\n"); /* p3 = [p1 + 4] */             \
259       fprintf(FILE, "\t.dw\t0x9149\n"); /* p1 = [p1] */                 \
260       fprintf(FILE, "\t.dw\t0x0051\n"); /* jump (p1)*/                  \
261     }                                                                   \
262   else                                                                  \
263     {                                                                   \
264       fprintf(FILE, "\t.dd\t0x0000e109\n"); /* p1.l = fn low */         \
265       fprintf(FILE, "\t.dd\t0x0000e149\n"); /* p1.h = fn high */        \
266       fprintf(FILE, "\t.dd\t0x0000e10a\n"); /* p2.l = sc low */         \
267       fprintf(FILE, "\t.dd\t0x0000e14a\n"); /* p2.h = sc high */        \
268       fprintf(FILE, "\t.dw\t0x0051\n"); /* jump (p1)*/                  \
269     }
270
271 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
272   initialize_trampoline (TRAMP, FNADDR, CXT)
273 \f
274 /* Definitions for register eliminations.
275
276    This is an array of structures.  Each structure initializes one pair
277    of eliminable registers.  The "from" register number is given first,
278    followed by "to".  Eliminations of the same "from" register are listed
279    in order of preference.
280
281    There are two registers that can always be eliminated on the i386.
282    The frame pointer and the arg pointer can be replaced by either the
283    hard frame pointer or to the stack pointer, depending upon the
284    circumstances.  The hard frame pointer is not used before reload and
285    so it is not eligible for elimination.  */
286
287 #define ELIMINABLE_REGS                         \
288 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},   \
289  { ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM},   \
290  { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}} \
291
292 /* Given FROM and TO register numbers, say whether this elimination is
293    allowed.  Frame pointer elimination is automatically handled.
294
295    All other eliminations are valid.  */
296
297 #define CAN_ELIMINATE(FROM, TO) \
298   ((TO) == STACK_POINTER_REGNUM ? ! frame_pointer_needed : 1)
299
300 /* Define the offset between two registers, one to be eliminated, and the other
301    its replacement, at the start of a routine.  */
302
303 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
304   ((OFFSET) = bfin_initial_elimination_offset ((FROM), (TO)))
305 \f
306 /* This processor has
307    8 data register for doing arithmetic
308    8  pointer register for doing addressing, including
309       1  stack pointer P6
310       1  frame pointer P7
311    4 sets of indexing registers (I0-3, B0-3, L0-3, M0-3)
312    1  condition code flag register CC
313    5  return address registers RETS/I/X/N/E
314    1  arithmetic status register (ASTAT).  */
315
316 #define FIRST_PSEUDO_REGISTER 50
317
318 #define D_REGNO_P(X) ((X) <= REG_R7)
319 #define P_REGNO_P(X) ((X) >= REG_P0 && (X) <= REG_P7)
320 #define I_REGNO_P(X) ((X) >= REG_I0 && (X) <= REG_I3)
321 #define DP_REGNO_P(X) (D_REGNO_P (X) || P_REGNO_P (X))
322 #define ADDRESS_REGNO_P(X) ((X) >= REG_P0 && (X) <= REG_M3)
323 #define DREG_P(X) (REG_P (X) && D_REGNO_P (REGNO (X)))
324 #define PREG_P(X) (REG_P (X) && P_REGNO_P (REGNO (X)))
325 #define IREG_P(X) (REG_P (X) && I_REGNO_P (REGNO (X)))
326 #define DPREG_P(X) (REG_P (X) && DP_REGNO_P (REGNO (X)))
327
328 #define REGISTER_NAMES { \
329   "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", \
330   "P0", "P1", "P2", "P3", "P4", "P5", "SP", "FP", \
331   "I0", "I1", "I2", "I3", "B0", "B1", "B2", "B3", \
332   "L0", "L1", "L2", "L3", "M0", "M1", "M2", "M3", \
333   "A0", "A1", \
334   "CC", \
335   "RETS", "RETI", "RETX", "RETN", "RETE", "ASTAT", "SEQSTAT", "USP", \
336   "ARGP", \
337   "LT0", "LT1", "LC0", "LC1", "LB0", "LB1" \
338 }
339
340 #define SHORT_REGISTER_NAMES { \
341         "R0.L", "R1.L", "R2.L", "R3.L", "R4.L", "R5.L", "R6.L", "R7.L", \
342         "P0.L", "P1.L", "P2.L", "P3.L", "P4.L", "P5.L", "SP.L", "FP.L", \
343         "I0.L", "I1.L", "I2.L", "I3.L", "B0.L", "B1.L", "B2.L", "B3.L", \
344         "L0.L", "L1.L", "L2.L", "L3.L", "M0.L", "M1.L", "M2.L", "M3.L", }
345
346 #define HIGH_REGISTER_NAMES { \
347         "R0.H", "R1.H", "R2.H", "R3.H", "R4.H", "R5.H", "R6.H", "R7.H", \
348         "P0.H", "P1.H", "P2.H", "P3.H", "P4.H", "P5.H", "SP.H", "FP.H", \
349         "I0.H", "I1.H", "I2.H", "I3.H", "B0.H", "B1.H", "B2.H", "B3.H", \
350         "L0.H", "L1.H", "L2.H", "L3.H", "M0.H", "M1.H", "M2.H", "M3.H", }
351
352 #define DREGS_PAIR_NAMES { \
353   "R1:0.p", 0, "R3:2.p", 0, "R5:4.p", 0, "R7:6.p", 0,  }
354
355 #define BYTE_REGISTER_NAMES { \
356   "R0.B", "R1.B", "R2.B", "R3.B", "R4.B", "R5.B", "R6.B", "R7.B",  }
357
358
359 /* 1 for registers that have pervasive standard uses
360    and are not available for the register allocator.  */
361
362 #define FIXED_REGISTERS \
363 /*r0 r1 r2 r3 r4 r5 r6 r7   p0 p1 p2 p3 p4 p5 p6 p7 */ \
364 { 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 1, 0,    \
365 /*i0 i1 i2 i3 b0 b1 b2 b3   l0 l1 l2 l3 m0 m1 m2 m3 */ \
366   0, 0, 0, 0, 0, 0, 0, 0,   1, 1, 1, 1, 0, 0, 0, 0,    \
367 /*a0 a1 cc rets/i/x/n/e     astat seqstat usp argp lt0/1 lc0/1 */ \
368   0, 0, 0, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,    \
369 /*lb0/1 */ \
370   1, 1  \
371 }
372
373 /* 1 for registers not available across function calls.
374    These must include the FIXED_REGISTERS and also any
375    registers that can be used without being saved.
376    The latter must include the registers where values are returned
377    and the register where structure-value addresses are passed.
378    Aside from that, you can include as many other registers as you like.  */
379
380 #define CALL_USED_REGISTERS \
381 /*r0 r1 r2 r3 r4 r5 r6 r7   p0 p1 p2 p3 p4 p5 p6 p7 */ \
382 { 1, 1, 1, 1, 0, 0, 0, 0,   1, 1, 1, 0, 0, 0, 1, 0, \
383 /*i0 i1 i2 i3 b0 b1 b2 b3   l0 l1 l2 l3 m0 m1 m2 m3 */ \
384   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   \
385 /*a0 a1 cc rets/i/x/n/e     astat seqstat usp argp lt0/1 lc0/1 */ \
386   1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1, \
387 /*lb0/1 */ \
388   1, 1  \
389 }
390
391 /* Order in which to allocate registers.  Each register must be
392    listed once, even those in FIXED_REGISTERS.  List frame pointer
393    late and fixed registers last.  Note that, in general, we prefer
394    registers listed in CALL_USED_REGISTERS, keeping the others
395    available for storage of persistent values. */
396
397 #define REG_ALLOC_ORDER \
398 { REG_R0, REG_R1, REG_R2, REG_R3, REG_R7, REG_R6, REG_R5, REG_R4, \
399   REG_P2, REG_P1, REG_P0, REG_P5, REG_P4, REG_P3, REG_P6, REG_P7, \
400   REG_A0, REG_A1, \
401   REG_I0, REG_I1, REG_I2, REG_I3, REG_B0, REG_B1, REG_B2, REG_B3, \
402   REG_L0, REG_L1, REG_L2, REG_L3, REG_M0, REG_M1, REG_M2, REG_M3, \
403   REG_RETS, REG_RETI, REG_RETX, REG_RETN, REG_RETE,               \
404   REG_ASTAT, REG_SEQSTAT, REG_USP,                                \
405   REG_CC, REG_ARGP,                                               \
406   REG_LT0, REG_LT1, REG_LC0, REG_LC1, REG_LB0, REG_LB1            \
407 }
408
409 /* Macro to conditionally modify fixed_regs/call_used_regs.  */
410 #define CONDITIONAL_REGISTER_USAGE                      \
411   {                                                     \
412     conditional_register_usage();                       \
413     if (TARGET_FDPIC)                                   \
414       call_used_regs[FDPIC_REGNO] = 1;                  \
415     if (!TARGET_FDPIC && flag_pic)                      \
416       {                                                 \
417         fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;        \
418         call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;    \
419       }                                                 \
420   }
421
422 /* Define the classes of registers for register constraints in the
423    machine description.  Also define ranges of constants.
424
425    One of the classes must always be named ALL_REGS and include all hard regs.
426    If there is more than one class, another class must be named NO_REGS
427    and contain no registers.
428
429    The name GENERAL_REGS must be the name of a class (or an alias for
430    another name such as ALL_REGS).  This is the class of registers
431    that is allowed by "g" or "r" in a register constraint.
432    Also, registers outside this class are allocated only when
433    instructions express preferences for them.
434
435    The classes must be numbered in nondecreasing order; that is,
436    a larger-numbered class must never be contained completely
437    in a smaller-numbered class.
438
439    For any two classes, it is very desirable that there be another
440    class that represents their union. */
441
442
443 enum reg_class
444 {
445   NO_REGS,
446   IREGS,
447   BREGS,
448   LREGS,
449   MREGS,
450   CIRCREGS, /* Circular buffering registers, Ix, Bx, Lx together form.  See Automatic Circular Buffering.  */
451   DAGREGS,
452   EVEN_AREGS,
453   ODD_AREGS,
454   AREGS,
455   CCREGS,
456   EVEN_DREGS,
457   ODD_DREGS,
458   D0REGS,
459   D1REGS,
460   D2REGS,
461   D3REGS,
462   D4REGS,
463   D5REGS,
464   D6REGS,
465   D7REGS,
466   DREGS,
467   P0REGS,
468   FDPIC_REGS,
469   FDPIC_FPTR_REGS,
470   PREGS_CLOBBERED,
471   PREGS,
472   IPREGS,
473   DPREGS,
474   MOST_REGS,
475   LT_REGS,
476   LC_REGS,
477   LB_REGS,
478   PROLOGUE_REGS,
479   NON_A_CC_REGS,
480   ALL_REGS, LIM_REG_CLASSES
481 };
482
483 #define N_REG_CLASSES ((int)LIM_REG_CLASSES)
484
485 #define GENERAL_REGS DPREGS
486
487 /* Give names of register classes as strings for dump file.   */
488
489 #define REG_CLASS_NAMES \
490 {  "NO_REGS",           \
491    "IREGS",             \
492    "BREGS",             \
493    "LREGS",             \
494    "MREGS",             \
495    "CIRCREGS",          \
496    "DAGREGS",           \
497    "EVEN_AREGS",        \
498    "ODD_AREGS",         \
499    "AREGS",             \
500    "CCREGS",            \
501    "EVEN_DREGS",        \
502    "ODD_DREGS",         \
503    "D0REGS",            \
504    "D1REGS",            \
505    "D2REGS",            \
506    "D3REGS",            \
507    "D4REGS",            \
508    "D5REGS",            \
509    "D6REGS",            \
510    "D7REGS",            \
511    "DREGS",             \
512    "P0REGS",            \
513    "FDPIC_REGS",        \
514    "FDPIC_FPTR_REGS",   \
515    "PREGS_CLOBBERED",   \
516    "PREGS",             \
517    "IPREGS",            \
518    "DPREGS",            \
519    "MOST_REGS",         \
520    "LT_REGS",           \
521    "LC_REGS",           \
522    "LB_REGS",           \
523    "PROLOGUE_REGS",     \
524    "NON_A_CC_REGS",     \
525    "ALL_REGS" }
526
527 /* An initializer containing the contents of the register classes, as integers
528    which are bit masks.  The Nth integer specifies the contents of class N.
529    The way the integer MASK is interpreted is that register R is in the class
530    if `MASK & (1 << R)' is 1.
531
532    When the machine has more than 32 registers, an integer does not suffice.
533    Then the integers are replaced by sub-initializers, braced groupings
534    containing several integers.  Each sub-initializer must be suitable as an
535    initializer for the type `HARD_REG_SET' which is defined in
536    `hard-reg-set.h'.  */
537
538 /* NOTE: DSP registers, IREGS - AREGS, are not GENERAL_REGS.  We use
539    MOST_REGS as the union of DPREGS and DAGREGS.  */
540
541 #define REG_CLASS_CONTENTS \
542     /* 31 - 0       63-32   */ \
543 {   { 0x00000000,    0 },               /* NO_REGS */   \
544     { 0x000f0000,    0 },               /* IREGS */     \
545     { 0x00f00000,    0 },               /* BREGS */             \
546     { 0x0f000000,    0 },               /* LREGS */     \
547     { 0xf0000000,    0 },               /* MREGS */   \
548     { 0x0fff0000,    0 },               /* CIRCREGS */   \
549     { 0xffff0000,    0 },               /* DAGREGS */   \
550     { 0x00000000,    0x1 },             /* EVEN_AREGS */   \
551     { 0x00000000,    0x2 },             /* ODD_AREGS */   \
552     { 0x00000000,    0x3 },             /* AREGS */   \
553     { 0x00000000,    0x4 },             /* CCREGS */  \
554     { 0x00000055,    0 },               /* EVEN_DREGS */   \
555     { 0x000000aa,    0 },               /* ODD_DREGS */   \
556     { 0x00000001,    0 },               /* D0REGS */   \
557     { 0x00000002,    0 },               /* D1REGS */   \
558     { 0x00000004,    0 },               /* D2REGS */   \
559     { 0x00000008,    0 },               /* D3REGS */   \
560     { 0x00000010,    0 },               /* D4REGS */   \
561     { 0x00000020,    0 },               /* D5REGS */   \
562     { 0x00000040,    0 },               /* D6REGS */   \
563     { 0x00000080,    0 },               /* D7REGS */   \
564     { 0x000000ff,    0 },               /* DREGS */   \
565     { 0x00000100,    0x000 },           /* P0REGS */   \
566     { 0x00000800,    0x000 },           /* FDPIC_REGS */   \
567     { 0x00000200,    0x000 },           /* FDPIC_FPTR_REGS */   \
568     { 0x00004700,    0x800 },           /* PREGS_CLOBBERED */   \
569     { 0x0000ff00,    0x800 },           /* PREGS */   \
570     { 0x000fff00,    0x800 },           /* IPREGS */    \
571     { 0x0000ffff,    0x800 },           /* DPREGS */   \
572     { 0xffffffff,    0x800 },           /* MOST_REGS */\
573     { 0x00000000,    0x3000 },          /* LT_REGS */\
574     { 0x00000000,    0xc000 },          /* LC_REGS */\
575     { 0x00000000,    0x30000 },         /* LB_REGS */\
576     { 0x00000000,    0x3f7f8 },         /* PROLOGUE_REGS */\
577     { 0xffffffff,    0x3fff8 },         /* NON_A_CC_REGS */\
578     { 0xffffffff,    0x3ffff }}         /* ALL_REGS */
579
580 #define IREG_POSSIBLE_P(OUTER)                               \
581   ((OUTER) == POST_INC || (OUTER) == PRE_INC                 \
582    || (OUTER) == POST_DEC || (OUTER) == PRE_DEC              \
583    || (OUTER) == MEM || (OUTER) == ADDRESS)
584
585 #define MODE_CODE_BASE_REG_CLASS(MODE, OUTER, INDEX)                    \
586   ((MODE) == HImode && IREG_POSSIBLE_P (OUTER) ? IPREGS : PREGS)
587
588 #define INDEX_REG_CLASS         PREGS
589
590 #define REGNO_OK_FOR_BASE_STRICT_P(X, MODE, OUTER, INDEX)       \
591   (P_REGNO_P (X) || (X) == REG_ARGP                             \
592    || (IREG_POSSIBLE_P (OUTER) && (MODE) == HImode              \
593        && I_REGNO_P (X)))
594
595 #define REGNO_OK_FOR_BASE_NONSTRICT_P(X, MODE, OUTER, INDEX)    \
596   ((X) >= FIRST_PSEUDO_REGISTER                                 \
597    || REGNO_OK_FOR_BASE_STRICT_P (X, MODE, OUTER, INDEX))
598
599 #ifdef REG_OK_STRICT
600 #define REGNO_MODE_CODE_OK_FOR_BASE_P(X, MODE, OUTER, INDEX) \
601   REGNO_OK_FOR_BASE_STRICT_P (X, MODE, OUTER, INDEX)
602 #else
603 #define REGNO_MODE_CODE_OK_FOR_BASE_P(X, MODE, OUTER, INDEX) \
604   REGNO_OK_FOR_BASE_NONSTRICT_P (X, MODE, OUTER, INDEX)
605 #endif
606
607 #define REGNO_OK_FOR_INDEX_P(X)   0
608
609 /* Get reg_class from a letter such as appears in the machine description.  */
610
611 #define REG_CLASS_FROM_CONSTRAINT(LETTER, STR)  \
612   ((LETTER) == 'a' ? PREGS :            \
613    (LETTER) == 'Z' ? FDPIC_REGS :       \
614    (LETTER) == 'Y' ? FDPIC_FPTR_REGS :  \
615    (LETTER) == 'd' ? DREGS :            \
616    (LETTER) == 'z' ? PREGS_CLOBBERED :  \
617    (LETTER) == 'D' ? EVEN_DREGS :       \
618    (LETTER) == 'W' ? ODD_DREGS :        \
619    (LETTER) == 'e' ? AREGS :            \
620    (LETTER) == 'A' ? EVEN_AREGS :       \
621    (LETTER) == 'B' ? ODD_AREGS :        \
622    (LETTER) == 'b' ? IREGS :            \
623    (LETTER) == 'v' ? BREGS :            \
624    (LETTER) == 'f' ? MREGS :            \
625    (LETTER) == 'c' ? CIRCREGS :         \
626    (LETTER) == 'C' ? CCREGS :           \
627    (LETTER) == 't' ? LT_REGS :          \
628    (LETTER) == 'k' ? LC_REGS :          \
629    (LETTER) == 'u' ? LB_REGS :          \
630    (LETTER) == 'x' ? MOST_REGS :        \
631    (LETTER) == 'y' ? PROLOGUE_REGS :    \
632    (LETTER) == 'w' ? NON_A_CC_REGS :    \
633    (LETTER) == 'q' \
634     ? ((STR)[1] == '0' ? D0REGS \
635        : (STR)[1] == '1' ? D1REGS \
636        : (STR)[1] == '2' ? D2REGS \
637        : (STR)[1] == '3' ? D3REGS \
638        : (STR)[1] == '4' ? D4REGS \
639        : (STR)[1] == '5' ? D5REGS \
640        : (STR)[1] == '6' ? D6REGS \
641        : (STR)[1] == '7' ? D7REGS \
642        : (STR)[1] == 'A' ? P0REGS \
643        : NO_REGS) : \
644    NO_REGS)
645
646 /* The same information, inverted:
647    Return the class number of the smallest class containing
648    reg number REGNO.  This could be a conditional expression
649    or could index an array.  */
650
651 #define REGNO_REG_CLASS(REGNO) \
652 ((REGNO) == REG_R0 ? D0REGS                             \
653  : (REGNO) == REG_R1 ? D1REGS                           \
654  : (REGNO) == REG_R2 ? D2REGS                           \
655  : (REGNO) == REG_R3 ? D3REGS                           \
656  : (REGNO) == REG_R4 ? D4REGS                           \
657  : (REGNO) == REG_R5 ? D5REGS                           \
658  : (REGNO) == REG_R6 ? D6REGS                           \
659  : (REGNO) == REG_R7 ? D7REGS                           \
660  : (REGNO) == REG_P0 ? P0REGS                           \
661  : (REGNO) < REG_I0 ? PREGS                             \
662  : (REGNO) == REG_ARGP ? PREGS                          \
663  : (REGNO) >= REG_I0 && (REGNO) <= REG_I3 ? IREGS       \
664  : (REGNO) >= REG_L0 && (REGNO) <= REG_L3 ? LREGS       \
665  : (REGNO) >= REG_B0 && (REGNO) <= REG_B3 ? BREGS       \
666  : (REGNO) >= REG_M0 && (REGNO) <= REG_M3 ? MREGS       \
667  : (REGNO) == REG_A0 || (REGNO) == REG_A1 ? AREGS       \
668  : (REGNO) == REG_LT0 || (REGNO) == REG_LT1 ? LT_REGS   \
669  : (REGNO) == REG_LC0 || (REGNO) == REG_LC1 ? LC_REGS   \
670  : (REGNO) == REG_LB0 || (REGNO) == REG_LB1 ? LB_REGS   \
671  : (REGNO) == REG_CC ? CCREGS                           \
672  : (REGNO) >= REG_RETS ? PROLOGUE_REGS                  \
673  : NO_REGS)
674
675 /* When defined, the compiler allows registers explicitly used in the
676    rtl to be used as spill registers but prevents the compiler from
677    extending the lifetime of these registers. */
678 #define SMALL_REGISTER_CLASSES 1
679
680 #define CLASS_LIKELY_SPILLED_P(CLASS) \
681     ((CLASS) == PREGS_CLOBBERED \
682      || (CLASS) == PROLOGUE_REGS \
683      || (CLASS) == P0REGS \
684      || (CLASS) == D0REGS \
685      || (CLASS) == D1REGS \
686      || (CLASS) == D2REGS \
687      || (CLASS) == CCREGS)
688
689 /* Do not allow to store a value in REG_CC for any mode */
690 /* Do not allow to store value in pregs if mode is not SI*/
691 #define HARD_REGNO_MODE_OK(REGNO, MODE) hard_regno_mode_ok((REGNO), (MODE))
692
693 /* Return the maximum number of consecutive registers
694    needed to represent mode MODE in a register of class CLASS.  */
695 #define CLASS_MAX_NREGS(CLASS, MODE)                                    \
696   ((MODE) == V2PDImode && (CLASS) == AREGS ? 2                          \
697    : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
698
699 #define HARD_REGNO_NREGS(REGNO, MODE) \
700   ((MODE) == PDImode && ((REGNO) == REG_A0 || (REGNO) == REG_A1) ? 1    \
701    : (MODE) == V2PDImode && ((REGNO) == REG_A0 || (REGNO) == REG_A1) ? 2 \
702    : CLASS_MAX_NREGS (GENERAL_REGS, MODE))
703
704 /* A C expression that is nonzero if hard register TO can be
705    considered for use as a rename register for FROM register */
706 #define HARD_REGNO_RENAME_OK(FROM, TO) bfin_hard_regno_rename_ok (FROM, TO)
707
708 /* A C expression that is nonzero if it is desirable to choose
709    register allocation so as to avoid move instructions between a
710    value of mode MODE1 and a value of mode MODE2.
711
712    If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R,
713    MODE2)' are ever different for any R, then `MODES_TIEABLE_P (MODE1,
714    MODE2)' must be zero. */
715 #define MODES_TIEABLE_P(MODE1, MODE2)                   \
716  ((MODE1) == (MODE2)                                    \
717   || ((GET_MODE_CLASS (MODE1) == MODE_INT               \
718        || GET_MODE_CLASS (MODE1) == MODE_FLOAT)         \
719       && (GET_MODE_CLASS (MODE2) == MODE_INT            \
720           || GET_MODE_CLASS (MODE2) == MODE_FLOAT)      \
721       && (MODE1) != BImode && (MODE2) != BImode         \
722       && GET_MODE_SIZE (MODE1) <= UNITS_PER_WORD        \
723       && GET_MODE_SIZE (MODE2) <= UNITS_PER_WORD))
724
725 /* `PREFERRED_RELOAD_CLASS (X, CLASS)'
726    A C expression that places additional restrictions on the register
727    class to use when it is necessary to copy value X into a register
728    in class CLASS.  The value is a register class; perhaps CLASS, or
729    perhaps another, smaller class.  */
730 #define PREFERRED_RELOAD_CLASS(X, CLASS)                \
731   (GET_CODE (X) == POST_INC                             \
732    || GET_CODE (X) == POST_DEC                          \
733    || GET_CODE (X) == PRE_DEC ? PREGS : (CLASS))
734
735 /* Function Calling Conventions. */
736
737 /* The type of the current function; normal functions are of type
738    SUBROUTINE.  */
739 typedef enum {
740   SUBROUTINE, INTERRUPT_HANDLER, EXCPT_HANDLER, NMI_HANDLER
741 } e_funkind;
742
743 #define FUNCTION_ARG_REGISTERS { REG_R0, REG_R1, REG_R2, -1 }
744
745 /* Flags for the call/call_value rtl operations set up by function_arg */
746 #define CALL_NORMAL             0x00000000      /* no special processing */
747 #define CALL_LONG               0x00000001      /* always call indirect */
748 #define CALL_SHORT              0x00000002      /* always call by symbol */
749
750 typedef struct {
751   int words;                    /* # words passed so far */
752   int nregs;                    /* # registers available for passing */
753   int *arg_regs;                /* array of register -1 terminated */
754   int call_cookie;              /* Do special things for this call */
755 } CUMULATIVE_ARGS;
756
757 /* Define where to put the arguments to a function.
758    Value is zero to push the argument on the stack,
759    or a hard register in which to store the argument.
760
761    MODE is the argument's machine mode.
762    TYPE is the data type of the argument (as a tree).
763     This is null for libcalls where that information may
764     not be available.
765    CUM is a variable of type CUMULATIVE_ARGS which gives info about
766     the preceding args and about the function being called.
767    NAMED is nonzero if this argument is a named parameter
768     (otherwise it is an extra parameter matching an ellipsis).  */
769
770 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
771   (function_arg (&CUM, MODE, TYPE, NAMED))
772
773 #define FUNCTION_ARG_REGNO_P(REGNO) function_arg_regno_p (REGNO)
774
775
776 /* Initialize a variable CUM of type CUMULATIVE_ARGS
777    for a call to a function whose data type is FNTYPE.
778    For a library call, FNTYPE is 0.  */
779 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT, N_NAMED_ARGS) \
780   (init_cumulative_args (&CUM, FNTYPE, LIBNAME))
781
782 /* Update the data in CUM to advance over an argument
783    of mode MODE and data type TYPE.
784    (TYPE is null for libcalls where that information may not be available.)  */
785 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)    \
786   (function_arg_advance (&CUM, MODE, TYPE, NAMED))
787
788 #define RETURN_POPS_ARGS(FDECL, FUNTYPE, STKSIZE) 0
789
790 /* Define how to find the value returned by a function.
791    VALTYPE is the data type of the value (as a tree).
792    If the precise function being called is known, FUNC is its FUNCTION_DECL;
793    otherwise, FUNC is 0.
794 */
795
796 #define VALUE_REGNO(MODE) (REG_R0)
797
798 #define FUNCTION_VALUE(VALTYPE, FUNC)           \
799   gen_rtx_REG (TYPE_MODE (VALTYPE),             \
800                VALUE_REGNO(TYPE_MODE(VALTYPE)))
801
802 /* Define how to find the value returned by a library function
803    assuming the value has mode MODE.  */
804
805 #define LIBCALL_VALUE(MODE)  gen_rtx_REG (MODE, VALUE_REGNO(MODE))
806
807 #define FUNCTION_VALUE_REGNO_P(N) ((N) == REG_R0)
808
809 #define DEFAULT_PCC_STRUCT_RETURN 0
810 #define RETURN_IN_MEMORY(TYPE) bfin_return_in_memory(TYPE)
811
812 /* Before the prologue, the return address is in the RETS register.  */
813 #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, REG_RETS)
814
815 #define RETURN_ADDR_RTX(COUNT, FRAME) bfin_return_addr_rtx (COUNT)
816
817 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (REG_RETS)
818
819 /* Call instructions don't modify the stack pointer on the Blackfin.  */
820 #define INCOMING_FRAME_SP_OFFSET 0
821
822 /* Describe how we implement __builtin_eh_return.  */
823 #define EH_RETURN_DATA_REGNO(N) ((N) < 2 ? (N) : INVALID_REGNUM)
824 #define EH_RETURN_STACKADJ_RTX  gen_rtx_REG (Pmode, REG_P2)
825 #define EH_RETURN_HANDLER_RTX \
826     gen_frame_mem (Pmode, plus_constant (frame_pointer_rtx, UNITS_PER_WORD))
827
828 /* Addressing Modes */
829
830 /* Recognize any constant value that is a valid address.  */
831 #define CONSTANT_ADDRESS_P(X)   (CONSTANT_P (X))
832
833 /* Nonzero if the constant value X is a legitimate general operand.
834    symbol_ref are not legitimate and will be put into constant pool.
835    See force_const_mem().
836    If -mno-pool, all constants are legitimate.
837  */
838 #define LEGITIMATE_CONSTANT_P(X) bfin_legitimate_constant_p (X)
839
840 /*   A number, the maximum number of registers that can appear in a
841      valid memory address.  Note that it is up to you to specify a
842      value equal to the maximum number that `GO_IF_LEGITIMATE_ADDRESS'
843      would ever accept. */
844 #define MAX_REGS_PER_ADDRESS 1
845
846 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
847    that is a valid memory address for an instruction.
848    The MODE argument is the machine mode for the MEM expression
849    that wants to use this address. 
850
851    Blackfin addressing modes are as follows:
852
853       [preg]
854       [preg + imm16]
855
856       B [ Preg + uimm15 ]
857       W [ Preg + uimm16m2 ]
858       [ Preg + uimm17m4 ] 
859
860       [preg++]
861       [preg--]
862       [--sp]
863 */
864
865 #define LEGITIMATE_MODE_FOR_AUTOINC_P(MODE) \
866       (GET_MODE_SIZE (MODE) <= 4 || (MODE) == PDImode)
867
868 #ifdef REG_OK_STRICT
869 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, WIN)          \
870   do {                                                  \
871     if (bfin_legitimate_address_p (MODE, X, 1))         \
872       goto WIN;                                         \
873   } while (0);
874 #else
875 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, WIN)          \
876   do {                                                  \
877     if (bfin_legitimate_address_p (MODE, X, 0))         \
878       goto WIN;                                         \
879   } while (0);
880 #endif
881
882 /* Try machine-dependent ways of modifying an illegitimate address
883    to be legitimate.  If we find one, return the new, valid address.
884    This macro is used in only one place: `memory_address' in explow.c.
885
886    OLDX is the address as it was before break_out_memory_refs was called.
887    In some cases it is useful to look at this to decide what needs to be done.
888
889    MODE and WIN are passed so that this macro can use
890    GO_IF_LEGITIMATE_ADDRESS.
891
892    It is always safe for this macro to do nothing.  It exists to recognize
893    opportunities to optimize the output.
894  */
895 #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN)    \
896 do {                                           \
897    rtx _q = legitimize_address(X, OLDX, MODE); \
898    if (_q) { X = _q; goto WIN; }               \
899 } while (0)
900
901 #define HAVE_POST_INCREMENT 1
902 #define HAVE_POST_DECREMENT 1
903 #define HAVE_PRE_DECREMENT  1
904
905 /* `LEGITIMATE_PIC_OPERAND_P (X)'
906      A C expression that is nonzero if X is a legitimate immediate
907      operand on the target machine when generating position independent
908      code.  You can assume that X satisfies `CONSTANT_P', so you need
909      not check this.  You can also assume FLAG_PIC is true, so you need
910      not check it either.  You need not define this macro if all
911      constants (including `SYMBOL_REF') can be immediate operands when
912      generating position independent code. */
913 #define LEGITIMATE_PIC_OPERAND_P(X) ! SYMBOLIC_CONST (X)
914
915 #define SYMBOLIC_CONST(X)       \
916 (GET_CODE (X) == SYMBOL_REF                                             \
917  || GET_CODE (X) == LABEL_REF                                           \
918  || (GET_CODE (X) == CONST && symbolic_reference_mentioned_p (X)))
919
920 /*
921      A C statement or compound statement with a conditional `goto
922      LABEL;' executed if memory address X (an RTX) can have different
923      meanings depending on the machine mode of the memory reference it
924      is used for or if the address is valid for some modes but not
925      others.
926
927      Autoincrement and autodecrement addresses typically have
928      mode-dependent effects because the amount of the increment or
929      decrement is the size of the operand being addressed.  Some
930      machines have other mode-dependent addresses.  Many RISC machines
931      have no mode-dependent addresses.
932
933      You may assume that ADDR is a valid address for the machine.
934 */
935 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)
936
937 #define NOTICE_UPDATE_CC(EXPR, INSN) 0
938
939 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
940    is done just by pretending it is already truncated.  */
941 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
942
943 /* Max number of bytes we can move from memory to memory
944    in one reasonably fast instruction.  */
945 #define MOVE_MAX UNITS_PER_WORD
946
947 /* If a memory-to-memory move would take MOVE_RATIO or more simple
948    move-instruction pairs, we will do a movmem or libcall instead.  */
949
950 #define MOVE_RATIO 5
951
952 /* STORAGE LAYOUT: target machine storage layout
953    Define this macro as a C expression which is nonzero if accessing
954    less than a word of memory (i.e. a `char' or a `short') is no
955    faster than accessing a word of memory, i.e., if such access
956    require more than one instruction or if there is no difference in
957    cost between byte and (aligned) word loads.
958
959    When this macro is not defined, the compiler will access a field by
960    finding the smallest containing object; when it is defined, a
961    fullword load will be used if alignment permits.  Unless bytes
962    accesses are faster than word accesses, using word accesses is
963    preferable since it may eliminate subsequent memory access if
964    subsequent accesses occur to other fields in the same word of the
965    structure, but to different bytes.  */
966 #define SLOW_BYTE_ACCESS  0
967 #define SLOW_SHORT_ACCESS 0
968
969 /* Define this if most significant bit is lowest numbered
970    in instructions that operate on numbered bit-fields. */
971 #define BITS_BIG_ENDIAN  0
972
973 /* Define this if most significant byte of a word is the lowest numbered.
974    We can't access bytes but if we could we would in the Big Endian order. */
975 #define BYTES_BIG_ENDIAN 0
976
977 /* Define this if most significant word of a multiword number is numbered. */
978 #define WORDS_BIG_ENDIAN 0
979
980 /* number of bits in an addressable storage unit */
981 #define BITS_PER_UNIT 8
982
983 /* Width in bits of a "word", which is the contents of a machine register.
984    Note that this is not necessarily the width of data type `int';
985    if using 16-bit ints on a 68000, this would still be 32.
986    But on a machine with 16-bit registers, this would be 16.  */
987 #define BITS_PER_WORD 32
988
989 /* Width of a word, in units (bytes).  */
990 #define UNITS_PER_WORD 4
991
992 /* Width in bits of a pointer.
993    See also the macro `Pmode1' defined below.  */
994 #define POINTER_SIZE 32
995
996 /* Allocation boundary (in *bits*) for storing pointers in memory.  */
997 #define POINTER_BOUNDARY 32
998
999 /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
1000 #define PARM_BOUNDARY 32
1001
1002 /* Boundary (in *bits*) on which stack pointer should be aligned.  */
1003 #define STACK_BOUNDARY 32
1004
1005 /* Allocation boundary (in *bits*) for the code of a function.  */
1006 #define FUNCTION_BOUNDARY 32
1007
1008 /* Alignment of field after `int : 0' in a structure.  */
1009 #define EMPTY_FIELD_BOUNDARY BITS_PER_WORD
1010
1011 /* No data type wants to be aligned rounder than this.  */
1012 #define BIGGEST_ALIGNMENT 32
1013
1014 /* Define this if move instructions will actually fail to work
1015    when given unaligned data.  */
1016 #define STRICT_ALIGNMENT 1
1017
1018 /* (shell-command "rm c-decl.o stor-layout.o")
1019  *  never define PCC_BITFIELD_TYPE_MATTERS
1020  *  really cause some alignment problem
1021  */
1022
1023 #define UNITS_PER_FLOAT  ((FLOAT_TYPE_SIZE  + BITS_PER_UNIT - 1) / \
1024                            BITS_PER_UNIT)
1025
1026 #define UNITS_PER_DOUBLE ((DOUBLE_TYPE_SIZE + BITS_PER_UNIT - 1) / \
1027                            BITS_PER_UNIT)
1028
1029
1030 /* what is the 'type' of size_t */
1031 #define SIZE_TYPE "long unsigned int"
1032
1033 /* Define this as 1 if `char' should by default be signed; else as 0.  */
1034 #define DEFAULT_SIGNED_CHAR 1
1035 #define FLOAT_TYPE_SIZE BITS_PER_WORD
1036 #define SHORT_TYPE_SIZE 16 
1037 #define CHAR_TYPE_SIZE  8
1038 #define INT_TYPE_SIZE   32
1039 #define LONG_TYPE_SIZE  32
1040 #define LONG_LONG_TYPE_SIZE 64 
1041
1042 /* Note: Fix this to depend on target switch. -- lev */
1043
1044 /* Note: Try to implement double and force long double. -- tonyko
1045  * #define __DOUBLES_ARE_FLOATS__
1046  * #define DOUBLE_TYPE_SIZE FLOAT_TYPE_SIZE
1047  * #define LONG_DOUBLE_TYPE_SIZE DOUBLE_TYPE_SIZE
1048  * #define DOUBLES_ARE_FLOATS 1
1049  */
1050
1051 #define DOUBLE_TYPE_SIZE        64
1052 #define LONG_DOUBLE_TYPE_SIZE   64
1053
1054 /* `PROMOTE_MODE (M, UNSIGNEDP, TYPE)'
1055      A macro to update M and UNSIGNEDP when an object whose type is
1056      TYPE and which has the specified mode and signedness is to be
1057      stored in a register.  This macro is only called when TYPE is a
1058      scalar type.
1059
1060      On most RISC machines, which only have operations that operate on
1061      a full register, define this macro to set M to `word_mode' if M is
1062      an integer mode narrower than `BITS_PER_WORD'.  In most cases,
1063      only integer modes should be widened because wider-precision
1064      floating-point operations are usually more expensive than their
1065      narrower counterparts.
1066
1067      For most machines, the macro definition does not change UNSIGNEDP.
1068      However, some machines, have instructions that preferentially
1069      handle either signed or unsigned quantities of certain modes.  For
1070      example, on the DEC Alpha, 32-bit loads from memory and 32-bit add
1071      instructions sign-extend the result to 64 bits.  On such machines,
1072      set UNSIGNEDP according to which kind of extension is more
1073      efficient.
1074
1075      Do not define this macro if it would never modify M.*/
1076
1077 #define BFIN_PROMOTE_MODE_P(MODE) \
1078     (!TARGET_DSP && GET_MODE_CLASS (MODE) == MODE_INT   \
1079       && GET_MODE_SIZE (MODE) < UNITS_PER_WORD)
1080
1081 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE)     \
1082   if (BFIN_PROMOTE_MODE_P(MODE))                \
1083     {                                           \
1084       if (MODE == QImode)                       \
1085         UNSIGNEDP = 1;                          \
1086       else if (MODE == HImode)                  \
1087         UNSIGNEDP = 0;                          \
1088       (MODE) = SImode;                          \
1089     }
1090
1091 /* Describing Relative Costs of Operations */
1092
1093 /* Do not put function addr into constant pool */
1094 #define NO_FUNCTION_CSE 1
1095
1096 /* A C expression for the cost of moving data from a register in class FROM to
1097    one in class TO.  The classes are expressed using the enumeration values
1098    such as `GENERAL_REGS'.  A value of 2 is the default; other values are
1099    interpreted relative to that.
1100
1101    It is not required that the cost always equal 2 when FROM is the same as TO;
1102    on some machines it is expensive to move between registers if they are not
1103    general registers.  */
1104
1105 #define REGISTER_MOVE_COST(MODE, CLASS1, CLASS2) \
1106    bfin_register_move_cost ((MODE), (CLASS1), (CLASS2))
1107
1108 /* A C expression for the cost of moving data of mode M between a
1109    register and memory.  A value of 2 is the default; this cost is
1110    relative to those in `REGISTER_MOVE_COST'.
1111
1112    If moving between registers and memory is more expensive than
1113    between two registers, you should define this macro to express the
1114    relative cost.  */
1115
1116 #define MEMORY_MOVE_COST(MODE, CLASS, IN)       \
1117   bfin_memory_move_cost ((MODE), (CLASS), (IN))
1118
1119 /* Specify the machine mode that this machine uses
1120    for the index in the tablejump instruction.  */
1121 #define CASE_VECTOR_MODE SImode
1122
1123 #define JUMP_TABLES_IN_TEXT_SECTION flag_pic
1124
1125 /* Define if operations between registers always perform the operation
1126    on the full register even if a narrower mode is specified. 
1127 #define WORD_REGISTER_OPERATIONS
1128 */
1129
1130 #define CONST_18UBIT_IMM_P(VALUE) ((VALUE) >= 0 && (VALUE) <= 262140)
1131 #define CONST_16BIT_IMM_P(VALUE) ((VALUE) >= -32768 && (VALUE) <= 32767)
1132 #define CONST_16UBIT_IMM_P(VALUE) ((VALUE) >= 0 && (VALUE) <= 65535)
1133 #define CONST_7BIT_IMM_P(VALUE) ((VALUE) >= -64 && (VALUE) <= 63)
1134 #define CONST_7NBIT_IMM_P(VALUE) ((VALUE) >= -64 && (VALUE) <= 0)
1135 #define CONST_5UBIT_IMM_P(VALUE) ((VALUE) >= 0 && (VALUE) <= 31)
1136 #define CONST_4BIT_IMM_P(VALUE) ((VALUE) >= -8 && (VALUE) <= 7)
1137 #define CONST_4UBIT_IMM_P(VALUE) ((VALUE) >= 0 && (VALUE) <= 15)
1138 #define CONST_3BIT_IMM_P(VALUE) ((VALUE) >= -4 && (VALUE) <= 3)
1139 #define CONST_3UBIT_IMM_P(VALUE) ((VALUE) >= 0 && (VALUE) <= 7)
1140
1141 #define CONSTRAINT_LEN(C, STR)                  \
1142     ((C) == 'P' || (C) == 'M' || (C) == 'N' || (C) == 'q' ? 2   \
1143      : (C) == 'K' ? 3                           \
1144      : DEFAULT_CONSTRAINT_LEN ((C), (STR)))
1145
1146 #define CONST_OK_FOR_P(VALUE, STR)    \
1147     ((STR)[1] == '0' ? (VALUE) == 0   \
1148      : (STR)[1] == '1' ? (VALUE) == 1 \
1149      : (STR)[1] == '2' ? (VALUE) == 2 \
1150      : (STR)[1] == '3' ? (VALUE) == 3 \
1151      : (STR)[1] == '4' ? (VALUE) == 4 \
1152      : (STR)[1] == 'A' ? (VALUE) != MACFLAG_M && (VALUE) != MACFLAG_IS_M \
1153      : (STR)[1] == 'B' ? (VALUE) == MACFLAG_M || (VALUE) == MACFLAG_IS_M \
1154      : 0)
1155
1156 #define CONST_OK_FOR_K(VALUE, STR)                      \
1157     ((STR)[1] == 'u'                                    \
1158      ? ((STR)[2] == '3' ? CONST_3UBIT_IMM_P (VALUE)     \
1159         : (STR)[2] == '4' ? CONST_4UBIT_IMM_P (VALUE)   \
1160         : (STR)[2] == '5' ? CONST_5UBIT_IMM_P (VALUE)   \
1161         : (STR)[2] == 'h' ? CONST_16UBIT_IMM_P (VALUE)  \
1162         : 0)                                            \
1163      : (STR)[1] == 's'                                  \
1164      ? ((STR)[2] == '3' ? CONST_3BIT_IMM_P (VALUE)      \
1165         : (STR)[2] == '4' ? CONST_4BIT_IMM_P (VALUE)    \
1166         : (STR)[2] == '7' ? CONST_7BIT_IMM_P (VALUE)    \
1167         : (STR)[2] == 'h' ? CONST_16BIT_IMM_P (VALUE)   \
1168         : 0)                                            \
1169      : (STR)[1] == 'n'                                  \
1170      ? ((STR)[2] == '7' ? CONST_7NBIT_IMM_P (VALUE)     \
1171         : 0)                                            \
1172      : (STR)[1] == 'N'                                  \
1173      ? ((STR)[2] == '7' ? CONST_7BIT_IMM_P (-(VALUE))   \
1174         : 0)                                            \
1175      : 0)
1176
1177 #define CONST_OK_FOR_M(VALUE, STR)                      \
1178     ((STR)[1] == '1' ? (VALUE) == 255                   \
1179      : (STR)[1] == '2' ? (VALUE) == 65535               \
1180      : 0)
1181
1182 /* The letters I, J, K, L and M in a register constraint string
1183    can be used to stand for particular ranges of immediate operands.
1184    This macro defines what the ranges are.
1185    C is the letter, and VALUE is a constant value.
1186    Return 1 if VALUE is in the range specified by C. 
1187    
1188    bfin constant operands are as follows
1189    
1190      J   2**N       5bit imm scaled
1191      Ks7 -64 .. 63  signed 7bit imm
1192      Ku5 0..31      unsigned 5bit imm
1193      Ks4 -8 .. 7    signed 4bit imm
1194      Ks3 -4 .. 3    signed 3bit imm
1195      Ku3 0 .. 7     unsigned 3bit imm
1196      Pn  0, 1, 2    constants 0, 1 or 2, corresponding to n
1197 */
1198 #define CONST_OK_FOR_CONSTRAINT_P(VALUE, C, STR)                \
1199   ((C) == 'J' ? (log2constp (VALUE))                            \
1200    : (C) == 'K' ? CONST_OK_FOR_K (VALUE, STR)                   \
1201    : (C) == 'L' ? log2constp (~(VALUE))                         \
1202    : (C) == 'M' ? CONST_OK_FOR_M (VALUE, STR)                   \
1203    : (C) == 'P' ? CONST_OK_FOR_P (VALUE, STR)                   \
1204    : 0)
1205
1206      /*Constant Output Formats */
1207 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)  \
1208   ((C) == 'H' ? 1 : 0)
1209
1210 #define EXTRA_CONSTRAINT(VALUE, D) \
1211     ((D) == 'Q' ? GET_CODE (VALUE) == SYMBOL_REF : 0)
1212
1213 /* Evaluates to true if A and B are mac flags that can be used
1214    together in a single multiply insn.  That is the case if they are
1215    both the same flag not involving M, or if one is a combination of
1216    the other with M.  */
1217 #define MACFLAGS_MATCH_P(A, B) \
1218  ((A) == (B) \
1219   || ((A) == MACFLAG_NONE && (B) == MACFLAG_M) \
1220   || ((A) == MACFLAG_M && (B) == MACFLAG_NONE) \
1221   || ((A) == MACFLAG_IS && (B) == MACFLAG_IS_M) \
1222   || ((A) == MACFLAG_IS_M && (B) == MACFLAG_IS))
1223
1224 /* Switch into a generic section.  */
1225 #define TARGET_ASM_NAMED_SECTION  default_elf_asm_named_section
1226
1227 #define PRINT_OPERAND(FILE, RTX, CODE)   print_operand (FILE, RTX, CODE)
1228 #define PRINT_OPERAND_ADDRESS(FILE, RTX) print_address_operand (FILE, RTX)
1229
1230 typedef enum sections {
1231     CODE_DIR,
1232     DATA_DIR,
1233     LAST_SECT_NM
1234 } SECT_ENUM_T;
1235
1236 typedef enum directives {
1237     LONG_CONST_DIR,
1238     SHORT_CONST_DIR,
1239     BYTE_CONST_DIR,
1240     SPACE_DIR,
1241     INIT_DIR,
1242     LAST_DIR_NM
1243 } DIR_ENUM_T;
1244
1245 #define TEXT_SECTION_ASM_OP ".text;"
1246 #define DATA_SECTION_ASM_OP ".data;"
1247
1248 #define ASM_APP_ON  ""
1249 #define ASM_APP_OFF ""
1250
1251 #define ASM_GLOBALIZE_LABEL1(FILE, NAME) \
1252   do {  fputs (".global ", FILE);               \
1253         assemble_name (FILE, NAME);             \
1254         fputc (';',FILE);                       \
1255         fputc ('\n',FILE);                      \
1256       } while (0)
1257
1258 #define ASM_DECLARE_FUNCTION_NAME(FILE,NAME,DECL) \
1259   do {                                  \
1260     fputs (".type ", FILE);             \
1261     assemble_name (FILE, NAME);         \
1262     fputs (", STT_FUNC", FILE);         \
1263     fputc (';',FILE);                   \
1264     fputc ('\n',FILE);                  \
1265     ASM_OUTPUT_LABEL(FILE, NAME);       \
1266   } while (0)
1267
1268 #define ASM_OUTPUT_LABEL(FILE, NAME)    \
1269   do {  assemble_name (FILE, NAME);             \
1270         fputs (":\n",FILE);                     \
1271       } while (0)
1272
1273 #define ASM_OUTPUT_LABELREF(FILE,NAME)  \
1274     do {  fprintf (FILE, "_%s", NAME); \
1275         } while (0)
1276
1277 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)            \
1278 do { char __buf[256];                                   \
1279      fprintf (FILE, "\t.dd\t");                         \
1280      ASM_GENERATE_INTERNAL_LABEL (__buf, "L", VALUE);   \
1281      assemble_name (FILE, __buf);                       \
1282      fputc (';', FILE);                                 \
1283      fputc ('\n', FILE);                                \
1284    } while (0)
1285
1286 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
1287     MY_ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL)
1288
1289 #define MY_ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL)           \
1290     do {                                                        \
1291         char __buf[256];                                        \
1292         fprintf (FILE, "\t.dd\t");                              \
1293         ASM_GENERATE_INTERNAL_LABEL (__buf, "L", VALUE);        \
1294         assemble_name (FILE, __buf);                            \
1295         fputs (" - ", FILE);                                    \
1296         ASM_GENERATE_INTERNAL_LABEL (__buf, "L", REL);          \
1297         assemble_name (FILE, __buf);                            \
1298         fputc (';', FILE);                                      \
1299         fputc ('\n', FILE);                                     \
1300     } while (0)
1301
1302 #define ASM_OUTPUT_ALIGN(FILE,LOG)                              \
1303     do {                                                        \
1304       if ((LOG) != 0)                                           \
1305         fprintf (FILE, "\t.align %d\n", 1 << (LOG));            \
1306     } while (0)
1307
1308 #define ASM_OUTPUT_SKIP(FILE,SIZE)              \
1309     do {                                        \
1310         asm_output_skip (FILE, SIZE);           \
1311     } while (0)
1312
1313 #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)     \
1314 do {                                            \
1315     switch_to_section (data_section);                           \
1316     if ((SIZE) >= (unsigned int) 4 ) ASM_OUTPUT_ALIGN(FILE,2);  \
1317     ASM_OUTPUT_SIZE_DIRECTIVE (FILE, NAME, SIZE);               \
1318     ASM_OUTPUT_LABEL (FILE, NAME);                              \
1319     fprintf (FILE, "%s %ld;\n", ASM_SPACE,                      \
1320              (ROUNDED) > (unsigned int) 1 ? (ROUNDED) : 1);     \
1321 } while (0)
1322
1323 #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)    \
1324      do {                                               \
1325         ASM_GLOBALIZE_LABEL1(FILE,NAME);                \
1326         ASM_OUTPUT_LOCAL (FILE, NAME, SIZE, ROUNDED); } while(0)
1327
1328 #define ASM_COMMENT_START "//"
1329
1330 #define FUNCTION_PROFILER(FILE, LABELNO)        \
1331   do {                                          \
1332     fprintf (FILE, "\tCALL __mcount;\n");       \
1333   } while(0)
1334
1335 #undef NO_PROFILE_COUNTERS
1336 #define NO_PROFILE_COUNTERS 1
1337
1338 #define ASM_OUTPUT_REG_PUSH(FILE, REGNO) fprintf (FILE, "[SP--] = %s;\n", reg_names[REGNO])
1339 #define ASM_OUTPUT_REG_POP(FILE, REGNO)  fprintf (FILE, "%s = [SP++];\n", reg_names[REGNO])
1340
1341 extern struct rtx_def *bfin_compare_op0, *bfin_compare_op1;
1342 extern struct rtx_def *bfin_cc_rtx, *bfin_rets_rtx;
1343
1344 /* This works for GAS and some other assemblers.  */
1345 #define SET_ASM_OP              ".set "
1346
1347 /* DBX register number for a given compiler register number */
1348 #define DBX_REGISTER_NUMBER(REGNO)  (REGNO) 
1349
1350 #define SIZE_ASM_OP     "\t.size\t"
1351
1352 extern int splitting_for_sched;
1353
1354 #define PRINT_OPERAND_PUNCT_VALID_P(CHAR) ((CHAR) == '!')
1355
1356 #endif /*  _BFIN_CONFIG */