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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [config/] [mn10300/] [mn10300.h] - Blame information for rev 282

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 282 jeremybenn
/* Definitions of target machine for GNU compiler.
2
   Matsushita MN10300 series
3
   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4
   2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5
   Contributed by Jeff Law (law@cygnus.com).
6
 
7
This file is part of GCC.
8
 
9
GCC is free software; you can redistribute it and/or modify
10
it under the terms of the GNU General Public License as published by
11
the Free Software Foundation; either version 3, or (at your option)
12
any later version.
13
 
14
GCC is distributed in the hope that it will be useful,
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
GNU General Public License for more details.
18
 
19
You should have received a copy of the GNU General Public License
20
along with GCC; see the file COPYING3.  If not see
21
<http://www.gnu.org/licenses/>.  */
22
 
23
 
24
#undef ASM_SPEC
25
#undef LIB_SPEC
26
#undef ENDFILE_SPEC
27
#undef LINK_SPEC
28
#define LINK_SPEC "%{mrelax:--relax}"
29
#undef STARTFILE_SPEC
30
#define STARTFILE_SPEC "%{!mno-crt0:%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}}"
31
 
32
/* Names to predefine in the preprocessor for this target machine.  */
33
 
34
#define TARGET_CPU_CPP_BUILTINS()               \
35
  do                                            \
36
    {                                           \
37
      builtin_define ("__mn10300__");           \
38
      builtin_define ("__MN10300__");           \
39
      builtin_assert ("cpu=mn10300");           \
40
      builtin_assert ("machine=mn10300");       \
41
    }                                           \
42
  while (0)
43
 
44
#define CPP_SPEC "%{mam33:-D__AM33__} %{mam33-2:-D__AM33__=2 -D__AM33_2__}"
45
 
46
extern GTY(()) int mn10300_unspec_int_label_counter;
47
 
48
enum processor_type {
49
  PROCESSOR_MN10300,
50
  PROCESSOR_AM33,
51
  PROCESSOR_AM33_2
52
};
53
 
54
extern enum processor_type mn10300_processor;
55
 
56
#define TARGET_AM33     (mn10300_processor >= PROCESSOR_AM33)
57
#define TARGET_AM33_2   (mn10300_processor == PROCESSOR_AM33_2)
58
 
59
#ifndef PROCESSOR_DEFAULT
60
#define PROCESSOR_DEFAULT PROCESSOR_MN10300
61
#endif
62
 
63
#define OVERRIDE_OPTIONS mn10300_override_options ()
64
 
65
/* Print subsidiary information on the compiler version in use.  */
66
 
67
#define TARGET_VERSION fprintf (stderr, " (MN10300)");
68
 
69
 
70
/* Target machine storage layout */
71
 
72
/* Define this if most significant bit is lowest numbered
73
   in instructions that operate on numbered bit-fields.
74
   This is not true on the Matsushita MN1003.  */
75
#define BITS_BIG_ENDIAN 0
76
 
77
/* Define this if most significant byte of a word is the lowest numbered.  */
78
/* This is not true on the Matsushita MN10300.  */
79
#define BYTES_BIG_ENDIAN 0
80
 
81
/* Define this if most significant word of a multiword number is lowest
82
   numbered.
83
   This is not true on the Matsushita MN10300.  */
84
#define WORDS_BIG_ENDIAN 0
85
 
86
/* Width of a word, in units (bytes).  */
87
#define UNITS_PER_WORD          4
88
 
89
/* Allocation boundary (in *bits*) for storing arguments in argument list.  */
90
#define PARM_BOUNDARY           32
91
 
92
/* The stack goes in 32-bit lumps.  */
93
#define STACK_BOUNDARY          32
94
 
95
/* Allocation boundary (in *bits*) for the code of a function.
96
   8 is the minimum boundary; it's unclear if bigger alignments
97
   would improve performance.  */
98
#define FUNCTION_BOUNDARY 8
99
 
100
/* No data type wants to be aligned rounder than this.  */
101
#define BIGGEST_ALIGNMENT       32
102
 
103
/* Alignment of field after `int : 0' in a structure.  */
104
#define EMPTY_FIELD_BOUNDARY 32
105
 
106
/* Define this if move instructions will actually fail to work
107
   when given unaligned data.  */
108
#define STRICT_ALIGNMENT 1
109
 
110
/* Define this as 1 if `char' should by default be signed; else as 0.  */
111
#define DEFAULT_SIGNED_CHAR 0
112
 
113
/* Standard register usage.  */
114
 
115
/* Number of actual hardware registers.
116
   The hardware registers are assigned numbers for the compiler
117
   from 0 to just below FIRST_PSEUDO_REGISTER.
118
 
119
   All registers that the compiler knows about must be given numbers,
120
   even those that are not normally considered general registers.  */
121
 
122
#define FIRST_PSEUDO_REGISTER 50
123
 
124
/* Specify machine-specific register numbers.  */
125
#define FIRST_DATA_REGNUM 0
126
#define LAST_DATA_REGNUM 3
127
#define FIRST_ADDRESS_REGNUM 4
128
#define LAST_ADDRESS_REGNUM 8
129
#define FIRST_EXTENDED_REGNUM 10
130
#define LAST_EXTENDED_REGNUM 17
131
#define FIRST_FP_REGNUM 18
132
#define LAST_FP_REGNUM 49
133
#define FIRST_ARGUMENT_REGNUM 0
134
 
135
/* Specify the registers used for certain standard purposes.
136
   The values of these macros are register numbers.  */
137
 
138
/* Register to use for pushing function arguments.  */
139
#define STACK_POINTER_REGNUM (LAST_ADDRESS_REGNUM+1)
140
 
141
/* Base register for access to local variables of the function.  */
142
#define FRAME_POINTER_REGNUM (LAST_ADDRESS_REGNUM-1)
143
 
144
/* Base register for access to arguments of the function.  This
145
   is a fake register and will be eliminated into either the frame
146
   pointer or stack pointer.  */
147
#define ARG_POINTER_REGNUM LAST_ADDRESS_REGNUM
148
 
149
/* Register in which static-chain is passed to a function.  */
150
#define STATIC_CHAIN_REGNUM (FIRST_ADDRESS_REGNUM+1)
151
 
152
/* 1 for registers that have pervasive standard uses
153
   and are not available for the register allocator.  */
154
 
155
#define FIXED_REGISTERS \
156
  { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 \
157
  , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \
158
  , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \
159
  }
160
 
161
/* 1 for registers not available across function calls.
162
   These must include the FIXED_REGISTERS and also any
163
   registers that can be used without being saved.
164
   The latter must include the registers where values are returned
165
   and the register where structure-value addresses are passed.
166
   Aside from that, you can include as many other registers as you
167
   like.  */
168
 
169
#define CALL_USED_REGISTERS \
170
  { 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 \
171
  , 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \
172
  , 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 \
173
  }
174
 
175
/* Note: The definition of CALL_REALLY_USED_REGISTERS is not
176
   redundant.  It is needed when compiling in PIC mode because
177
   the a2 register becomes fixed (and hence must be marked as
178
   call_used) but in order to preserve the ABI it is not marked
179
   as call_really_used.  */
180
#define CALL_REALLY_USED_REGISTERS CALL_USED_REGISTERS
181
 
182
#define REG_ALLOC_ORDER \
183
  { 0, 1, 4, 5, 2, 3, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 8, 9 \
184
  , 42, 43, 44, 45, 46, 47, 48, 49, 34, 35, 36, 37, 38, 39, 40, 41 \
185
  , 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33 \
186
  }
187
 
188
#define CONDITIONAL_REGISTER_USAGE \
189
{                                               \
190
  unsigned int i;                               \
191
                                                \
192
  if (!TARGET_AM33)                             \
193
    {                                           \
194
      for (i = FIRST_EXTENDED_REGNUM;           \
195
           i <= LAST_EXTENDED_REGNUM; i++)      \
196
        fixed_regs[i] = call_used_regs[i] = 1;  \
197
    }                                           \
198
  if (!TARGET_AM33_2)                           \
199
    {                                           \
200
      for (i = FIRST_FP_REGNUM;                 \
201
           i <= LAST_FP_REGNUM;                 \
202
           i++)                                 \
203
        fixed_regs[i] = call_used_regs[i] = 1;  \
204
    }                                           \
205
  if (flag_pic)                                 \
206
    fixed_regs[PIC_OFFSET_TABLE_REGNUM] =       \
207
    call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;\
208
}
209
 
210
/* Return number of consecutive hard regs needed starting at reg REGNO
211
   to hold something of mode MODE.
212
 
213
   This is ordinarily the length in words of a value of mode MODE
214
   but can be less for certain modes in special long registers.  */
215
 
216
#define HARD_REGNO_NREGS(REGNO, MODE)   \
217
  ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
218
 
219
/* Value is 1 if hard register REGNO can hold a value of machine-mode
220
   MODE.  */
221
 
222
#define HARD_REGNO_MODE_OK(REGNO, MODE) \
223
 ((REGNO_REG_CLASS (REGNO) == DATA_REGS \
224
   || (TARGET_AM33 && REGNO_REG_CLASS (REGNO) == ADDRESS_REGS) \
225
   || REGNO_REG_CLASS (REGNO) == EXTENDED_REGS) \
226
  ? ((REGNO) & 1) == 0 || GET_MODE_SIZE (MODE) <= 4      \
227
  : ((REGNO) & 1) == 0 || GET_MODE_SIZE (MODE) == 4)
228
 
229
/* Value is 1 if it is a good idea to tie two pseudo registers
230
   when one has mode MODE1 and one has mode MODE2.
231
   If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
232
   for any hard reg, then this must be 0 for correct output.  */
233
#define MODES_TIEABLE_P(MODE1, MODE2) \
234
  (TARGET_AM33  \
235
   || MODE1 == MODE2 \
236
   || (GET_MODE_SIZE (MODE1) <= 4 && GET_MODE_SIZE (MODE2) <= 4))
237
 
238
/* 4 data, and effectively 3 address registers is small as far as I'm
239
   concerned.  */
240
#define SMALL_REGISTER_CLASSES 1
241
 
242
/* Define the classes of registers for register constraints in the
243
   machine description.  Also define ranges of constants.
244
 
245
   One of the classes must always be named ALL_REGS and include all hard regs.
246
   If there is more than one class, another class must be named NO_REGS
247
   and contain no registers.
248
 
249
   The name GENERAL_REGS must be the name of a class (or an alias for
250
   another name such as ALL_REGS).  This is the class of registers
251
   that is allowed by "g" or "r" in a register constraint.
252
   Also, registers outside this class are allocated only when
253
   instructions express preferences for them.
254
 
255
   The classes must be numbered in nondecreasing order; that is,
256
   a larger-numbered class must never be contained completely
257
   in a smaller-numbered class.
258
 
259
   For any two classes, it is very desirable that there be another
260
   class that represents their union.  */
261
 
262
enum reg_class {
263
  NO_REGS, DATA_REGS, ADDRESS_REGS, SP_REGS,
264
  DATA_OR_ADDRESS_REGS, SP_OR_ADDRESS_REGS,
265
  EXTENDED_REGS, DATA_OR_EXTENDED_REGS, ADDRESS_OR_EXTENDED_REGS,
266
  SP_OR_EXTENDED_REGS, SP_OR_ADDRESS_OR_EXTENDED_REGS,
267
  FP_REGS, FP_ACC_REGS,
268
  GENERAL_REGS, ALL_REGS, LIM_REG_CLASSES
269
};
270
 
271
#define N_REG_CLASSES (int) LIM_REG_CLASSES
272
 
273
/* Give names of register classes as strings for dump file.  */
274
 
275
#define REG_CLASS_NAMES \
276
{ "NO_REGS", "DATA_REGS", "ADDRESS_REGS", \
277
  "SP_REGS", "DATA_OR_ADDRESS_REGS", "SP_OR_ADDRESS_REGS", \
278
  "EXTENDED_REGS", \
279
  "DATA_OR_EXTENDED_REGS", "ADDRESS_OR_EXTENDED_REGS", \
280
  "SP_OR_EXTENDED_REGS", "SP_OR_ADDRESS_OR_EXTENDED_REGS", \
281
  "FP_REGS", "FP_ACC_REGS", \
282
  "GENERAL_REGS", "ALL_REGS", "LIM_REGS" }
283
 
284
/* Define which registers fit in which classes.
285
   This is an initializer for a vector of HARD_REG_SET
286
   of length N_REG_CLASSES.  */
287
 
288
#define REG_CLASS_CONTENTS                      \
289
{  { 0,  0 },             /* No regs      */      \
290
 { 0x0000f, 0 }, /* DATA_REGS */         \
291
 { 0x001f0, 0 }, /* ADDRESS_REGS */      \
292
 { 0x00200, 0 }, /* SP_REGS */           \
293
 { 0x001ff, 0 }, /* DATA_OR_ADDRESS_REGS */\
294
 { 0x003f0, 0 }, /* SP_OR_ADDRESS_REGS */\
295
 { 0x3fc00, 0 }, /* EXTENDED_REGS */     \
296
 { 0x3fc0f, 0 }, /* DATA_OR_EXTENDED_REGS */     \
297
 { 0x3fdf0, 0 }, /* ADDRESS_OR_EXTENDED_REGS */  \
298
 { 0x3fe00, 0 }, /* SP_OR_EXTENDED_REGS */       \
299
 { 0x3fff0, 0 }, /* SP_OR_ADDRESS_OR_EXTENDED_REGS */    \
300
 { 0xfffc0000, 0x3ffff }, /* FP_REGS */         \
301
 { 0x03fc0000, 0 },      /* FP_ACC_REGS */       \
302
 { 0x3fdff, 0 },         /* GENERAL_REGS */      \
303
 { 0xffffffff, 0x3ffff } /* ALL_REGS    */      \
304
}
305
 
306
/* The following macro defines cover classes for Integrated Register
307
   Allocator.  Cover classes is a set of non-intersected register
308
   classes covering all hard registers used for register allocation
309
   purpose.  Any move between two registers of a cover class should be
310
   cheaper than load or store of the registers.  The macro value is
311
   array of register classes with LIM_REG_CLASSES used as the end
312
   marker.  */
313
 
314
#define IRA_COVER_CLASSES                                                    \
315
{                                                                            \
316
  GENERAL_REGS, FP_REGS, LIM_REG_CLASSES \
317
}
318
 
319
/* The same information, inverted:
320
   Return the class number of the smallest class containing
321
   reg number REGNO.  This could be a conditional expression
322
   or could index an array.  */
323
 
324
#define REGNO_REG_CLASS(REGNO) \
325
  ((REGNO) <= LAST_DATA_REGNUM ? DATA_REGS : \
326
   (REGNO) <= LAST_ADDRESS_REGNUM ? ADDRESS_REGS : \
327
   (REGNO) == STACK_POINTER_REGNUM ? SP_REGS : \
328
   (REGNO) <= LAST_EXTENDED_REGNUM ? EXTENDED_REGS : \
329
   (REGNO) <= LAST_FP_REGNUM ? FP_REGS : \
330
   NO_REGS)
331
 
332
/* The class value for index registers, and the one for base regs.  */
333
#define INDEX_REG_CLASS DATA_OR_EXTENDED_REGS
334
#define BASE_REG_CLASS  SP_OR_ADDRESS_REGS
335
 
336
/* Macros to check register numbers against specific register classes.  */
337
 
338
/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
339
   and check its validity for a certain class.
340
   We have two alternate definitions for each of them.
341
   The usual definition accepts all pseudo regs; the other rejects
342
   them unless they have been allocated suitable hard regs.
343
   The symbol REG_OK_STRICT causes the latter definition to be used.
344
 
345
   Most source files want to accept pseudo regs in the hope that
346
   they will get allocated to the class that the insn wants them to be in.
347
   Source files for reload pass need to be strict.
348
   After reload, it makes no difference, since pseudo regs have
349
   been eliminated by then.  */
350
 
351
/* These assume that REGNO is a hard or pseudo reg number.
352
   They give nonzero only if REGNO is a hard reg of the suitable class
353
   or a pseudo reg currently allocated to a suitable hard reg.
354
   Since they use reg_renumber, they are safe only once reg_renumber
355
   has been allocated, which happens in local-alloc.c.  */
356
 
357
#ifndef REG_OK_STRICT
358
# define REG_STRICT 0
359
#else
360
# define REG_STRICT 1
361
#endif
362
 
363
# define REGNO_IN_RANGE_P(regno,min,max,strict) \
364
  (IN_RANGE ((regno), (min), (max))             \
365
   || ((strict)                                 \
366
       ? (reg_renumber                          \
367
          && reg_renumber[(regno)] >= (min)     \
368
          && reg_renumber[(regno)] <= (max))    \
369
       : (regno) >= FIRST_PSEUDO_REGISTER))
370
 
371
#define REGNO_DATA_P(regno, strict) \
372
  (REGNO_IN_RANGE_P ((regno), FIRST_DATA_REGNUM, LAST_DATA_REGNUM, \
373
                     (strict)))
374
#define REGNO_ADDRESS_P(regno, strict) \
375
  (REGNO_IN_RANGE_P ((regno), FIRST_ADDRESS_REGNUM, LAST_ADDRESS_REGNUM, \
376
                     (strict)))
377
#define REGNO_SP_P(regno, strict) \
378
  (REGNO_IN_RANGE_P ((regno), STACK_POINTER_REGNUM, STACK_POINTER_REGNUM, \
379
                     (strict)))
380
#define REGNO_EXTENDED_P(regno, strict) \
381
  (REGNO_IN_RANGE_P ((regno), FIRST_EXTENDED_REGNUM, LAST_EXTENDED_REGNUM, \
382
                     (strict)))
383
#define REGNO_AM33_P(regno, strict) \
384
  (REGNO_DATA_P ((regno), (strict)) || REGNO_ADDRESS_P ((regno), (strict)) \
385
   || REGNO_EXTENDED_P ((regno), (strict)))
386
#define REGNO_FP_P(regno, strict) \
387
  (REGNO_IN_RANGE_P ((regno), FIRST_FP_REGNUM, LAST_FP_REGNUM, (strict)))
388
 
389
#define REGNO_STRICT_OK_FOR_BASE_P(regno, strict) \
390
  (REGNO_SP_P ((regno), (strict)) \
391
   || REGNO_ADDRESS_P ((regno), (strict)) \
392
   || REGNO_EXTENDED_P ((regno), (strict)))
393
#define REGNO_OK_FOR_BASE_P(regno) \
394
  (REGNO_STRICT_OK_FOR_BASE_P ((regno), REG_STRICT))
395
#define REG_OK_FOR_BASE_P(X) \
396
  (REGNO_OK_FOR_BASE_P (REGNO (X)))
397
 
398
#define REGNO_STRICT_OK_FOR_BIT_BASE_P(regno, strict) \
399
  (REGNO_SP_P ((regno), (strict)) || REGNO_ADDRESS_P ((regno), (strict)))
400
#define REGNO_OK_FOR_BIT_BASE_P(regno) \
401
  (REGNO_STRICT_OK_FOR_BIT_BASE_P ((regno), REG_STRICT))
402
#define REG_OK_FOR_BIT_BASE_P(X) \
403
  (REGNO_OK_FOR_BIT_BASE_P (REGNO (X)))
404
 
405
#define REGNO_STRICT_OK_FOR_INDEX_P(regno, strict) \
406
  (REGNO_DATA_P ((regno), (strict)) || REGNO_EXTENDED_P ((regno), (strict)))
407
#define REGNO_OK_FOR_INDEX_P(regno) \
408
  (REGNO_STRICT_OK_FOR_INDEX_P ((regno), REG_STRICT))
409
#define REG_OK_FOR_INDEX_P(X) \
410
  (REGNO_OK_FOR_INDEX_P (REGNO (X)))
411
 
412
/* Given an rtx X being reloaded into a reg required to be
413
   in class CLASS, return the class of reg to actually use.
414
   In general this is just CLASS; but on some machines
415
   in some cases it is preferable to use a more restrictive class.  */
416
 
417
#define PREFERRED_RELOAD_CLASS(X,CLASS)                         \
418
  ((X) == stack_pointer_rtx && (CLASS) != SP_REGS               \
419
   ? ADDRESS_OR_EXTENDED_REGS                                   \
420
   : (GET_CODE (X) == MEM                                       \
421
      || (GET_CODE (X) == REG                                   \
422
          && REGNO (X) >= FIRST_PSEUDO_REGISTER)                \
423
      || (GET_CODE (X) == SUBREG                                \
424
          && GET_CODE (SUBREG_REG (X)) == REG                   \
425
          && REGNO (SUBREG_REG (X)) >= FIRST_PSEUDO_REGISTER)   \
426
      ? LIMIT_RELOAD_CLASS (GET_MODE (X), CLASS)                \
427
      : (CLASS)))
428
 
429
#define PREFERRED_OUTPUT_RELOAD_CLASS(X,CLASS) \
430
  (X == stack_pointer_rtx && CLASS != SP_REGS \
431
   ? ADDRESS_OR_EXTENDED_REGS : CLASS)
432
 
433
#define LIMIT_RELOAD_CLASS(MODE, CLASS) \
434
  (!TARGET_AM33 && (MODE == QImode || MODE == HImode) ? DATA_REGS : CLASS)
435
 
436
#define SECONDARY_RELOAD_CLASS(CLASS,MODE,IN) \
437
  mn10300_secondary_reload_class(CLASS,MODE,IN)
438
 
439
/* Return the maximum number of consecutive registers
440
   needed to represent mode MODE in a register of class CLASS.  */
441
 
442
#define CLASS_MAX_NREGS(CLASS, MODE)    \
443
  ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
444
 
445
/* A class that contains registers which the compiler must always
446
   access in a mode that is the same size as the mode in which it
447
   loaded the register.  */
448
#define CLASS_CANNOT_CHANGE_SIZE FP_REGS
449
 
450
/* Return 1 if VALUE is in the range specified.  */
451
 
452
#define INT_8_BITS(VALUE) ((unsigned) (VALUE) + 0x80 < 0x100)
453
#define INT_16_BITS(VALUE) ((unsigned) (VALUE) + 0x8000 < 0x10000)
454
 
455
 
456
/* Stack layout; function entry, exit and calling.  */
457
 
458
/* Define this if pushing a word on the stack
459
   makes the stack pointer a smaller address.  */
460
 
461
#define STACK_GROWS_DOWNWARD
462
 
463
/* Define this to nonzero if the nominal address of the stack frame
464
   is at the high-address end of the local variables;
465
   that is, each additional local variable allocated
466
   goes at a more negative offset in the frame.  */
467
 
468
#define FRAME_GROWS_DOWNWARD 1
469
 
470
/* Offset within stack frame to start allocating local variables at.
471
   If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
472
   first local allocated.  Otherwise, it is the offset to the BEGINNING
473
   of the first local allocated.  */
474
 
475
#define STARTING_FRAME_OFFSET 0
476
 
477
/* Offset of first parameter from the argument pointer register value.  */
478
/* Is equal to the size of the saved fp + pc, even if an fp isn't
479
   saved since the value is used before we know.  */
480
 
481
#define FIRST_PARM_OFFSET(FNDECL) 4
482
 
483
#define ELIMINABLE_REGS                         \
484
{{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},   \
485
 { ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM},   \
486
 { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}}
487
 
488
#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
489
  OFFSET = initial_offset (FROM, TO)
490
 
491
/* We can debug without frame pointers on the mn10300, so eliminate
492
   them whenever possible.  */
493
#define CAN_DEBUG_WITHOUT_FP
494
 
495
/* Value is the number of bytes of arguments automatically
496
   popped when returning from a subroutine call.
497
   FUNDECL is the declaration node of the function (as a tree),
498
   FUNTYPE is the data type of the function (as a tree),
499
   or for a library call it is an identifier node for the subroutine name.
500
   SIZE is the number of bytes of arguments passed on the stack.  */
501
 
502
#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
503
 
504
/* We use d0/d1 for passing parameters, so allocate 8 bytes of space
505
   for a register flushback area.  */
506
#define REG_PARM_STACK_SPACE(DECL) 8
507
#define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1
508
#define ACCUMULATE_OUTGOING_ARGS 1
509
 
510
/* So we can allocate space for return pointers once for the function
511
   instead of around every call.  */
512
#define STACK_POINTER_OFFSET 4
513
 
514
/* 1 if N is a possible register number for function argument passing.
515
   On the MN10300, d0 and d1 are used in this way.  */
516
 
517
#define FUNCTION_ARG_REGNO_P(N) ((N) <= 1)
518
 
519
 
520
/* Define a data type for recording info about an argument list
521
   during the scan of that argument list.  This data type should
522
   hold all necessary information about the function itself
523
   and about the args processed so far, enough to enable macros
524
   such as FUNCTION_ARG to determine where the next arg should go.
525
 
526
   On the MN10300, this is a single integer, which is a number of bytes
527
   of arguments scanned so far.  */
528
 
529
#define CUMULATIVE_ARGS struct cum_arg
530
struct cum_arg {int nbytes; };
531
 
532
/* Initialize a variable CUM of type CUMULATIVE_ARGS
533
   for a call to a function whose data type is FNTYPE.
534
   For a library call, FNTYPE is 0.
535
 
536
   On the MN10300, the offset starts at 0.  */
537
 
538
#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
539
 ((CUM).nbytes = 0)
540
 
541
/* Update the data in CUM to advance over an argument
542
   of mode MODE and data type TYPE.
543
   (TYPE is null for libcalls where that information may not be available.)  */
544
 
545
#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)    \
546
 ((CUM).nbytes += ((MODE) != BLKmode                    \
547
                   ? (GET_MODE_SIZE (MODE) + 3) & ~3    \
548
                   : (int_size_in_bytes (TYPE) + 3) & ~3))
549
 
550
/* Define where to put the arguments to a function.
551
   Value is zero to push the argument on the stack,
552
   or a hard register in which to store the argument.
553
 
554
   MODE is the argument's machine mode.
555
   TYPE is the data type of the argument (as a tree).
556
    This is null for libcalls where that information may
557
    not be available.
558
   CUM is a variable of type CUMULATIVE_ARGS which gives info about
559
    the preceding args and about the function being called.
560
   NAMED is nonzero if this argument is a named parameter
561
    (otherwise it is an extra parameter matching an ellipsis).  */
562
 
563
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
564
  function_arg (&CUM, MODE, TYPE, NAMED)
565
 
566
#define FUNCTION_VALUE_REGNO_P(N)  mn10300_function_value_regno_p (N)
567
 
568
#define DEFAULT_PCC_STRUCT_RETURN 0
569
 
570
/* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
571
   the stack pointer does not matter.  The value is tested only in
572
   functions that have frame pointers.
573
   No definition is equivalent to always zero.  */
574
 
575
#define EXIT_IGNORE_STACK 1
576
 
577
/* Output assembler code to FILE to increment profiler label # LABELNO
578
   for profiling a function entry.  */
579
 
580
#define FUNCTION_PROFILER(FILE, LABELNO) ;
581
 
582
/* Length in units of the trampoline for entering a nested function.  */
583
 
584
#define TRAMPOLINE_SIZE 0x1b
585
 
586
#define TRAMPOLINE_ALIGNMENT 32
587
 
588
/* A C expression whose value is RTL representing the value of the return
589
   address for the frame COUNT steps up from the current frame.
590
 
591
   On the mn10300, the return address is not at a constant location
592
   due to the frame layout.  Luckily, it is at a constant offset from
593
   the argument pointer, so we define RETURN_ADDR_RTX to return a
594
   MEM using arg_pointer_rtx.  Reload will replace arg_pointer_rtx
595
   with a reference to the stack/frame pointer + an appropriate offset.  */
596
 
597
#define RETURN_ADDR_RTX(COUNT, FRAME)   \
598
  ((COUNT == 0)                         \
599
   ? gen_rtx_MEM (Pmode, arg_pointer_rtx) \
600
   : (rtx) 0)
601
 
602
/* Maximum number of registers that can appear in a valid memory address.  */
603
 
604
#define MAX_REGS_PER_ADDRESS 2
605
 
606
 
607
#define HAVE_POST_INCREMENT (TARGET_AM33)
608
 
609
/* Accept either REG or SUBREG where a register is valid.  */
610
 
611
#define RTX_OK_FOR_BASE_P(X, strict)                            \
612
  ((REG_P (X) && REGNO_STRICT_OK_FOR_BASE_P (REGNO (X),         \
613
                                             (strict)))         \
614
   || (GET_CODE (X) == SUBREG && REG_P (SUBREG_REG (X))         \
615
       && REGNO_STRICT_OK_FOR_BASE_P (REGNO (SUBREG_REG (X)),   \
616
                                      (strict))))
617
 
618
 
619
 
620
/* Nonzero if the constant value X is a legitimate general operand.
621
   It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
622
 
623
#define LEGITIMATE_CONSTANT_P(X) 1
624
 
625
/* Zero if this needs fixing up to become PIC.  */
626
 
627
#define LEGITIMATE_PIC_OPERAND_P(X) (legitimate_pic_operand_p (X))
628
 
629
/* Register to hold the addressing base for
630
   position independent code access to data items.  */
631
#define PIC_OFFSET_TABLE_REGNUM PIC_REG
632
 
633
/* The name of the pseudo-symbol representing the Global Offset Table.  */
634
#define GOT_SYMBOL_NAME "*_GLOBAL_OFFSET_TABLE_"
635
 
636
#define SYMBOLIC_CONST_P(X)     \
637
((GET_CODE (X) == SYMBOL_REF || GET_CODE (X) == LABEL_REF)      \
638
  && ! LEGITIMATE_PIC_OPERAND_P (X))
639
 
640
/* Non-global SYMBOL_REFs have SYMBOL_REF_FLAG enabled.  */
641
#define MN10300_GLOBAL_P(X) (! SYMBOL_REF_FLAG (X))
642
 
643
/* Recognize machine-specific patterns that may appear within
644
   constants.  Used for PIC-specific UNSPECs.  */
645
#define OUTPUT_ADDR_CONST_EXTRA(STREAM, X, FAIL) \
646
  do                                                                    \
647
    if (GET_CODE (X) == UNSPEC)                                         \
648
      {                                                                 \
649
        switch (XINT ((X), 1))                                          \
650
          {                                                             \
651
          case UNSPEC_INT_LABEL:                                        \
652
            asm_fprintf ((STREAM), ".%LLIL" HOST_WIDE_INT_PRINT_DEC,    \
653
                         INTVAL (XVECEXP ((X), 0, 0)));                   \
654
            break;                                                      \
655
          case UNSPEC_PIC:                                              \
656
            /* GLOBAL_OFFSET_TABLE or local symbols, no suffix.  */     \
657
            output_addr_const ((STREAM), XVECEXP ((X), 0, 0));            \
658
            break;                                                      \
659
          case UNSPEC_GOT:                                              \
660
            output_addr_const ((STREAM), XVECEXP ((X), 0, 0));            \
661
            fputs ("@GOT", (STREAM));                                   \
662
            break;                                                      \
663
          case UNSPEC_GOTOFF:                                           \
664
            output_addr_const ((STREAM), XVECEXP ((X), 0, 0));            \
665
            fputs ("@GOTOFF", (STREAM));                                \
666
            break;                                                      \
667
          case UNSPEC_PLT:                                              \
668
            output_addr_const ((STREAM), XVECEXP ((X), 0, 0));            \
669
            fputs ("@PLT", (STREAM));                                   \
670
            break;                                                      \
671
          case UNSPEC_GOTSYM_OFF:                                       \
672
            assemble_name (STREAM, GOT_SYMBOL_NAME);                    \
673
            fputs ("-(", STREAM);                                       \
674
            output_addr_const (STREAM, XVECEXP (X, 0, 0));                \
675
            fputs ("-.)", STREAM);                                      \
676
            break;                                                      \
677
          default:                                                      \
678
            goto FAIL;                                                  \
679
          }                                                             \
680
        break;                                                          \
681
      }                                                                 \
682
    else                                                                \
683
      goto FAIL;                                                        \
684
  while (0)
685
 
686
/* Tell final.c how to eliminate redundant test instructions.  */
687
 
688
/* Here we define machine-dependent flags and fields in cc_status
689
   (see `conditions.h').  No extra ones are needed for the VAX.  */
690
 
691
/* Store in cc_status the expressions
692
   that the condition codes will describe
693
   after execution of an instruction whose pattern is EXP.
694
   Do not alter them if the instruction would not alter the cc's.  */
695
 
696
#define CC_OVERFLOW_UNUSABLE 0x200
697
#define CC_NO_CARRY CC_NO_OVERFLOW
698
#define NOTICE_UPDATE_CC(EXP, INSN) notice_update_cc(EXP, INSN)
699
 
700
#define REGISTER_MOVE_COST(MODE, CLASS1, CLASS2) \
701
  ((CLASS1 == CLASS2 && (CLASS1 == ADDRESS_REGS || CLASS1 == DATA_REGS)) ? 2 :\
702
   ((CLASS1 == ADDRESS_REGS || CLASS1 == DATA_REGS) && \
703
    (CLASS2 == ADDRESS_REGS || CLASS2 == DATA_REGS)) ? 4 : \
704
   (CLASS1 == SP_REGS && CLASS2 == ADDRESS_REGS) ? 2 : \
705
   (CLASS1 == ADDRESS_REGS && CLASS2 == SP_REGS) ? 4 : \
706
   ! TARGET_AM33 ? 6 : \
707
   (CLASS1 == SP_REGS || CLASS2 == SP_REGS) ? 6 : \
708
   (CLASS1 == CLASS2 && CLASS1 == EXTENDED_REGS) ? 6 : \
709
   (CLASS1 == FP_REGS || CLASS2 == FP_REGS) ? 6 : \
710
   (CLASS1 == EXTENDED_REGS || CLASS2 == EXTENDED_REGS) ? 4 : \
711
   4)
712
 
713
/* Nonzero if access to memory by bytes or half words is no faster
714
   than accessing full words.  */
715
#define SLOW_BYTE_ACCESS 1
716
 
717
#define NO_FUNCTION_CSE
718
 
719
/* According expr.c, a value of around 6 should minimize code size, and
720
   for the MN10300 series, that's our primary concern.  */
721
#define MOVE_RATIO(speed) 6
722
 
723
#define TEXT_SECTION_ASM_OP "\t.section .text"
724
#define DATA_SECTION_ASM_OP "\t.section .data"
725
#define BSS_SECTION_ASM_OP "\t.section .bss"
726
 
727
#define ASM_COMMENT_START "#"
728
 
729
/* Output to assembler file text saying following lines
730
   may contain character constants, extra white space, comments, etc.  */
731
 
732
#define ASM_APP_ON "#APP\n"
733
 
734
/* Output to assembler file text saying following lines
735
   no longer contain unusual constructs.  */
736
 
737
#define ASM_APP_OFF "#NO_APP\n"
738
 
739
#undef  USER_LABEL_PREFIX
740
#define USER_LABEL_PREFIX "_"
741
 
742
/* This says how to output the assembler to define a global
743
   uninitialized but not common symbol.
744
   Try to use asm_output_bss to implement this macro.  */
745
 
746
#define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN) \
747
  asm_output_aligned_bss ((FILE), (DECL), (NAME), (SIZE), (ALIGN))
748
 
749
/* Globalizing directive for a label.  */
750
#define GLOBAL_ASM_OP "\t.global "
751
 
752
/* This is how to output a reference to a user-level label named NAME.
753
   `assemble_name' uses this.  */
754
 
755
#undef ASM_OUTPUT_LABELREF
756
#define ASM_OUTPUT_LABELREF(FILE, NAME) \
757
  asm_fprintf (FILE, "%U%s", (*targetm.strip_name_encoding) (NAME))
758
 
759
#define ASM_PN_FORMAT "%s___%lu"
760
 
761
/* This is how we tell the assembler that two symbols have the same value.  */
762
 
763
#define ASM_OUTPUT_DEF(FILE,NAME1,NAME2) \
764
  do { assemble_name(FILE, NAME1);       \
765
       fputs(" = ", FILE);               \
766
       assemble_name(FILE, NAME2);       \
767
       fputc('\n', FILE); } while (0)
768
 
769
 
770
/* How to refer to registers in assembler output.
771
   This sequence is indexed by compiler's hard-register-number (see above).  */
772
 
773
#define REGISTER_NAMES \
774
{ "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3", "ap", "sp", \
775
  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7" \
776
, "fs0", "fs1", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7" \
777
, "fs8", "fs9", "fs10", "fs11", "fs12", "fs13", "fs14", "fs15" \
778
, "fs16", "fs17", "fs18", "fs19", "fs20", "fs21", "fs22", "fs23" \
779
, "fs24", "fs25", "fs26", "fs27", "fs28", "fs29", "fs30", "fs31" \
780
}
781
 
782
#define ADDITIONAL_REGISTER_NAMES \
783
{ {"r8",  4}, {"r9",  5}, {"r10", 6}, {"r11", 7}, \
784
  {"r12", 0}, {"r13", 1}, {"r14", 2}, {"r15", 3}, \
785
  {"e0", 10}, {"e1", 11}, {"e2", 12}, {"e3", 13}, \
786
  {"e4", 14}, {"e5", 15}, {"e6", 16}, {"e7", 17} \
787
, {"fd0", 18}, {"fd2", 20}, {"fd4", 22}, {"fd6", 24} \
788
, {"fd8", 26}, {"fd10", 28}, {"fd12", 30}, {"fd14", 32} \
789
, {"fd16", 34}, {"fd18", 36}, {"fd20", 38}, {"fd22", 40} \
790
, {"fd24", 42}, {"fd26", 44}, {"fd28", 46}, {"fd30", 48} \
791
}
792
 
793
/* Print an instruction operand X on file FILE.
794
   look in mn10300.c for details */
795
 
796
#define PRINT_OPERAND(FILE, X, CODE)  print_operand(FILE,X,CODE)
797
 
798
/* Print a memory operand whose address is X, on file FILE.
799
   This uses a function in output-vax.c.  */
800
 
801
#define PRINT_OPERAND_ADDRESS(FILE, ADDR) print_operand_address (FILE, ADDR)
802
 
803
#define ASM_OUTPUT_REG_PUSH(FILE,REGNO)
804
#define ASM_OUTPUT_REG_POP(FILE,REGNO)
805
 
806
/* This is how to output an element of a case-vector that is absolute.  */
807
 
808
#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
809
  fprintf (FILE, "\t%s .L%d\n", ".long", VALUE)
810
 
811
/* This is how to output an element of a case-vector that is relative.  */
812
 
813
#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
814
  fprintf (FILE, "\t%s .L%d-.L%d\n", ".long", VALUE, REL)
815
 
816
#define ASM_OUTPUT_ALIGN(FILE,LOG)      \
817
  if ((LOG) != 0)                        \
818
    fprintf (FILE, "\t.align %d\n", (LOG))
819
 
820
/* We don't have to worry about dbx compatibility for the mn10300.  */
821
#define DEFAULT_GDB_EXTENSIONS 1
822
 
823
/* Use dwarf2 debugging info by default.  */
824
#undef PREFERRED_DEBUGGING_TYPE
825
#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
826
 
827
#define DWARF2_ASM_LINE_DEBUG_INFO 1
828
 
829
/* GDB always assumes the current function's frame begins at the value
830
   of the stack pointer upon entry to the current function.  Accessing
831
   local variables and parameters passed on the stack is done using the
832
   base of the frame + an offset provided by GCC.
833
 
834
   For functions which have frame pointers this method works fine;
835
   the (frame pointer) == (stack pointer at function entry) and GCC provides
836
   an offset relative to the frame pointer.
837
 
838
   This loses for functions without a frame pointer; GCC provides an offset
839
   which is relative to the stack pointer after adjusting for the function's
840
   frame size.  GDB would prefer the offset to be relative to the value of
841
   the stack pointer at the function's entry.  Yuk!  */
842
#define DEBUGGER_AUTO_OFFSET(X) \
843
  ((GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) \
844
    + (frame_pointer_needed \
845
       ? 0 : -initial_offset (FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM)))
846
 
847
#define DEBUGGER_ARG_OFFSET(OFFSET, X) \
848
  ((GET_CODE (X) == PLUS ? OFFSET : 0) \
849
    + (frame_pointer_needed \
850
       ? 0 : -initial_offset (ARG_POINTER_REGNUM, STACK_POINTER_REGNUM)))
851
 
852
/* Specify the machine mode that this machine uses
853
   for the index in the tablejump instruction.  */
854
#define CASE_VECTOR_MODE Pmode
855
 
856
/* Define if operations between registers always perform the operation
857
   on the full register even if a narrower mode is specified.  */
858
#define WORD_REGISTER_OPERATIONS
859
 
860
#define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
861
 
862
/* This flag, if defined, says the same insns that convert to a signed fixnum
863
   also convert validly to an unsigned one.  */
864
#define FIXUNS_TRUNC_LIKE_FIX_TRUNC
865
 
866
/* Max number of bytes we can move from memory to memory
867
   in one reasonably fast instruction.  */
868
#define MOVE_MAX        4
869
 
870
/* Define if shifts truncate the shift count
871
   which implies one can omit a sign-extension or zero-extension
872
   of a shift count.  */
873
#define SHIFT_COUNT_TRUNCATED 1
874
 
875
/* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
876
   is done just by pretending it is already truncated.  */
877
#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
878
 
879
/* Specify the machine mode that pointers have.
880
   After generation of rtl, the compiler makes no further distinction
881
   between pointers and any other objects of this machine mode.  */
882
#define Pmode SImode
883
 
884
/* A function address in a call instruction
885
   is a byte address (for indexing purposes)
886
   so give the MEM rtx a byte's mode.  */
887
#define FUNCTION_MODE QImode
888
 
889
/* The assembler op to get a word.  */
890
 
891
#define FILE_ASM_OP "\t.file\n"
892
 
893
typedef struct mn10300_cc_status_mdep
894
  {
895
    int fpCC;
896
  }
897
cc_status_mdep;
898
 
899
#define CC_STATUS_MDEP cc_status_mdep
900
 
901
#define CC_STATUS_MDEP_INIT (cc_status.mdep.fpCC = 0)

powered by: WebSVN 2.1.0

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