Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* frags.c - manage frags - |
b3adc24a | 2 | Copyright (C) 1987-2020 Free Software Foundation, Inc. |
252b5132 RH |
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 | |
ec2655a6 | 8 | the Free Software Foundation; either version 3, or (at your option) |
252b5132 RH |
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. */ | |
252b5132 RH |
20 | |
21 | #include "as.h" | |
22 | #include "subsegs.h" | |
23 | #include "obstack.h" | |
24 | ||
25 | extern fragS zero_address_frag; | |
6885131b | 26 | extern fragS predefined_address_frag; |
a82c7d90 DW |
27 | |
28 | static int totalfrags; | |
29 | ||
30 | int | |
31 | get_frag_count (void) | |
32 | { | |
33 | return totalfrags; | |
34 | } | |
35 | ||
36 | void | |
37 | clear_frag_count (void) | |
38 | { | |
39 | totalfrags = 0; | |
40 | } | |
252b5132 RH |
41 | \f |
42 | /* Initialization for frag routines. */ | |
29f8404c | 43 | |
252b5132 | 44 | void |
dd625418 | 45 | frag_init (void) |
252b5132 RH |
46 | { |
47 | zero_address_frag.fr_type = rs_fill; | |
6885131b | 48 | predefined_address_frag.fr_type = rs_fill; |
252b5132 RH |
49 | } |
50 | \f | |
e85ca5bb AM |
51 | /* Check that we're not trying to assemble into a section that can't |
52 | allocate frags (currently, this is only possible in the absolute | |
53 | section), or into an mri common. */ | |
54 | ||
55 | static void | |
56 | frag_alloc_check (const struct obstack *ob) | |
57 | { | |
58 | if (ob->chunk_size == 0) | |
59 | { | |
60 | as_bad (_("attempt to allocate data in absolute section")); | |
61 | subseg_set (text_section, 0); | |
62 | } | |
63 | ||
64 | if (mri_common_symbol != NULL) | |
65 | { | |
66 | as_bad (_("attempt to allocate data in common section")); | |
67 | mri_common_symbol = NULL; | |
68 | } | |
69 | } | |
70 | ||
252b5132 RH |
71 | /* Allocate a frag on the specified obstack. |
72 | Call this routine from everywhere else, so that all the weird alignment | |
73 | hackery can be done in just one place. */ | |
29f8404c | 74 | |
252b5132 | 75 | fragS * |
dd625418 | 76 | frag_alloc (struct obstack *ob) |
252b5132 RH |
77 | { |
78 | fragS *ptr; | |
79 | int oalign; | |
80 | ||
81 | (void) obstack_alloc (ob, 0); | |
82 | oalign = obstack_alignment_mask (ob); | |
83 | obstack_alignment_mask (ob) = 0; | |
1e9cc1c2 | 84 | ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG); |
252b5132 RH |
85 | obstack_alignment_mask (ob) = oalign; |
86 | memset (ptr, 0, SIZEOF_STRUCT_FRAG); | |
a82c7d90 | 87 | totalfrags++; |
252b5132 RH |
88 | return ptr; |
89 | } | |
90 | \f | |
088b3cd0 | 91 | /* Try to augment current frag by nchars chars. |
9e85f042 NC |
92 | If there is no room, close off the current frag with a ".fill 0" |
93 | and begin a new frag. Then loop until the new frag has at least | |
94 | nchars chars available. Does not set up any fields in frag_now. */ | |
29f8404c KH |
95 | |
96 | void | |
e57e6ddc | 97 | frag_grow (size_t nchars) |
252b5132 RH |
98 | { |
99 | if (obstack_room (&frchain_now->frch_obstack) < nchars) | |
100 | { | |
e57e6ddc AM |
101 | size_t oldc; |
102 | size_t newc; | |
252b5132 | 103 | |
ee192366 MM |
104 | /* Try to allocate a bit more than needed right now. But don't do |
105 | this if we would waste too much memory. Especially necessary | |
8d8385cf | 106 | for extremely big (like 2GB initialized) frags. */ |
ee192366 | 107 | if (nchars < 0x10000) |
8d8385cf | 108 | newc = 2 * nchars; |
ee192366 | 109 | else |
8d8385cf TG |
110 | newc = nchars + 0x10000; |
111 | newc += SIZEOF_STRUCT_FRAG; | |
112 | ||
113 | /* Check for possible overflow. */ | |
e57e6ddc | 114 | if (newc < nchars) |
992a06ee AM |
115 | as_fatal (ngettext ("can't extend frag %lu char", |
116 | "can't extend frag %lu chars", | |
117 | (unsigned long) nchars), | |
118 | (unsigned long) nchars); | |
8d8385cf | 119 | |
3db8daf3 MR |
120 | /* Force to allocate at least NEWC bytes, but not less than the |
121 | default. */ | |
8d8385cf | 122 | oldc = obstack_chunk_size (&frchain_now->frch_obstack); |
3db8daf3 MR |
123 | if (newc > oldc) |
124 | obstack_chunk_size (&frchain_now->frch_obstack) = newc; | |
8d8385cf TG |
125 | |
126 | while (obstack_room (&frchain_now->frch_obstack) < nchars) | |
127 | { | |
128 | /* Not enough room in this frag. Close it and start a new one. | |
129 | This must be done in a loop because the created frag may not | |
130 | be big enough if the current obstack chunk is used. */ | |
131 | frag_wane (frag_now); | |
132 | frag_new (0); | |
133 | } | |
134 | ||
135 | /* Restore the old chunk size. */ | |
136 | obstack_chunk_size (&frchain_now->frch_obstack) = oldc; | |
252b5132 | 137 | } |
252b5132 RH |
138 | } |
139 | \f | |
29f8404c KH |
140 | /* Call this to close off a completed frag, and start up a new (empty) |
141 | frag, in the same subsegment as the old frag. | |
142 | [frchain_now remains the same but frag_now is updated.] | |
143 | Because this calculates the correct value of fr_fix by | |
144 | looking at the obstack 'frags', it needs to know how many | |
145 | characters at the end of the old frag belong to the maximal | |
146 | variable part; The rest must belong to fr_fix. | |
147 | It doesn't actually set up the old frag's fr_var. You may have | |
148 | set fr_var == 1, but allocated 10 chars to the end of the frag; | |
149 | In this case you pass old_frags_var_max_size == 10. | |
150 | In fact, you may use fr_var for something totally unrelated to the | |
151 | size of the variable part of the frag; None of the generic frag | |
152 | handling code makes use of fr_var. | |
153 | ||
154 | Make a new frag, initialising some components. Link new frag at end | |
155 | of frchain_now. */ | |
156 | ||
157 | void | |
e57e6ddc | 158 | frag_new (size_t old_frags_var_max_size |
dd625418 KH |
159 | /* Number of chars (already allocated on obstack frags) in |
160 | variable_length part of frag. */) | |
252b5132 RH |
161 | { |
162 | fragS *former_last_fragP; | |
163 | frchainS *frchP; | |
164 | ||
9c2799c2 | 165 | gas_assert (frchain_now->frch_last == frag_now); |
252b5132 RH |
166 | |
167 | /* Fix up old frag's fr_fix. */ | |
871a6bd2 AM |
168 | frag_now->fr_fix = frag_now_fix_octets (); |
169 | gas_assert (frag_now->fr_fix >= old_frags_var_max_size); | |
170 | frag_now->fr_fix -= old_frags_var_max_size; | |
252b5132 | 171 | /* Make sure its type is valid. */ |
9c2799c2 | 172 | gas_assert (frag_now->fr_type != 0); |
252b5132 RH |
173 | |
174 | /* This will align the obstack so the next struct we allocate on it | |
29f8404c | 175 | will begin at a correct boundary. */ |
252b5132 RH |
176 | obstack_finish (&frchain_now->frch_obstack); |
177 | frchP = frchain_now; | |
178 | know (frchP); | |
179 | former_last_fragP = frchP->frch_last; | |
9c2799c2 NC |
180 | gas_assert (former_last_fragP != 0); |
181 | gas_assert (former_last_fragP == frag_now); | |
252b5132 RH |
182 | frag_now = frag_alloc (&frchP->frch_obstack); |
183 | ||
3b4dbbbf | 184 | frag_now->fr_file = as_where (&frag_now->fr_line); |
252b5132 RH |
185 | |
186 | /* Generally, frag_now->points to an address rounded up to next | |
187 | alignment. However, characters will add to obstack frags | |
188 | IMMEDIATELY after the struct frag, even if they are not starting | |
29f8404c | 189 | at an alignment address. */ |
252b5132 RH |
190 | former_last_fragP->fr_next = frag_now; |
191 | frchP->frch_last = frag_now; | |
192 | ||
193 | #ifndef NO_LISTING | |
194 | { | |
195 | extern struct list_info_struct *listing_tail; | |
196 | frag_now->line = listing_tail; | |
197 | } | |
198 | #endif | |
199 | ||
9c2799c2 | 200 | gas_assert (frchain_now->frch_last == frag_now); |
252b5132 RH |
201 | |
202 | frag_now->fr_next = NULL; | |
29f8404c | 203 | } |
252b5132 | 204 | \f |
29f8404c KH |
205 | /* Start a new frag unless we have n more chars of room in the current frag. |
206 | Close off the old frag with a .fill 0. | |
207 | ||
208 | Return the address of the 1st char to write into. Advance | |
209 | frag_now_growth past the new chars. */ | |
252b5132 RH |
210 | |
211 | char * | |
e57e6ddc | 212 | frag_more (size_t nchars) |
252b5132 | 213 | { |
ed9e98c2 | 214 | char *retval; |
252b5132 | 215 | |
e85ca5bb | 216 | frag_alloc_check (&frchain_now->frch_obstack); |
252b5132 RH |
217 | frag_grow (nchars); |
218 | retval = obstack_next_free (&frchain_now->frch_obstack); | |
219 | obstack_blank_fast (&frchain_now->frch_obstack, nchars); | |
ed9e98c2 | 220 | return retval; |
29f8404c | 221 | } |
252b5132 | 222 | \f |
69b1d605 TG |
223 | /* Close the current frag, setting its fields for a relaxable frag. Start a |
224 | new frag. */ | |
29f8404c | 225 | |
69b1d605 | 226 | static void |
e57e6ddc AM |
227 | frag_var_init (relax_stateT type, size_t max_chars, size_t var, |
228 | relax_substateT subtype, symbolS *symbol, offsetT offset, | |
69b1d605 | 229 | char *opcode) |
252b5132 | 230 | { |
252b5132 RH |
231 | frag_now->fr_var = var; |
232 | frag_now->fr_type = type; | |
233 | frag_now->fr_subtype = subtype; | |
234 | frag_now->fr_symbol = symbol; | |
235 | frag_now->fr_offset = offset; | |
236 | frag_now->fr_opcode = opcode; | |
237 | #ifdef USING_CGEN | |
238 | frag_now->fr_cgen.insn = 0; | |
239 | frag_now->fr_cgen.opindex = 0; | |
240 | frag_now->fr_cgen.opinfo = 0; | |
241 | #endif | |
242 | #ifdef TC_FRAG_INIT | |
db222310 | 243 | TC_FRAG_INIT (frag_now, max_chars); |
252b5132 | 244 | #endif |
3b4dbbbf | 245 | frag_now->fr_file = as_where (&frag_now->fr_line); |
69b1d605 | 246 | |
252b5132 | 247 | frag_new (max_chars); |
69b1d605 TG |
248 | } |
249 | ||
250 | /* Start a new frag unless we have max_chars more chars of room in the | |
251 | current frag. Close off the old frag with a .fill 0. | |
252 | ||
253 | Set up a machine_dependent relaxable frag, then start a new frag. | |
254 | Return the address of the 1st char of the var part of the old frag | |
255 | to write into. */ | |
256 | ||
257 | char * | |
e57e6ddc AM |
258 | frag_var (relax_stateT type, size_t max_chars, size_t var, |
259 | relax_substateT subtype, symbolS *symbol, offsetT offset, | |
260 | char *opcode) | |
69b1d605 | 261 | { |
ed9e98c2 | 262 | char *retval; |
69b1d605 TG |
263 | |
264 | frag_grow (max_chars); | |
265 | retval = obstack_next_free (&frchain_now->frch_obstack); | |
266 | obstack_blank_fast (&frchain_now->frch_obstack, max_chars); | |
267 | frag_var_init (type, max_chars, var, subtype, symbol, offset, opcode); | |
268 | return retval; | |
252b5132 RH |
269 | } |
270 | \f | |
29f8404c KH |
271 | /* OVE: This variant of frag_var assumes that space for the tail has been |
272 | allocated by caller. | |
273 | No call to frag_grow is done. */ | |
252b5132 RH |
274 | |
275 | char * | |
e57e6ddc | 276 | frag_variant (relax_stateT type, size_t max_chars, size_t var, |
dd625418 KH |
277 | relax_substateT subtype, symbolS *symbol, offsetT offset, |
278 | char *opcode) | |
252b5132 | 279 | { |
ed9e98c2 | 280 | char *retval; |
252b5132 RH |
281 | |
282 | retval = obstack_next_free (&frchain_now->frch_obstack); | |
69b1d605 TG |
283 | frag_var_init (type, max_chars, var, subtype, symbol, offset, opcode); |
284 | ||
285 | return retval; | |
29f8404c | 286 | } |
252b5132 | 287 | \f |
29f8404c KH |
288 | /* Reduce the variable end of a frag to a harmless state. */ |
289 | ||
290 | void | |
ed9e98c2 | 291 | frag_wane (fragS *fragP) |
252b5132 RH |
292 | { |
293 | fragP->fr_type = rs_fill; | |
294 | fragP->fr_offset = 0; | |
295 | fragP->fr_var = 0; | |
0530d30a RS |
296 | } |
297 | \f | |
298 | /* Return the number of bytes by which the current frag can be grown. */ | |
299 | ||
e57e6ddc | 300 | size_t |
0530d30a RS |
301 | frag_room (void) |
302 | { | |
303 | return obstack_room (&frchain_now->frch_obstack); | |
252b5132 RH |
304 | } |
305 | \f | |
306 | /* Make an alignment frag. The size of this frag will be adjusted to | |
307 | force the next frag to have the appropriate alignment. ALIGNMENT | |
308 | is the power of two to which to align. FILL_CHARACTER is the | |
309 | character to use to fill in any bytes which are skipped. MAX is | |
310 | the maximum number of characters to skip when doing the alignment, | |
311 | or 0 if there is no maximum. */ | |
312 | ||
29f8404c | 313 | void |
dd625418 | 314 | frag_align (int alignment, int fill_character, int max) |
252b5132 RH |
315 | { |
316 | if (now_seg == absolute_section) | |
317 | { | |
318 | addressT new_off; | |
65e68b04 | 319 | addressT mask; |
252b5132 | 320 | |
29f8404c KH |
321 | mask = (~(addressT) 0) << alignment; |
322 | new_off = (abs_section_offset + ~mask) & mask; | |
252b5132 RH |
323 | if (max == 0 || new_off - abs_section_offset <= (addressT) max) |
324 | abs_section_offset = new_off; | |
325 | } | |
326 | else | |
327 | { | |
328 | char *p; | |
329 | ||
330 | p = frag_var (rs_align, 1, 1, (relax_substateT) max, | |
331 | (symbolS *) 0, (offsetT) alignment, (char *) 0); | |
332 | *p = fill_character; | |
333 | } | |
334 | } | |
335 | ||
336 | /* Make an alignment frag like frag_align, but fill with a repeating | |
337 | pattern rather than a single byte. ALIGNMENT is the power of two | |
338 | to which to align. FILL_PATTERN is the fill pattern to repeat in | |
339 | the bytes which are skipped. N_FILL is the number of bytes in | |
340 | FILL_PATTERN. MAX is the maximum number of characters to skip when | |
341 | doing the alignment, or 0 if there is no maximum. */ | |
342 | ||
29f8404c | 343 | void |
dd625418 | 344 | frag_align_pattern (int alignment, const char *fill_pattern, |
e57e6ddc | 345 | size_t n_fill, int max) |
252b5132 RH |
346 | { |
347 | char *p; | |
348 | ||
349 | p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) max, | |
350 | (symbolS *) 0, (offsetT) alignment, (char *) 0); | |
351 | memcpy (p, fill_pattern, n_fill); | |
352 | } | |
353 | ||
0a9ef439 RH |
354 | /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop |
355 | instruction so that the disassembler does not choke on it. */ | |
356 | #ifndef NOP_OPCODE | |
357 | #define NOP_OPCODE 0x00 | |
358 | #endif | |
359 | ||
360 | /* Use this to restrict the amount of memory allocated for representing | |
361 | the alignment code. Needs to be large enough to hold any fixed sized | |
362 | prologue plus the replicating portion. */ | |
363 | #ifndef MAX_MEM_FOR_RS_ALIGN_CODE | |
364 | /* Assume that if HANDLE_ALIGN is not defined then no special action | |
365 | is required to code fill, which means that we get just repeat the | |
366 | one NOP_OPCODE byte. */ | |
367 | # ifndef HANDLE_ALIGN | |
368 | # define MAX_MEM_FOR_RS_ALIGN_CODE 1 | |
369 | # else | |
370 | # define MAX_MEM_FOR_RS_ALIGN_CODE ((1 << alignment) - 1) | |
371 | # endif | |
372 | #endif | |
373 | ||
374 | void | |
dd625418 | 375 | frag_align_code (int alignment, int max) |
0a9ef439 RH |
376 | { |
377 | char *p; | |
378 | ||
379 | p = frag_var (rs_align_code, MAX_MEM_FOR_RS_ALIGN_CODE, 1, | |
380 | (relax_substateT) max, (symbolS *) 0, | |
381 | (offsetT) alignment, (char *) 0); | |
382 | *p = NOP_OPCODE; | |
383 | } | |
384 | ||
252b5132 | 385 | addressT |
dd625418 | 386 | frag_now_fix_octets (void) |
252b5132 RH |
387 | { |
388 | if (now_seg == absolute_section) | |
389 | return abs_section_offset; | |
bea9907b | 390 | |
29f8404c KH |
391 | return ((char *) obstack_next_free (&frchain_now->frch_obstack) |
392 | - frag_now->fr_literal); | |
bea9907b TW |
393 | } |
394 | ||
395 | addressT | |
dd625418 | 396 | frag_now_fix (void) |
bea9907b | 397 | { |
61826503 CE |
398 | /* Symbols whose section has SEC_ELF_OCTETS set, |
399 | resolve to octets instead of target bytes. */ | |
400 | if (now_seg->flags & SEC_OCTETS) | |
401 | return frag_now_fix_octets (); | |
402 | else | |
403 | return frag_now_fix_octets () / OCTETS_PER_BYTE; | |
252b5132 RH |
404 | } |
405 | ||
406 | void | |
dd625418 | 407 | frag_append_1_char (int datum) |
252b5132 | 408 | { |
e85ca5bb | 409 | frag_alloc_check (&frchain_now->frch_obstack); |
252b5132 RH |
410 | if (obstack_room (&frchain_now->frch_obstack) <= 1) |
411 | { | |
412 | frag_wane (frag_now); | |
413 | frag_new (0); | |
414 | } | |
415 | obstack_1grow (&frchain_now->frch_obstack, datum); | |
416 | } | |
99630778 AM |
417 | |
418 | /* Return TRUE if FRAG1 and FRAG2 have a fixed relationship between | |
419 | their start addresses. Set OFFSET to the difference in address | |
420 | not already accounted for in the frag FR_ADDRESS. */ | |
421 | ||
422 | bfd_boolean | |
08ea7020 | 423 | frag_offset_fixed_p (const fragS *frag1, const fragS *frag2, offsetT *offset) |
99630778 | 424 | { |
6cbe03fb | 425 | const fragS *frag; |
08ea7020 | 426 | offsetT off; |
99630778 AM |
427 | |
428 | /* Start with offset initialised to difference between the two frags. | |
429 | Prior to assigning frag addresses this will be zero. */ | |
430 | off = frag1->fr_address - frag2->fr_address; | |
431 | if (frag1 == frag2) | |
432 | { | |
433 | *offset = off; | |
434 | return TRUE; | |
435 | } | |
436 | ||
437 | /* Maybe frag2 is after frag1. */ | |
438 | frag = frag1; | |
439 | while (frag->fr_type == rs_fill) | |
440 | { | |
441 | off += frag->fr_fix + frag->fr_offset * frag->fr_var; | |
442 | frag = frag->fr_next; | |
443 | if (frag == NULL) | |
444 | break; | |
445 | if (frag == frag2) | |
446 | { | |
447 | *offset = off; | |
448 | return TRUE; | |
449 | } | |
450 | } | |
451 | ||
452 | /* Maybe frag1 is after frag2. */ | |
ec651a3b | 453 | off = frag1->fr_address - frag2->fr_address; |
99630778 AM |
454 | frag = frag2; |
455 | while (frag->fr_type == rs_fill) | |
456 | { | |
457 | off -= frag->fr_fix + frag->fr_offset * frag->fr_var; | |
458 | frag = frag->fr_next; | |
459 | if (frag == NULL) | |
460 | break; | |
461 | if (frag == frag1) | |
462 | { | |
463 | *offset = off; | |
464 | return TRUE; | |
465 | } | |
466 | } | |
467 | ||
468 | return FALSE; | |
469 | } | |
38c3873e | 470 | |
058430b4 AM |
471 | /* Return TRUE if FRAG2 follows FRAG1 with a fixed relationship |
472 | between the two assuming alignment frags do nothing. Set OFFSET to | |
473 | the difference in address not already accounted for in the frag | |
474 | FR_ADDRESS. */ | |
475 | ||
476 | bfd_boolean | |
477 | frag_offset_ignore_align_p (const fragS *frag1, const fragS *frag2, | |
478 | offsetT *offset) | |
479 | { | |
480 | const fragS *frag; | |
481 | offsetT off; | |
482 | ||
483 | /* Start with offset initialised to difference between the two frags. | |
484 | Prior to assigning frag addresses this will be zero. */ | |
485 | off = frag1->fr_address - frag2->fr_address; | |
486 | if (frag1 == frag2) | |
487 | { | |
488 | *offset = off; | |
489 | return TRUE; | |
490 | } | |
491 | ||
492 | frag = frag1; | |
493 | while (frag->fr_type == rs_fill | |
494 | || frag->fr_type == rs_align | |
495 | || frag->fr_type == rs_align_code | |
496 | || frag->fr_type == rs_align_test) | |
497 | { | |
498 | if (frag->fr_type == rs_fill) | |
499 | off += frag->fr_fix + frag->fr_offset * frag->fr_var; | |
500 | frag = frag->fr_next; | |
501 | if (frag == NULL) | |
502 | break; | |
503 | if (frag == frag2) | |
504 | { | |
505 | *offset = off; | |
506 | return TRUE; | |
507 | } | |
508 | } | |
509 | ||
510 | return FALSE; | |
511 | } | |
512 | ||
38c3873e AO |
513 | /* Return TRUE if we can determine whether FRAG2 OFF2 appears after |
514 | (strict >, not >=) FRAG1 OFF1, assuming it is not before. Set | |
515 | *OFFSET so that resolve_expression will resolve an O_gt operation | |
516 | between them to false (0) if they are guaranteed to be at the same | |
517 | location, or to true (-1) if they are guaranteed to be at different | |
518 | locations. Return FALSE conservatively, e.g. if neither result can | |
519 | be guaranteed (yet). | |
520 | ||
521 | They are known to be in the same segment, and not the same frag | |
522 | (this is a fallback for frag_offset_fixed_p, that always takes care | |
523 | of this case), and it is expected (from the uses this is designed | |
524 | to simplify, namely location view increments) that frag2 is | |
525 | reachable from frag1 following the fr_next links, rather than the | |
526 | other way round. */ | |
527 | ||
528 | bfd_boolean | |
529 | frag_gtoffset_p (valueT off2, const fragS *frag2, | |
530 | valueT off1, const fragS *frag1, offsetT *offset) | |
531 | { | |
532 | /* Insanity check. */ | |
533 | if (frag2 == frag1 || off1 > frag1->fr_fix) | |
534 | return FALSE; | |
535 | ||
536 | /* If the first symbol offset is at the end of the first frag and | |
537 | the second symbol offset at the beginning of the second frag then | |
538 | it is possible they are at the same address. Go looking for a | |
539 | non-zero fr_fix in any frag between these frags. If found then | |
540 | we can say the O_gt result will be true. If no such frag is | |
541 | found we assume that frag1 or any of the following frags might | |
542 | have a variable tail and thus the answer is unknown. This isn't | |
543 | strictly true; some frags don't have a variable tail, but it | |
544 | doesn't seem worth optimizing for those cases. */ | |
545 | const fragS *frag = frag1; | |
546 | offsetT delta = off2 - off1; | |
547 | for (;;) | |
548 | { | |
549 | delta += frag->fr_fix; | |
550 | frag = frag->fr_next; | |
551 | if (frag == frag2) | |
552 | { | |
553 | if (delta == 0) | |
554 | return FALSE; | |
555 | break; | |
556 | } | |
557 | /* If we run off the end of the frag chain then we have a case | |
558 | where frag2 is not after frag1, ie. an O_gt expression not | |
559 | created for .loc view. */ | |
560 | if (frag == NULL) | |
561 | return FALSE; | |
562 | } | |
563 | ||
564 | *offset = (off2 - off1 - delta) * OCTETS_PER_BYTE; | |
565 | return TRUE; | |
566 | } |