Mercurial > hg > CbC > CbC_gcc
comparison gcc/config/mn10300/mn10300.h @ 67:f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
author | nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Tue, 22 Mar 2011 17:18:12 +0900 |
parents | b7f97abdc517 |
children | 04ced10e8804 |
comparison
equal
deleted
inserted
replaced
65:65488c3d617d | 67:f6334be47118 |
---|---|
2 Matsushita MN10300 series | 2 Matsushita MN10300 series |
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, | 3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, |
4 2007, 2008, 2009, 2010 Free Software Foundation, Inc. | 4 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
5 Contributed by Jeff Law (law@cygnus.com). | 5 Contributed by Jeff Law (law@cygnus.com). |
6 | 6 |
7 This file is part of GCC. | 7 This file is part of GCC. |
8 | 8 |
9 GCC is free software; you can redistribute it and/or modify | 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 | 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) | 11 the Free Software Foundation; either version 3, or (at your option) |
12 any later version. | 12 any later version. |
13 | 13 |
14 GCC is distributed in the hope that it will be useful, | 14 GCC is distributed in the hope that it will be useful, |
15 but WITHOUT ANY WARRANTY; without even the implied warranty of | 15 but WITHOUT ANY WARRANTY; without even the implied warranty of |
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
17 GNU General Public License for more details. | 17 GNU General Public License for more details. |
18 | 18 |
19 You should have received a copy of the GNU General Public License | 19 You should have received a copy of the GNU General Public License |
20 along with GCC; see the file COPYING3. If not see | 20 along with GCC; see the file COPYING3. If not see |
21 <http://www.gnu.org/licenses/>. */ | 21 <http://www.gnu.org/licenses/>. */ |
22 | |
23 | 22 |
24 #undef ASM_SPEC | 23 #undef ASM_SPEC |
25 #undef LIB_SPEC | 24 #undef LIB_SPEC |
26 #undef ENDFILE_SPEC | 25 #undef ENDFILE_SPEC |
27 #undef LINK_SPEC | 26 #undef LINK_SPEC |
28 #define LINK_SPEC "%{mrelax:--relax}" | 27 #define LINK_SPEC "%{mrelax:--relax}" |
29 #undef STARTFILE_SPEC | 28 #undef STARTFILE_SPEC |
30 #define STARTFILE_SPEC "%{!mno-crt0:%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}}" | 29 #define STARTFILE_SPEC "%{!mno-crt0:%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}}" |
31 | 30 |
32 /* Names to predefine in the preprocessor for this target machine. */ | 31 /* Names to predefine in the preprocessor for this target machine. */ |
33 | 32 |
34 #define TARGET_CPU_CPP_BUILTINS() \ | 33 #define TARGET_CPU_CPP_BUILTINS() \ |
36 { \ | 35 { \ |
37 builtin_define ("__mn10300__"); \ | 36 builtin_define ("__mn10300__"); \ |
38 builtin_define ("__MN10300__"); \ | 37 builtin_define ("__MN10300__"); \ |
39 builtin_assert ("cpu=mn10300"); \ | 38 builtin_assert ("cpu=mn10300"); \ |
40 builtin_assert ("machine=mn10300"); \ | 39 builtin_assert ("machine=mn10300"); \ |
40 \ | |
41 if (TARGET_AM34) \ | |
42 { \ | |
43 builtin_define ("__AM33__=4"); \ | |
44 builtin_define ("__AM34__"); \ | |
45 } \ | |
46 else if (TARGET_AM33_2) \ | |
47 { \ | |
48 builtin_define ("__AM33__=2"); \ | |
49 builtin_define ("__AM33_2__"); \ | |
50 } \ | |
51 else if (TARGET_AM33) \ | |
52 builtin_define ("__AM33__=1"); \ | |
53 \ | |
54 builtin_define (TARGET_ALLOW_LIW ? \ | |
55 "__LIW__" : "__NO_LIW__");\ | |
56 \ | |
41 } \ | 57 } \ |
42 while (0) | 58 while (0) |
43 | 59 |
44 #define CPP_SPEC "%{mam33:-D__AM33__} %{mam33-2:-D__AM33__=2 -D__AM33_2__}" | 60 enum processor_type |
45 | 61 { |
46 extern GTY(()) int mn10300_unspec_int_label_counter; | |
47 | |
48 enum processor_type { | |
49 PROCESSOR_MN10300, | 62 PROCESSOR_MN10300, |
50 PROCESSOR_AM33, | 63 PROCESSOR_AM33, |
51 PROCESSOR_AM33_2 | 64 PROCESSOR_AM33_2, |
65 PROCESSOR_AM34 | |
52 }; | 66 }; |
53 | 67 |
54 extern enum processor_type mn10300_processor; | 68 extern enum processor_type mn10300_processor; |
69 extern enum processor_type mn10300_tune_cpu; | |
55 | 70 |
56 #define TARGET_AM33 (mn10300_processor >= PROCESSOR_AM33) | 71 #define TARGET_AM33 (mn10300_processor >= PROCESSOR_AM33) |
57 #define TARGET_AM33_2 (mn10300_processor == PROCESSOR_AM33_2) | 72 #define TARGET_AM33_2 (mn10300_processor >= PROCESSOR_AM33_2) |
73 #define TARGET_AM34 (mn10300_processor >= PROCESSOR_AM34) | |
58 | 74 |
59 #ifndef PROCESSOR_DEFAULT | 75 #ifndef PROCESSOR_DEFAULT |
60 #define PROCESSOR_DEFAULT PROCESSOR_MN10300 | 76 #define PROCESSOR_DEFAULT PROCESSOR_MN10300 |
61 #endif | 77 #endif |
62 | |
63 #define OVERRIDE_OPTIONS mn10300_override_options () | |
64 | 78 |
65 /* Print subsidiary information on the compiler version in use. */ | 79 /* Print subsidiary information on the compiler version in use. */ |
66 | 80 |
67 #define TARGET_VERSION fprintf (stderr, " (MN10300)"); | 81 #define TARGET_VERSION fprintf (stderr, " (MN10300)"); |
68 | 82 |
99 | 113 |
100 /* No data type wants to be aligned rounder than this. */ | 114 /* No data type wants to be aligned rounder than this. */ |
101 #define BIGGEST_ALIGNMENT 32 | 115 #define BIGGEST_ALIGNMENT 32 |
102 | 116 |
103 /* Alignment of field after `int : 0' in a structure. */ | 117 /* Alignment of field after `int : 0' in a structure. */ |
104 #define EMPTY_FIELD_BOUNDARY 32 | 118 #define EMPTY_FIELD_BOUNDARY 32 |
105 | 119 |
106 /* Define this if move instructions will actually fail to work | 120 /* Define this if move instructions will actually fail to work |
107 when given unaligned data. */ | 121 when given unaligned data. */ |
108 #define STRICT_ALIGNMENT 1 | 122 #define STRICT_ALIGNMENT 1 |
109 | 123 |
110 /* Define this as 1 if `char' should by default be signed; else as 0. */ | 124 /* Define this as 1 if `char' should by default be signed; else as 0. */ |
111 #define DEFAULT_SIGNED_CHAR 0 | 125 #define DEFAULT_SIGNED_CHAR 0 |
126 | |
127 #undef SIZE_TYPE | |
128 #define SIZE_TYPE "unsigned int" | |
129 | |
130 #undef PTRDIFF_TYPE | |
131 #define PTRDIFF_TYPE "int" | |
132 | |
133 #undef WCHAR_TYPE | |
134 #define WCHAR_TYPE "long int" | |
135 | |
136 #undef WCHAR_TYPE_SIZE | |
137 #define WCHAR_TYPE_SIZE BITS_PER_WORD | |
112 | 138 |
113 /* Standard register usage. */ | 139 /* Standard register usage. */ |
114 | 140 |
115 /* Number of actual hardware registers. | 141 /* Number of actual hardware registers. |
116 The hardware registers are assigned numbers for the compiler | 142 The hardware registers are assigned numbers for the compiler |
117 from 0 to just below FIRST_PSEUDO_REGISTER. | 143 from 0 to just below FIRST_PSEUDO_REGISTER. |
118 | 144 |
119 All registers that the compiler knows about must be given numbers, | 145 All registers that the compiler knows about must be given numbers, |
120 even those that are not normally considered general registers. */ | 146 even those that are not normally considered general registers. */ |
121 | 147 |
122 #define FIRST_PSEUDO_REGISTER 50 | 148 #define FIRST_PSEUDO_REGISTER 52 |
123 | 149 |
124 /* Specify machine-specific register numbers. */ | 150 /* Specify machine-specific register numbers. The commented out entries |
125 #define FIRST_DATA_REGNUM 0 | 151 are defined in mn10300.md. */ |
126 #define LAST_DATA_REGNUM 3 | 152 #define FIRST_DATA_REGNUM 0 |
127 #define FIRST_ADDRESS_REGNUM 4 | 153 #define LAST_DATA_REGNUM 3 |
128 #define LAST_ADDRESS_REGNUM 8 | 154 #define FIRST_ADDRESS_REGNUM 4 |
155 /* #define PIC_REG 6 */ | |
156 #define LAST_ADDRESS_REGNUM 8 | |
157 /* #define SP_REG 9 */ | |
129 #define FIRST_EXTENDED_REGNUM 10 | 158 #define FIRST_EXTENDED_REGNUM 10 |
130 #define LAST_EXTENDED_REGNUM 17 | 159 #define LAST_EXTENDED_REGNUM 17 |
131 #define FIRST_FP_REGNUM 18 | 160 #define FIRST_FP_REGNUM 18 |
132 #define LAST_FP_REGNUM 49 | 161 #define LAST_FP_REGNUM 49 |
133 #define FIRST_ARGUMENT_REGNUM 0 | 162 /* #define MDR_REG 50 */ |
163 /* #define CC_REG 51 */ | |
164 #define FIRST_ARGUMENT_REGNUM 0 | |
134 | 165 |
135 /* Specify the registers used for certain standard purposes. | 166 /* Specify the registers used for certain standard purposes. |
136 The values of these macros are register numbers. */ | 167 The values of these macros are register numbers. */ |
137 | 168 |
138 /* Register to use for pushing function arguments. */ | 169 /* Register to use for pushing function arguments. */ |
139 #define STACK_POINTER_REGNUM (LAST_ADDRESS_REGNUM+1) | 170 #define STACK_POINTER_REGNUM (LAST_ADDRESS_REGNUM + 1) |
140 | 171 |
141 /* Base register for access to local variables of the function. */ | 172 /* Base register for access to local variables of the function. */ |
142 #define FRAME_POINTER_REGNUM (LAST_ADDRESS_REGNUM-1) | 173 #define FRAME_POINTER_REGNUM (LAST_ADDRESS_REGNUM - 1) |
143 | 174 |
144 /* Base register for access to arguments of the function. This | 175 /* Base register for access to arguments of the function. This |
145 is a fake register and will be eliminated into either the frame | 176 is a fake register and will be eliminated into either the frame |
146 pointer or stack pointer. */ | 177 pointer or stack pointer. */ |
147 #define ARG_POINTER_REGNUM LAST_ADDRESS_REGNUM | 178 #define ARG_POINTER_REGNUM LAST_ADDRESS_REGNUM |
148 | 179 |
149 /* Register in which static-chain is passed to a function. */ | 180 /* Register in which static-chain is passed to a function. */ |
150 #define STATIC_CHAIN_REGNUM (FIRST_ADDRESS_REGNUM+1) | 181 #define STATIC_CHAIN_REGNUM (FIRST_ADDRESS_REGNUM + 1) |
151 | 182 |
152 /* 1 for registers that have pervasive standard uses | 183 /* 1 for registers that have pervasive standard uses |
153 and are not available for the register allocator. */ | 184 and are not available for the register allocator. */ |
154 | 185 |
155 #define FIXED_REGISTERS \ | 186 #define FIXED_REGISTERS \ |
156 { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 \ | 187 { 0, 0, 0, 0, /* data regs */ \ |
157 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \ | 188 0, 0, 0, 0, /* addr regs */ \ |
158 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \ | 189 1, /* arg reg */ \ |
190 1, /* sp reg */ \ | |
191 0, 0, 0, 0, 0, 0, 0, 0, /* extended regs */ \ | |
192 0, 0, /* fp regs (18-19) */ \ | |
193 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* fp regs (20-29) */ \ | |
194 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* fp regs (30-39) */ \ | |
195 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* fp regs (40-49) */ \ | |
196 0, /* mdr reg */ \ | |
197 1 /* cc reg */ \ | |
159 } | 198 } |
160 | 199 |
161 /* 1 for registers not available across function calls. | 200 /* 1 for registers not available across function calls. |
162 These must include the FIXED_REGISTERS and also any | 201 These must include the FIXED_REGISTERS and also any |
163 registers that can be used without being saved. | 202 registers that can be used without being saved. |
165 and the register where structure-value addresses are passed. | 204 and the register where structure-value addresses are passed. |
166 Aside from that, you can include as many other registers as you | 205 Aside from that, you can include as many other registers as you |
167 like. */ | 206 like. */ |
168 | 207 |
169 #define CALL_USED_REGISTERS \ | 208 #define CALL_USED_REGISTERS \ |
170 { 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 \ | 209 { 1, 1, 0, 0, /* data regs */ \ |
171 , 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \ | 210 1, 1, 0, 0, /* addr regs */ \ |
172 , 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 \ | 211 1, /* arg reg */ \ |
212 1, /* sp reg */ \ | |
213 1, 1, 1, 1, 0, 0, 0, 0, /* extended regs */ \ | |
214 1, 1, /* fp regs (18-19) */ \ | |
215 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, /* fp regs (20-29) */ \ | |
216 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, /* fp regs (30-39) */ \ | |
217 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* fp regs (40-49) */ \ | |
218 1, /* mdr reg */ \ | |
219 1 /* cc reg */ \ | |
173 } | 220 } |
174 | 221 |
175 /* Note: The definition of CALL_REALLY_USED_REGISTERS is not | 222 /* Note: The definition of CALL_REALLY_USED_REGISTERS is not |
176 redundant. It is needed when compiling in PIC mode because | 223 redundant. It is needed when compiling in PIC mode because |
177 the a2 register becomes fixed (and hence must be marked as | 224 the a2 register becomes fixed (and hence must be marked as |
180 #define CALL_REALLY_USED_REGISTERS CALL_USED_REGISTERS | 227 #define CALL_REALLY_USED_REGISTERS CALL_USED_REGISTERS |
181 | 228 |
182 #define REG_ALLOC_ORDER \ | 229 #define REG_ALLOC_ORDER \ |
183 { 0, 1, 4, 5, 2, 3, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 8, 9 \ | 230 { 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 \ | 231 , 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 \ | 232 , 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 50, 51 \ |
186 } | 233 } |
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 | 234 |
210 /* Return number of consecutive hard regs needed starting at reg REGNO | 235 /* Return number of consecutive hard regs needed starting at reg REGNO |
211 to hold something of mode MODE. | 236 to hold something of mode MODE. |
212 | 237 |
213 This is ordinarily the length in words of a value of mode MODE | 238 This is ordinarily the length in words of a value of mode MODE |
216 #define HARD_REGNO_NREGS(REGNO, MODE) \ | 241 #define HARD_REGNO_NREGS(REGNO, MODE) \ |
217 ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) | 242 ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) |
218 | 243 |
219 /* Value is 1 if hard register REGNO can hold a value of machine-mode | 244 /* Value is 1 if hard register REGNO can hold a value of machine-mode |
220 MODE. */ | 245 MODE. */ |
221 | |
222 #define HARD_REGNO_MODE_OK(REGNO, MODE) \ | 246 #define HARD_REGNO_MODE_OK(REGNO, MODE) \ |
223 ((REGNO_REG_CLASS (REGNO) == DATA_REGS \ | 247 mn10300_hard_regno_mode_ok ((REGNO), (MODE)) |
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 | 248 |
229 /* Value is 1 if it is a good idea to tie two pseudo registers | 249 /* 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. | 250 when one has mode MODE1 and one has mode MODE2. |
231 If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2, | 251 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. */ | 252 for any hard reg, then this must be 0 for correct output. */ |
233 #define MODES_TIEABLE_P(MODE1, MODE2) \ | 253 #define MODES_TIEABLE_P(MODE1, MODE2) \ |
234 (TARGET_AM33 \ | 254 mn10300_modes_tieable ((MODE1), (MODE2)) |
235 || MODE1 == MODE2 \ | |
236 || (GET_MODE_SIZE (MODE1) <= 4 && GET_MODE_SIZE (MODE2) <= 4)) | |
237 | 255 |
238 /* 4 data, and effectively 3 address registers is small as far as I'm | 256 /* 4 data, and effectively 3 address registers is small as far as I'm |
239 concerned. */ | 257 concerned. */ |
240 #define TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P hook_bool_mode_true | 258 #define TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P hook_bool_mode_true |
241 | 259 |
257 in a smaller-numbered class. | 275 in a smaller-numbered class. |
258 | 276 |
259 For any two classes, it is very desirable that there be another | 277 For any two classes, it is very desirable that there be another |
260 class that represents their union. */ | 278 class that represents their union. */ |
261 | 279 |
262 enum reg_class { | 280 enum reg_class |
263 NO_REGS, DATA_REGS, ADDRESS_REGS, SP_REGS, | 281 { |
264 DATA_OR_ADDRESS_REGS, SP_OR_ADDRESS_REGS, | 282 NO_REGS, DATA_REGS, ADDRESS_REGS, SP_REGS, SP_OR_ADDRESS_REGS, |
265 EXTENDED_REGS, DATA_OR_EXTENDED_REGS, ADDRESS_OR_EXTENDED_REGS, | 283 EXTENDED_REGS, FP_REGS, FP_ACC_REGS, CC_REGS, MDR_REGS, |
266 SP_OR_EXTENDED_REGS, SP_OR_ADDRESS_OR_EXTENDED_REGS, | 284 GENERAL_REGS, SP_OR_GENERAL_REGS, ALL_REGS, LIM_REG_CLASSES |
267 FP_REGS, FP_ACC_REGS, | |
268 GENERAL_REGS, ALL_REGS, LIM_REG_CLASSES | |
269 }; | 285 }; |
270 | 286 |
271 #define N_REG_CLASSES (int) LIM_REG_CLASSES | 287 #define N_REG_CLASSES (int) LIM_REG_CLASSES |
272 | 288 |
273 /* Give names of register classes as strings for dump file. */ | 289 /* Give names of register classes as strings for dump file. */ |
274 | 290 |
275 #define REG_CLASS_NAMES \ | 291 #define REG_CLASS_NAMES \ |
276 { "NO_REGS", "DATA_REGS", "ADDRESS_REGS", \ | 292 { "NO_REGS", "DATA_REGS", "ADDRESS_REGS", "SP_REGS", "SP_OR_ADDRESS_REGS", \ |
277 "SP_REGS", "DATA_OR_ADDRESS_REGS", "SP_OR_ADDRESS_REGS", \ | 293 "EXTENDED_REGS", "FP_REGS", "FP_ACC_REGS", "CC_REGS", "MDR_REGS", \ |
278 "EXTENDED_REGS", \ | 294 "GENERAL_REGS", "SP_OR_GENERAL_REGS", "ALL_REGS", "LIM_REGS" \ |
279 "DATA_OR_EXTENDED_REGS", "ADDRESS_OR_EXTENDED_REGS", \ | 295 } |
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 | 296 |
284 /* Define which registers fit in which classes. | 297 /* Define which registers fit in which classes. |
285 This is an initializer for a vector of HARD_REG_SET | 298 This is an initializer for a vector of HARD_REG_SET |
286 of length N_REG_CLASSES. */ | 299 of length N_REG_CLASSES. */ |
287 | 300 |
288 #define REG_CLASS_CONTENTS \ | 301 #define REG_CLASS_CONTENTS \ |
289 { { 0, 0 }, /* No regs */ \ | 302 { { 0, 0 }, /* No regs */ \ |
290 { 0x0000f, 0 }, /* DATA_REGS */ \ | 303 { 0x0000000f, 0 }, /* DATA_REGS */ \ |
291 { 0x001f0, 0 }, /* ADDRESS_REGS */ \ | 304 { 0x000001f0, 0 }, /* ADDRESS_REGS */ \ |
292 { 0x00200, 0 }, /* SP_REGS */ \ | 305 { 0x00000200, 0 }, /* SP_REGS */ \ |
293 { 0x001ff, 0 }, /* DATA_OR_ADDRESS_REGS */\ | 306 { 0x000003f0, 0 }, /* SP_OR_ADDRESS_REGS */ \ |
294 { 0x003f0, 0 }, /* SP_OR_ADDRESS_REGS */\ | 307 { 0x0003fc00, 0 }, /* EXTENDED_REGS */ \ |
295 { 0x3fc00, 0 }, /* EXTENDED_REGS */ \ | 308 { 0xfffc0000, 0x3ffff },/* FP_REGS */ \ |
296 { 0x3fc0f, 0 }, /* DATA_OR_EXTENDED_REGS */ \ | 309 { 0x03fc0000, 0 }, /* FP_ACC_REGS */ \ |
297 { 0x3fdf0, 0 }, /* ADDRESS_OR_EXTENDED_REGS */ \ | 310 { 0x00000000, 0x80000 },/* CC_REGS */ \ |
298 { 0x3fe00, 0 }, /* SP_OR_EXTENDED_REGS */ \ | 311 { 0x00000000, 0x40000 },/* MDR_REGS */ \ |
299 { 0x3fff0, 0 }, /* SP_OR_ADDRESS_OR_EXTENDED_REGS */ \ | 312 { 0x0003fdff, 0 }, /* GENERAL_REGS */ \ |
300 { 0xfffc0000, 0x3ffff }, /* FP_REGS */ \ | 313 { 0x0003ffff, 0 }, /* SP_OR_GENERAL_REGS */ \ |
301 { 0x03fc0000, 0 }, /* FP_ACC_REGS */ \ | 314 { 0xffffffff, 0xfffff } /* ALL_REGS */ \ |
302 { 0x3fdff, 0 }, /* GENERAL_REGS */ \ | |
303 { 0xffffffff, 0x3ffff } /* ALL_REGS */ \ | |
304 } | 315 } |
305 | 316 |
306 /* The following macro defines cover classes for Integrated Register | 317 /* The following macro defines cover classes for Integrated Register |
307 Allocator. Cover classes is a set of non-intersected register | 318 Allocator. Cover classes is a set of non-intersected register |
308 classes covering all hard registers used for register allocation | 319 classes covering all hard registers used for register allocation |
309 purpose. Any move between two registers of a cover class should be | 320 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 | 321 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 | 322 array of register classes with LIM_REG_CLASSES used as the end |
312 marker. */ | 323 marker. */ |
313 | 324 |
314 #define IRA_COVER_CLASSES \ | 325 #define IRA_COVER_CLASSES \ |
315 { \ | 326 { \ |
316 GENERAL_REGS, FP_REGS, LIM_REG_CLASSES \ | 327 GENERAL_REGS, FP_REGS, MDR_REGS, LIM_REG_CLASSES \ |
317 } | 328 } |
318 | 329 |
319 /* The same information, inverted: | 330 /* The same information, inverted: |
320 Return the class number of the smallest class containing | 331 Return the class number of the smallest class containing |
321 reg number REGNO. This could be a conditional expression | 332 reg number REGNO. This could be a conditional expression |
322 or could index an array. */ | 333 or could index an array. */ |
323 | 334 |
324 #define REGNO_REG_CLASS(REGNO) \ | 335 #define REGNO_REG_CLASS(REGNO) \ |
325 ((REGNO) <= LAST_DATA_REGNUM ? DATA_REGS : \ | 336 ((REGNO) <= LAST_DATA_REGNUM ? DATA_REGS : \ |
326 (REGNO) <= LAST_ADDRESS_REGNUM ? ADDRESS_REGS : \ | 337 (REGNO) <= LAST_ADDRESS_REGNUM ? ADDRESS_REGS : \ |
327 (REGNO) == STACK_POINTER_REGNUM ? SP_REGS : \ | 338 (REGNO) == STACK_POINTER_REGNUM ? SP_REGS : \ |
328 (REGNO) <= LAST_EXTENDED_REGNUM ? EXTENDED_REGS : \ | 339 (REGNO) <= LAST_EXTENDED_REGNUM ? EXTENDED_REGS : \ |
329 (REGNO) <= LAST_FP_REGNUM ? FP_REGS : \ | 340 (REGNO) <= LAST_FP_REGNUM ? FP_REGS : \ |
341 (REGNO) == MDR_REG ? MDR_REGS : \ | |
342 (REGNO) == CC_REG ? CC_REGS : \ | |
330 NO_REGS) | 343 NO_REGS) |
331 | 344 |
332 /* The class value for index registers, and the one for base regs. */ | 345 /* The class value for index registers, and the one for base regs. */ |
333 #define INDEX_REG_CLASS DATA_OR_EXTENDED_REGS | 346 #define INDEX_REG_CLASS \ |
334 #define BASE_REG_CLASS SP_OR_ADDRESS_REGS | 347 (TARGET_AM33 ? GENERAL_REGS : DATA_REGS) |
348 #define BASE_REG_CLASS \ | |
349 (TARGET_AM33 ? SP_OR_GENERAL_REGS : SP_OR_ADDRESS_REGS) | |
335 | 350 |
336 /* Macros to check register numbers against specific register classes. */ | 351 /* Macros to check register numbers against specific register classes. */ |
337 | 352 |
338 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx | 353 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx |
339 and check its validity for a certain class. | 354 and check its validity for a certain class. |
358 # define REG_STRICT 0 | 373 # define REG_STRICT 0 |
359 #else | 374 #else |
360 # define REG_STRICT 1 | 375 # define REG_STRICT 1 |
361 #endif | 376 #endif |
362 | 377 |
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) \ | 378 #define REGNO_DATA_P(regno, strict) \ |
372 (REGNO_IN_RANGE_P ((regno), FIRST_DATA_REGNUM, LAST_DATA_REGNUM, \ | 379 mn10300_regno_in_class_p (regno, DATA_REGS, strict) |
373 (strict))) | |
374 #define REGNO_ADDRESS_P(regno, strict) \ | 380 #define REGNO_ADDRESS_P(regno, strict) \ |
375 (REGNO_IN_RANGE_P ((regno), FIRST_ADDRESS_REGNUM, LAST_ADDRESS_REGNUM, \ | 381 mn10300_regno_in_class_p (regno, ADDRESS_REGS, strict) |
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) \ | 382 #define REGNO_EXTENDED_P(regno, strict) \ |
381 (REGNO_IN_RANGE_P ((regno), FIRST_EXTENDED_REGNUM, LAST_EXTENDED_REGNUM, \ | 383 mn10300_regno_in_class_p (regno, EXTENDED_REGS, strict) |
382 (strict))) | 384 #define REGNO_GENERAL_P(regno, strict) \ |
383 #define REGNO_AM33_P(regno, strict) \ | 385 mn10300_regno_in_class_p (regno, GENERAL_REGS, 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 | 386 |
389 #define REGNO_STRICT_OK_FOR_BASE_P(regno, strict) \ | 387 #define REGNO_STRICT_OK_FOR_BASE_P(regno, strict) \ |
390 (REGNO_SP_P ((regno), (strict)) \ | 388 mn10300_regno_in_class_p (regno, BASE_REG_CLASS, strict) |
391 || REGNO_ADDRESS_P ((regno), (strict)) \ | |
392 || REGNO_EXTENDED_P ((regno), (strict))) | |
393 #define REGNO_OK_FOR_BASE_P(regno) \ | 389 #define REGNO_OK_FOR_BASE_P(regno) \ |
394 (REGNO_STRICT_OK_FOR_BASE_P ((regno), REG_STRICT)) | 390 (REGNO_STRICT_OK_FOR_BASE_P ((regno), REG_STRICT)) |
395 #define REG_OK_FOR_BASE_P(X) \ | 391 #define REG_OK_FOR_BASE_P(X) \ |
396 (REGNO_OK_FOR_BASE_P (REGNO (X))) | 392 (REGNO_OK_FOR_BASE_P (REGNO (X))) |
397 | 393 |
398 #define REGNO_STRICT_OK_FOR_BIT_BASE_P(regno, strict) \ | 394 #define REGNO_STRICT_OK_FOR_BIT_BASE_P(regno, strict) \ |
399 (REGNO_SP_P ((regno), (strict)) || REGNO_ADDRESS_P ((regno), (strict))) | 395 mn10300_regno_in_class_p (regno, ADDRESS_REGS, strict) |
400 #define REGNO_OK_FOR_BIT_BASE_P(regno) \ | 396 #define REGNO_OK_FOR_BIT_BASE_P(regno) \ |
401 (REGNO_STRICT_OK_FOR_BIT_BASE_P ((regno), REG_STRICT)) | 397 (REGNO_STRICT_OK_FOR_BIT_BASE_P ((regno), REG_STRICT)) |
402 #define REG_OK_FOR_BIT_BASE_P(X) \ | 398 #define REG_OK_FOR_BIT_BASE_P(X) \ |
403 (REGNO_OK_FOR_BIT_BASE_P (REGNO (X))) | 399 (REGNO_OK_FOR_BIT_BASE_P (REGNO (X))) |
404 | 400 |
405 #define REGNO_STRICT_OK_FOR_INDEX_P(regno, strict) \ | 401 #define REGNO_STRICT_OK_FOR_INDEX_P(regno, strict) \ |
406 (REGNO_DATA_P ((regno), (strict)) || REGNO_EXTENDED_P ((regno), (strict))) | 402 mn10300_regno_in_class_p (regno, INDEX_REG_CLASS, strict) |
407 #define REGNO_OK_FOR_INDEX_P(regno) \ | 403 #define REGNO_OK_FOR_INDEX_P(regno) \ |
408 (REGNO_STRICT_OK_FOR_INDEX_P ((regno), REG_STRICT)) | 404 (REGNO_STRICT_OK_FOR_INDEX_P ((regno), REG_STRICT)) |
409 #define REG_OK_FOR_INDEX_P(X) \ | 405 #define REG_OK_FOR_INDEX_P(X) \ |
410 (REGNO_OK_FOR_INDEX_P (REGNO (X))) | 406 (REGNO_OK_FOR_INDEX_P (REGNO (X))) |
411 | 407 |
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) \ | 408 #define LIMIT_RELOAD_CLASS(MODE, CLASS) \ |
434 (!TARGET_AM33 && (MODE == QImode || MODE == HImode) ? DATA_REGS : CLASS) | 409 (!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 | 410 |
439 /* Return the maximum number of consecutive registers | 411 /* Return the maximum number of consecutive registers |
440 needed to represent mode MODE in a register of class CLASS. */ | 412 needed to represent mode MODE in a register of class CLASS. */ |
441 | 413 |
442 #define CLASS_MAX_NREGS(CLASS, MODE) \ | 414 #define CLASS_MAX_NREGS(CLASS, MODE) \ |
478 /* Is equal to the size of the saved fp + pc, even if an fp isn't | 450 /* 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. */ | 451 saved since the value is used before we know. */ |
480 | 452 |
481 #define FIRST_PARM_OFFSET(FNDECL) 4 | 453 #define FIRST_PARM_OFFSET(FNDECL) 4 |
482 | 454 |
455 /* But the CFA is at the arg pointer directly, not at the first argument. */ | |
456 #define ARG_POINTER_CFA_OFFSET(FNDECL) 0 | |
457 | |
483 #define ELIMINABLE_REGS \ | 458 #define ELIMINABLE_REGS \ |
484 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ | 459 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ |
485 { ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \ | 460 { ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \ |
486 { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}} | 461 { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}} |
487 | 462 |
488 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ | 463 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ |
489 OFFSET = initial_offset (FROM, TO) | 464 OFFSET = mn10300_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 | 465 |
504 /* We use d0/d1 for passing parameters, so allocate 8 bytes of space | 466 /* We use d0/d1 for passing parameters, so allocate 8 bytes of space |
505 for a register flushback area. */ | 467 for a register flushback area. */ |
506 #define REG_PARM_STACK_SPACE(DECL) 8 | 468 #define REG_PARM_STACK_SPACE(DECL) 8 |
507 #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1 | 469 #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1 |
525 | 487 |
526 On the MN10300, this is a single integer, which is a number of bytes | 488 On the MN10300, this is a single integer, which is a number of bytes |
527 of arguments scanned so far. */ | 489 of arguments scanned so far. */ |
528 | 490 |
529 #define CUMULATIVE_ARGS struct cum_arg | 491 #define CUMULATIVE_ARGS struct cum_arg |
530 struct cum_arg {int nbytes; }; | 492 |
493 struct cum_arg | |
494 { | |
495 int nbytes; | |
496 }; | |
531 | 497 |
532 /* Initialize a variable CUM of type CUMULATIVE_ARGS | 498 /* Initialize a variable CUM of type CUMULATIVE_ARGS |
533 for a call to a function whose data type is FNTYPE. | 499 for a call to a function whose data type is FNTYPE. |
534 For a library call, FNTYPE is 0. | 500 For a library call, FNTYPE is 0. |
535 | 501 |
536 On the MN10300, the offset starts at 0. */ | 502 On the MN10300, the offset starts at 0. */ |
537 | 503 |
538 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \ | 504 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \ |
539 ((CUM).nbytes = 0) | 505 ((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 | 506 |
566 #define FUNCTION_VALUE_REGNO_P(N) mn10300_function_value_regno_p (N) | 507 #define FUNCTION_VALUE_REGNO_P(N) mn10300_function_value_regno_p (N) |
567 | 508 |
568 #define DEFAULT_PCC_STRUCT_RETURN 0 | 509 #define DEFAULT_PCC_STRUCT_RETURN 0 |
569 | 510 |
579 | 520 |
580 #define FUNCTION_PROFILER(FILE, LABELNO) ; | 521 #define FUNCTION_PROFILER(FILE, LABELNO) ; |
581 | 522 |
582 /* Length in units of the trampoline for entering a nested function. */ | 523 /* Length in units of the trampoline for entering a nested function. */ |
583 | 524 |
584 #define TRAMPOLINE_SIZE 0x1b | 525 #define TRAMPOLINE_SIZE 16 |
585 | 526 #define TRAMPOLINE_ALIGNMENT 32 |
586 #define TRAMPOLINE_ALIGNMENT 32 | |
587 | 527 |
588 /* A C expression whose value is RTL representing the value of the return | 528 /* 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. | 529 address for the frame COUNT steps up from the current frame. |
590 | 530 |
591 On the mn10300, the return address is not at a constant location | 531 On the mn10300, the return address is not at a constant location |
596 | 536 |
597 #define RETURN_ADDR_RTX(COUNT, FRAME) \ | 537 #define RETURN_ADDR_RTX(COUNT, FRAME) \ |
598 ((COUNT == 0) \ | 538 ((COUNT == 0) \ |
599 ? gen_rtx_MEM (Pmode, arg_pointer_rtx) \ | 539 ? gen_rtx_MEM (Pmode, arg_pointer_rtx) \ |
600 : (rtx) 0) | 540 : (rtx) 0) |
541 | |
542 /* The return address is saved both in the stack and in MDR. Using | |
543 the stack location is handiest for what unwinding needs. */ | |
544 #define INCOMING_RETURN_ADDR_RTX \ | |
545 gen_rtx_MEM (VOIDmode, gen_rtx_REG (VOIDmode, STACK_POINTER_REGNUM)) | |
601 | 546 |
602 /* Maximum number of registers that can appear in a valid memory address. */ | 547 /* Maximum number of registers that can appear in a valid memory address. */ |
603 | 548 |
604 #define MAX_REGS_PER_ADDRESS 2 | 549 #define MAX_REGS_PER_ADDRESS 2 |
605 | 550 |
606 | 551 |
607 #define HAVE_POST_INCREMENT (TARGET_AM33) | 552 /* We have post-increments. */ |
553 #define HAVE_POST_INCREMENT TARGET_AM33 | |
554 #define HAVE_POST_MODIFY_DISP TARGET_AM33 | |
555 | |
556 /* ... But we don't want to use them for block moves. Small offsets are | |
557 just as effective, at least for inline block move sizes, and appears | |
558 to produce cleaner code. */ | |
559 #define USE_LOAD_POST_INCREMENT(M) 0 | |
560 #define USE_STORE_POST_INCREMENT(M) 0 | |
608 | 561 |
609 /* Accept either REG or SUBREG where a register is valid. */ | 562 /* Accept either REG or SUBREG where a register is valid. */ |
610 | 563 |
611 #define RTX_OK_FOR_BASE_P(X, strict) \ | 564 #define RTX_OK_FOR_BASE_P(X, strict) \ |
612 ((REG_P (X) && REGNO_STRICT_OK_FOR_BASE_P (REGNO (X), \ | 565 ((REG_P (X) && REGNO_STRICT_OK_FOR_BASE_P (REGNO (X), \ |
613 (strict))) \ | 566 (strict))) \ |
614 || (GET_CODE (X) == SUBREG && REG_P (SUBREG_REG (X)) \ | 567 || (GET_CODE (X) == SUBREG && REG_P (SUBREG_REG (X)) \ |
615 && REGNO_STRICT_OK_FOR_BASE_P (REGNO (SUBREG_REG (X)), \ | 568 && REGNO_STRICT_OK_FOR_BASE_P (REGNO (SUBREG_REG (X)), \ |
616 (strict)))) | 569 (strict)))) |
617 | 570 |
571 #define LEGITIMIZE_RELOAD_ADDRESS(X,MODE,OPNUM,TYPE,IND_L,WIN) \ | |
572 do { \ | |
573 rtx new_x = mn10300_legitimize_reload_address (X, MODE, OPNUM, TYPE, IND_L); \ | |
574 if (new_x) \ | |
575 { \ | |
576 X = new_x; \ | |
577 goto WIN; \ | |
578 } \ | |
579 } while (0) | |
618 | 580 |
619 | 581 |
620 /* Nonzero if the constant value X is a legitimate general operand. | 582 /* 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. */ | 583 It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */ |
622 | 584 #define LEGITIMATE_CONSTANT_P(X) mn10300_legitimate_constant_p (X) |
623 #define LEGITIMATE_CONSTANT_P(X) 1 | |
624 | 585 |
625 /* Zero if this needs fixing up to become PIC. */ | 586 /* Zero if this needs fixing up to become PIC. */ |
626 | 587 |
627 #define LEGITIMATE_PIC_OPERAND_P(X) (legitimate_pic_operand_p (X)) | 588 #define LEGITIMATE_PIC_OPERAND_P(X) \ |
589 mn10300_legitimate_pic_operand_p (X) | |
628 | 590 |
629 /* Register to hold the addressing base for | 591 /* Register to hold the addressing base for |
630 position independent code access to data items. */ | 592 position independent code access to data items. */ |
631 #define PIC_OFFSET_TABLE_REGNUM PIC_REG | 593 #define PIC_OFFSET_TABLE_REGNUM PIC_REG |
632 | 594 |
637 ((GET_CODE (X) == SYMBOL_REF || GET_CODE (X) == LABEL_REF) \ | 599 ((GET_CODE (X) == SYMBOL_REF || GET_CODE (X) == LABEL_REF) \ |
638 && ! LEGITIMATE_PIC_OPERAND_P (X)) | 600 && ! LEGITIMATE_PIC_OPERAND_P (X)) |
639 | 601 |
640 /* Non-global SYMBOL_REFs have SYMBOL_REF_FLAG enabled. */ | 602 /* Non-global SYMBOL_REFs have SYMBOL_REF_FLAG enabled. */ |
641 #define MN10300_GLOBAL_P(X) (! SYMBOL_REF_FLAG (X)) | 603 #define MN10300_GLOBAL_P(X) (! SYMBOL_REF_FLAG (X)) |
642 | 604 |
643 /* Recognize machine-specific patterns that may appear within | 605 #define SELECT_CC_MODE(OP, X, Y) mn10300_select_cc_mode (OP, X, Y) |
644 constants. Used for PIC-specific UNSPECs. */ | 606 #define REVERSIBLE_CC_MODE(MODE) 0 |
645 #define OUTPUT_ADDR_CONST_EXTRA(STREAM, X, FAIL) \ | 607 |
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 | 608 /* Nonzero if access to memory by bytes or half words is no faster |
714 than accessing full words. */ | 609 than accessing full words. */ |
715 #define SLOW_BYTE_ACCESS 1 | 610 #define SLOW_BYTE_ACCESS 1 |
716 | 611 |
717 #define NO_FUNCTION_CSE | 612 #define NO_FUNCTION_CSE |
720 for the MN10300 series, that's our primary concern. */ | 615 for the MN10300 series, that's our primary concern. */ |
721 #define MOVE_RATIO(speed) 6 | 616 #define MOVE_RATIO(speed) 6 |
722 | 617 |
723 #define TEXT_SECTION_ASM_OP "\t.section .text" | 618 #define TEXT_SECTION_ASM_OP "\t.section .text" |
724 #define DATA_SECTION_ASM_OP "\t.section .data" | 619 #define DATA_SECTION_ASM_OP "\t.section .data" |
725 #define BSS_SECTION_ASM_OP "\t.section .bss" | 620 #define BSS_SECTION_ASM_OP "\t.section .bss" |
726 | 621 |
727 #define ASM_COMMENT_START "#" | 622 #define ASM_COMMENT_START "#" |
728 | 623 |
729 /* Output to assembler file text saying following lines | 624 /* Output to assembler file text saying following lines |
730 may contain character constants, extra white space, comments, etc. */ | 625 may contain character constants, extra white space, comments, etc. */ |
750 #define GLOBAL_ASM_OP "\t.global " | 645 #define GLOBAL_ASM_OP "\t.global " |
751 | 646 |
752 /* This is how to output a reference to a user-level label named NAME. | 647 /* This is how to output a reference to a user-level label named NAME. |
753 `assemble_name' uses this. */ | 648 `assemble_name' uses this. */ |
754 | 649 |
755 #undef ASM_OUTPUT_LABELREF | 650 #undef ASM_OUTPUT_LABELREF |
756 #define ASM_OUTPUT_LABELREF(FILE, NAME) \ | 651 #define ASM_OUTPUT_LABELREF(FILE, NAME) \ |
757 asm_fprintf (FILE, "%U%s", (*targetm.strip_name_encoding) (NAME)) | 652 asm_fprintf (FILE, "%U%s", (*targetm.strip_name_encoding) (NAME)) |
758 | 653 |
759 #define ASM_PN_FORMAT "%s___%lu" | |
760 | |
761 /* This is how we tell the assembler that two symbols have the same value. */ | 654 /* This is how we tell the assembler that two symbols have the same value. */ |
762 | 655 |
763 #define ASM_OUTPUT_DEF(FILE,NAME1,NAME2) \ | 656 #define ASM_OUTPUT_DEF(FILE,NAME1,NAME2) \ |
764 do { assemble_name(FILE, NAME1); \ | 657 do \ |
765 fputs(" = ", FILE); \ | 658 { \ |
766 assemble_name(FILE, NAME2); \ | 659 assemble_name (FILE, NAME1); \ |
767 fputc('\n', FILE); } while (0) | 660 fputs (" = ", FILE); \ |
768 | 661 assemble_name (FILE, NAME2); \ |
662 fputc ('\n', FILE); \ | |
663 } \ | |
664 while (0) | |
769 | 665 |
770 /* How to refer to registers in assembler output. | 666 /* How to refer to registers in assembler output. |
771 This sequence is indexed by compiler's hard-register-number (see above). */ | 667 This sequence is indexed by compiler's hard-register-number (see above). */ |
772 | 668 |
773 #define REGISTER_NAMES \ | 669 #define REGISTER_NAMES \ |
774 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3", "ap", "sp", \ | 670 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3", "ap", "sp", \ |
775 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7" \ | 671 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7" \ |
776 , "fs0", "fs1", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7" \ | 672 , "fs0", "fs1", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7" \ |
777 , "fs8", "fs9", "fs10", "fs11", "fs12", "fs13", "fs14", "fs15" \ | 673 , "fs8", "fs9", "fs10", "fs11", "fs12", "fs13", "fs14", "fs15" \ |
778 , "fs16", "fs17", "fs18", "fs19", "fs20", "fs21", "fs22", "fs23" \ | 674 , "fs16", "fs17", "fs18", "fs19", "fs20", "fs21", "fs22", "fs23" \ |
779 , "fs24", "fs25", "fs26", "fs27", "fs28", "fs29", "fs30", "fs31" \ | 675 , "fs24", "fs25", "fs26", "fs27", "fs28", "fs29", "fs30", "fs31" \ |
676 , "mdr", "EPSW" \ | |
780 } | 677 } |
781 | 678 |
782 #define ADDITIONAL_REGISTER_NAMES \ | 679 #define ADDITIONAL_REGISTER_NAMES \ |
783 { {"r8", 4}, {"r9", 5}, {"r10", 6}, {"r11", 7}, \ | 680 { {"r8", 4}, {"r9", 5}, {"r10", 6}, {"r11", 7}, \ |
784 {"r12", 0}, {"r13", 1}, {"r14", 2}, {"r15", 3}, \ | 681 {"r12", 0}, {"r13", 1}, {"r14", 2}, {"r15", 3}, \ |
785 {"e0", 10}, {"e1", 11}, {"e2", 12}, {"e3", 13}, \ | 682 {"e0", 10}, {"e1", 11}, {"e2", 12}, {"e3", 13}, \ |
786 {"e4", 14}, {"e5", 15}, {"e6", 16}, {"e7", 17} \ | 683 {"e4", 14}, {"e5", 15}, {"e6", 16}, {"e7", 17} \ |
787 , {"fd0", 18}, {"fd2", 20}, {"fd4", 22}, {"fd6", 24} \ | 684 , {"fd0", 18}, {"fd2", 20}, {"fd4", 22}, {"fd6", 24} \ |
788 , {"fd8", 26}, {"fd10", 28}, {"fd12", 30}, {"fd14", 32} \ | 685 , {"fd8", 26}, {"fd10", 28}, {"fd12", 30}, {"fd14", 32} \ |
789 , {"fd16", 34}, {"fd18", 36}, {"fd20", 38}, {"fd22", 40} \ | 686 , {"fd16", 34}, {"fd18", 36}, {"fd20", 38}, {"fd22", 40} \ |
790 , {"fd24", 42}, {"fd26", 44}, {"fd28", 46}, {"fd30", 48} \ | 687 , {"fd24", 42}, {"fd26", 44}, {"fd28", 46}, {"fd30", 48} \ |
688 , {"cc", CC_REG} \ | |
791 } | 689 } |
792 | 690 |
793 /* Print an instruction operand X on file FILE. | 691 /* Print an instruction operand X on file FILE. |
794 look in mn10300.c for details */ | 692 look in mn10300.c for details */ |
795 | 693 |
796 #define PRINT_OPERAND(FILE, X, CODE) print_operand(FILE,X,CODE) | 694 #define PRINT_OPERAND(FILE, X, CODE) \ |
695 mn10300_print_operand (FILE, X, CODE) | |
797 | 696 |
798 /* Print a memory operand whose address is X, on file FILE. | 697 /* Print a memory operand whose address is X, on file FILE. |
799 This uses a function in output-vax.c. */ | 698 This uses a function in output-vax.c. */ |
800 | 699 |
801 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) print_operand_address (FILE, ADDR) | 700 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) \ |
802 | 701 mn10300_print_operand_address (FILE, ADDR) |
803 #define ASM_OUTPUT_REG_PUSH(FILE,REGNO) | |
804 #define ASM_OUTPUT_REG_POP(FILE,REGNO) | |
805 | 702 |
806 /* This is how to output an element of a case-vector that is absolute. */ | 703 /* This is how to output an element of a case-vector that is absolute. */ |
807 | 704 |
808 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ | 705 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ |
809 fprintf (FILE, "\t%s .L%d\n", ".long", VALUE) | 706 fprintf (FILE, "\t%s .L%d\n", ".long", VALUE) |
819 | 716 |
820 /* We don't have to worry about dbx compatibility for the mn10300. */ | 717 /* We don't have to worry about dbx compatibility for the mn10300. */ |
821 #define DEFAULT_GDB_EXTENSIONS 1 | 718 #define DEFAULT_GDB_EXTENSIONS 1 |
822 | 719 |
823 /* Use dwarf2 debugging info by default. */ | 720 /* Use dwarf2 debugging info by default. */ |
824 #undef PREFERRED_DEBUGGING_TYPE | 721 #undef PREFERRED_DEBUGGING_TYPE |
825 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG | 722 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG |
826 | 723 #define DWARF2_DEBUGGING_INFO 1 |
827 #define DWARF2_ASM_LINE_DEBUG_INFO 1 | 724 #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 | 725 |
852 /* Specify the machine mode that this machine uses | 726 /* Specify the machine mode that this machine uses |
853 for the index in the tablejump instruction. */ | 727 for the index in the tablejump instruction. */ |
854 #define CASE_VECTOR_MODE Pmode | 728 #define CASE_VECTOR_MODE Pmode |
855 | 729 |
888 | 762 |
889 /* The assembler op to get a word. */ | 763 /* The assembler op to get a word. */ |
890 | 764 |
891 #define FILE_ASM_OP "\t.file\n" | 765 #define FILE_ASM_OP "\t.file\n" |
892 | 766 |
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) |