1 /* frags.c - manage frags -
2    Copyright (C) 1987-2020 Free Software Foundation, Inc.
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 3, 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
18    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
19    02110-1301, USA.  */
20 
21 #include "as.h"
22 #include "subsegs.h"
23 #include "obstack.h"
24 
25 extern fragS zero_address_frag;
26 extern fragS predefined_address_frag;
27 
28 static int totalfrags;
29 
30 int
get_frag_count(void)31 get_frag_count (void)
32 {
33   return totalfrags;
34 }
35 
36 void
clear_frag_count(void)37 clear_frag_count (void)
38 {
39   totalfrags = 0;
40 }
41 
42 /* Initialization for frag routines.  */
43 
44 void
frag_init(void)45 frag_init (void)
46 {
47   zero_address_frag.fr_type = rs_fill;
48   predefined_address_frag.fr_type = rs_fill;
49 }
50 
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
frag_alloc_check(const struct obstack * ob)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 
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.  */
74 
75 fragS *
frag_alloc(struct obstack * ob)76 frag_alloc (struct obstack *ob)
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;
84   ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG);
85   obstack_alignment_mask (ob) = oalign;
86   memset (ptr, 0, SIZEOF_STRUCT_FRAG);
87   totalfrags++;
88   return ptr;
89 }
90 
91 /* Try to augment current frag by nchars chars.
92    If there is no room, close of the current frag with a ".fill 0"
93    and begin a new frag. Unless the new frag has nchars chars available
94    do not return. Do not set up any fields of *now_frag.  */
95 
96 void
frag_grow(size_t nchars)97 frag_grow (size_t nchars)
98 {
99   if (obstack_room (&frchain_now->frch_obstack) < nchars)
100     {
101       size_t oldc;
102       size_t newc;
103 
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
106          for extremely big (like 2GB initialized) frags.  */
107       if (nchars < 0x10000)
108         newc = 2 * nchars;
109       else
110         newc = nchars + 0x10000;
111       newc += SIZEOF_STRUCT_FRAG;
112 
113       /* Check for possible overflow.  */
114       if (newc < nchars)
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);
119 
120       /* Force to allocate at least NEWC bytes, but not less than the
121          default.  */
122       oldc = obstack_chunk_size (&frchain_now->frch_obstack);
123       if (newc > oldc)
124 	obstack_chunk_size (&frchain_now->frch_obstack) = newc;
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;
137     }
138 }
139 
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
frag_new(size_t old_frags_var_max_size)158 frag_new (size_t old_frags_var_max_size
159 	  /* Number of chars (already allocated on obstack frags) in
160 	     variable_length part of frag.  */)
161 {
162   fragS *former_last_fragP;
163   frchainS *frchP;
164 
165   gas_assert (frchain_now->frch_last == frag_now);
166 
167   /* Fix up old frag's fr_fix.  */
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;
171   /* Make sure its type is valid.  */
172   gas_assert (frag_now->fr_type != 0);
173 
174   /* This will align the obstack so the next struct we allocate on it
175      will begin at a correct boundary.  */
176   obstack_finish (&frchain_now->frch_obstack);
177   frchP = frchain_now;
178   know (frchP);
179   former_last_fragP = frchP->frch_last;
180   gas_assert (former_last_fragP != 0);
181   gas_assert (former_last_fragP == frag_now);
182   frag_now = frag_alloc (&frchP->frch_obstack);
183 
184   frag_now->fr_file = as_where (&frag_now->fr_line);
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
189      at an alignment address.  */
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 
200   gas_assert (frchain_now->frch_last == frag_now);
201 
202   frag_now->fr_next = NULL;
203 }
204 
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.  */
210 
211 char *
frag_more(size_t nchars)212 frag_more (size_t nchars)
213 {
214   char *retval;
215 
216   frag_alloc_check (&frchain_now->frch_obstack);
217   frag_grow (nchars);
218   retval = obstack_next_free (&frchain_now->frch_obstack);
219   obstack_blank_fast (&frchain_now->frch_obstack, nchars);
220   return retval;
221 }
222 
223 /* Close the current frag, setting its fields for a relaxable frag.  Start a
224    new frag.  */
225 
226 static void
frag_var_init(relax_stateT type,size_t max_chars,size_t var,relax_substateT subtype,symbolS * symbol,offsetT offset,char * opcode)227 frag_var_init (relax_stateT type, size_t max_chars, size_t var,
228 	       relax_substateT subtype, symbolS *symbol, offsetT offset,
229                char *opcode)
230 {
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
243   TC_FRAG_INIT (frag_now, max_chars);
244 #endif
245   frag_now->fr_file = as_where (&frag_now->fr_line);
246 
247   frag_new (max_chars);
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 *
frag_var(relax_stateT type,size_t max_chars,size_t var,relax_substateT subtype,symbolS * symbol,offsetT offset,char * opcode)258 frag_var (relax_stateT type, size_t max_chars, size_t var,
259 	  relax_substateT subtype, symbolS *symbol, offsetT offset,
260 	  char *opcode)
261 {
262   char *retval;
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;
269 }
270 
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.  */
274 
275 char *
frag_variant(relax_stateT type,size_t max_chars,size_t var,relax_substateT subtype,symbolS * symbol,offsetT offset,char * opcode)276 frag_variant (relax_stateT type, size_t max_chars, size_t var,
277 	      relax_substateT subtype, symbolS *symbol, offsetT offset,
278 	      char *opcode)
279 {
280   char *retval;
281 
282   retval = obstack_next_free (&frchain_now->frch_obstack);
283   frag_var_init (type, max_chars, var, subtype, symbol, offset, opcode);
284 
285   return retval;
286 }
287 
288 /* Reduce the variable end of a frag to a harmless state.  */
289 
290 void
frag_wane(fragS * fragP)291 frag_wane (fragS *fragP)
292 {
293   fragP->fr_type = rs_fill;
294   fragP->fr_offset = 0;
295   fragP->fr_var = 0;
296 }
297 
298 /* Return the number of bytes by which the current frag can be grown.  */
299 
300 size_t
frag_room(void)301 frag_room (void)
302 {
303   return obstack_room (&frchain_now->frch_obstack);
304 }
305 
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 
313 void
frag_align(int alignment,int fill_character,int max)314 frag_align (int alignment, int fill_character, int max)
315 {
316   if (now_seg == absolute_section)
317     {
318       addressT new_off;
319       addressT mask;
320 
321       mask = (~(addressT) 0) << alignment;
322       new_off = (abs_section_offset + ~mask) & mask;
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 
343 void
frag_align_pattern(int alignment,const char * fill_pattern,size_t n_fill,int max)344 frag_align_pattern (int alignment, const char *fill_pattern,
345 		    size_t n_fill, int max)
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 
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
frag_align_code(int alignment,int max)375 frag_align_code (int alignment, int max)
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 
385 addressT
frag_now_fix_octets(void)386 frag_now_fix_octets (void)
387 {
388   if (now_seg == absolute_section)
389     return abs_section_offset;
390 
391   return ((char *) obstack_next_free (&frchain_now->frch_obstack)
392 	  - frag_now->fr_literal);
393 }
394 
395 addressT
frag_now_fix(void)396 frag_now_fix (void)
397 {
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;
404 }
405 
406 void
frag_append_1_char(int datum)407 frag_append_1_char (int datum)
408 {
409   frag_alloc_check (&frchain_now->frch_obstack);
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 }
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
frag_offset_fixed_p(const fragS * frag1,const fragS * frag2,offsetT * offset)423 frag_offset_fixed_p (const fragS *frag1, const fragS *frag2, offsetT *offset)
424 {
425   const fragS *frag;
426   offsetT off;
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.  */
453   off = frag1->fr_address - frag2->fr_address;
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 }
470 
471 /* Return TRUE if we can determine whether FRAG2 OFF2 appears after
472    (strict >, not >=) FRAG1 OFF1, assuming it is not before.  Set
473    *OFFSET so that resolve_expression will resolve an O_gt operation
474    between them to false (0) if they are guaranteed to be at the same
475    location, or to true (-1) if they are guaranteed to be at different
476    locations.  Return FALSE conservatively, e.g. if neither result can
477    be guaranteed (yet).
478 
479    They are known to be in the same segment, and not the same frag
480    (this is a fallback for frag_offset_fixed_p, that always takes care
481    of this case), and it is expected (from the uses this is designed
482    to simplify, namely location view increments) that frag2 is
483    reachable from frag1 following the fr_next links, rather than the
484    other way round.  */
485 
486 bfd_boolean
frag_gtoffset_p(valueT off2,const fragS * frag2,valueT off1,const fragS * frag1,offsetT * offset)487 frag_gtoffset_p (valueT off2, const fragS *frag2,
488 		 valueT off1, const fragS *frag1, offsetT *offset)
489 {
490   /* Insanity check.  */
491   if (frag2 == frag1 || off1 > frag1->fr_fix)
492     return FALSE;
493 
494   /* If the first symbol offset is at the end of the first frag and
495      the second symbol offset at the beginning of the second frag then
496      it is possible they are at the same address.  Go looking for a
497      non-zero fr_fix in any frag between these frags.  If found then
498      we can say the O_gt result will be true.  If no such frag is
499      found we assume that frag1 or any of the following frags might
500      have a variable tail and thus the answer is unknown.  This isn't
501      strictly true; some frags don't have a variable tail, but it
502      doesn't seem worth optimizing for those cases.  */
503   const fragS *frag = frag1;
504   offsetT delta = off2 - off1;
505   for (;;)
506     {
507       delta += frag->fr_fix;
508       frag = frag->fr_next;
509       if (frag == frag2)
510 	{
511 	  if (delta == 0)
512 	    return FALSE;
513 	  break;
514 	}
515       /* If we run off the end of the frag chain then we have a case
516 	 where frag2 is not after frag1, ie. an O_gt expression not
517 	 created for .loc view.  */
518       if (frag == NULL)
519 	return FALSE;
520     }
521 
522   *offset = (off2 - off1 - delta) * OCTETS_PER_BYTE;
523   return TRUE;
524 }
525