1 /* Mach-O object file format 2 Copyright (C) 2009-2014 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 8 published by the Free Software Foundation; either version 3, 9 or (at your option) any later version. 10 11 GAS is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 14 the 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 /* Here we handle the mach-o directives that are common to all architectures. 22 23 Most significant are mach-o named sections and a variety of symbol type 24 decorations. */ 25 26 /* Mach-O supports multiple, named segments each of which may contain 27 multiple named sections. Thus the concept of subsectioning is 28 handled by (say) having a __TEXT segment with appropriate flags from 29 which subsections are generated like __text, __const etc. 30 31 The well-known as short-hand section switch directives like .text, .data 32 etc. are mapped onto predefined segment/section pairs using facilites 33 supplied by the mach-o port of bfd. 34 35 A number of additional mach-o short-hand section switch directives are 36 also defined. */ 37 38 #define OBJ_HEADER "obj-macho.h" 39 40 #include "as.h" 41 #include "subsegs.h" 42 #include "symbols.h" 43 #include "write.h" 44 #include "mach-o.h" 45 #include "mach-o/loader.h" 46 #include "obj-macho.h" 47 48 #include <string.h> 49 50 /* Forward decls. */ 51 static segT obj_mach_o_segT_from_bfd_name (const char *, int); 52 53 /* TODO: Implement "-dynamic"/"-static" command line options. */ 54 55 static int obj_mach_o_is_static; 56 57 /* TODO: Implement the "-n" command line option to suppress the initial 58 switch to the text segment. */ 59 60 static int obj_mach_o_start_with_text_section = 1; 61 62 /* Allow for special re-ordering on output. */ 63 64 static int obj_mach_o_seen_objc_section; 65 66 /* Start-up: At present, just create the sections we want. */ 67 void 68 mach_o_begin (void) 69 { 70 /* Mach-O only defines the .text section by default, and even this can 71 be suppressed by a flag. In the latter event, the first code MUST 72 be a section definition. */ 73 if (obj_mach_o_start_with_text_section) 74 { 75 text_section = obj_mach_o_segT_from_bfd_name (TEXT_SECTION_NAME, 1); 76 subseg_set (text_section, 0); 77 if (obj_mach_o_is_static) 78 { 79 bfd_mach_o_section *mo_sec 80 = bfd_mach_o_get_mach_o_section (text_section); 81 mo_sec->flags &= ~BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS; 82 } 83 } 84 } 85 86 /* Remember the subsections_by_symbols state in case we need to reset 87 the file flags. */ 88 89 static int obj_mach_o_subsections_by_symbols; 90 91 /* This will put at most 16 characters (terminated by a ',' or newline) from 92 the input stream into dest. If there are more than 16 chars before the 93 delimiter, a warning is given and the string is truncated. On completion of 94 this function, input_line_pointer will point to the char after the ',' or 95 to the newline. 96 97 It trims leading and trailing space. */ 98 99 static int 100 collect_16char_name (char *dest, const char *msg, int require_comma) 101 { 102 char c, *namstart; 103 104 SKIP_WHITESPACE (); 105 namstart = input_line_pointer; 106 107 while ( (c = *input_line_pointer) != ',' 108 && !is_end_of_line[(unsigned char) c]) 109 input_line_pointer++; 110 111 { 112 int len = input_line_pointer - namstart; /* could be zero. */ 113 /* lose any trailing space. */ 114 while (len > 0 && namstart[len-1] == ' ') 115 len--; 116 if (len > 16) 117 { 118 *input_line_pointer = '\0'; /* make a temp string. */ 119 as_bad (_("the %s name '%s' is too long (maximum 16 characters)"), 120 msg, namstart); 121 *input_line_pointer = c; /* restore for printing. */ 122 len = 16; 123 } 124 if (len > 0) 125 memcpy (dest, namstart, len); 126 } 127 128 if (c != ',' && require_comma) 129 { 130 as_bad (_("expected a %s name followed by a `,'"), msg); 131 return 1; 132 } 133 134 return 0; 135 } 136 137 static int 138 obj_mach_o_get_section_names (char *seg, char *sec, 139 unsigned segl, unsigned secl) 140 { 141 /* Zero-length segment and section names are allowed. */ 142 /* Parse segment name. */ 143 memset (seg, 0, segl); 144 if (collect_16char_name (seg, "segment", 1)) 145 { 146 ignore_rest_of_line (); 147 return 0; 148 } 149 input_line_pointer++; /* Skip the terminating ',' */ 150 151 /* Parse section name, which can be empty. */ 152 memset (sec, 0, secl); 153 collect_16char_name (sec, "section", 0); 154 return 1; 155 } 156 157 /* Build (or get) a section from the mach-o description - which includes 158 optional definitions for type, attributes, alignment and stub size. 159 160 BFD supplies default values for sections which have a canonical name. */ 161 162 #define SECT_TYPE_SPECIFIED 0x0001 163 #define SECT_ATTR_SPECIFIED 0x0002 164 #define SECT_ALGN_SPECIFIED 0x0004 165 #define SECT_STUB_SPECIFIED 0x0008 166 167 static segT 168 obj_mach_o_make_or_get_sect (char * segname, char * sectname, 169 unsigned int specified_mask, 170 unsigned int usectype, unsigned int usecattr, 171 unsigned int ualign, offsetT stub_size) 172 { 173 unsigned int sectype, secattr, secalign; 174 flagword oldflags, flags; 175 const char *name; 176 segT sec; 177 bfd_mach_o_section *msect; 178 const mach_o_section_name_xlat *xlat; 179 180 /* This provides default bfd flags and default mach-o section type and 181 attributes along with the canonical name. */ 182 xlat = bfd_mach_o_section_data_for_mach_sect (stdoutput, segname, sectname); 183 184 /* TODO: more checking of whether overides are acually allowed. */ 185 186 if (xlat != NULL) 187 { 188 name = xstrdup (xlat->bfd_name); 189 sectype = xlat->macho_sectype; 190 if (specified_mask & SECT_TYPE_SPECIFIED) 191 { 192 if ((sectype == BFD_MACH_O_S_ZEROFILL 193 || sectype == BFD_MACH_O_S_GB_ZEROFILL) 194 && sectype != usectype) 195 as_bad (_("cannot overide zerofill section type for `%s,%s'"), 196 segname, sectname); 197 else 198 sectype = usectype; 199 } 200 secattr = xlat->macho_secattr; 201 secalign = xlat->sectalign; 202 flags = xlat->bfd_flags; 203 } 204 else 205 { 206 /* There is no normal BFD section name for this section. Create one. 207 The name created doesn't really matter as it will never be written 208 on disk. */ 209 size_t seglen = strlen (segname); 210 size_t sectlen = strlen (sectname); 211 char *n; 212 213 n = xmalloc (seglen + 1 + sectlen + 1); 214 memcpy (n, segname, seglen); 215 n[seglen] = '.'; 216 memcpy (n + seglen + 1, sectname, sectlen); 217 n[seglen + 1 + sectlen] = 0; 218 name = n; 219 if (specified_mask & SECT_TYPE_SPECIFIED) 220 sectype = usectype; 221 else 222 sectype = BFD_MACH_O_S_REGULAR; 223 secattr = BFD_MACH_O_S_ATTR_NONE; 224 secalign = 0; 225 flags = SEC_NO_FLAGS; 226 } 227 228 /* For now, just use what the user provided. */ 229 230 if (specified_mask & SECT_ATTR_SPECIFIED) 231 secattr = usecattr; 232 233 if (specified_mask & SECT_ALGN_SPECIFIED) 234 secalign = ualign; 235 236 /* Sub-segments don't exists as is on Mach-O. */ 237 sec = subseg_new (name, 0); 238 239 oldflags = bfd_get_section_flags (stdoutput, sec); 240 msect = bfd_mach_o_get_mach_o_section (sec); 241 242 if (oldflags == SEC_NO_FLAGS) 243 { 244 /* In the absence of canonical information, try to determine CODE and 245 DEBUG section flags from the mach-o section data. */ 246 if (flags == SEC_NO_FLAGS 247 && (specified_mask & SECT_ATTR_SPECIFIED) 248 && (secattr & BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS)) 249 flags |= SEC_CODE; 250 251 if (flags == SEC_NO_FLAGS 252 && (specified_mask & SECT_ATTR_SPECIFIED) 253 && (secattr & BFD_MACH_O_S_ATTR_DEBUG)) 254 flags |= SEC_DEBUGGING; 255 256 /* New, so just use the defaults or what's specified. */ 257 if (! bfd_set_section_flags (stdoutput, sec, flags)) 258 as_warn (_("failed to set flags for \"%s\": %s"), 259 bfd_section_name (stdoutput, sec), 260 bfd_errmsg (bfd_get_error ())); 261 262 strncpy (msect->segname, segname, sizeof (msect->segname)); 263 strncpy (msect->sectname, sectname, sizeof (msect->sectname)); 264 265 msect->align = secalign; 266 msect->flags = sectype | secattr; 267 268 if (sectype == BFD_MACH_O_S_ZEROFILL 269 || sectype == BFD_MACH_O_S_GB_ZEROFILL) 270 seg_info (sec)->bss = 1; 271 } 272 else if (flags != SEC_NO_FLAGS) 273 { 274 if (flags != oldflags 275 || msect->flags != (secattr | sectype)) 276 as_warn (_("Ignoring changed section attributes for %s"), name); 277 } 278 279 if (specified_mask & SECT_STUB_SPECIFIED) 280 /* At present, the stub size is not supplied from the BFD tables. */ 281 msect->reserved2 = stub_size; 282 283 return sec; 284 } 285 286 /* .section 287 288 The '.section' specification syntax looks like: 289 .section <segment> , <section> [, type [, attribs [, size]]] 290 291 White space is allowed everywhere between elements. 292 293 <segment> and <section> may be from 0 to 16 chars in length - they may 294 contain spaces but leading and trailing space will be trimmed. It is 295 mandatory that they be present (or that zero-length names are indicated 296 by ",,"). 297 298 There is only a single section type for any entry. 299 300 There may be multiple attributes, they are delimited by `+'. 301 302 Not all section types and attributes are accepted by the Darwin system 303 assemblers as user-specifiable - although, at present, we do here. */ 304 305 static void 306 obj_mach_o_section (int ignore ATTRIBUTE_UNUSED) 307 { 308 unsigned int sectype = BFD_MACH_O_S_REGULAR; 309 unsigned int specified_mask = 0; 310 unsigned int secattr = 0; 311 offsetT sizeof_stub = 0; 312 segT new_seg; 313 char segname[17]; 314 char sectname[17]; 315 316 #ifdef md_flush_pending_output 317 md_flush_pending_output (); 318 #endif 319 320 /* Get the User's segment annd section names. */ 321 if (! obj_mach_o_get_section_names (segname, sectname, 17, 17)) 322 return; 323 324 /* Parse section type, if present. */ 325 if (*input_line_pointer == ',') 326 { 327 char *p; 328 char c; 329 char tmpc; 330 int len; 331 input_line_pointer++; 332 SKIP_WHITESPACE (); 333 p = input_line_pointer; 334 while ((c = *input_line_pointer) != ',' 335 && !is_end_of_line[(unsigned char) c]) 336 input_line_pointer++; 337 338 len = input_line_pointer - p; 339 /* strip trailing spaces. */ 340 while (len > 0 && p[len-1] == ' ') 341 len--; 342 tmpc = p[len]; 343 344 /* Temporarily make a string from the token. */ 345 p[len] = 0; 346 sectype = bfd_mach_o_get_section_type_from_name (stdoutput, p); 347 if (sectype > 255) /* Max Section ID == 255. */ 348 { 349 as_bad (_("unknown or invalid section type '%s'"), p); 350 p[len] = tmpc; 351 ignore_rest_of_line (); 352 return; 353 } 354 else 355 specified_mask |= SECT_TYPE_SPECIFIED; 356 /* Restore. */ 357 p[len] = tmpc; 358 359 /* Parse attributes. 360 TODO: check validity of attributes for section type. */ 361 if ((specified_mask & SECT_TYPE_SPECIFIED) 362 && c == ',') 363 { 364 do 365 { 366 int attr; 367 368 /* Skip initial `,' and subsequent `+'. */ 369 input_line_pointer++; 370 SKIP_WHITESPACE (); 371 p = input_line_pointer; 372 while ((c = *input_line_pointer) != '+' 373 && c != ',' 374 && !is_end_of_line[(unsigned char) c]) 375 input_line_pointer++; 376 377 len = input_line_pointer - p; 378 /* strip trailing spaces. */ 379 while (len > 0 && p[len-1] == ' ') 380 len--; 381 tmpc = p[len]; 382 383 /* Temporarily make a string from the token. */ 384 p[len] ='\0'; 385 attr = bfd_mach_o_get_section_attribute_from_name (p); 386 if (attr == -1) 387 { 388 as_bad (_("unknown or invalid section attribute '%s'"), p); 389 p[len] = tmpc; 390 ignore_rest_of_line (); 391 return; 392 } 393 else 394 { 395 specified_mask |= SECT_ATTR_SPECIFIED; 396 secattr |= attr; 397 } 398 /* Restore. */ 399 p[len] = tmpc; 400 } 401 while (*input_line_pointer == '+'); 402 403 /* Parse sizeof_stub. */ 404 if ((specified_mask & SECT_ATTR_SPECIFIED) 405 && *input_line_pointer == ',') 406 { 407 if (sectype != BFD_MACH_O_S_SYMBOL_STUBS) 408 { 409 as_bad (_("unexpected section size information")); 410 ignore_rest_of_line (); 411 return; 412 } 413 414 input_line_pointer++; 415 sizeof_stub = get_absolute_expression (); 416 specified_mask |= SECT_STUB_SPECIFIED; 417 } 418 else if ((specified_mask & SECT_ATTR_SPECIFIED) 419 && sectype == BFD_MACH_O_S_SYMBOL_STUBS) 420 { 421 as_bad (_("missing sizeof_stub expression")); 422 ignore_rest_of_line (); 423 return; 424 } 425 } 426 } 427 428 new_seg = obj_mach_o_make_or_get_sect (segname, sectname, specified_mask, 429 sectype, secattr, 0 /*align */, 430 sizeof_stub); 431 if (new_seg != NULL) 432 { 433 subseg_set (new_seg, 0); 434 demand_empty_rest_of_line (); 435 } 436 } 437 438 /* .zerofill segname, sectname [, symbolname, size [, align]] 439 440 Zerofill switches, temporarily, to a sect of type 'zerofill'. 441 442 If a variable name is given, it defines that in the section. 443 Otherwise it just creates the section if it doesn't exist. */ 444 445 static void 446 obj_mach_o_zerofill (int ignore ATTRIBUTE_UNUSED) 447 { 448 char segname[17]; 449 char sectname[17]; 450 segT old_seg = now_seg; 451 segT new_seg; 452 symbolS *sym = NULL; 453 unsigned int align = 0; 454 unsigned int specified_mask = 0; 455 offsetT size = 0; 456 457 #ifdef md_flush_pending_output 458 md_flush_pending_output (); 459 #endif 460 461 /* Get the User's segment annd section names. */ 462 if (! obj_mach_o_get_section_names (segname, sectname, 17, 17)) 463 return; 464 465 /* Parse variable definition, if present. */ 466 if (*input_line_pointer == ',') 467 { 468 /* Parse symbol, size [.align] 469 We follow the method of s_common_internal, with the difference 470 that the symbol cannot be a duplicate-common. */ 471 char *name; 472 char c; 473 char *p; 474 expressionS exp; 475 476 input_line_pointer++; /* Skip ',' */ 477 SKIP_WHITESPACE (); 478 name = input_line_pointer; 479 c = get_symbol_end (); 480 /* Just after name is now '\0'. */ 481 p = input_line_pointer; 482 *p = c; 483 484 if (name == p) 485 { 486 as_bad (_("expected symbol name")); 487 ignore_rest_of_line (); 488 goto done; 489 } 490 491 SKIP_WHITESPACE (); 492 if (*input_line_pointer == ',') 493 input_line_pointer++; 494 495 expression_and_evaluate (&exp); 496 if (exp.X_op != O_constant 497 && exp.X_op != O_absent) 498 { 499 as_bad (_("bad or irreducible absolute expression")); 500 ignore_rest_of_line (); 501 goto done; 502 } 503 else if (exp.X_op == O_absent) 504 { 505 as_bad (_("missing size expression")); 506 ignore_rest_of_line (); 507 goto done; 508 } 509 510 size = exp.X_add_number; 511 size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1; 512 if (exp.X_add_number != size || !exp.X_unsigned) 513 { 514 as_warn (_("size (%ld) out of range, ignored"), 515 (long) exp.X_add_number); 516 ignore_rest_of_line (); 517 goto done; 518 } 519 520 *p = 0; /* Make the name into a c string for err messages. */ 521 sym = symbol_find_or_make (name); 522 if (S_IS_DEFINED (sym) || symbol_equated_p (sym)) 523 { 524 as_bad (_("symbol `%s' is already defined"), name); 525 *p = c; 526 ignore_rest_of_line (); 527 goto done; 528 } 529 530 size = S_GET_VALUE (sym); 531 if (size == 0) 532 size = exp.X_add_number; 533 else if (size != exp.X_add_number) 534 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"), 535 name, (long) size, (long) exp.X_add_number); 536 537 *p = c; /* Restore the termination char. */ 538 539 SKIP_WHITESPACE (); 540 if (*input_line_pointer == ',') 541 { 542 align = (unsigned int) parse_align (0); 543 if (align == (unsigned int) -1) 544 { 545 as_warn (_("align value not recognized, using size")); 546 align = size; 547 } 548 if (align > 15) 549 { 550 as_warn (_("Alignment (%lu) too large: 15 assumed."), 551 (unsigned long)align); 552 align = 15; 553 } 554 specified_mask |= SECT_ALGN_SPECIFIED; 555 } 556 } 557 /* else just a section definition. */ 558 559 specified_mask |= SECT_TYPE_SPECIFIED; 560 new_seg = obj_mach_o_make_or_get_sect (segname, sectname, specified_mask, 561 BFD_MACH_O_S_ZEROFILL, 562 BFD_MACH_O_S_ATTR_NONE, 563 align, (offsetT) 0 /*stub size*/); 564 if (new_seg == NULL) 565 return; 566 567 /* In case the user specifies the bss section by mach-o name. 568 Create it on demand */ 569 if (strcmp (new_seg->name, BSS_SECTION_NAME) == 0 570 && bss_section == NULL) 571 bss_section = new_seg; 572 573 subseg_set (new_seg, 0); 574 575 if (sym != NULL) 576 { 577 char *pfrag; 578 579 if (align) 580 { 581 record_alignment (new_seg, align); 582 frag_align (align, 0, 0); 583 } 584 585 /* Detach from old frag. */ 586 if (S_GET_SEGMENT (sym) == new_seg) 587 symbol_get_frag (sym)->fr_symbol = NULL; 588 589 symbol_set_frag (sym, frag_now); 590 pfrag = frag_var (rs_org, 1, 1, 0, sym, size, NULL); 591 *pfrag = 0; 592 593 S_SET_SEGMENT (sym, new_seg); 594 if (new_seg == bss_section) 595 S_CLEAR_EXTERNAL (sym); 596 } 597 598 done: 599 /* switch back to the section that was current before the .zerofill. */ 600 subseg_set (old_seg, 0); 601 } 602 603 static segT 604 obj_mach_o_segT_from_bfd_name (const char *nam, int must_succeed) 605 { 606 const mach_o_section_name_xlat *xlat; 607 const char *segn; 608 segT sec; 609 610 /* BFD has tables of flags and default attributes for all the sections that 611 have a 'canonical' name. */ 612 xlat = bfd_mach_o_section_data_for_bfd_name (stdoutput, nam, &segn); 613 if (xlat == NULL) 614 { 615 if (must_succeed) 616 as_fatal (_("BFD is out of sync with GAS, " 617 "unhandled well-known section type `%s'"), nam); 618 return NULL; 619 } 620 621 sec = bfd_get_section_by_name (stdoutput, nam); 622 if (sec == NULL) 623 { 624 bfd_mach_o_section *msect; 625 626 sec = subseg_force_new (xlat->bfd_name, 0); 627 628 /* Set default type, attributes and alignment. */ 629 msect = bfd_mach_o_get_mach_o_section (sec); 630 msect->flags = xlat->macho_sectype | xlat->macho_secattr; 631 msect->align = xlat->sectalign; 632 633 if ((msect->flags & BFD_MACH_O_SECTION_TYPE_MASK) 634 == BFD_MACH_O_S_ZEROFILL) 635 seg_info (sec)->bss = 1; 636 } 637 638 return sec; 639 } 640 641 static const char * const known_sections[] = 642 { 643 /* 0 */ NULL, 644 /* __TEXT */ 645 /* 1 */ ".const", 646 /* 2 */ ".static_const", 647 /* 3 */ ".cstring", 648 /* 4 */ ".literal4", 649 /* 5 */ ".literal8", 650 /* 6 */ ".literal16", 651 /* 7 */ ".constructor", 652 /* 8 */ ".destructor", 653 /* 9 */ ".eh_frame", 654 /* __DATA */ 655 /* 10 */ ".const_data", 656 /* 11 */ ".static_data", 657 /* 12 */ ".mod_init_func", 658 /* 13 */ ".mod_term_func", 659 /* 14 */ ".dyld", 660 /* 15 */ ".cfstring" 661 }; 662 663 /* Interface for a known non-optional section directive. */ 664 665 static void 666 obj_mach_o_known_section (int sect_index) 667 { 668 segT section; 669 670 #ifdef md_flush_pending_output 671 md_flush_pending_output (); 672 #endif 673 674 section = obj_mach_o_segT_from_bfd_name (known_sections[sect_index], 1); 675 if (section != NULL) 676 subseg_set (section, 0); 677 678 /* else, we leave the section as it was; there was a fatal error anyway. */ 679 } 680 681 static const char * const objc_sections[] = 682 { 683 /* 0 */ NULL, 684 /* 1 */ ".objc_class", 685 /* 2 */ ".objc_meta_class", 686 /* 3 */ ".objc_cat_cls_meth", 687 /* 4 */ ".objc_cat_inst_meth", 688 /* 5 */ ".objc_protocol", 689 /* 6 */ ".objc_string_object", 690 /* 7 */ ".objc_cls_meth", 691 /* 8 */ ".objc_inst_meth", 692 /* 9 */ ".objc_cls_refs", 693 /* 10 */ ".objc_message_refs", 694 /* 11 */ ".objc_symbols", 695 /* 12 */ ".objc_category", 696 /* 13 */ ".objc_class_vars", 697 /* 14 */ ".objc_instance_vars", 698 /* 15 */ ".objc_module_info", 699 /* 16 */ ".cstring", /* objc_class_names Alias for .cstring */ 700 /* 17 */ ".cstring", /* Alias objc_meth_var_types for .cstring */ 701 /* 18 */ ".cstring", /* objc_meth_var_names Alias for .cstring */ 702 /* 19 */ ".objc_selector_strs", 703 /* 20 */ ".objc_image_info", /* extension. */ 704 /* 21 */ ".objc_selector_fixup", /* extension. */ 705 /* 22 */ ".objc1_class_ext", /* ObjC-1 extension. */ 706 /* 23 */ ".objc1_property_list", /* ObjC-1 extension. */ 707 /* 24 */ ".objc1_protocol_ext" /* ObjC-1 extension. */ 708 }; 709 710 /* This currently does the same as known_sections, but kept separate for 711 ease of maintenance. */ 712 713 static void 714 obj_mach_o_objc_section (int sect_index) 715 { 716 segT section; 717 718 #ifdef md_flush_pending_output 719 md_flush_pending_output (); 720 #endif 721 722 section = obj_mach_o_segT_from_bfd_name (objc_sections[sect_index], 1); 723 if (section != NULL) 724 { 725 obj_mach_o_seen_objc_section = 1; /* We need to ensure that certain 726 sections are present and in the 727 right order. */ 728 subseg_set (section, 0); 729 } 730 731 /* else, we leave the section as it was; there was a fatal error anyway. */ 732 } 733 734 /* Debug section directives. */ 735 736 static const char * const debug_sections[] = 737 { 738 /* 0 */ NULL, 739 /* __DWARF */ 740 /* 1 */ ".debug_frame", 741 /* 2 */ ".debug_info", 742 /* 3 */ ".debug_abbrev", 743 /* 4 */ ".debug_aranges", 744 /* 5 */ ".debug_macinfo", 745 /* 6 */ ".debug_line", 746 /* 7 */ ".debug_loc", 747 /* 8 */ ".debug_pubnames", 748 /* 9 */ ".debug_pubtypes", 749 /* 10 */ ".debug_str", 750 /* 11 */ ".debug_ranges", 751 /* 12 */ ".debug_macro" 752 }; 753 754 /* ??? Maybe these should be conditional on gdwarf-*. 755 It`s also likely that we will need to be able to set them from the cfi 756 code. */ 757 758 static void 759 obj_mach_o_debug_section (int sect_index) 760 { 761 segT section; 762 763 #ifdef md_flush_pending_output 764 md_flush_pending_output (); 765 #endif 766 767 section = obj_mach_o_segT_from_bfd_name (debug_sections[sect_index], 1); 768 if (section != NULL) 769 subseg_set (section, 0); 770 771 /* else, we leave the section as it was; there was a fatal error anyway. */ 772 } 773 774 /* This could be moved to the tc-xx files, but there is so little dependency 775 there, that the code might as well be shared. */ 776 777 struct opt_tgt_sect 778 { 779 const char *name; 780 unsigned x86_val; 781 unsigned ppc_val; 782 }; 783 784 /* The extensions here are for specific sections that are generated by GCC 785 and Darwin system tools, but don't have directives in the `system as'. */ 786 787 static const struct opt_tgt_sect tgt_sections[] = 788 { 789 /* 0 */ { NULL, 0, 0}, 790 /* 1 */ { ".lazy_symbol_pointer", 0, 0}, 791 /* 2 */ { ".lazy_symbol_pointer2", 0, 0}, /* X86 - extension */ 792 /* 3 */ { ".lazy_symbol_pointer3", 0, 0}, /* X86 - extension */ 793 /* 4 */ { ".non_lazy_symbol_pointer", 0, 0}, 794 /* 5 */ { ".non_lazy_symbol_pointer_x86", 0, 0}, /* X86 - extension */ 795 /* 6 */ { ".symbol_stub", 16, 20}, 796 /* 7 */ { ".symbol_stub1", 0, 16}, /* PPC - extension */ 797 /* 8 */ { ".picsymbol_stub", 26, 36}, 798 /* 9 */ { ".picsymbol_stub1", 0, 32}, /* PPC - extension */ 799 /* 10 */ { ".picsymbol_stub2", 25, 0}, /* X86 - extension */ 800 /* 11 */ { ".picsymbol_stub3", 5, 0}, /* X86 - extension */ 801 }; 802 803 /* Interface for an optional section directive. */ 804 805 static void 806 obj_mach_o_opt_tgt_section (int sect_index) 807 { 808 const struct opt_tgt_sect *tgtsct = &tgt_sections[sect_index]; 809 segT section; 810 811 #ifdef md_flush_pending_output 812 md_flush_pending_output (); 813 #endif 814 815 section = obj_mach_o_segT_from_bfd_name (tgtsct->name, 0); 816 if (section == NULL) 817 { 818 as_bad (_("%s is not used for the selected target"), tgtsct->name); 819 /* Leave the section as it is. */ 820 } 821 else 822 { 823 bfd_mach_o_section *mo_sec = bfd_mach_o_get_mach_o_section (section); 824 subseg_set (section, 0); 825 #if defined (TC_I386) 826 mo_sec->reserved2 = tgtsct->x86_val; 827 #elif defined (TC_PPC) 828 mo_sec->reserved2 = tgtsct->ppc_val; 829 #else 830 mo_sec->reserved2 = 0; 831 #endif 832 } 833 } 834 835 /* We don't necessarily have the three 'base' sections on mach-o. 836 Normally, we would start up with only the 'text' section defined. 837 However, even that can be suppressed with (TODO) c/l option "-n". 838 Thus, we have to be able to create all three sections on-demand. */ 839 840 static void 841 obj_mach_o_base_section (int sect_index) 842 { 843 segT section; 844 845 #ifdef md_flush_pending_output 846 md_flush_pending_output (); 847 #endif 848 849 /* We don't support numeric (or any other) qualifications on the 850 well-known section shorthands. */ 851 demand_empty_rest_of_line (); 852 853 switch (sect_index) 854 { 855 /* Handle the three sections that are globally known within GAS. 856 For Mach-O, these are created on demand rather than at startup. */ 857 case 1: 858 if (text_section == NULL) 859 text_section = obj_mach_o_segT_from_bfd_name (TEXT_SECTION_NAME, 1); 860 if (obj_mach_o_is_static) 861 { 862 bfd_mach_o_section *mo_sec 863 = bfd_mach_o_get_mach_o_section (text_section); 864 mo_sec->flags &= ~BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS; 865 } 866 section = text_section; 867 break; 868 case 2: 869 if (data_section == NULL) 870 data_section = obj_mach_o_segT_from_bfd_name (DATA_SECTION_NAME, 1); 871 section = data_section; 872 break; 873 case 3: 874 /* ??? maybe this achieves very little, as an addition. */ 875 if (bss_section == NULL) 876 { 877 bss_section = obj_mach_o_segT_from_bfd_name (BSS_SECTION_NAME, 1); 878 seg_info (bss_section)->bss = 1; 879 } 880 section = bss_section; 881 break; 882 default: 883 as_fatal (_("internal error: base section index out of range")); 884 return; 885 break; 886 } 887 subseg_set (section, 0); 888 } 889 890 /* This finishes off parsing a .comm or .lcomm statement, which both can have 891 an (optional) alignment field. It also allows us to create the bss section 892 on demand. */ 893 894 static symbolS * 895 obj_mach_o_common_parse (int is_local, symbolS *symbolP, 896 addressT size) 897 { 898 addressT align = 0; 899 bfd_mach_o_asymbol *s; 900 901 SKIP_WHITESPACE (); 902 903 /* Both comm and lcomm take an optional alignment, as a power 904 of two between 1 and 15. */ 905 if (*input_line_pointer == ',') 906 { 907 /* We expect a power of 2. */ 908 align = parse_align (0); 909 if (align == (addressT) -1) 910 return NULL; 911 if (align > 15) 912 { 913 as_warn (_("Alignment (%lu) too large: 15 assumed."), 914 (unsigned long)align); 915 align = 15; 916 } 917 } 918 919 s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (symbolP); 920 if (is_local) 921 { 922 /* Create the BSS section on demand. */ 923 if (bss_section == NULL) 924 { 925 bss_section = obj_mach_o_segT_from_bfd_name (BSS_SECTION_NAME, 1); 926 seg_info (bss_section)->bss = 1; 927 } 928 bss_alloc (symbolP, size, align); 929 s->n_type = BFD_MACH_O_N_SECT; 930 S_CLEAR_EXTERNAL (symbolP); 931 } 932 else 933 { 934 S_SET_VALUE (symbolP, size); 935 S_SET_ALIGN (symbolP, align); 936 S_SET_EXTERNAL (symbolP); 937 S_SET_SEGMENT (symbolP, bfd_com_section_ptr); 938 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT; 939 } 940 941 /* This is a data object (whatever we choose that to mean). */ 942 s->symbol.flags |= BSF_OBJECT; 943 944 /* We've set symbol qualifiers, so validate if you can. */ 945 s->symbol.udata.i = SYM_MACHO_FIELDS_NOT_VALIDATED; 946 947 return symbolP; 948 } 949 950 static void 951 obj_mach_o_comm (int is_local) 952 { 953 s_comm_internal (is_local, obj_mach_o_common_parse); 954 } 955 956 /* Set properties that apply to the whole file. At present, the only 957 one defined, is subsections_via_symbols. */ 958 959 typedef enum obj_mach_o_file_properties { 960 OBJ_MACH_O_FILE_PROP_NONE = 0, 961 OBJ_MACH_O_FILE_PROP_SUBSECTS_VIA_SYMS, 962 OBJ_MACH_O_FILE_PROP_MAX 963 } obj_mach_o_file_properties; 964 965 static void 966 obj_mach_o_fileprop (int prop) 967 { 968 if (prop < 0 || prop >= OBJ_MACH_O_FILE_PROP_MAX) 969 as_fatal (_("internal error: bad file property ID %d"), prop); 970 971 switch ((obj_mach_o_file_properties) prop) 972 { 973 case OBJ_MACH_O_FILE_PROP_SUBSECTS_VIA_SYMS: 974 obj_mach_o_subsections_by_symbols = 1; 975 if (!bfd_set_private_flags (stdoutput, 976 BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS)) 977 as_bad (_("failed to set subsections by symbols")); 978 demand_empty_rest_of_line (); 979 break; 980 default: 981 break; 982 } 983 } 984 985 /* Temporary markers for symbol reference data. 986 Lazy will remain in place. */ 987 #define LAZY 0x01 988 #define REFE 0x02 989 990 /* We have a bunch of qualifiers that may be applied to symbols. 991 .globl is handled here so that we might make sure that conflicting qualifiers 992 are caught where possible. */ 993 994 typedef enum obj_mach_o_symbol_type { 995 OBJ_MACH_O_SYM_UNK = 0, 996 OBJ_MACH_O_SYM_LOCAL = 1, 997 OBJ_MACH_O_SYM_GLOBL = 2, 998 OBJ_MACH_O_SYM_REFERENCE = 3, 999 OBJ_MACH_O_SYM_WEAK_REF = 4, 1000 OBJ_MACH_O_SYM_LAZY_REF = 5, 1001 OBJ_MACH_O_SYM_WEAK_DEF = 6, 1002 OBJ_MACH_O_SYM_PRIV_EXT = 7, 1003 OBJ_MACH_O_SYM_NO_DEAD_STRIP = 8, 1004 OBJ_MACH_O_SYM_WEAK = 9 1005 } obj_mach_o_symbol_type; 1006 1007 /* Set Mach-O-specific symbol qualifiers. */ 1008 1009 static int 1010 obj_mach_o_set_symbol_qualifier (symbolS *sym, int type) 1011 { 1012 int is_defined; 1013 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (sym); 1014 bfd_mach_o_section *sec; 1015 int sectype = -1; 1016 1017 /* If the symbol is defined, then we can do more rigorous checking on 1018 the validity of the qualifiers. Otherwise, we are stuck with waiting 1019 until it's defined - or until write the file. 1020 1021 In certain cases (e.g. when a symbol qualifier is intended to introduce 1022 an undefined symbol in a stubs section) we should check that the current 1023 section is appropriate to the qualifier. */ 1024 1025 is_defined = s->symbol.section != bfd_und_section_ptr; 1026 if (is_defined) 1027 sec = bfd_mach_o_get_mach_o_section (s->symbol.section) ; 1028 else 1029 sec = bfd_mach_o_get_mach_o_section (now_seg) ; 1030 1031 if (sec != NULL) 1032 sectype = sec->flags & BFD_MACH_O_SECTION_TYPE_MASK; 1033 1034 switch ((obj_mach_o_symbol_type) type) 1035 { 1036 case OBJ_MACH_O_SYM_LOCAL: 1037 /* This is an extension over the system tools. */ 1038 if (s->n_type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT)) 1039 { 1040 as_bad (_("'%s' previously declared as '%s'."), s->symbol.name, 1041 (s->n_type & BFD_MACH_O_N_PEXT) ? "private extern" 1042 : "global" ); 1043 s->symbol.udata.i = SYM_MACHO_FIELDS_UNSET; 1044 return 1; 1045 } 1046 else 1047 { 1048 s->n_type &= ~BFD_MACH_O_N_EXT; 1049 S_CLEAR_EXTERNAL (sym); 1050 } 1051 break; 1052 1053 case OBJ_MACH_O_SYM_PRIV_EXT: 1054 s->n_type |= BFD_MACH_O_N_PEXT ; 1055 s->n_desc &= ~LAZY; /* The native tool switches this off too. */ 1056 /* We follow the system tools in marking PEXT as also global. */ 1057 /* Fall through. */ 1058 1059 case OBJ_MACH_O_SYM_GLOBL: 1060 /* It's not an error to define a symbol and then make it global. */ 1061 s->n_type |= BFD_MACH_O_N_EXT; 1062 S_SET_EXTERNAL (sym); 1063 break; 1064 1065 case OBJ_MACH_O_SYM_REFERENCE: 1066 if (is_defined) 1067 s->n_desc |= BFD_MACH_O_N_NO_DEAD_STRIP; 1068 else 1069 s->n_desc |= (REFE | BFD_MACH_O_N_NO_DEAD_STRIP); 1070 break; 1071 1072 case OBJ_MACH_O_SYM_LAZY_REF: 1073 if (is_defined) 1074 s->n_desc |= BFD_MACH_O_N_NO_DEAD_STRIP; 1075 else 1076 s->n_desc |= (REFE | LAZY | BFD_MACH_O_N_NO_DEAD_STRIP); 1077 break; 1078 1079 /* Force ld to retain the symbol - even if it appears unused. */ 1080 case OBJ_MACH_O_SYM_NO_DEAD_STRIP: 1081 s->n_desc |= BFD_MACH_O_N_NO_DEAD_STRIP ; 1082 break; 1083 1084 /* Mach-O's idea of weak ... */ 1085 case OBJ_MACH_O_SYM_WEAK_REF: 1086 s->n_desc |= BFD_MACH_O_N_WEAK_REF ; 1087 break; 1088 1089 case OBJ_MACH_O_SYM_WEAK_DEF: 1090 if (is_defined && sectype != BFD_MACH_O_S_COALESCED) 1091 { 1092 as_bad (_("'%s' can't be a weak_definition (currently only" 1093 " supported in sections of type coalesced)"), 1094 s->symbol.name); 1095 s->symbol.udata.i = SYM_MACHO_FIELDS_UNSET; 1096 return 1; 1097 } 1098 else 1099 s->n_desc |= BFD_MACH_O_N_WEAK_DEF; 1100 break; 1101 1102 case OBJ_MACH_O_SYM_WEAK: 1103 /* A generic 'weak' - we try to figure out what it means at 1104 symbol frob time. */ 1105 S_SET_WEAK (sym); 1106 break; 1107 1108 default: 1109 break; 1110 } 1111 1112 /* We've seen some kind of qualifier - check validity if or when the entity 1113 is defined. */ 1114 s->symbol.udata.i = SYM_MACHO_FIELDS_NOT_VALIDATED; 1115 return 0; 1116 } 1117 1118 /* Respond to symbol qualifiers. 1119 All of the form: 1120 .<qualifier> symbol [, symbol]* 1121 a list of symbols is an extension over the Darwin system as. */ 1122 1123 static void 1124 obj_mach_o_sym_qual (int ntype) 1125 { 1126 char *name; 1127 char c; 1128 symbolS *symbolP; 1129 1130 #ifdef md_flush_pending_output 1131 md_flush_pending_output (); 1132 #endif 1133 1134 do 1135 { 1136 name = input_line_pointer; 1137 c = get_symbol_end (); 1138 symbolP = symbol_find_or_make (name); 1139 obj_mach_o_set_symbol_qualifier (symbolP, ntype); 1140 *input_line_pointer = c; 1141 SKIP_WHITESPACE (); 1142 c = *input_line_pointer; 1143 if (c == ',') 1144 { 1145 input_line_pointer++; 1146 SKIP_WHITESPACE (); 1147 if (is_end_of_line[(unsigned char) *input_line_pointer]) 1148 c = '\n'; 1149 } 1150 } 1151 while (c == ','); 1152 1153 demand_empty_rest_of_line (); 1154 } 1155 1156 typedef struct obj_mach_o_indirect_sym 1157 { 1158 symbolS *sym; 1159 segT sect; 1160 struct obj_mach_o_indirect_sym *next; 1161 } obj_mach_o_indirect_sym; 1162 1163 /* We store in order an maintain a pointer to the last one - to save reversing 1164 later. */ 1165 obj_mach_o_indirect_sym *indirect_syms; 1166 obj_mach_o_indirect_sym *indirect_syms_tail; 1167 1168 static void 1169 obj_mach_o_indirect_symbol (int arg ATTRIBUTE_UNUSED) 1170 { 1171 bfd_mach_o_section *sec = bfd_mach_o_get_mach_o_section (now_seg); 1172 1173 #ifdef md_flush_pending_output 1174 md_flush_pending_output (); 1175 #endif 1176 1177 if (obj_mach_o_is_static) 1178 as_bad (_("use of .indirect_symbols requires `-dynamic'")); 1179 1180 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK) 1181 { 1182 case BFD_MACH_O_S_SYMBOL_STUBS: 1183 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS: 1184 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS: 1185 { 1186 obj_mach_o_indirect_sym *isym; 1187 char *name = input_line_pointer; 1188 char c = get_symbol_end (); 1189 symbolS *sym = symbol_find_or_make (name); 1190 unsigned int elsize = 1191 bfd_mach_o_section_get_entry_size (stdoutput, sec); 1192 1193 if (elsize == 0) 1194 { 1195 as_bad (_("attempt to add an indirect_symbol to a stub or" 1196 " reference section with a zero-sized element at %s"), 1197 name); 1198 *input_line_pointer = c; 1199 ignore_rest_of_line (); 1200 return; 1201 } 1202 *input_line_pointer = c; 1203 1204 /* The indirect symbols are validated after the symbol table is 1205 frozen, we must make sure that if a local symbol is used as an 1206 indirect, it is promoted to a 'real' one. Fetching the bfd sym 1207 achieves this. */ 1208 symbol_get_bfdsym (sym); 1209 isym = (obj_mach_o_indirect_sym *) 1210 xmalloc (sizeof (obj_mach_o_indirect_sym)); 1211 1212 /* Just record the data for now, we will validate it when we 1213 compute the output in obj_mach_o_set_indirect_symbols. */ 1214 isym->sym = sym; 1215 isym->sect = now_seg; 1216 isym->next = NULL; 1217 if (indirect_syms == NULL) 1218 indirect_syms = isym; 1219 else 1220 indirect_syms_tail->next = isym; 1221 indirect_syms_tail = isym; 1222 } 1223 break; 1224 1225 default: 1226 as_bad (_("an .indirect_symbol must be in a symbol pointer" 1227 " or stub section.")); 1228 ignore_rest_of_line (); 1229 return; 1230 } 1231 demand_empty_rest_of_line (); 1232 } 1233 1234 const pseudo_typeS mach_o_pseudo_table[] = 1235 { 1236 /* Section directives. */ 1237 { "comm", obj_mach_o_comm, 0 }, 1238 { "lcomm", obj_mach_o_comm, 1 }, 1239 1240 { "text", obj_mach_o_base_section, 1}, 1241 { "data", obj_mach_o_base_section, 2}, 1242 { "bss", obj_mach_o_base_section, 3}, /* extension */ 1243 1244 { "const", obj_mach_o_known_section, 1}, 1245 { "static_const", obj_mach_o_known_section, 2}, 1246 { "cstring", obj_mach_o_known_section, 3}, 1247 { "literal4", obj_mach_o_known_section, 4}, 1248 { "literal8", obj_mach_o_known_section, 5}, 1249 { "literal16", obj_mach_o_known_section, 6}, 1250 { "constructor", obj_mach_o_known_section, 7}, 1251 { "destructor", obj_mach_o_known_section, 8}, 1252 { "eh_frame", obj_mach_o_known_section, 9}, 1253 1254 { "const_data", obj_mach_o_known_section, 10}, 1255 { "static_data", obj_mach_o_known_section, 11}, 1256 { "mod_init_func", obj_mach_o_known_section, 12}, 1257 { "mod_term_func", obj_mach_o_known_section, 13}, 1258 { "dyld", obj_mach_o_known_section, 14}, 1259 { "cfstring", obj_mach_o_known_section, 15}, 1260 1261 { "objc_class", obj_mach_o_objc_section, 1}, 1262 { "objc_meta_class", obj_mach_o_objc_section, 2}, 1263 { "objc_cat_cls_meth", obj_mach_o_objc_section, 3}, 1264 { "objc_cat_inst_meth", obj_mach_o_objc_section, 4}, 1265 { "objc_protocol", obj_mach_o_objc_section, 5}, 1266 { "objc_string_object", obj_mach_o_objc_section, 6}, 1267 { "objc_cls_meth", obj_mach_o_objc_section, 7}, 1268 { "objc_inst_meth", obj_mach_o_objc_section, 8}, 1269 { "objc_cls_refs", obj_mach_o_objc_section, 9}, 1270 { "objc_message_refs", obj_mach_o_objc_section, 10}, 1271 { "objc_symbols", obj_mach_o_objc_section, 11}, 1272 { "objc_category", obj_mach_o_objc_section, 12}, 1273 { "objc_class_vars", obj_mach_o_objc_section, 13}, 1274 { "objc_instance_vars", obj_mach_o_objc_section, 14}, 1275 { "objc_module_info", obj_mach_o_objc_section, 15}, 1276 { "objc_class_names", obj_mach_o_objc_section, 16}, /* Alias for .cstring */ 1277 { "objc_meth_var_types", obj_mach_o_objc_section, 17}, /* Alias for .cstring */ 1278 { "objc_meth_var_names", obj_mach_o_objc_section, 18}, /* Alias for .cstring */ 1279 { "objc_selector_strs", obj_mach_o_objc_section, 19}, 1280 { "objc_image_info", obj_mach_o_objc_section, 20}, /* extension. */ 1281 { "objc_selector_fixup", obj_mach_o_objc_section, 21}, /* extension. */ 1282 { "objc1_class_ext", obj_mach_o_objc_section, 22}, /* ObjC-1 extension. */ 1283 { "objc1_property_list", obj_mach_o_objc_section, 23}, /* ObjC-1 extension. */ 1284 { "objc1_protocol_ext", obj_mach_o_objc_section, 24}, /* ObjC-1 extension. */ 1285 1286 { "debug_frame", obj_mach_o_debug_section, 1}, /* extension. */ 1287 { "debug_info", obj_mach_o_debug_section, 2}, /* extension. */ 1288 { "debug_abbrev", obj_mach_o_debug_section, 3}, /* extension. */ 1289 { "debug_aranges", obj_mach_o_debug_section, 4}, /* extension. */ 1290 { "debug_macinfo", obj_mach_o_debug_section, 5}, /* extension. */ 1291 { "debug_line", obj_mach_o_debug_section, 6}, /* extension. */ 1292 { "debug_loc", obj_mach_o_debug_section, 7}, /* extension. */ 1293 { "debug_pubnames", obj_mach_o_debug_section, 8}, /* extension. */ 1294 { "debug_pubtypes", obj_mach_o_debug_section, 9}, /* extension. */ 1295 { "debug_str", obj_mach_o_debug_section, 10}, /* extension. */ 1296 { "debug_ranges", obj_mach_o_debug_section, 11}, /* extension. */ 1297 { "debug_macro", obj_mach_o_debug_section, 12}, /* extension. */ 1298 1299 { "lazy_symbol_pointer", obj_mach_o_opt_tgt_section, 1}, 1300 { "lazy_symbol_pointer2", obj_mach_o_opt_tgt_section, 2}, /* extension. */ 1301 { "lazy_symbol_pointer3", obj_mach_o_opt_tgt_section, 3}, /* extension. */ 1302 { "non_lazy_symbol_pointer", obj_mach_o_opt_tgt_section, 4}, 1303 { "non_lazy_symbol_pointer_x86", obj_mach_o_opt_tgt_section, 5}, /* extension. */ 1304 { "symbol_stub", obj_mach_o_opt_tgt_section, 6}, 1305 { "symbol_stub1", obj_mach_o_opt_tgt_section, 7}, /* extension. */ 1306 { "picsymbol_stub", obj_mach_o_opt_tgt_section, 8}, /* extension. */ 1307 { "picsymbol_stub1", obj_mach_o_opt_tgt_section, 9}, /* extension. */ 1308 { "picsymbol_stub2", obj_mach_o_opt_tgt_section, 4}, /* extension. */ 1309 { "picsymbol_stub3", obj_mach_o_opt_tgt_section, 4}, /* extension. */ 1310 1311 { "section", obj_mach_o_section, 0}, 1312 { "zerofill", obj_mach_o_zerofill, 0}, 1313 1314 /* Symbol qualifiers. */ 1315 {"local", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_LOCAL}, 1316 {"globl", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_GLOBL}, 1317 {"reference", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_REFERENCE}, 1318 {"weak_reference", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_WEAK_REF}, 1319 {"lazy_reference", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_LAZY_REF}, 1320 {"weak_definition", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_WEAK_DEF}, 1321 {"private_extern", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_PRIV_EXT}, 1322 {"no_dead_strip", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_NO_DEAD_STRIP}, 1323 {"weak", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_WEAK}, /* ext */ 1324 1325 { "indirect_symbol", obj_mach_o_indirect_symbol, 0}, 1326 1327 /* File flags. */ 1328 { "subsections_via_symbols", obj_mach_o_fileprop, 1329 OBJ_MACH_O_FILE_PROP_SUBSECTS_VIA_SYMS}, 1330 1331 {NULL, NULL, 0} 1332 }; 1333 1334 /* Determine the default n_type value for a symbol from its section. */ 1335 1336 static unsigned 1337 obj_mach_o_type_for_symbol (bfd_mach_o_asymbol *s) 1338 { 1339 if (s->symbol.section == bfd_abs_section_ptr) 1340 return BFD_MACH_O_N_ABS; 1341 else if (s->symbol.section == bfd_com_section_ptr 1342 || s->symbol.section == bfd_und_section_ptr) 1343 return BFD_MACH_O_N_UNDF; 1344 else 1345 return BFD_MACH_O_N_SECT; 1346 } 1347 1348 void 1349 obj_mach_o_frob_colon (const char *name) 1350 { 1351 if (!bfd_is_local_label_name (stdoutput, name)) 1352 { 1353 /* A non-local label will create a new subsection, so start a new 1354 frag. */ 1355 frag_wane (frag_now); 1356 frag_new (0); 1357 } 1358 } 1359 1360 /* We need to check the correspondence between some kinds of symbols and their 1361 sections. Common and BSS vars will seen via the obj_macho_comm() function. 1362 1363 The earlier we can pick up a problem, the better the diagnostics will be. 1364 1365 However, when symbol type information is attached, the symbol section will 1366 quite possibly be unknown. So we are stuck with checking (most of the) 1367 validity at the time the file is written (unfortunately, then one doesn't 1368 get line number information in the diagnostic). */ 1369 1370 /* Here we pick up the case where symbol qualifiers have been applied that 1371 are possibly incompatible with the section etc. that the symbol is defined 1372 in. */ 1373 1374 void obj_mach_o_frob_label (struct symbol *sp) 1375 { 1376 bfd_mach_o_asymbol *s; 1377 unsigned base_type; 1378 bfd_mach_o_section *sec; 1379 int sectype = -1; 1380 1381 if (!bfd_is_local_label_name (stdoutput, S_GET_NAME (sp))) 1382 { 1383 /* If this is a non-local label, it should have started a new sub- 1384 section. */ 1385 gas_assert (frag_now->obj_frag_data.subsection == NULL); 1386 frag_now->obj_frag_data.subsection = sp; 1387 } 1388 1389 /* Leave local symbols alone. */ 1390 1391 if (S_IS_LOCAL (sp)) 1392 return; 1393 1394 s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (sp); 1395 /* Leave debug symbols alone. */ 1396 if ((s->n_type & BFD_MACH_O_N_STAB) != 0) 1397 return; 1398 1399 /* This is the base symbol type, that we mask in. */ 1400 base_type = obj_mach_o_type_for_symbol (s); 1401 1402 sec = bfd_mach_o_get_mach_o_section (s->symbol.section); 1403 if (sec != NULL) 1404 sectype = sec->flags & BFD_MACH_O_SECTION_TYPE_MASK; 1405 1406 /* If there is a pre-existing qualifier, we can make some checks about 1407 validity now. */ 1408 1409 if(s->symbol.udata.i == SYM_MACHO_FIELDS_NOT_VALIDATED) 1410 { 1411 if ((s->n_desc & BFD_MACH_O_N_WEAK_DEF) 1412 && sectype != BFD_MACH_O_S_COALESCED) 1413 { 1414 as_bad (_("'%s' can't be a weak_definition (currently only supported" 1415 " in sections of type coalesced)"), s->symbol.name); 1416 /* Don't cascade errors. */ 1417 s->symbol.udata.i = SYM_MACHO_FIELDS_UNSET; 1418 } 1419 1420 /* Have we changed from an undefined to defined ref? */ 1421 s->n_desc &= ~(REFE | LAZY); 1422 } 1423 1424 s->n_type &= ~BFD_MACH_O_N_TYPE; 1425 s->n_type |= base_type; 1426 } 1427 1428 /* This is the fall-back, we come here when we get to the end of the file and 1429 the symbol is not defined - or there are combinations of qualifiers required 1430 (e.g. global + weak_def). */ 1431 1432 int 1433 obj_mach_o_frob_symbol (struct symbol *sp) 1434 { 1435 bfd_mach_o_asymbol *s; 1436 unsigned base_type; 1437 bfd_mach_o_section *sec; 1438 int sectype = -1; 1439 1440 /* Leave local symbols alone. */ 1441 if (S_IS_LOCAL (sp)) 1442 return 0; 1443 1444 s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (sp); 1445 /* Leave debug symbols alone. */ 1446 if ((s->n_type & BFD_MACH_O_N_STAB) != 0) 1447 return 0; 1448 1449 base_type = obj_mach_o_type_for_symbol (s); 1450 sec = bfd_mach_o_get_mach_o_section (s->symbol.section); 1451 if (sec != NULL) 1452 sectype = sec->flags & BFD_MACH_O_SECTION_TYPE_MASK; 1453 1454 if (s->symbol.section == bfd_und_section_ptr) 1455 { 1456 /* ??? Do we really gain much from implementing this as well as the 1457 mach-o specific ones? */ 1458 if (s->symbol.flags & BSF_WEAK) 1459 s->n_desc |= BFD_MACH_O_N_WEAK_REF; 1460 1461 /* Undefined syms, become extern. */ 1462 s->n_type |= BFD_MACH_O_N_EXT; 1463 S_SET_EXTERNAL (sp); 1464 } 1465 else if (s->symbol.section == bfd_com_section_ptr) 1466 { 1467 /* ... so do comm. */ 1468 s->n_type |= BFD_MACH_O_N_EXT; 1469 S_SET_EXTERNAL (sp); 1470 } 1471 else 1472 { 1473 if ((s->symbol.flags & BSF_WEAK) 1474 && (sectype == BFD_MACH_O_S_COALESCED) 1475 && (s->n_type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))) 1476 s->n_desc |= BFD_MACH_O_N_WEAK_DEF; 1477 /* ??? we should do this - but then that reveals that the semantics of weak 1478 are different from what's supported in mach-o object files. 1479 else 1480 as_bad (_("'%s' can't be a weak_definition."), 1481 s->symbol.name); */ 1482 } 1483 1484 if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET) 1485 { 1486 /* Anything here that should be added that is non-standard. */ 1487 s->n_desc &= ~BFD_MACH_O_REFERENCE_MASK; 1488 } 1489 else if (s->symbol.udata.i == SYM_MACHO_FIELDS_NOT_VALIDATED) 1490 { 1491 /* Try to validate any combinations. */ 1492 if (s->n_desc & BFD_MACH_O_N_WEAK_DEF) 1493 { 1494 if (s->symbol.section == bfd_und_section_ptr) 1495 as_bad (_("'%s' can't be a weak_definition (since it is" 1496 " undefined)"), s->symbol.name); 1497 else if (sectype != BFD_MACH_O_S_COALESCED) 1498 as_bad (_("'%s' can't be a weak_definition (currently only supported" 1499 " in sections of type coalesced)"), s->symbol.name); 1500 else if (! (s->n_type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))) 1501 as_bad (_("Non-global symbol: '%s' can't be a weak_definition."), 1502 s->symbol.name); 1503 } 1504 1505 } 1506 else 1507 as_bad (_("internal error: [%s] unexpected code [%lx] in frob symbol"), 1508 s->symbol.name, (unsigned long)s->symbol.udata.i); 1509 1510 s->n_type &= ~BFD_MACH_O_N_TYPE; 1511 s->n_type |= base_type; 1512 1513 if (s->symbol.flags & BSF_GLOBAL) 1514 s->n_type |= BFD_MACH_O_N_EXT; 1515 1516 /* This cuts both ways - we promote some things to external above. */ 1517 if (s->n_type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT)) 1518 S_SET_EXTERNAL (sp); 1519 1520 return 0; 1521 } 1522 1523 /* Support stabs for mach-o. */ 1524 1525 void 1526 obj_mach_o_process_stab (int what, const char *string, 1527 int type, int other, int desc) 1528 { 1529 symbolS *symbolP; 1530 bfd_mach_o_asymbol *s; 1531 1532 switch (what) 1533 { 1534 case 'd': 1535 symbolP = symbol_new ("", now_seg, frag_now_fix (), frag_now); 1536 /* Special stabd NULL name indicator. */ 1537 S_SET_NAME (symbolP, NULL); 1538 break; 1539 1540 case 'n': 1541 case 's': 1542 symbolP = symbol_new (string, undefined_section, (valueT) 0, 1543 &zero_address_frag); 1544 pseudo_set (symbolP); 1545 break; 1546 1547 default: 1548 as_bad(_("unrecognized stab type '%c'"), (char)what); 1549 abort (); 1550 break; 1551 } 1552 1553 s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (symbolP); 1554 s->n_type = type; 1555 s->n_desc = desc; 1556 /* For stabd, this will eventually get overwritten by the section number. */ 1557 s->n_sect = other; 1558 1559 /* It's a debug symbol. */ 1560 s->symbol.flags |= BSF_DEBUGGING; 1561 1562 /* We've set it - so check it, if you can, but don't try to create the 1563 flags. */ 1564 s->symbol.udata.i = SYM_MACHO_FIELDS_NOT_VALIDATED; 1565 } 1566 1567 /* This is a place to check for any errors that we can't detect until we know 1568 what remains undefined at the end of assembly. */ 1569 1570 static void 1571 obj_mach_o_check_before_writing (bfd *abfd ATTRIBUTE_UNUSED, 1572 asection *sec, 1573 void *unused ATTRIBUTE_UNUSED) 1574 { 1575 fixS *fixP; 1576 struct frchain *frchp; 1577 segment_info_type *seginfo = seg_info (sec); 1578 1579 if (seginfo == NULL) 1580 return; 1581 1582 /* We are not allowed subtractions where either of the operands is 1583 undefined. So look through the frags for any fixes to check. */ 1584 for (frchp = seginfo->frchainP; frchp != NULL; frchp = frchp->frch_next) 1585 for (fixP = frchp->fix_root; fixP != NULL; fixP = fixP->fx_next) 1586 { 1587 if (fixP->fx_addsy != NULL 1588 && fixP->fx_subsy != NULL 1589 && (! S_IS_DEFINED (fixP->fx_addsy) 1590 || ! S_IS_DEFINED (fixP->fx_subsy))) 1591 { 1592 segT add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy); 1593 segT sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy); 1594 1595 if (! S_IS_DEFINED (fixP->fx_addsy) 1596 && S_IS_DEFINED (fixP->fx_subsy)) 1597 { 1598 as_bad_where (fixP->fx_file, fixP->fx_line, 1599 _("`%s' can't be undefined in `%s' - `%s' {%s section}"), 1600 S_GET_NAME (fixP->fx_addsy), S_GET_NAME (fixP->fx_addsy), 1601 S_GET_NAME (fixP->fx_subsy), segment_name (sub_symbol_segment)); 1602 } 1603 else if (! S_IS_DEFINED (fixP->fx_subsy) 1604 && S_IS_DEFINED (fixP->fx_addsy)) 1605 { 1606 as_bad_where (fixP->fx_file, fixP->fx_line, 1607 _("`%s' can't be undefined in `%s' {%s section} - `%s'"), 1608 S_GET_NAME (fixP->fx_subsy), S_GET_NAME (fixP->fx_addsy), 1609 segment_name (add_symbol_segment), S_GET_NAME (fixP->fx_subsy)); 1610 } 1611 else 1612 { 1613 as_bad_where (fixP->fx_file, fixP->fx_line, 1614 _("`%s' and `%s' can't be undefined in `%s' - `%s'"), 1615 S_GET_NAME (fixP->fx_addsy), S_GET_NAME (fixP->fx_subsy), 1616 S_GET_NAME (fixP->fx_addsy), S_GET_NAME (fixP->fx_subsy)); 1617 } 1618 } 1619 } 1620 } 1621 1622 /* Do any checks that we can't complete without knowing what's undefined. */ 1623 void 1624 obj_mach_o_pre_output_hook (void) 1625 { 1626 bfd_map_over_sections (stdoutput, obj_mach_o_check_before_writing, (char *) 0); 1627 } 1628 1629 /* Here we count up frags in each subsection (where a sub-section is defined 1630 as starting with a non-local symbol). 1631 Note that, if there are no non-local symbols in a section, all the frags will 1632 be attached as one anonymous subsection. */ 1633 1634 static void 1635 obj_mach_o_set_subsections (bfd *abfd ATTRIBUTE_UNUSED, 1636 asection *sec, 1637 void *unused ATTRIBUTE_UNUSED) 1638 { 1639 segment_info_type *seginfo = seg_info (sec); 1640 symbolS *cur_subsection = NULL; 1641 struct obj_mach_o_symbol_data *cur_subsection_data = NULL; 1642 fragS *frag; 1643 frchainS *chain; 1644 1645 /* Protect against sections not created by gas. */ 1646 if (seginfo == NULL) 1647 return; 1648 1649 /* Attach every frag to a subsection. */ 1650 for (chain = seginfo->frchainP; chain != NULL; chain = chain->frch_next) 1651 for (frag = chain->frch_root; frag != NULL; frag = frag->fr_next) 1652 { 1653 if (frag->obj_frag_data.subsection == NULL) 1654 frag->obj_frag_data.subsection = cur_subsection; 1655 else 1656 { 1657 cur_subsection = frag->obj_frag_data.subsection; 1658 cur_subsection_data = symbol_get_obj (cur_subsection); 1659 cur_subsection_data->subsection_size = 0; 1660 } 1661 if (cur_subsection_data != NULL) 1662 { 1663 /* Update subsection size. */ 1664 cur_subsection_data->subsection_size += frag->fr_fix; 1665 } 1666 } 1667 } 1668 1669 /* Handle mach-o subsections-via-symbols counting up frags belonging to each 1670 sub-section. */ 1671 1672 void 1673 obj_mach_o_pre_relax_hook (void) 1674 { 1675 bfd_map_over_sections (stdoutput, obj_mach_o_set_subsections, (char *) 0); 1676 } 1677 1678 /* Zerofill and GB Zerofill sections must be sorted to follow all other 1679 sections in their segments. 1680 1681 The native 'as' leaves the sections physically in the order they appear in 1682 the source, and adjusts the section VMAs to meet the constraint. 1683 1684 We follow this for now - if nothing else, it makes comparison easier. 1685 1686 An alternative implementation would be to sort the sections as ld requires. 1687 It might be advantageous to implement such a scheme in the future (or even 1688 to make the style of section ordering user-selectable). */ 1689 1690 typedef struct obj_mach_o_set_vma_data 1691 { 1692 bfd_vma vma; 1693 unsigned vma_pass; 1694 unsigned zerofill_seen; 1695 unsigned gb_zerofill_seen; 1696 } obj_mach_o_set_vma_data; 1697 1698 /* We do (possibly) three passes through to set the vma, so that: 1699 1700 zerofill sections get VMAs after all others in their segment 1701 GB zerofill get VMAs last. 1702 1703 As we go, we notice if we see any Zerofill or GB Zerofill sections, so that 1704 we can skip the additional passes if there's nothing to do. */ 1705 1706 static void 1707 obj_mach_o_set_section_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *v_p) 1708 { 1709 bfd_mach_o_section *ms = bfd_mach_o_get_mach_o_section (sec); 1710 unsigned bfd_align = bfd_get_section_alignment (abfd, sec); 1711 obj_mach_o_set_vma_data *p = (struct obj_mach_o_set_vma_data *)v_p; 1712 unsigned sectype = (ms->flags & BFD_MACH_O_SECTION_TYPE_MASK); 1713 unsigned zf; 1714 1715 zf = 0; 1716 if (sectype == BFD_MACH_O_S_ZEROFILL) 1717 { 1718 zf = 1; 1719 p->zerofill_seen = zf; 1720 } 1721 else if (sectype == BFD_MACH_O_S_GB_ZEROFILL) 1722 { 1723 zf = 2; 1724 p->gb_zerofill_seen = zf; 1725 } 1726 1727 if (p->vma_pass != zf) 1728 return; 1729 1730 /* We know the section size now - so make a vma for the section just 1731 based on order. */ 1732 ms->size = bfd_get_section_size (sec); 1733 1734 /* Make sure that the align agrees, and set to the largest value chosen. */ 1735 ms->align = ms->align > bfd_align ? ms->align : bfd_align; 1736 bfd_set_section_alignment (abfd, sec, ms->align); 1737 1738 p->vma += (1 << ms->align) - 1; 1739 p->vma &= ~((1 << ms->align) - 1); 1740 ms->addr = p->vma; 1741 bfd_set_section_vma (abfd, sec, p->vma); 1742 p->vma += ms->size; 1743 } 1744 1745 /* (potentially) three passes over the sections, setting VMA. We skip the 1746 {gb}zerofill passes if we didn't see any of the relevant sections. */ 1747 1748 void obj_mach_o_post_relax_hook (void) 1749 { 1750 obj_mach_o_set_vma_data d; 1751 1752 memset (&d, 0, sizeof (d)); 1753 1754 bfd_map_over_sections (stdoutput, obj_mach_o_set_section_vma, (char *) &d); 1755 if ((d.vma_pass = d.zerofill_seen) != 0) 1756 bfd_map_over_sections (stdoutput, obj_mach_o_set_section_vma, (char *) &d); 1757 if ((d.vma_pass = d.gb_zerofill_seen) != 0) 1758 bfd_map_over_sections (stdoutput, obj_mach_o_set_section_vma, (char *) &d); 1759 } 1760 1761 static void 1762 obj_mach_o_set_indirect_symbols (bfd *abfd, asection *sec, 1763 void *xxx ATTRIBUTE_UNUSED) 1764 { 1765 bfd_vma sect_size = bfd_section_size (abfd, sec); 1766 bfd_mach_o_section *ms = bfd_mach_o_get_mach_o_section (sec); 1767 unsigned lazy = 0; 1768 1769 /* See if we have any indirect syms to consider. */ 1770 if (indirect_syms == NULL) 1771 return; 1772 1773 /* Process indirect symbols. 1774 Check for errors, if OK attach them as a flat array to the section 1775 for which they are defined. */ 1776 1777 switch (ms->flags & BFD_MACH_O_SECTION_TYPE_MASK) 1778 { 1779 case BFD_MACH_O_S_SYMBOL_STUBS: 1780 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS: 1781 lazy = LAZY; 1782 /* Fall through. */ 1783 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS: 1784 { 1785 unsigned int nactual = 0; 1786 unsigned int ncalc; 1787 obj_mach_o_indirect_sym *isym; 1788 obj_mach_o_indirect_sym *list = NULL; 1789 obj_mach_o_indirect_sym *list_tail = NULL; 1790 unsigned long eltsiz = 1791 bfd_mach_o_section_get_entry_size (abfd, ms); 1792 1793 for (isym = indirect_syms; isym != NULL; isym = isym->next) 1794 { 1795 if (isym->sect == sec) 1796 { 1797 nactual++; 1798 if (list == NULL) 1799 list = isym; 1800 else 1801 list_tail->next = isym; 1802 list_tail = isym; 1803 } 1804 } 1805 1806 /* If none are in this section, stop here. */ 1807 if (nactual == 0) 1808 break; 1809 1810 /* If we somehow added indirect symbols to a section with a zero 1811 entry size, we're dead ... */ 1812 gas_assert (eltsiz != 0); 1813 1814 ncalc = (unsigned int) (sect_size / eltsiz); 1815 if (nactual != ncalc) 1816 as_bad (_("the number of .indirect_symbols defined in section %s" 1817 " does not match the number expected (%d defined, %d" 1818 " expected)"), sec->name, nactual, ncalc); 1819 else 1820 { 1821 unsigned n; 1822 bfd_mach_o_asymbol *sym; 1823 ms->indirect_syms = 1824 bfd_zalloc (abfd, 1825 nactual * sizeof (bfd_mach_o_asymbol *)); 1826 1827 if (ms->indirect_syms == NULL) 1828 { 1829 as_fatal (_("internal error: failed to allocate %d indirect" 1830 "symbol pointers"), nactual); 1831 } 1832 1833 for (isym = list, n = 0; isym != NULL; isym = isym->next, n++) 1834 { 1835 sym = (bfd_mach_o_asymbol *)symbol_get_bfdsym (isym->sym); 1836 /* Array is init to NULL & NULL signals a local symbol 1837 If the section is lazy-bound, we need to keep the 1838 reference to the symbol, since dyld can override. 1839 1840 Absolute symbols are handled specially. */ 1841 if (sym->symbol.section == bfd_abs_section_ptr) 1842 ms->indirect_syms[n] = sym; 1843 else if (S_IS_LOCAL (isym->sym) && ! lazy) 1844 ; 1845 else 1846 { 1847 if (sym == NULL) 1848 ; 1849 /* If the symbols is external ... */ 1850 else if (S_IS_EXTERNAL (isym->sym) 1851 || (sym->n_type & BFD_MACH_O_N_EXT) 1852 || ! S_IS_DEFINED (isym->sym) 1853 || lazy) 1854 { 1855 sym->n_desc &= ~LAZY; 1856 /* ... it can be lazy, if not defined or hidden. */ 1857 if ((sym->n_type & BFD_MACH_O_N_TYPE) 1858 == BFD_MACH_O_N_UNDF 1859 && ! (sym->n_type & BFD_MACH_O_N_PEXT) 1860 && (sym->n_type & BFD_MACH_O_N_EXT)) 1861 sym->n_desc |= lazy; 1862 ms->indirect_syms[n] = sym; 1863 } 1864 } 1865 } 1866 } 1867 } 1868 break; 1869 1870 default: 1871 break; 1872 } 1873 } 1874 1875 /* The process of relocation could alter what's externally visible, thus we 1876 leave setting the indirect symbols until last. */ 1877 1878 void 1879 obj_mach_o_frob_file_after_relocs (void) 1880 { 1881 bfd_map_over_sections (stdoutput, obj_mach_o_set_indirect_symbols, (char *) 0); 1882 } 1883 1884 /* Reverse relocations order to make ld happy. */ 1885 1886 void 1887 obj_mach_o_reorder_section_relocs (asection *sec, arelent **rels, unsigned int n) 1888 { 1889 unsigned int i; 1890 unsigned int max = n / 2; 1891 1892 for (i = 0; i < max; i++) 1893 { 1894 arelent *r = rels[i]; 1895 rels[i] = rels[n - i - 1]; 1896 rels[n - i - 1] = r; 1897 } 1898 bfd_set_reloc (stdoutput, sec, rels, n); 1899 } 1900 1901 /* Relocation rules are different in frame sections. */ 1902 1903 static int 1904 obj_mach_o_is_frame_section (segT sec) 1905 { 1906 int l; 1907 l = strlen (segment_name (sec)); 1908 if ((l == 9 && strncmp (".eh_frame", segment_name (sec), 9) == 0) 1909 || (l == 12 && strncmp (".debug_frame", segment_name (sec), 12) == 0)) 1910 return 1; 1911 return 0; 1912 } 1913 1914 /* Unless we're in a frame section, we need to force relocs to be generated for 1915 local subtractions. We might eliminate them later (if they are within the 1916 same sub-section) but we don't know that at the point that this decision is 1917 being made. */ 1918 1919 int 1920 obj_mach_o_allow_local_subtract (expressionS * left ATTRIBUTE_UNUSED, 1921 expressionS * right ATTRIBUTE_UNUSED, 1922 segT seg) 1923 { 1924 /* Don't interfere if it's one of the GAS internal sections. */ 1925 if (! SEG_NORMAL (seg)) 1926 return 1; 1927 1928 /* Allow in frame sections, otherwise emit a reloc. */ 1929 return obj_mach_o_is_frame_section (seg); 1930 } 1931 1932 int 1933 obj_mach_o_in_different_subsection (symbolS *a, symbolS *b) 1934 { 1935 fragS *fa; 1936 fragS *fb; 1937 1938 if (S_GET_SEGMENT (a) != S_GET_SEGMENT (b) 1939 || !S_IS_DEFINED (a) 1940 || !S_IS_DEFINED (b)) 1941 { 1942 /* Not in the same segment, or undefined symbol. */ 1943 return 1; 1944 } 1945 1946 fa = symbol_get_frag (a); 1947 fb = symbol_get_frag (b); 1948 if (fa == NULL || fb == NULL) 1949 { 1950 /* One of the symbols is not in a subsection. */ 1951 return 1; 1952 } 1953 1954 return fa->obj_frag_data.subsection != fb->obj_frag_data.subsection; 1955 } 1956 1957 int 1958 obj_mach_o_force_reloc_sub_same (fixS *fix, segT seg) 1959 { 1960 if (! SEG_NORMAL (seg)) 1961 return 1; 1962 return obj_mach_o_in_different_subsection (fix->fx_addsy, fix->fx_subsy); 1963 } 1964 1965 int 1966 obj_mach_o_force_reloc_sub_local (fixS *fix, segT seg ATTRIBUTE_UNUSED) 1967 { 1968 return obj_mach_o_in_different_subsection (fix->fx_addsy, fix->fx_subsy); 1969 } 1970 1971 int 1972 obj_mach_o_force_reloc (fixS *fix) 1973 { 1974 if (generic_force_reloc (fix)) 1975 return 1; 1976 1977 /* Force a reloc if the target is not in the same subsection. 1978 FIXME: handle (a - b) where a and b belongs to the same subsection ? */ 1979 if (fix->fx_addsy != NULL) 1980 { 1981 symbolS *subsec = fix->fx_frag->obj_frag_data.subsection; 1982 symbolS *targ = fix->fx_addsy; 1983 1984 /* There might be no subsections at all. */ 1985 if (subsec == NULL) 1986 return 0; 1987 1988 if (S_GET_SEGMENT (targ) == absolute_section) 1989 return 0; 1990 1991 return obj_mach_o_in_different_subsection (targ, subsec); 1992 } 1993 return 0; 1994 } 1995
