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 31 get_frag_count (void) 32 { 33 return totalfrags; 34 } 35 36 void 37 clear_frag_count (void) 38 { 39 totalfrags = 0; 40 } 41 42 /* Initialization for frag routines. */ 43 44 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 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 * 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 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 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 * 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 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 * 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 * 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 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 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 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 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 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 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 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 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 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 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