OSDN Git Service

gcc/
[pf3gnuchains/gcc-fork.git] / gcc / config / lm32 / lm32.h
1 /* Definitions of target machine for GNU compiler, Lattice Mico32 architecture.
2    Contributed by Jon Beniston <jon@beniston.com>
3
4    Copyright (C) 2009, 2010 Free Software Foundation, Inc.
5
6    This file is part of GCC.
7
8    GCC is free software; you can redistribute it and/or modify it
9    under the terms of the GNU General Public License as published
10    by the Free Software Foundation; either version 3, or (at your
11    option) any later version.
12
13    GCC is distributed in the hope that it will be useful, but WITHOUT
14    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
16    License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with GCC; see the file COPYING3.  If not see
20    <http://www.gnu.org/licenses/>.  */
21
22 /*-------------------------------*/
23 /* Run-time Target Specification */
24 /*-------------------------------*/
25
26 /* Print subsidiary information on the compiler version in use.  */
27 #ifndef TARGET_VERSION
28 #define TARGET_VERSION fprintf (stderr, " (LatticeMico32)")
29 #endif
30
31 /* Target CPU builtins.  */
32 #define TARGET_CPU_CPP_BUILTINS()                       \
33   do                                                    \
34     {                                                   \
35       builtin_define ("__lm32__");                      \
36       builtin_assert ("cpu=lm32");                      \
37       builtin_assert ("machine=lm32");                  \
38       if (TARGET_MULTIPLY_ENABLED)                      \
39         builtin_define ("__multiply_enabled__");        \
40       if (TARGET_DIVIDE_ENABLED)                        \
41         builtin_define ("__divide_enabled__");          \
42       if (TARGET_BARREL_SHIFT_ENABLED)                  \
43         builtin_define ("__barrel_shift_enabled__");    \
44       if (TARGET_SIGN_EXTEND_ENABLED)                   \
45         builtin_define ("__sign_extend_enabled__");     \
46       if (TARGET_USER_ENABLED)                          \
47         builtin_define ("__user_enabled__");            \
48     }                                                   \
49   while (0)
50
51 #undef  ASM_SPEC
52 #define ASM_SPEC "\
53 %{mmultiply-enabled} \
54 %{mdivide-enabled} \
55 %{mbarrel-shift-enabled} \
56 %{msign-extend-enabled} \
57 %{muser-extend-enabled} \
58 %{v} \
59 "
60
61 /* Let link script define all link options. 
62    Default to using simulator link script.  */
63
64 #undef  STARTFILE_SPEC
65 #define STARTFILE_SPEC ""
66 #undef  ENDFILE_SPEC
67 #define ENDFILE_SPEC ""
68 #undef  LIB_SPEC
69 #define LIB_SPEC "%{!T*:-T sim.ld}"
70
71 /* Add -G xx support.  */
72
73 #undef  SWITCH_TAKES_ARG
74 #define SWITCH_TAKES_ARG(CHAR) \
75 (DEFAULT_SWITCH_TAKES_ARG (CHAR) || (CHAR) == 'G')
76
77 #undef  CC1_SPEC
78 #define CC1_SPEC "%{G*}"
79
80 /*---------------------------------*/
81 /* Target machine storage layout.  */
82 /*---------------------------------*/
83
84 #define BITS_BIG_ENDIAN 0
85 #define BYTES_BIG_ENDIAN 1
86 #define WORDS_BIG_ENDIAN 1
87
88 #define BITS_PER_UNIT 8
89 #define BITS_PER_WORD 32
90 #define UNITS_PER_WORD 4
91
92 #define POINTER_SIZE 32
93
94 #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)               \
95 do {                                                    \
96   if (GET_MODE_CLASS (MODE) == MODE_INT                 \
97       && GET_MODE_SIZE (MODE) < UNITS_PER_WORD)         \
98     (MODE) = word_mode;                                 \
99 } while (0)
100
101 #define PARM_BOUNDARY 32
102
103 #define STACK_BOUNDARY 32
104
105 #define BIGGEST_ALIGNMENT 64
106
107 #define FUNCTION_BOUNDARY  32
108
109 #define EMPTY_FIELD_BOUNDARY 32
110
111 #define STRICT_ALIGNMENT 1
112
113 #define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT
114
115 /* Make strings word-aligned so strcpy from constants will be faster.  */
116 #define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
117   (TREE_CODE (EXP) == STRING_CST        \
118    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
119
120 /* Make arrays and structures word-aligned to allow faster copying etc.  */
121 #define DATA_ALIGNMENT(TYPE, ALIGN)                                     \
122   ((((ALIGN) < BITS_PER_WORD)                                           \
123     && (TREE_CODE (TYPE) == ARRAY_TYPE                                  \
124         || TREE_CODE (TYPE) == UNION_TYPE                               \
125         || TREE_CODE (TYPE) == RECORD_TYPE)) ? BITS_PER_WORD : (ALIGN))
126
127 /* We need this for the same reason as DATA_ALIGNMENT, namely to cause
128    character arrays to be word-aligned so that `strcpy' calls that copy
129    constants to character arrays can be done inline, and 'strcmp' can be
130    optimised to use word loads.  */
131 #define LOCAL_ALIGNMENT(TYPE, ALIGN) \
132   DATA_ALIGNMENT (TYPE, ALIGN)
133
134 /*----------------------------------------*/
135 /* Layout of source language data types.  */
136 /*----------------------------------------*/
137
138 #define INT_TYPE_SIZE               32
139 #define SHORT_TYPE_SIZE             16
140 #define LONG_TYPE_SIZE              32
141 #define LONG_LONG_TYPE_SIZE         64
142
143 #define FLOAT_TYPE_SIZE             32
144 #define DOUBLE_TYPE_SIZE            64
145 #define LONG_DOUBLE_TYPE_SIZE       64
146
147 #define DEFAULT_SIGNED_CHAR         0
148
149 #define SIZE_TYPE "unsigned int"
150
151 #define PTRDIFF_TYPE "int"
152
153 /*---------------------------*/
154 /* Standard register usage.  */
155 /*---------------------------*/
156
157 #define FIRST_PSEUDO_REGISTER  32
158
159 #define RV_REGNUM   1
160 #define GP_REGNUM   26
161 #define FP_REGNUM   27
162 #define SP_REGNUM   28
163 #define RA_REGNUM   29
164
165 #define G_REG_P(X)      ((X)<32)
166
167 #define FIXED_REGISTERS   \
168 { 1, 0, 0, 0, 0, 0, 0, 0, \
169   0, 0, 0, 0, 0, 0, 0, 0, \
170   0, 0, 0, 0, 0, 0, 0, 0, \
171   0, 0, 1, 0, 1, 0, 1, 1}
172
173 #define CALL_USED_REGISTERS \
174 { 1, 1, 1, 1, 1, 1, 1, 1,   \
175   1, 1, 1, 0, 0, 0, 0, 0,   \
176   0, 0, 0, 0, 0, 0, 0, 0,   \
177   0, 0, 1, 0, 1, 0, 1, 1}
178
179 #define HARD_REGNO_NREGS(REGNO, MODE)                                   \
180     ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
181
182 #define HARD_REGNO_MODE_OK(REGNO, MODE) G_REG_P(REGNO)
183
184 #define MODES_TIEABLE_P(MODE1, MODE2)           \
185 (      GET_MODE_CLASS (MODE1) == MODE_INT               \
186     && GET_MODE_CLASS (MODE2) == MODE_INT               \
187     && GET_MODE_SIZE (MODE1) <= UNITS_PER_WORD  \
188     && GET_MODE_SIZE (MODE2) <= UNITS_PER_WORD)
189
190 #define AVOID_CCMODE_COPIES
191
192 /*----------------------------------*/
193 /* Register classes and constants.  */
194 /*----------------------------------*/
195
196 enum reg_class
197 {
198   NO_REGS,                                      
199   GENERAL_REGS,
200   ALL_REGS,
201   LIM_REG_CLASSES
202 };
203
204 #define N_REG_CLASSES (int) LIM_REG_CLASSES
205
206 #define REG_CLASS_NAMES { "NO_REGS", "GENERAL_REGS", "ALL_REGS" }
207
208 #define REG_CLASS_CONTENTS      \
209 { {0x00000000},                 \
210   {0xffffffff},                 \
211   {0xffffffff}                  \
212 }
213
214 #define REGNO_REG_CLASS(REGNO) \
215     (G_REG_P(REGNO) ? GENERAL_REGS : NO_REGS)
216
217 #define CLASS_MAX_NREGS(CLASS, MODE) \
218     ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
219
220 #define INDEX_REG_CLASS NO_REGS
221
222 #define BASE_REG_CLASS GENERAL_REGS
223
224 #define REGNO_OK_FOR_BASE_P(REGNO) \
225     (G_REG_P (REGNO) || G_REG_P ((unsigned) reg_renumber[REGNO]))
226
227 #define REGNO_OK_FOR_INDEX_P(REGNO) 0
228
229 /*----------------------------------------*/
230 /* Stack Layout and Calling Conventions.  */
231 /*----------------------------------------*/
232
233 #define STACK_GROWS_DOWNWARD 1
234
235 #define FRAME_GROWS_DOWNWARD 1
236
237 #define STACK_POINTER_OFFSET (UNITS_PER_WORD)
238
239 #define STARTING_FRAME_OFFSET (UNITS_PER_WORD)
240
241 #define FIRST_PARM_OFFSET(FNDECL) (UNITS_PER_WORD)
242
243 #define STACK_POINTER_REGNUM SP_REGNUM
244
245 #define FRAME_POINTER_REGNUM FP_REGNUM
246
247 #define ARG_POINTER_REGNUM FRAME_POINTER_REGNUM
248
249 #define RETURN_ADDR_RTX(count, frame)                                   \
250   lm32_return_addr_rtx (count, frame)
251
252 /* FIXME - This is not yet supported.  */
253 #define STATIC_CHAIN_REGNUM 9
254
255 #define ELIMINABLE_REGS \
256 {{ FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM },                        \
257  { ARG_POINTER_REGNUM, STACK_POINTER_REGNUM },                          \
258 }
259
260 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)                    \
261   (OFFSET) = lm32_compute_initial_elimination_offset (FROM, TO)
262
263 /*-----------------------------*/
264 /* Function argument passing.  */
265 /*-----------------------------*/
266
267 #define ACCUMULATE_OUTGOING_ARGS 1
268
269 /*--------------------------------*/
270 /* Passing Arguments in Registers */
271 /*--------------------------------*/
272
273 /* The first argument register.  */
274 #define LM32_FIRST_ARG_REG 1
275
276 /* The number of (integer) argument register available.  */
277 #define LM32_NUM_ARG_REGS 8
278
279 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED)                            \
280   lm32_function_arg ((CUM), (MODE), (TYPE), (NAMED))
281
282 #define CUMULATIVE_ARGS int
283
284 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT,N_NAMED_ARGS)  \
285   (CUM) = 0
286
287 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)                    \
288   (CUM) += LM32_NUM_REGS2 (MODE, TYPE)
289
290 #define FUNCTION_ARG_REGNO_P(r)                                         \
291   (((r) >= LM32_FIRST_ARG_REG) && ((r) <= LM32_NUM_ARG_REGS))
292
293 /*--------------------*/
294 /* Function results.  */
295 /*--------------------*/
296
297 #define FUNCTION_VALUE(VALTYPE, FUNC)                                   \
298    gen_rtx_REG ((INTEGRAL_TYPE_P (VALTYPE)                              \
299                  && TYPE_PRECISION (VALTYPE) < BITS_PER_WORD)           \
300                     ? word_mode                                         \
301                     : TYPE_MODE (VALTYPE),                              \
302                     RV_REGNUM)
303
304 #define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, RV_REGNUM)
305
306 #define FUNCTION_VALUE_REGNO_P(N) ((N) == RV_REGNUM)
307
308 #define RETURN_IN_MEMORY(TYPE) lm32_return_in_memory (TYPE)
309
310 #define DEFAULT_PCC_STRUCT_RETURN 0
311
312 /* Convert from bytes to ints.  */
313 #define LM32_NUM_INTS(X) (((X) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
314
315 /* The number of (integer) registers required to hold a quantity of
316    type MODE.  */
317 #define LM32_NUM_REGS(MODE) LM32_NUM_INTS (GET_MODE_SIZE (MODE))
318
319 /* The number of (integer) registers required to hold a quantity of
320    TYPE MODE.  */
321 #define LM32_NUM_REGS2(MODE, TYPE)                       \
322   LM32_NUM_INTS ((MODE) == BLKmode ?                     \
323   int_size_in_bytes (TYPE) : GET_MODE_SIZE (MODE))
324
325 #define STRUCT_VALUE 0
326
327 /*---------------------------*/
328 /* Function entry and exit.  */
329 /*---------------------------*/
330
331 /*-------------*/
332 /* Profiling.  */
333 /*-------------*/
334
335 #define FUNCTION_PROFILER(FILE, LABELNO)
336
337 /*---------------*/
338 /* Trampolines.  */
339 /*---------------*/
340
341 #define TRAMPOLINE_SIZE         0
342
343 /*---------------------*/
344 /*  Addressing Modes.  */
345 /*---------------------*/
346
347 #define CONSTANT_ADDRESS_P(X)                                           \
348   ((GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF             \
349     || GET_CODE (X) == CONST_INT || GET_CODE (X) == HIGH                \
350     || (GET_CODE (X) == CONST)))
351
352 #define MAX_REGS_PER_ADDRESS 1
353
354 #define STRICT_REG_OK_FOR_BASE_P(X)                                     \
355   (REGNO_OK_FOR_BASE_P (REGNO (X)))
356 #define NONSTRICT_REG_OK_FOR_BASE_P(X)                                  \
357   (G_REG_P (REGNO (X)) || !HARD_REGISTER_NUM_P (REGNO (X)))
358
359 #ifdef REG_OK_STRICT
360 #define REG_OK_FOR_BASE_P(X) STRICT_REG_OK_FOR_BASE_P(X)
361 #else
362 #define REG_OK_FOR_BASE_P(X) NONSTRICT_REG_OK_FOR_BASE_P(X)
363 #endif
364
365 #define LEGITIMATE_CONSTANT_P(X) lm32_legitimate_constant_p
366
367 /*-------------------------*/
368 /* Condition Code Status.  */
369 /*-------------------------*/
370
371 #define REVERSIBLE_CC_MODE(MODE) 1
372
373 /*---------*/
374 /* Costs.  */
375 /*---------*/
376
377 #define SLOW_BYTE_ACCESS 1
378
379 #define NO_FUNCTION_CSE
380
381 #define BRANCH_COST(speed_p, predictable_p) 4
382
383 #define MOVE_RATIO(speed) (speed ? 24 : 3)
384
385 /*------------*/
386 /* Sections.  */
387 /*------------*/
388
389 #define TEXT_SECTION_ASM_OP             "\t.section\t.text"
390 #define DATA_SECTION_ASM_OP             "\t.section\t.data"
391 #define SDATA_SECTION_ASM_OP            "\t.section\t.sdata,\"aw\""
392 #define BSS_SECTION_ASM_OP              "\t.section\t.bss"
393 #define SBSS_SECTION_ASM_OP             "\t.section\t.sbss,\"aw\""
394
395 /*-------*/
396 /* PIC.  */
397 /*-------*/
398
399 #define PIC_OFFSET_TABLE_REGNUM (flag_pic ? GP_REGNUM : INVALID_REGNUM)
400
401 #define JUMP_TABLES_IN_TEXT_SECTION (flag_pic)
402
403 #define LEGITIMATE_PIC_OPERAND_P(X)                                    \
404         (!(nonpic_symbol_mentioned_p (X)))
405
406 /*-------------*/
407 /* Assembler.  */
408 /*-------------*/
409
410 #define ASM_COMMENT_START "#"
411
412 #define ASM_APP_ON "#APP\n"
413
414 #define ASM_APP_OFF "#NO_APP\n"
415
416 #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2)                              \
417  do {                                                                   \
418         fputc ( '\t', FILE);                                            \
419         assemble_name (FILE, LABEL1);                                   \
420         fputs ( " = ", FILE);                                           \
421         assemble_name (FILE, LABEL2);                                   \
422         fputc ( '\n', FILE);                                            \
423  } while (0)
424
425 /* Override default implementation in elfos.h to support -G.  */
426 #undef  ASM_OUTPUT_ALIGNED_LOCAL
427 #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN)               \
428 do {                                                                    \
429   if ((SIZE) <= (unsigned HOST_WIDE_INT) g_switch_value)                \
430     switch_to_section (sbss_section);                                   \
431   else                                                                  \
432     switch_to_section (bss_section);                                    \
433   ASM_OUTPUT_TYPE_DIRECTIVE (FILE, NAME, "object");                     \
434   if (!flag_inhibit_size_directive)                                     \
435     ASM_OUTPUT_SIZE_DIRECTIVE (FILE, NAME, SIZE);                       \
436   ASM_OUTPUT_ALIGN ((FILE), exact_log2((ALIGN) / BITS_PER_UNIT));       \
437   ASM_OUTPUT_LABEL(FILE, NAME);                                         \
438   ASM_OUTPUT_SKIP((FILE), (SIZE) ? (SIZE) : 1);                         \
439 } while (0)
440
441 /* Override default implementation in elfos.h to support -G.  */
442 #undef  ASM_OUTPUT_ALIGNED_COMMON
443 #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)              \
444 do                                                                      \
445 {                                                                       \
446   if ((SIZE) <= (unsigned HOST_WIDE_INT) g_switch_value)                \
447     {                                                                   \
448       switch_to_section (sbss_section);                                 \
449       (*targetm.asm_out.globalize_label) (FILE, NAME);                  \
450       ASM_OUTPUT_TYPE_DIRECTIVE (FILE, NAME, "object");                 \
451       if (!flag_inhibit_size_directive)                                 \
452         ASM_OUTPUT_SIZE_DIRECTIVE (FILE, NAME, SIZE);                   \
453       ASM_OUTPUT_ALIGN ((FILE), exact_log2((ALIGN) / BITS_PER_UNIT));   \
454       ASM_OUTPUT_LABEL(FILE, NAME);                                     \
455       ASM_OUTPUT_SKIP((FILE), (SIZE) ? (SIZE) : 1);                     \
456     }                                                                   \
457   else                                                                  \
458     {                                                                   \
459       switch_to_section (bss_section);                                  \
460       fprintf ((FILE), "%s", COMMON_ASM_OP);                            \
461       assemble_name ((FILE), (NAME));                                   \
462       fprintf ((FILE), ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n",          \
463                (SIZE), (ALIGN) / BITS_PER_UNIT);                        \
464     }                                                                   \
465 }                                                                       \
466 while (0)
467
468 #define ASM_OUTPUT_LABEL(FILE, NAME) \
469   do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0)
470
471 #define ASM_OUTPUT_LABELREF(FILE,NAME)  \
472   do {                                  \
473     const char *xname = (NAME);         \
474     if (xname[0] == '@')                \
475       xname += 1;                       \
476     if (xname[0] == '*')                \
477       xname += 1;                       \
478     fputs (xname, FILE);                \
479   } while (0)
480
481 #define ASM_OUTPUT_SYMBOL_REF(STREAM, SYMBOL)                           \
482   do {                                                                  \
483     assemble_name (STREAM, XSTR (SYMBOL, 0));                           \
484   } while (0)
485
486 #define GLOBAL_ASM_OP "\t.global\t"
487
488 #define REGISTER_NAMES                                          \
489 {                                                               \
490  "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",         \
491  "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",        \
492  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",        \
493  "r24", "r25",  "gp",  "fp",  "sp",  "ra",  "ea",  "ba"}
494
495 #define PRINT_OPERAND_PUNCT_VALID_P(CHAR) \
496   (((CHAR) == '&') || ((CHAR) == '@') || ((CHAR) == '*'))
497
498 #define PRINT_OPERAND(FILE, X, CODE)                            \
499   lm32_print_operand (FILE, X, CODE)
500
501 #define PRINT_OPERAND_ADDRESS(FILE, ADDR)                       \
502   lm32_print_operand_address (FILE, ADDR)
503
504 #ifndef LOCAL_LABEL_PREFIX
505 #define LOCAL_LABEL_PREFIX      "."
506 #endif
507
508 #define ASM_OUTPUT_ALIGN(FILE,LOG)                              \
509   do { if ((LOG) != 0) fprintf (FILE, "\t.align %d\n", (1 << (LOG))); } while (0)
510
511 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)                    \
512 do {                                                            \
513   char label[64];                                               \
514   ASM_GENERATE_INTERNAL_LABEL (label, "L", VALUE);              \
515   fprintf (FILE, "\n\t.word\t");                                \
516   assemble_name (FILE, label);                                  \
517   fprintf (FILE, "\n");                                         \
518 } while (0)
519
520 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL)        \
521 do {                                                            \
522   char label[64];                                               \
523   fprintf (FILE, "\t.word\t(");                                 \
524   ASM_GENERATE_INTERNAL_LABEL (label, "L", VALUE);              \
525   assemble_name (FILE, label);                                  \
526   fprintf (FILE, "-");                                          \
527   ASM_GENERATE_INTERNAL_LABEL (label, "L", REL);                \
528   assemble_name (FILE, label);                                  \
529   fprintf (FILE, ")\n");                                        \
530 } while (0)
531
532 /*-------------*/
533 /* Debugging.  */
534 /*-------------*/
535
536 #define DBX_REGISTER_NUMBER(REGNO) (REGNO)
537
538 #define DEFAULT_GDB_EXTENSIONS 1
539
540 /*--------*/
541 /* Misc.  */
542 /*--------*/
543
544 #define CASE_VECTOR_MODE Pmode
545
546 #define WORD_REGISTER_OPERATIONS
547
548 #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
549
550 #define SHORT_IMMEDIATES_SIGN_EXTEND
551
552 #define MOVE_MAX        UNITS_PER_WORD
553 #define MAX_MOVE_MAX    4
554
555 #define SHIFT_COUNT_TRUNCATED 1
556
557 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
558
559 #define Pmode SImode
560
561 #define FUNCTION_MODE SImode
562
563 #ifndef NO_IMPLICIT_EXTERN_C
564 #define NO_IMPLICIT_EXTERN_C
565 #endif
566
567 #define STORE_FLAG_VALUE 1