Commit | Line | Data |
---|---|---|
e0001a05 | 1 | /* tc-xtensa.h -- Header file for tc-xtensa.c. |
7be1c489 | 2 | Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc. |
e0001a05 NC |
3 | |
4 | This file is part of GAS, the GNU Assembler. | |
5 | ||
6 | GAS is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 2, or (at your option) | |
9 | any later version. | |
10 | ||
11 | GAS is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with GAS; see the file COPYING. If not, write to the Free | |
4b4da160 NC |
18 | Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA |
19 | 02110-1301, USA. */ | |
e0001a05 NC |
20 | |
21 | #ifndef TC_XTENSA | |
22 | #define TC_XTENSA 1 | |
23 | ||
e0001a05 | 24 | struct fix; |
e0001a05 | 25 | |
e0001a05 NC |
26 | #ifndef OBJ_ELF |
27 | #error Xtensa support requires ELF object format | |
28 | #endif | |
29 | ||
43cd72b9 | 30 | #include "xtensa-isa.h" |
e0001a05 NC |
31 | #include "xtensa-config.h" |
32 | ||
33 | #define TARGET_BYTES_BIG_ENDIAN XCHAL_HAVE_BE | |
34 | ||
35 | ||
43cd72b9 | 36 | /* Maximum number of opcode slots in a VLIW instruction. */ |
b08b5071 | 37 | #define MAX_SLOTS 15 |
43cd72b9 BW |
38 | |
39 | ||
40 | /* For all xtensa relax states except RELAX_DESIRE_ALIGN and | |
41 | RELAX_DESIRE_ALIGN_IF_TARGET, the amount a frag might grow is stored | |
42 | in the fr_var field. For the two exceptions, fr_var is a float value | |
43 | that records the frequency with which the following instruction is | |
44 | executed as a branch target. The aligner uses this information to | |
45 | tell which targets are most important to be aligned. */ | |
46 | ||
47 | enum xtensa_relax_statesE | |
48 | { | |
49 | RELAX_ALIGN_NEXT_OPCODE, | |
50 | /* Use the first opcode of the next fragment to determine the | |
51 | alignment requirements. This is ONLY used for LOOPs currently. */ | |
52 | ||
53 | RELAX_CHECK_ALIGN_NEXT_OPCODE, | |
54 | /* The next non-empty frag contains a loop instruction. Check to see | |
55 | if it is correctly aligned, but do not align it. */ | |
56 | ||
57 | RELAX_DESIRE_ALIGN_IF_TARGET, | |
58 | /* These are placed in front of labels and converted to either | |
59 | RELAX_DESIRE_ALIGN / RELAX_LOOP_END or rs_fill of 0 before | |
60 | relaxation begins. */ | |
61 | ||
62 | RELAX_ADD_NOP_IF_A0_B_RETW, | |
63 | /* These are placed in front of conditional branches. Before | |
64 | relaxation begins, they are turned into either NOPs for branches | |
65 | immediately followed by RETW or RETW.N or rs_fills of 0. This is | |
66 | used to avoid a hardware bug in some early versions of the | |
67 | processor. */ | |
68 | ||
69 | RELAX_ADD_NOP_IF_PRE_LOOP_END, | |
70 | /* These are placed after JX instructions. Before relaxation begins, | |
71 | they are turned into either NOPs, if the JX is one instruction | |
72 | before a loop end label, or rs_fills of 0. This is used to avoid a | |
73 | hardware interlock issue prior to Xtensa version T1040. */ | |
74 | ||
75 | RELAX_ADD_NOP_IF_SHORT_LOOP, | |
76 | /* These are placed after LOOP instructions and turned into NOPs when: | |
77 | (1) there are less than 3 instructions in the loop; we place 2 of | |
78 | these in a row to add up to 2 NOPS in short loops; or (2) the | |
79 | instructions in the loop do not include a branch or jump. | |
80 | Otherwise they are turned into rs_fills of 0 before relaxation | |
81 | begins. This is used to avoid hardware bug PR3830. */ | |
82 | ||
83 | RELAX_ADD_NOP_IF_CLOSE_LOOP_END, | |
84 | /* These are placed after LOOP instructions and turned into NOPs if | |
85 | there are less than 12 bytes to the end of some other loop's end. | |
86 | Otherwise they are turned into rs_fills of 0 before relaxation | |
87 | begins. This is used to avoid hardware bug PR3830. */ | |
88 | ||
89 | RELAX_DESIRE_ALIGN, | |
90 | /* The next fragment would like its first instruction to NOT cross an | |
91 | instruction fetch boundary. */ | |
92 | ||
93 | RELAX_MAYBE_DESIRE_ALIGN, | |
94 | /* The next fragment might like its first instruction to NOT cross an | |
95 | instruction fetch boundary. These are placed after a branch that | |
96 | might be relaxed. If the branch is relaxed, then this frag will be | |
97 | a branch target and this frag will be changed to RELAX_DESIRE_ALIGN | |
98 | frag. */ | |
99 | ||
100 | RELAX_LOOP_END, | |
101 | /* This will be turned into a NOP or NOP.N if the previous instruction | |
102 | is expanded to negate a loop. */ | |
103 | ||
104 | RELAX_LOOP_END_ADD_NOP, | |
105 | /* When the code density option is available, this will generate a | |
106 | NOP.N marked RELAX_NARROW. Otherwise, it will create an rs_fill | |
107 | fragment with a NOP in it. */ | |
108 | ||
109 | RELAX_LITERAL, | |
110 | /* Another fragment could generate an expansion here but has not yet. */ | |
111 | ||
112 | RELAX_LITERAL_NR, | |
113 | /* Expansion has been generated by an instruction that generates a | |
114 | literal. However, the stretch has NOT been reported yet in this | |
115 | fragment. */ | |
116 | ||
117 | RELAX_LITERAL_FINAL, | |
118 | /* Expansion has been generated by an instruction that generates a | |
119 | literal. */ | |
120 | ||
121 | RELAX_LITERAL_POOL_BEGIN, | |
122 | RELAX_LITERAL_POOL_END, | |
123 | /* Technically these are not relaxations at all but mark a location | |
124 | to store literals later. Note that fr_var stores the frchain for | |
125 | BEGIN frags and fr_var stores now_seg for END frags. */ | |
126 | ||
127 | RELAX_NARROW, | |
128 | /* The last instruction in this fragment (at->fr_opcode) can be | |
129 | freely replaced with a single wider instruction if a future | |
130 | alignment desires or needs it. */ | |
131 | ||
132 | RELAX_IMMED, | |
133 | /* The last instruction in this fragment (at->fr_opcode) contains | |
134 | the value defined by fr_symbol (fr_offset = 0). If the value | |
135 | does not fit, use the specified expansion. This is similar to | |
136 | "NARROW", except that these may not be expanded in order to align | |
137 | code. */ | |
c138bc38 | 138 | |
43cd72b9 BW |
139 | RELAX_IMMED_STEP1, |
140 | /* The last instruction in this fragment (at->fr_opcode) contains a | |
141 | literal. It has already been expanded at least 1 step. */ | |
142 | ||
143 | RELAX_IMMED_STEP2, | |
144 | /* The last instruction in this fragment (at->fr_opcode) contains a | |
145 | literal. It has already been expanded at least 2 steps. */ | |
146 | ||
147 | RELAX_SLOTS, | |
148 | /* There are instructions within the last VLIW instruction that need | |
149 | relaxation. Find the relaxation based on the slot info in | |
150 | xtensa_frag_type. Relaxations that deal with particular opcodes | |
151 | are slot-based (e.g., converting a MOVI to an L32R). Relaxations | |
152 | that deal with entire instructions, such as alignment, are not | |
153 | slot-based. */ | |
154 | ||
155 | RELAX_FILL_NOP, | |
156 | /* This marks the location of a pipeline stall. We can fill these guys | |
157 | in for alignment of any size. */ | |
158 | ||
159 | RELAX_UNREACHABLE, | |
160 | /* This marks the location as unreachable. The assembler may widen or | |
161 | narrow this area to meet alignment requirements of nearby | |
162 | instructions. */ | |
163 | ||
164 | RELAX_MAYBE_UNREACHABLE, | |
165 | /* This marks the location as possibly unreachable. These are placed | |
166 | after a branch that may be relaxed into a branch and jump. If the | |
c138bc38 | 167 | branch is relaxed, then this frag will be converted to a |
43cd72b9 BW |
168 | RELAX_UNREACHABLE frag. */ |
169 | ||
170 | RELAX_NONE | |
171 | }; | |
172 | ||
173 | /* This is used as a stopper to bound the number of steps that | |
174 | can be taken. */ | |
175 | #define RELAX_IMMED_MAXSTEPS (RELAX_IMMED_STEP2 - RELAX_IMMED) | |
176 | ||
e0001a05 NC |
177 | struct xtensa_frag_type |
178 | { | |
43cd72b9 BW |
179 | /* Info about the current state of assembly, e.g., transform, |
180 | absolute_literals, etc. These need to be passed to the backend and | |
181 | then to the object file. | |
182 | ||
183 | When is_assembly_state_set is false, the frag inherits some of the | |
184 | state settings from the previous frag in this segment. Because it | |
185 | is not possible to intercept all fragment closures (frag_more and | |
186 | frag_append_1_char can close a frag), we use a pass after initial | |
187 | assembly to fill in the assembly states. */ | |
188 | ||
189 | unsigned int is_assembly_state_set : 1; | |
190 | unsigned int is_no_density : 1; | |
191 | unsigned int is_no_transform : 1; | |
7c834684 | 192 | unsigned int use_longcalls : 1; |
43cd72b9 BW |
193 | unsigned int use_absolute_literals : 1; |
194 | ||
195 | /* Inhibits relaxation of machine-dependent alignment frags the | |
196 | first time through a relaxation.... */ | |
197 | unsigned int relax_seen : 1; | |
198 | ||
0fa77c95 | 199 | /* Information that is needed in the object file and set when known. */ |
43cd72b9 BW |
200 | unsigned int is_literal : 1; |
201 | unsigned int is_loop_target : 1; | |
202 | unsigned int is_branch_target : 1; | |
203 | unsigned int is_insn : 1; | |
204 | unsigned int is_unreachable : 1; | |
e0001a05 | 205 | |
43cd72b9 | 206 | unsigned int is_specific_opcode : 1; /* also implies no_transform */ |
e0001a05 | 207 | |
43cd72b9 BW |
208 | unsigned int is_align : 1; |
209 | unsigned int is_text_align : 1; | |
210 | unsigned int alignment : 5; | |
211 | ||
212 | /* A frag with this bit set is the first in a loop that actually | |
213 | contains an instruction. */ | |
214 | unsigned int is_first_loop_insn : 1; | |
e0001a05 NC |
215 | |
216 | /* For text fragments that can generate literals at relax time, this | |
217 | variable points to the frag where the literal will be stored. For | |
218 | literal frags, this variable points to the nearest literal pool | |
219 | location frag. This literal frag will be moved to after this | |
220 | location. */ | |
e0001a05 NC |
221 | fragS *literal_frag; |
222 | ||
223 | /* The destination segment for literal frags. (Note that this is only | |
dd49a749 BW |
224 | valid after xtensa_move_literals.) This field is also used for |
225 | LITERAL_POOL_END frags. */ | |
e0001a05 NC |
226 | segT lit_seg; |
227 | ||
dd49a749 BW |
228 | /* Frag chain for LITERAL_POOL_BEGIN frags. */ |
229 | struct frchain *lit_frchain; | |
230 | ||
e0001a05 NC |
231 | /* For the relaxation scheme, some literal fragments can have their |
232 | expansions modified by an instruction that relaxes. */ | |
43cd72b9 BW |
233 | int text_expansion[MAX_SLOTS]; |
234 | int literal_expansion[MAX_SLOTS]; | |
235 | int unreported_expansion; | |
236 | ||
237 | /* For text fragments that can generate literals at relax time: */ | |
238 | fragS *literal_frags[MAX_SLOTS]; | |
239 | enum xtensa_relax_statesE slot_subtypes[MAX_SLOTS]; | |
240 | symbolS *slot_symbols[MAX_SLOTS]; | |
241 | symbolS *slot_sub_symbols[MAX_SLOTS]; | |
242 | offsetT slot_offsets[MAX_SLOTS]; | |
243 | ||
244 | /* The global aligner needs to walk backward through the list of | |
245 | frags. This field is only valid after xtensa_end. */ | |
246 | fragS *fr_prev; | |
e0001a05 NC |
247 | }; |
248 | ||
43cd72b9 BW |
249 | |
250 | /* For VLIW support, we need to know what slot a fixup applies to. */ | |
251 | typedef struct xtensa_fix_data_struct | |
252 | { | |
253 | int slot; | |
254 | symbolS *X_add_symbol; | |
255 | offsetT X_add_number; | |
256 | } xtensa_fix_data; | |
257 | ||
258 | ||
259 | /* Structure to record xtensa-specific symbol information. */ | |
260 | typedef struct xtensa_symfield_type | |
e0001a05 | 261 | { |
43cd72b9 BW |
262 | unsigned int is_loop_target : 1; |
263 | unsigned int is_branch_target : 1; | |
264 | } xtensa_symfield_type; | |
265 | ||
266 | ||
267 | /* Structure for saving information about a block of property data | |
268 | for frags that have the same flags. The forward reference is | |
269 | in this header file. The actual definition is in tc-xtensa.c. */ | |
270 | struct xtensa_block_info_struct; | |
271 | typedef struct xtensa_block_info_struct xtensa_block_info; | |
272 | ||
e0001a05 | 273 | |
43cd72b9 | 274 | /* Property section types. */ |
e0001a05 NC |
275 | typedef enum |
276 | { | |
e0001a05 | 277 | xt_literal_sec, |
43cd72b9 | 278 | xt_prop_sec, |
e0001a05 NC |
279 | max_xt_sec |
280 | } xt_section_type; | |
281 | ||
282 | typedef struct xtensa_segment_info_struct | |
283 | { | |
284 | fragS *literal_pool_loc; | |
285 | xtensa_block_info *blocks[max_xt_sec]; | |
286 | } xtensa_segment_info; | |
287 | ||
e0001a05 | 288 | |
7fa3d080 BW |
289 | extern const char *xtensa_target_format (void); |
290 | extern void xtensa_init_fix_data (struct fix *); | |
291 | extern void xtensa_frag_init (fragS *); | |
292 | extern int xtensa_force_relocation (struct fix *); | |
30f725a1 | 293 | extern int xtensa_validate_fix_sub (struct fix *); |
7fa3d080 BW |
294 | extern void xtensa_frob_label (struct symbol *); |
295 | extern void xtensa_end (void); | |
296 | extern void xtensa_post_relax_hook (void); | |
297 | extern void xtensa_file_arch_init (bfd *); | |
298 | extern void xtensa_flush_pending_output (void); | |
299 | extern bfd_boolean xtensa_fix_adjustable (struct fix *); | |
300 | extern void xtensa_symbol_new_hook (symbolS *); | |
301 | extern long xtensa_relax_frag (fragS *, long, int *); | |
302 | extern void xtensa_elf_section_change_hook (void); | |
303 | extern int xtensa_unrecognized_line (int); | |
304 | extern bfd_boolean xtensa_check_inside_bundle (void); | |
305 | extern void xtensa_handle_align (fragS *); | |
9456465c | 306 | extern char *xtensa_section_rename (char *); |
e0001a05 NC |
307 | |
308 | #define TARGET_FORMAT xtensa_target_format () | |
309 | #define TARGET_ARCH bfd_arch_xtensa | |
310 | #define TC_SEGMENT_INFO_TYPE xtensa_segment_info | |
43cd72b9 BW |
311 | #define TC_SYMFIELD_TYPE struct xtensa_symfield_type |
312 | #define TC_FIX_TYPE xtensa_fix_data | |
313 | #define TC_INIT_FIX_DATA(x) xtensa_init_fix_data (x) | |
e0001a05 NC |
314 | #define TC_FRAG_TYPE struct xtensa_frag_type |
315 | #define TC_FRAG_INIT(frag) xtensa_frag_init (frag) | |
43cd72b9 | 316 | #define TC_FORCE_RELOCATION(fix) xtensa_force_relocation (fix) |
30f725a1 BW |
317 | #define TC_FORCE_RELOCATION_SUB_SAME(fix, seg) \ |
318 | (! SEG_NORMAL (seg) || xtensa_force_relocation (fix)) | |
319 | #define TC_VALIDATE_FIX_SUB(fix) xtensa_validate_fix_sub (fix) | |
43cd72b9 | 320 | #define NO_PSEUDO_DOT xtensa_check_inside_bundle () |
e0001a05 | 321 | #define tc_canonicalize_symbol_name(s) xtensa_section_rename (s) |
9456465c | 322 | #define tc_canonicalize_section_name(s) xtensa_section_rename (s) |
e0001a05 NC |
323 | #define tc_init_after_args() xtensa_file_arch_init (stdoutput) |
324 | #define tc_fix_adjustable(fix) xtensa_fix_adjustable (fix) | |
325 | #define tc_frob_label(sym) xtensa_frob_label (sym) | |
43cd72b9 BW |
326 | #define tc_unrecognized_line(ch) xtensa_unrecognized_line (ch) |
327 | #define md_do_align(a,b,c,d,e) xtensa_flush_pending_output () | |
328 | #define md_elf_section_change_hook xtensa_elf_section_change_hook | |
e0001a05 NC |
329 | #define md_end xtensa_end |
330 | #define md_flush_pending_output() xtensa_flush_pending_output () | |
331 | #define md_operand(x) | |
332 | #define TEXT_SECTION_NAME xtensa_section_rename (".text") | |
333 | #define DATA_SECTION_NAME xtensa_section_rename (".data") | |
334 | #define BSS_SECTION_NAME xtensa_section_rename (".bss") | |
43cd72b9 | 335 | #define HANDLE_ALIGN(fragP) xtensa_handle_align (fragP) |
e0001a05 NC |
336 | |
337 | ||
338 | /* The renumber_section function must be mapped over all the sections | |
339 | after calling xtensa_post_relax_hook. That function is static in | |
340 | write.c so it cannot be called from xtensa_post_relax_hook itself. */ | |
341 | ||
342 | #define md_post_relax_hook \ | |
343 | do \ | |
344 | { \ | |
345 | int i = 0; \ | |
346 | xtensa_post_relax_hook (); \ | |
347 | bfd_map_over_sections (stdoutput, renumber_sections, &i); \ | |
348 | } \ | |
349 | while (0) | |
350 | ||
351 | ||
352 | /* Because xtensa relaxation can insert a new literal into the middle of | |
353 | fragment and thus require re-running the relaxation pass on the | |
354 | section, we need an explicit flag here. We explicitly use the name | |
355 | "stretched" here to avoid changing the source code in write.c. */ | |
356 | ||
357 | #define md_relax_frag(segment, fragP, stretch) \ | |
358 | xtensa_relax_frag (fragP, stretch, &stretched) | |
359 | ||
360 | ||
361 | #define LOCAL_LABELS_FB 1 | |
362 | #define WORKING_DOT_WORD 1 | |
363 | #define DOUBLESLASH_LINE_COMMENTS | |
364 | #define TC_HANDLES_FX_DONE | |
365 | #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 0 | |
43cd72b9 | 366 | #define TC_LINKRELAX_FIXUP(SEG) 0 |
e0001a05 | 367 | #define MD_APPLY_SYM_VALUE(FIX) 0 |
43cd72b9 BW |
368 | #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0 |
369 | ||
370 | ||
371 | /* Resource reservation info functions. */ | |
372 | ||
373 | /* Returns the number of copies of a particular unit. */ | |
374 | typedef int (*unit_num_copies_func) (void *, xtensa_funcUnit); | |
375 | ||
376 | /* Returns the number of units the opcode uses. */ | |
377 | typedef int (*opcode_num_units_func) (void *, xtensa_opcode); | |
378 | ||
c138bc38 | 379 | /* Given an opcode and an index into the opcode's funcUnit list, |
43cd72b9 BW |
380 | returns the unit used for the index. */ |
381 | typedef int (*opcode_funcUnit_use_unit_func) (void *, xtensa_opcode, int); | |
382 | ||
c138bc38 | 383 | /* Given an opcode and an index into the opcode's funcUnit list, |
43cd72b9 BW |
384 | returns the cycle during which the unit is used. */ |
385 | typedef int (*opcode_funcUnit_use_stage_func) (void *, xtensa_opcode, int); | |
386 | ||
c138bc38 | 387 | /* The above typedefs parameterize the resource_table so that the |
43cd72b9 | 388 | optional scheduler doesn't need its own resource reservation system. |
c138bc38 BW |
389 | |
390 | For simple resource checking, which is all that happens normally, | |
391 | the functions will be as follows (with some wrapping to make the | |
392 | interface more convenient): | |
43cd72b9 BW |
393 | |
394 | unit_num_copies_func = xtensa_funcUnit_num_copies | |
395 | opcode_num_units_func = xtensa_opcode_num_funcUnit_uses | |
396 | opcode_funcUnit_use_unit_func = xtensa_opcode_funcUnit_use->unit | |
397 | opcode_funcUnit_use_stage_func = xtensa_opcode_funcUnit_use->stage | |
398 | ||
c138bc38 | 399 | Of course the optional scheduler has its own reservation table |
43cd72b9 BW |
400 | and functions. */ |
401 | ||
7fa3d080 BW |
402 | int opcode_funcUnit_use_unit (void *, xtensa_opcode, int); |
403 | int opcode_funcUnit_use_stage (void *, xtensa_opcode, int); | |
43cd72b9 BW |
404 | |
405 | typedef struct | |
406 | { | |
407 | void *data; | |
408 | int cycles; | |
409 | int allocated_cycles; | |
410 | int num_units; | |
411 | unit_num_copies_func unit_num_copies; | |
412 | opcode_num_units_func opcode_num_units; | |
413 | opcode_funcUnit_use_unit_func opcode_unit_use; | |
414 | opcode_funcUnit_use_stage_func opcode_unit_stage; | |
0bf60745 | 415 | unsigned char **units; |
43cd72b9 BW |
416 | } resource_table; |
417 | ||
c138bc38 BW |
418 | resource_table *new_resource_table |
419 | (void *, int, int, unit_num_copies_func, opcode_num_units_func, | |
7fa3d080 BW |
420 | opcode_funcUnit_use_unit_func, opcode_funcUnit_use_stage_func); |
421 | void resize_resource_table (resource_table *, int); | |
422 | void clear_resource_table (resource_table *); | |
423 | bfd_boolean resources_available (resource_table *, xtensa_opcode, int); | |
424 | void reserve_resources (resource_table *, xtensa_opcode, int); | |
425 | void release_resources (resource_table *, xtensa_opcode, int); | |
e0001a05 | 426 | |
e0001a05 | 427 | #endif /* TC_XTENSA */ |