Commit | Line | Data |
---|---|---|
e0001a05 | 1 | /* tc-xtensa.h -- Header file for tc-xtensa.c. |
63a7429b | 2 | Copyright (C) 2003, 2004, 2005, 2007 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 | ||
99ded152 BW |
170 | RELAX_ORG, |
171 | /* This marks the location as having previously been an rs_org frag. | |
172 | rs_org frags are converted to fill-zero frags immediately after | |
173 | relaxation. However, we need to remember where they were so we can | |
174 | prevent the linker from changing the size of any frag between the | |
175 | section start and the org frag. */ | |
176 | ||
43cd72b9 BW |
177 | RELAX_NONE |
178 | }; | |
179 | ||
180 | /* This is used as a stopper to bound the number of steps that | |
181 | can be taken. */ | |
182 | #define RELAX_IMMED_MAXSTEPS (RELAX_IMMED_STEP2 - RELAX_IMMED) | |
183 | ||
e0001a05 NC |
184 | struct xtensa_frag_type |
185 | { | |
43cd72b9 BW |
186 | /* Info about the current state of assembly, e.g., transform, |
187 | absolute_literals, etc. These need to be passed to the backend and | |
188 | then to the object file. | |
189 | ||
190 | When is_assembly_state_set is false, the frag inherits some of the | |
191 | state settings from the previous frag in this segment. Because it | |
192 | is not possible to intercept all fragment closures (frag_more and | |
193 | frag_append_1_char can close a frag), we use a pass after initial | |
194 | assembly to fill in the assembly states. */ | |
195 | ||
196 | unsigned int is_assembly_state_set : 1; | |
197 | unsigned int is_no_density : 1; | |
198 | unsigned int is_no_transform : 1; | |
7c834684 | 199 | unsigned int use_longcalls : 1; |
43cd72b9 BW |
200 | unsigned int use_absolute_literals : 1; |
201 | ||
202 | /* Inhibits relaxation of machine-dependent alignment frags the | |
203 | first time through a relaxation.... */ | |
204 | unsigned int relax_seen : 1; | |
205 | ||
0fa77c95 | 206 | /* Information that is needed in the object file and set when known. */ |
43cd72b9 BW |
207 | unsigned int is_literal : 1; |
208 | unsigned int is_loop_target : 1; | |
209 | unsigned int is_branch_target : 1; | |
210 | unsigned int is_insn : 1; | |
211 | unsigned int is_unreachable : 1; | |
e0001a05 | 212 | |
43cd72b9 | 213 | unsigned int is_specific_opcode : 1; /* also implies no_transform */ |
e0001a05 | 214 | |
43cd72b9 BW |
215 | unsigned int is_align : 1; |
216 | unsigned int is_text_align : 1; | |
217 | unsigned int alignment : 5; | |
218 | ||
219 | /* A frag with this bit set is the first in a loop that actually | |
220 | contains an instruction. */ | |
221 | unsigned int is_first_loop_insn : 1; | |
e0001a05 | 222 | |
b5e4a23d BW |
223 | /* A frag with this bit set is a branch that we are using to |
224 | align branch targets as if it were a normal narrow instruction. */ | |
225 | unsigned int is_aligning_branch : 1; | |
226 | ||
e0001a05 NC |
227 | /* For text fragments that can generate literals at relax time, this |
228 | variable points to the frag where the literal will be stored. For | |
229 | literal frags, this variable points to the nearest literal pool | |
230 | location frag. This literal frag will be moved to after this | |
c48aaca0 BW |
231 | location. For RELAX_LITERAL_POOL_BEGIN frags, this field points |
232 | to the frag immediately before the corresponding RELAX_LITERAL_POOL_END | |
233 | frag, to make moving frags for this literal pool efficient. */ | |
e0001a05 NC |
234 | fragS *literal_frag; |
235 | ||
236 | /* The destination segment for literal frags. (Note that this is only | |
dd49a749 BW |
237 | valid after xtensa_move_literals.) This field is also used for |
238 | LITERAL_POOL_END frags. */ | |
e0001a05 NC |
239 | segT lit_seg; |
240 | ||
dd49a749 BW |
241 | /* Frag chain for LITERAL_POOL_BEGIN frags. */ |
242 | struct frchain *lit_frchain; | |
243 | ||
e0001a05 NC |
244 | /* For the relaxation scheme, some literal fragments can have their |
245 | expansions modified by an instruction that relaxes. */ | |
43cd72b9 BW |
246 | int text_expansion[MAX_SLOTS]; |
247 | int literal_expansion[MAX_SLOTS]; | |
248 | int unreported_expansion; | |
249 | ||
250 | /* For text fragments that can generate literals at relax time: */ | |
251 | fragS *literal_frags[MAX_SLOTS]; | |
252 | enum xtensa_relax_statesE slot_subtypes[MAX_SLOTS]; | |
253 | symbolS *slot_symbols[MAX_SLOTS]; | |
43cd72b9 BW |
254 | offsetT slot_offsets[MAX_SLOTS]; |
255 | ||
256 | /* The global aligner needs to walk backward through the list of | |
257 | frags. This field is only valid after xtensa_end. */ | |
258 | fragS *fr_prev; | |
e0001a05 NC |
259 | }; |
260 | ||
43cd72b9 BW |
261 | |
262 | /* For VLIW support, we need to know what slot a fixup applies to. */ | |
263 | typedef struct xtensa_fix_data_struct | |
264 | { | |
265 | int slot; | |
266 | symbolS *X_add_symbol; | |
267 | offsetT X_add_number; | |
268 | } xtensa_fix_data; | |
269 | ||
270 | ||
271 | /* Structure to record xtensa-specific symbol information. */ | |
272 | typedef struct xtensa_symfield_type | |
e0001a05 | 273 | { |
43cd72b9 BW |
274 | unsigned int is_loop_target : 1; |
275 | unsigned int is_branch_target : 1; | |
276 | } xtensa_symfield_type; | |
277 | ||
278 | ||
279 | /* Structure for saving information about a block of property data | |
280 | for frags that have the same flags. The forward reference is | |
281 | in this header file. The actual definition is in tc-xtensa.c. */ | |
282 | struct xtensa_block_info_struct; | |
283 | typedef struct xtensa_block_info_struct xtensa_block_info; | |
284 | ||
e0001a05 | 285 | |
43cd72b9 | 286 | /* Property section types. */ |
e0001a05 NC |
287 | typedef enum |
288 | { | |
e0001a05 | 289 | xt_literal_sec, |
43cd72b9 | 290 | xt_prop_sec, |
e0001a05 NC |
291 | max_xt_sec |
292 | } xt_section_type; | |
293 | ||
294 | typedef struct xtensa_segment_info_struct | |
295 | { | |
296 | fragS *literal_pool_loc; | |
297 | xtensa_block_info *blocks[max_xt_sec]; | |
298 | } xtensa_segment_info; | |
299 | ||
e0001a05 | 300 | |
7fa3d080 BW |
301 | extern const char *xtensa_target_format (void); |
302 | extern void xtensa_init_fix_data (struct fix *); | |
303 | extern void xtensa_frag_init (fragS *); | |
304 | extern int xtensa_force_relocation (struct fix *); | |
30f725a1 | 305 | extern int xtensa_validate_fix_sub (struct fix *); |
7fa3d080 BW |
306 | extern void xtensa_frob_label (struct symbol *); |
307 | extern void xtensa_end (void); | |
308 | extern void xtensa_post_relax_hook (void); | |
309 | extern void xtensa_file_arch_init (bfd *); | |
310 | extern void xtensa_flush_pending_output (void); | |
311 | extern bfd_boolean xtensa_fix_adjustable (struct fix *); | |
312 | extern void xtensa_symbol_new_hook (symbolS *); | |
313 | extern long xtensa_relax_frag (fragS *, long, int *); | |
314 | extern void xtensa_elf_section_change_hook (void); | |
315 | extern int xtensa_unrecognized_line (int); | |
316 | extern bfd_boolean xtensa_check_inside_bundle (void); | |
317 | extern void xtensa_handle_align (fragS *); | |
9456465c | 318 | extern char *xtensa_section_rename (char *); |
e0001a05 NC |
319 | |
320 | #define TARGET_FORMAT xtensa_target_format () | |
321 | #define TARGET_ARCH bfd_arch_xtensa | |
322 | #define TC_SEGMENT_INFO_TYPE xtensa_segment_info | |
43cd72b9 BW |
323 | #define TC_SYMFIELD_TYPE struct xtensa_symfield_type |
324 | #define TC_FIX_TYPE xtensa_fix_data | |
325 | #define TC_INIT_FIX_DATA(x) xtensa_init_fix_data (x) | |
e0001a05 NC |
326 | #define TC_FRAG_TYPE struct xtensa_frag_type |
327 | #define TC_FRAG_INIT(frag) xtensa_frag_init (frag) | |
43cd72b9 | 328 | #define TC_FORCE_RELOCATION(fix) xtensa_force_relocation (fix) |
30f725a1 BW |
329 | #define TC_FORCE_RELOCATION_SUB_SAME(fix, seg) \ |
330 | (! SEG_NORMAL (seg) || xtensa_force_relocation (fix)) | |
331 | #define TC_VALIDATE_FIX_SUB(fix) xtensa_validate_fix_sub (fix) | |
43cd72b9 | 332 | #define NO_PSEUDO_DOT xtensa_check_inside_bundle () |
e0001a05 | 333 | #define tc_canonicalize_symbol_name(s) xtensa_section_rename (s) |
9456465c | 334 | #define tc_canonicalize_section_name(s) xtensa_section_rename (s) |
e0001a05 NC |
335 | #define tc_init_after_args() xtensa_file_arch_init (stdoutput) |
336 | #define tc_fix_adjustable(fix) xtensa_fix_adjustable (fix) | |
337 | #define tc_frob_label(sym) xtensa_frob_label (sym) | |
43cd72b9 BW |
338 | #define tc_unrecognized_line(ch) xtensa_unrecognized_line (ch) |
339 | #define md_do_align(a,b,c,d,e) xtensa_flush_pending_output () | |
340 | #define md_elf_section_change_hook xtensa_elf_section_change_hook | |
e0001a05 NC |
341 | #define md_end xtensa_end |
342 | #define md_flush_pending_output() xtensa_flush_pending_output () | |
343 | #define md_operand(x) | |
344 | #define TEXT_SECTION_NAME xtensa_section_rename (".text") | |
345 | #define DATA_SECTION_NAME xtensa_section_rename (".data") | |
346 | #define BSS_SECTION_NAME xtensa_section_rename (".bss") | |
43cd72b9 | 347 | #define HANDLE_ALIGN(fragP) xtensa_handle_align (fragP) |
cf523b8e | 348 | #define MAX_MEM_FOR_RS_ALIGN_CODE 1 |
e0001a05 NC |
349 | |
350 | ||
351 | /* The renumber_section function must be mapped over all the sections | |
352 | after calling xtensa_post_relax_hook. That function is static in | |
353 | write.c so it cannot be called from xtensa_post_relax_hook itself. */ | |
354 | ||
355 | #define md_post_relax_hook \ | |
356 | do \ | |
357 | { \ | |
358 | int i = 0; \ | |
359 | xtensa_post_relax_hook (); \ | |
360 | bfd_map_over_sections (stdoutput, renumber_sections, &i); \ | |
361 | } \ | |
362 | while (0) | |
363 | ||
364 | ||
365 | /* Because xtensa relaxation can insert a new literal into the middle of | |
366 | fragment and thus require re-running the relaxation pass on the | |
367 | section, we need an explicit flag here. We explicitly use the name | |
368 | "stretched" here to avoid changing the source code in write.c. */ | |
369 | ||
370 | #define md_relax_frag(segment, fragP, stretch) \ | |
371 | xtensa_relax_frag (fragP, stretch, &stretched) | |
372 | ||
373 | ||
374 | #define LOCAL_LABELS_FB 1 | |
375 | #define WORKING_DOT_WORD 1 | |
376 | #define DOUBLESLASH_LINE_COMMENTS | |
377 | #define TC_HANDLES_FX_DONE | |
378 | #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 0 | |
43cd72b9 | 379 | #define TC_LINKRELAX_FIXUP(SEG) 0 |
e0001a05 | 380 | #define MD_APPLY_SYM_VALUE(FIX) 0 |
43cd72b9 BW |
381 | #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0 |
382 | ||
1737851b BW |
383 | /* Use line number format that is amenable to linker relaxation. */ |
384 | #define DWARF2_USE_FIXED_ADVANCE_PC (linkrelax != 0) | |
385 | ||
43cd72b9 BW |
386 | |
387 | /* Resource reservation info functions. */ | |
388 | ||
389 | /* Returns the number of copies of a particular unit. */ | |
390 | typedef int (*unit_num_copies_func) (void *, xtensa_funcUnit); | |
391 | ||
392 | /* Returns the number of units the opcode uses. */ | |
393 | typedef int (*opcode_num_units_func) (void *, xtensa_opcode); | |
394 | ||
c138bc38 | 395 | /* Given an opcode and an index into the opcode's funcUnit list, |
43cd72b9 BW |
396 | returns the unit used for the index. */ |
397 | typedef int (*opcode_funcUnit_use_unit_func) (void *, xtensa_opcode, int); | |
398 | ||
c138bc38 | 399 | /* Given an opcode and an index into the opcode's funcUnit list, |
43cd72b9 BW |
400 | returns the cycle during which the unit is used. */ |
401 | typedef int (*opcode_funcUnit_use_stage_func) (void *, xtensa_opcode, int); | |
402 | ||
c138bc38 | 403 | /* The above typedefs parameterize the resource_table so that the |
43cd72b9 | 404 | optional scheduler doesn't need its own resource reservation system. |
c138bc38 BW |
405 | |
406 | For simple resource checking, which is all that happens normally, | |
407 | the functions will be as follows (with some wrapping to make the | |
408 | interface more convenient): | |
43cd72b9 BW |
409 | |
410 | unit_num_copies_func = xtensa_funcUnit_num_copies | |
411 | opcode_num_units_func = xtensa_opcode_num_funcUnit_uses | |
412 | opcode_funcUnit_use_unit_func = xtensa_opcode_funcUnit_use->unit | |
413 | opcode_funcUnit_use_stage_func = xtensa_opcode_funcUnit_use->stage | |
414 | ||
c138bc38 | 415 | Of course the optional scheduler has its own reservation table |
43cd72b9 BW |
416 | and functions. */ |
417 | ||
7fa3d080 BW |
418 | int opcode_funcUnit_use_unit (void *, xtensa_opcode, int); |
419 | int opcode_funcUnit_use_stage (void *, xtensa_opcode, int); | |
43cd72b9 BW |
420 | |
421 | typedef struct | |
422 | { | |
423 | void *data; | |
424 | int cycles; | |
425 | int allocated_cycles; | |
426 | int num_units; | |
427 | unit_num_copies_func unit_num_copies; | |
428 | opcode_num_units_func opcode_num_units; | |
429 | opcode_funcUnit_use_unit_func opcode_unit_use; | |
430 | opcode_funcUnit_use_stage_func opcode_unit_stage; | |
0bf60745 | 431 | unsigned char **units; |
43cd72b9 BW |
432 | } resource_table; |
433 | ||
c138bc38 BW |
434 | resource_table *new_resource_table |
435 | (void *, int, int, unit_num_copies_func, opcode_num_units_func, | |
7fa3d080 BW |
436 | opcode_funcUnit_use_unit_func, opcode_funcUnit_use_stage_func); |
437 | void resize_resource_table (resource_table *, int); | |
438 | void clear_resource_table (resource_table *); | |
439 | bfd_boolean resources_available (resource_table *, xtensa_opcode, int); | |
440 | void reserve_resources (resource_table *, xtensa_opcode, int); | |
441 | void release_resources (resource_table *, xtensa_opcode, int); | |
e0001a05 | 442 | |
e0001a05 | 443 | #endif /* TC_XTENSA */ |