1
/* Mach-O object file format
2
Copyright 2009, 2011, 2012 Free Software Foundation, Inc.
4
This file is part of GAS, the GNU Assembler.
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.
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.
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
21
/* Here we handle the mach-o directives that are common to all architectures.
23
Most significant are mach-o named sections and a variety of symbol type
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.
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.
35
A number of additional mach-o short-hand section switch directives are
38
#define OBJ_HEADER "obj-macho.h"
45
#include "mach-o/loader.h"
46
#include "obj-macho.h"
51
static segT obj_mach_o_segT_from_bfd_name (const char *, int);
53
/* TODO: Implement "-dynamic"/"-static" command line options. */
55
static int obj_mach_o_is_static;
57
/* TODO: Implement the "-n" command line option to suppress the initial
58
switch to the text segment. */
60
static int obj_mach_o_start_with_text_section = 1;
62
/* Allow for special re-ordering on output. */
64
static int obj_mach_o_seen_objc_section;
66
/* Start-up: At present, just create the sections we want. */
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)
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)
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;
86
/* Remember the subsections_by_symbols state in case we need to reset
89
static int obj_mach_o_subsections_by_symbols;
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
97
It trims leading and trailing space. */
100
collect_16char_name (char *dest, const char *msg, int require_comma)
105
namstart = input_line_pointer;
107
while ( (c = *input_line_pointer) != ','
108
&& !is_end_of_line[(unsigned char) c])
109
input_line_pointer++;
112
int len = input_line_pointer - namstart; /* could be zero. */
113
/* lose any trailing space. */
114
while (len > 0 && namstart[len-1] == ' ')
118
*input_line_pointer = '\0'; /* make a temp string. */
119
as_bad (_("the %s name '%s' is too long (maximum 16 characters)"),
121
*input_line_pointer = c; /* restore for printing. */
125
memcpy (dest, namstart, len);
128
if (c != ',' && require_comma)
130
as_bad (_("expected a %s name followed by a `,'"), msg);
138
obj_mach_o_get_section_names (char *seg, char *sec,
139
unsigned segl, unsigned secl)
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))
146
ignore_rest_of_line ();
149
input_line_pointer++; /* Skip the terminating ',' */
151
/* Parse section name, which can be empty. */
152
memset (sec, 0, secl);
153
collect_16char_name (sec, "section", 0);
157
/* Build (or get) a section from the mach-o description - which includes
158
optional definitions for type, attributes, alignment and stub size.
160
BFD supplies default values for sections which have a canonical name. */
162
#define SECT_TYPE_SPECIFIED 0x0001
163
#define SECT_ATTR_SPECIFIED 0x0002
164
#define SECT_ALGN_SPECIFIED 0x0004
165
#define SECT_STUB_SPECIFIED 0x0008
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)
173
unsigned int sectype, secattr, secalign;
174
flagword oldflags, flags;
177
bfd_mach_o_section *msect;
178
const mach_o_section_name_xlat *xlat;
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);
184
/* TODO: more checking of whether overides are acually allowed. */
188
name = xstrdup (xlat->bfd_name);
189
sectype = xlat->macho_sectype;
190
if (specified_mask & SECT_TYPE_SPECIFIED)
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'"),
200
secattr = xlat->macho_secattr;
201
secalign = xlat->sectalign;
202
flags = xlat->bfd_flags;
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
209
size_t seglen = strlen (segname);
210
size_t sectlen = strlen (sectname);
213
n = xmalloc (seglen + 1 + sectlen + 1);
214
memcpy (n, segname, seglen);
216
memcpy (n + seglen + 1, sectname, sectlen);
217
n[seglen + 1 + sectlen] = 0;
219
if (specified_mask & SECT_TYPE_SPECIFIED)
222
sectype = BFD_MACH_O_S_REGULAR;
223
secattr = BFD_MACH_O_S_ATTR_NONE;
225
flags = SEC_NO_FLAGS;
228
/* For now, just use what the user provided. */
230
if (specified_mask & SECT_ATTR_SPECIFIED)
233
if (specified_mask & SECT_ALGN_SPECIFIED)
236
/* Sub-segments don't exists as is on Mach-O. */
237
sec = subseg_new (name, 0);
239
oldflags = bfd_get_section_flags (stdoutput, sec);
240
msect = bfd_mach_o_get_mach_o_section (sec);
242
if (oldflags == SEC_NO_FLAGS)
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))
251
if (flags == SEC_NO_FLAGS
252
&& (specified_mask & SECT_ATTR_SPECIFIED)
253
&& (secattr & BFD_MACH_O_S_ATTR_DEBUG))
254
flags |= SEC_DEBUGGING;
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 ()));
262
strncpy (msect->segname, segname, sizeof (msect->segname));
263
strncpy (msect->sectname, sectname, sizeof (msect->sectname));
265
msect->align = secalign;
266
msect->flags = sectype | secattr;
268
if (sectype == BFD_MACH_O_S_ZEROFILL
269
|| sectype == BFD_MACH_O_S_GB_ZEROFILL)
270
seg_info (sec)->bss = 1;
272
else if (flags != SEC_NO_FLAGS)
274
if (flags != oldflags
275
|| msect->flags != (secattr | sectype))
276
as_warn (_("Ignoring changed section attributes for %s"), name);
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;
288
The '.section' specification syntax looks like:
289
.section <segment> , <section> [, type [, attribs [, size]]]
291
White space is allowed everywhere between elements.
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
298
There is only a single section type for any entry.
300
There may be multiple attributes, they are delimited by `+'.
302
Not all section types and attributes are accepted by the Darwin system
303
assemblers as user-specifiable - although, at present, we do here. */
306
obj_mach_o_section (int ignore ATTRIBUTE_UNUSED)
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;
316
#ifdef md_flush_pending_output
317
md_flush_pending_output ();
320
/* Get the User's segment annd section names. */
321
if (! obj_mach_o_get_section_names (segname, sectname, 17, 17))
324
/* Parse section type, if present. */
325
if (*input_line_pointer == ',')
331
input_line_pointer++;
333
p = input_line_pointer;
334
while ((c = *input_line_pointer) != ','
335
&& !is_end_of_line[(unsigned char) c])
336
input_line_pointer++;
338
len = input_line_pointer - p;
339
/* strip trailing spaces. */
340
while (len > 0 && p[len-1] == ' ')
344
/* Temporarily make a string from the token. */
346
sectype = bfd_mach_o_get_section_type_from_name (stdoutput, p);
347
if (sectype > 255) /* Max Section ID == 255. */
349
as_bad (_("unknown or invalid section type '%s'"), p);
351
ignore_rest_of_line ();
355
specified_mask |= SECT_TYPE_SPECIFIED;
360
TODO: check validity of attributes for section type. */
361
if ((specified_mask & SECT_TYPE_SPECIFIED)
368
/* Skip initial `,' and subsequent `+'. */
369
input_line_pointer++;
371
p = input_line_pointer;
372
while ((c = *input_line_pointer) != '+'
374
&& !is_end_of_line[(unsigned char) c])
375
input_line_pointer++;
377
len = input_line_pointer - p;
378
/* strip trailing spaces. */
379
while (len > 0 && p[len-1] == ' ')
383
/* Temporarily make a string from the token. */
385
attr = bfd_mach_o_get_section_attribute_from_name (p);
388
as_bad (_("unknown or invalid section attribute '%s'"), p);
390
ignore_rest_of_line ();
395
specified_mask |= SECT_ATTR_SPECIFIED;
401
while (*input_line_pointer == '+');
403
/* Parse sizeof_stub. */
404
if ((specified_mask & SECT_ATTR_SPECIFIED)
405
&& *input_line_pointer == ',')
407
if (sectype != BFD_MACH_O_S_SYMBOL_STUBS)
409
as_bad (_("unexpected section size information"));
410
ignore_rest_of_line ();
414
input_line_pointer++;
415
sizeof_stub = get_absolute_expression ();
416
specified_mask |= SECT_STUB_SPECIFIED;
418
else if ((specified_mask & SECT_ATTR_SPECIFIED)
419
&& sectype == BFD_MACH_O_S_SYMBOL_STUBS)
421
as_bad (_("missing sizeof_stub expression"));
422
ignore_rest_of_line ();
428
new_seg = obj_mach_o_make_or_get_sect (segname, sectname, specified_mask,
429
sectype, secattr, 0 /*align */,
433
subseg_set (new_seg, 0);
434
demand_empty_rest_of_line ();
438
/* .zerofill segname, sectname [, symbolname, size [, align]]
440
Zerofill switches, temporarily, to a sect of type 'zerofill'.
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. */
446
obj_mach_o_zerofill (int ignore ATTRIBUTE_UNUSED)
450
segT old_seg = now_seg;
453
unsigned int align = 0;
454
unsigned int specified_mask = 0;
457
#ifdef md_flush_pending_output
458
md_flush_pending_output ();
461
/* Get the User's segment annd section names. */
462
if (! obj_mach_o_get_section_names (segname, sectname, 17, 17))
465
/* Parse variable definition, if present. */
466
if (*input_line_pointer == ',')
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. */
476
input_line_pointer++; /* Skip ',' */
478
name = input_line_pointer;
479
c = get_symbol_end ();
480
/* Just after name is now '\0'. */
481
p = input_line_pointer;
486
as_bad (_("expected symbol name"));
487
ignore_rest_of_line ();
492
if (*input_line_pointer == ',')
493
input_line_pointer++;
495
expression_and_evaluate (&exp);
496
if (exp.X_op != O_constant
497
&& exp.X_op != O_absent)
499
as_bad (_("bad or irreducible absolute expression"));
500
ignore_rest_of_line ();
503
else if (exp.X_op == O_absent)
505
as_bad (_("missing size expression"));
506
ignore_rest_of_line ();
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)
514
as_warn (_("size (%ld) out of range, ignored"),
515
(long) exp.X_add_number);
516
ignore_rest_of_line ();
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))
524
as_bad (_("symbol `%s' is already defined"), name);
526
ignore_rest_of_line ();
530
size = S_GET_VALUE (sym);
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);
537
*p = c; /* Restore the termination char. */
540
if (*input_line_pointer == ',')
542
align = (unsigned int) parse_align (0);
543
if (align == (unsigned int) -1)
545
as_warn (_("align value not recognized, using size"));
550
as_warn (_("Alignment (%lu) too large: 15 assumed."),
551
(unsigned long)align);
554
specified_mask |= SECT_ALGN_SPECIFIED;
557
/* else just a section definition. */
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*/);
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;
573
subseg_set (new_seg, 0);
581
record_alignment (new_seg, align);
582
frag_align (align, 0, 0);
585
/* Detach from old frag. */
586
if (S_GET_SEGMENT (sym) == new_seg)
587
symbol_get_frag (sym)->fr_symbol = NULL;
589
symbol_set_frag (sym, frag_now);
590
pfrag = frag_var (rs_org, 1, 1, 0, sym, size, NULL);
593
S_SET_SEGMENT (sym, new_seg);
594
if (new_seg == bss_section)
595
S_CLEAR_EXTERNAL (sym);
599
/* switch back to the section that was current before the .zerofill. */
600
subseg_set (old_seg, 0);
604
obj_mach_o_segT_from_bfd_name (const char *nam, int must_succeed)
606
const mach_o_section_name_xlat *xlat;
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);
616
as_fatal (_("BFD is out of sync with GAS, "
617
"unhandled well-known section type `%s'"), nam);
621
sec = bfd_get_section_by_name (stdoutput, nam);
624
bfd_mach_o_section *msect;
626
sec = subseg_force_new (xlat->bfd_name, 0);
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;
633
if ((msect->flags & BFD_MACH_O_SECTION_TYPE_MASK)
634
== BFD_MACH_O_S_ZEROFILL)
635
seg_info (sec)->bss = 1;
641
static const char * const known_sections[] =
646
/* 2 */ ".static_const",
650
/* 6 */ ".literal16",
651
/* 7 */ ".constructor",
652
/* 8 */ ".destructor",
655
/* 10 */ ".const_data",
656
/* 11 */ ".static_data",
657
/* 12 */ ".mod_init_func",
658
/* 13 */ ".mod_term_func",
663
/* Interface for a known non-optional section directive. */
666
obj_mach_o_known_section (int sect_index)
670
#ifdef md_flush_pending_output
671
md_flush_pending_output ();
674
section = obj_mach_o_segT_from_bfd_name (known_sections[sect_index], 1);
676
subseg_set (section, 0);
678
/* else, we leave the section as it was; there was a fatal error anyway. */
681
static const char * const objc_sections[] =
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. */
710
/* This currently does the same as known_sections, but kept separate for
711
ease of maintenance. */
714
obj_mach_o_objc_section (int sect_index)
718
#ifdef md_flush_pending_output
719
md_flush_pending_output ();
722
section = obj_mach_o_segT_from_bfd_name (objc_sections[sect_index], 1);
725
obj_mach_o_seen_objc_section = 1; /* We need to ensure that certain
726
sections are present and in the
728
subseg_set (section, 0);
731
/* else, we leave the section as it was; there was a fatal error anyway. */
734
/* Debug section directives. */
736
static const char * const debug_sections[] =
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"
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
759
obj_mach_o_debug_section (int sect_index)
763
#ifdef md_flush_pending_output
764
md_flush_pending_output ();
767
section = obj_mach_o_segT_from_bfd_name (debug_sections[sect_index], 1);
769
subseg_set (section, 0);
771
/* else, we leave the section as it was; there was a fatal error anyway. */
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. */
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'. */
787
static const struct opt_tgt_sect tgt_sections[] =
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 */
803
/* Interface for an optional section directive. */
806
obj_mach_o_opt_tgt_section (int sect_index)
808
const struct opt_tgt_sect *tgtsct = &tgt_sections[sect_index];
811
#ifdef md_flush_pending_output
812
md_flush_pending_output ();
815
section = obj_mach_o_segT_from_bfd_name (tgtsct->name, 0);
818
as_bad (_("%s is not used for the selected target"), tgtsct->name);
819
/* Leave the section as it is. */
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;
830
mo_sec->reserved2 = 0;
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. */
841
obj_mach_o_base_section (int sect_index)
845
#ifdef md_flush_pending_output
846
md_flush_pending_output ();
849
/* We don't support numeric (or any other) qualifications on the
850
well-known section shorthands. */
851
demand_empty_rest_of_line ();
855
/* Handle the three sections that are globally known within GAS.
856
For Mach-O, these are created on demand rather than at startup. */
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)
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;
866
section = text_section;
869
if (data_section == NULL)
870
data_section = obj_mach_o_segT_from_bfd_name (DATA_SECTION_NAME, 1);
871
section = data_section;
874
/* ??? maybe this achieves very little, as an addition. */
875
if (bss_section == NULL)
877
bss_section = obj_mach_o_segT_from_bfd_name (BSS_SECTION_NAME, 1);
878
seg_info (bss_section)->bss = 1;
880
section = bss_section;
883
as_fatal (_("internal error: base section index out of range"));
887
subseg_set (section, 0);
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
895
obj_mach_o_common_parse (int is_local, symbolS *symbolP,
899
bfd_mach_o_asymbol *s;
903
/* Both comm and lcomm take an optional alignment, as a power
904
of two between 1 and 15. */
905
if (*input_line_pointer == ',')
907
/* We expect a power of 2. */
908
align = parse_align (0);
909
if (align == (addressT) -1)
913
as_warn (_("Alignment (%lu) too large: 15 assumed."),
914
(unsigned long)align);
919
s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (symbolP);
922
/* Create the BSS section on demand. */
923
if (bss_section == NULL)
925
bss_section = obj_mach_o_segT_from_bfd_name (BSS_SECTION_NAME, 1);
926
seg_info (bss_section)->bss = 1;
928
bss_alloc (symbolP, size, align);
929
s->n_type = BFD_MACH_O_N_SECT;
930
S_CLEAR_EXTERNAL (symbolP);
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;
941
/* This is a data object (whatever we choose that to mean). */
942
s->symbol.flags |= BSF_OBJECT;
944
/* We've set symbol qualifiers, so validate if you can. */
945
s->symbol.udata.i = SYM_MACHO_FIELDS_NOT_VALIDATED;
951
obj_mach_o_comm (int is_local)
953
s_comm_internal (is_local, obj_mach_o_common_parse);
956
/* Set properties that apply to the whole file. At present, the only
957
one defined, is subsections_via_symbols. */
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;
966
obj_mach_o_fileprop (int prop)
968
if (prop < 0 || prop >= OBJ_MACH_O_FILE_PROP_MAX)
969
as_fatal (_("internal error: bad file property ID %d"), prop);
971
switch ((obj_mach_o_file_properties) prop)
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 ();
985
/* Temporary markers for symbol reference data.
986
Lazy will remain in place. */
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. */
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;
1007
/* Set Mach-O-specific symbol qualifiers. */
1010
obj_mach_o_set_symbol_qualifier (symbolS *sym, int type)
1013
bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (sym);
1014
bfd_mach_o_section *sec;
1018
/* If the symbol is defined, then we can do more rigorous checking on
1019
the validity of the qualifiers. Otherwise, we are stuck with waiting
1020
until it's defined - or until write the file.
1022
In certain cases (e.g. when a symbol qualifier is intended to introduce
1023
an undefined symbol in a stubs section) we should check that the current
1024
section is appropriate to the qualifier. */
1026
is_defined = s->symbol.section != bfd_und_section_ptr;
1028
sec = bfd_mach_o_get_mach_o_section (s->symbol.section) ;
1030
sec = bfd_mach_o_get_mach_o_section (now_seg) ;
1033
sectype = sec->flags & BFD_MACH_O_SECTION_TYPE_MASK;
1035
switch ((obj_mach_o_symbol_type) type)
1037
case OBJ_MACH_O_SYM_LOCAL:
1038
/* This is an extension over the system tools. */
1039
if (s->n_type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
1041
as_bad (_("'%s' previously declared as '%s'."), s->symbol.name,
1042
(s->n_type & BFD_MACH_O_N_PEXT) ? "private extern"
1048
s->n_type &= ~BFD_MACH_O_N_EXT;
1049
S_CLEAR_EXTERNAL (sym);
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. */
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);
1065
case OBJ_MACH_O_SYM_REFERENCE:
1067
s->n_desc |= BFD_MACH_O_N_NO_DEAD_STRIP;
1069
s->n_desc |= (REFE | BFD_MACH_O_N_NO_DEAD_STRIP);
1072
case OBJ_MACH_O_SYM_LAZY_REF:
1074
s->n_desc |= BFD_MACH_O_N_NO_DEAD_STRIP;
1076
s->n_desc |= (REFE | LAZY | BFD_MACH_O_N_NO_DEAD_STRIP);
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 ;
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 ;
1089
case OBJ_MACH_O_SYM_WEAK_DEF:
1090
if (is_defined && sectype != BFD_MACH_O_S_COALESCED)
1092
as_bad (_("'%s' can't be a weak_definition (currently only"
1093
" supported in sections of type coalesced)"),
1098
s->n_desc |= BFD_MACH_O_N_WEAK_DEF;
1101
case OBJ_MACH_O_SYM_WEAK:
1102
/* A generic 'weak' - we try to figure out what it means at
1103
symbol frob time. */
1111
/* We've seen some kind of qualifier - check validity if or when the entity
1113
s->symbol.udata.i = SYM_MACHO_FIELDS_NOT_VALIDATED;
1117
/* Respond to symbol qualifiers.
1119
.<qualifier> symbol [, symbol]*
1120
a list of symbols is an extension over the Darwin system as. */
1123
obj_mach_o_sym_qual (int ntype)
1129
#ifdef md_flush_pending_output
1130
md_flush_pending_output ();
1135
name = input_line_pointer;
1136
c = get_symbol_end ();
1137
symbolP = symbol_find_or_make (name);
1138
obj_mach_o_set_symbol_qualifier (symbolP, ntype);
1139
*input_line_pointer = c;
1141
c = *input_line_pointer;
1144
input_line_pointer++;
1146
if (is_end_of_line[(unsigned char) *input_line_pointer])
1152
demand_empty_rest_of_line ();
1155
typedef struct obj_mach_o_indirect_sym
1159
struct obj_mach_o_indirect_sym *next;
1160
} obj_mach_o_indirect_sym;
1162
/* We store in order an maintain a pointer to the last one - to save reversing
1164
obj_mach_o_indirect_sym *indirect_syms;
1165
obj_mach_o_indirect_sym *indirect_syms_tail;
1168
obj_mach_o_indirect_symbol (int arg ATTRIBUTE_UNUSED)
1170
bfd_mach_o_section *sec = bfd_mach_o_get_mach_o_section (now_seg);
1172
#ifdef md_flush_pending_output
1173
md_flush_pending_output ();
1176
if (obj_mach_o_is_static)
1177
as_bad (_("use of .indirect_symbols requires `-dynamic'"));
1179
switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
1181
case BFD_MACH_O_S_SYMBOL_STUBS:
1182
case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
1183
case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
1185
obj_mach_o_indirect_sym *isym;
1186
char *name = input_line_pointer;
1187
char c = get_symbol_end ();
1188
symbolS *sym = symbol_find_or_make (name);
1189
unsigned int elsize =
1190
bfd_mach_o_section_get_entry_size (stdoutput, sec);
1194
as_bad (_("attempt to add an indirect_symbol to a stub or"
1195
" reference section with a zero-sized element at %s"),
1197
*input_line_pointer = c;
1198
ignore_rest_of_line ();
1201
*input_line_pointer = c;
1203
/* The indirect symbols are validated after the symbol table is
1204
frozen, we must make sure that if a local symbol is used as an
1205
indirect, it is promoted to a 'real' one. Fetching the bfd sym
1207
symbol_get_bfdsym (sym);
1208
isym = (obj_mach_o_indirect_sym *)
1209
xmalloc (sizeof (obj_mach_o_indirect_sym));
1211
/* Just record the data for now, we will validate it when we
1212
compute the output in obj_mach_o_set_indirect_symbols. */
1214
isym->sect = now_seg;
1216
if (indirect_syms == NULL)
1217
indirect_syms = isym;
1219
indirect_syms_tail->next = isym;
1220
indirect_syms_tail = isym;
1225
as_bad (_("an .indirect_symbol must be in a symbol pointer"
1226
" or stub section."));
1227
ignore_rest_of_line ();
1230
demand_empty_rest_of_line ();
1233
const pseudo_typeS mach_o_pseudo_table[] =
1235
/* Section directives. */
1236
{ "comm", obj_mach_o_comm, 0 },
1237
{ "lcomm", obj_mach_o_comm, 1 },
1239
{ "text", obj_mach_o_base_section, 1},
1240
{ "data", obj_mach_o_base_section, 2},
1241
{ "bss", obj_mach_o_base_section, 3}, /* extension */
1243
{ "const", obj_mach_o_known_section, 1},
1244
{ "static_const", obj_mach_o_known_section, 2},
1245
{ "cstring", obj_mach_o_known_section, 3},
1246
{ "literal4", obj_mach_o_known_section, 4},
1247
{ "literal8", obj_mach_o_known_section, 5},
1248
{ "literal16", obj_mach_o_known_section, 6},
1249
{ "constructor", obj_mach_o_known_section, 7},
1250
{ "destructor", obj_mach_o_known_section, 8},
1251
{ "eh_frame", obj_mach_o_known_section, 9},
1253
{ "const_data", obj_mach_o_known_section, 10},
1254
{ "static_data", obj_mach_o_known_section, 11},
1255
{ "mod_init_func", obj_mach_o_known_section, 12},
1256
{ "mod_term_func", obj_mach_o_known_section, 13},
1257
{ "dyld", obj_mach_o_known_section, 14},
1258
{ "cfstring", obj_mach_o_known_section, 15},
1260
{ "objc_class", obj_mach_o_objc_section, 1},
1261
{ "objc_meta_class", obj_mach_o_objc_section, 2},
1262
{ "objc_cat_cls_meth", obj_mach_o_objc_section, 3},
1263
{ "objc_cat_inst_meth", obj_mach_o_objc_section, 4},
1264
{ "objc_protocol", obj_mach_o_objc_section, 5},
1265
{ "objc_string_object", obj_mach_o_objc_section, 6},
1266
{ "objc_cls_meth", obj_mach_o_objc_section, 7},
1267
{ "objc_inst_meth", obj_mach_o_objc_section, 8},
1268
{ "objc_cls_refs", obj_mach_o_objc_section, 9},
1269
{ "objc_message_refs", obj_mach_o_objc_section, 10},
1270
{ "objc_symbols", obj_mach_o_objc_section, 11},
1271
{ "objc_category", obj_mach_o_objc_section, 12},
1272
{ "objc_class_vars", obj_mach_o_objc_section, 13},
1273
{ "objc_instance_vars", obj_mach_o_objc_section, 14},
1274
{ "objc_module_info", obj_mach_o_objc_section, 15},
1275
{ "objc_class_names", obj_mach_o_objc_section, 16}, /* Alias for .cstring */
1276
{ "objc_meth_var_types", obj_mach_o_objc_section, 17}, /* Alias for .cstring */
1277
{ "objc_meth_var_names", obj_mach_o_objc_section, 18}, /* Alias for .cstring */
1278
{ "objc_selector_strs", obj_mach_o_objc_section, 19},
1279
{ "objc_image_info", obj_mach_o_objc_section, 20}, /* extension. */
1280
{ "objc_selector_fixup", obj_mach_o_objc_section, 21}, /* extension. */
1281
{ "objc1_class_ext", obj_mach_o_objc_section, 22}, /* ObjC-1 extension. */
1282
{ "objc1_property_list", obj_mach_o_objc_section, 23}, /* ObjC-1 extension. */
1283
{ "objc1_protocol_ext", obj_mach_o_objc_section, 24}, /* ObjC-1 extension. */
1285
{ "debug_frame", obj_mach_o_debug_section, 1}, /* extension. */
1286
{ "debug_info", obj_mach_o_debug_section, 2}, /* extension. */
1287
{ "debug_abbrev", obj_mach_o_debug_section, 3}, /* extension. */
1288
{ "debug_aranges", obj_mach_o_debug_section, 4}, /* extension. */
1289
{ "debug_macinfo", obj_mach_o_debug_section, 5}, /* extension. */
1290
{ "debug_line", obj_mach_o_debug_section, 6}, /* extension. */
1291
{ "debug_loc", obj_mach_o_debug_section, 7}, /* extension. */
1292
{ "debug_pubnames", obj_mach_o_debug_section, 8}, /* extension. */
1293
{ "debug_pubtypes", obj_mach_o_debug_section, 9}, /* extension. */
1294
{ "debug_str", obj_mach_o_debug_section, 10}, /* extension. */
1295
{ "debug_ranges", obj_mach_o_debug_section, 11}, /* extension. */
1296
{ "debug_macro", obj_mach_o_debug_section, 12}, /* extension. */
1298
{ "lazy_symbol_pointer", obj_mach_o_opt_tgt_section, 1},
1299
{ "lazy_symbol_pointer2", obj_mach_o_opt_tgt_section, 2}, /* extension. */
1300
{ "lazy_symbol_pointer3", obj_mach_o_opt_tgt_section, 3}, /* extension. */
1301
{ "non_lazy_symbol_pointer", obj_mach_o_opt_tgt_section, 4},
1302
{ "non_lazy_symbol_pointer_x86", obj_mach_o_opt_tgt_section, 5}, /* extension. */
1303
{ "symbol_stub", obj_mach_o_opt_tgt_section, 6},
1304
{ "symbol_stub1", obj_mach_o_opt_tgt_section, 7}, /* extension. */
1305
{ "picsymbol_stub", obj_mach_o_opt_tgt_section, 8}, /* extension. */
1306
{ "picsymbol_stub1", obj_mach_o_opt_tgt_section, 9}, /* extension. */
1307
{ "picsymbol_stub2", obj_mach_o_opt_tgt_section, 4}, /* extension. */
1308
{ "picsymbol_stub3", obj_mach_o_opt_tgt_section, 4}, /* extension. */
1310
{ "section", obj_mach_o_section, 0},
1311
{ "zerofill", obj_mach_o_zerofill, 0},
1313
/* Symbol qualifiers. */
1314
{"local", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_LOCAL},
1315
{"globl", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_GLOBL},
1316
{"reference", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_REFERENCE},
1317
{"weak_reference", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_WEAK_REF},
1318
{"lazy_reference", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_LAZY_REF},
1319
{"weak_definition", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_WEAK_DEF},
1320
{"private_extern", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_PRIV_EXT},
1321
{"no_dead_strip", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_NO_DEAD_STRIP},
1322
{"weak", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_WEAK}, /* ext */
1324
{ "indirect_symbol", obj_mach_o_indirect_symbol, 0},
1327
{ "subsections_via_symbols", obj_mach_o_fileprop,
1328
OBJ_MACH_O_FILE_PROP_SUBSECTS_VIA_SYMS},
1333
/* Determine the default n_type value for a symbol from its section. */
1336
obj_mach_o_type_for_symbol (bfd_mach_o_asymbol *s)
1338
if (s->symbol.section == bfd_abs_section_ptr)
1339
return BFD_MACH_O_N_ABS;
1340
else if (s->symbol.section == bfd_com_section_ptr
1341
|| s->symbol.section == bfd_und_section_ptr)
1342
return BFD_MACH_O_N_UNDF;
1344
return BFD_MACH_O_N_SECT;
1348
obj_mach_o_frob_colon (const char *name)
1350
if (!bfd_is_local_label_name (stdoutput, name))
1352
/* A non-local label will create a new subsection, so start a new
1354
frag_wane (frag_now);
1359
/* We need to check the correspondence between some kinds of symbols and their
1360
sections. Common and BSS vars will seen via the obj_macho_comm() function.
1362
The earlier we can pick up a problem, the better the diagnostics will be.
1364
However, when symbol type information is attached, the symbol section will
1365
quite possibly be unknown. So we are stuck with checking (most of the)
1366
validity at the time the file is written (unfortunately, then one doesn't
1367
get line number information in the diagnostic). */
1369
/* Here we pick up the case where symbol qualifiers have been applied that
1370
are possibly incompatible with the section etc. that the symbol is defined
1373
void obj_mach_o_frob_label (struct symbol *sp)
1375
bfd_mach_o_asymbol *s;
1377
bfd_mach_o_section *sec;
1380
if (!bfd_is_local_label_name (stdoutput, S_GET_NAME (sp)))
1382
/* If this is a non-local label, it should have started a new sub-
1384
gas_assert (frag_now->obj_frag_data.subsection == NULL);
1385
frag_now->obj_frag_data.subsection = sp;
1388
/* Leave local symbols alone. */
1390
if (S_IS_LOCAL (sp))
1393
s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (sp);
1394
/* Leave debug symbols alone. */
1395
if ((s->n_type & BFD_MACH_O_N_STAB) != 0)
1398
/* This is the base symbol type, that we mask in. */
1399
base_type = obj_mach_o_type_for_symbol (s);
1401
sec = bfd_mach_o_get_mach_o_section (s->symbol.section);
1403
sectype = sec->flags & BFD_MACH_O_SECTION_TYPE_MASK;
1405
/* If there is a pre-existing qualifier, we can make some checks about
1408
if(s->symbol.udata.i == SYM_MACHO_FIELDS_NOT_VALIDATED)
1410
if ((s->n_desc & BFD_MACH_O_N_WEAK_DEF)
1411
&& sectype != BFD_MACH_O_S_COALESCED)
1412
as_bad (_("'%s' can't be a weak_definition (currently only supported"
1413
" in sections of type coalesced)"), s->symbol.name);
1415
/* Have we changed from an undefined to defined ref? */
1416
s->n_desc &= ~(REFE | LAZY);
1419
s->n_type &= ~BFD_MACH_O_N_TYPE;
1420
s->n_type |= base_type;
1423
/* This is the fall-back, we come here when we get to the end of the file and
1424
the symbol is not defined - or there are combinations of qualifiers required
1425
(e.g. global + weak_def). */
1428
obj_mach_o_frob_symbol (struct symbol *sp)
1430
bfd_mach_o_asymbol *s;
1432
bfd_mach_o_section *sec;
1435
/* Leave local symbols alone. */
1436
if (S_IS_LOCAL (sp))
1439
s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (sp);
1440
/* Leave debug symbols alone. */
1441
if ((s->n_type & BFD_MACH_O_N_STAB) != 0)
1444
base_type = obj_mach_o_type_for_symbol (s);
1445
sec = bfd_mach_o_get_mach_o_section (s->symbol.section);
1447
sectype = sec->flags & BFD_MACH_O_SECTION_TYPE_MASK;
1449
if (s->symbol.section == bfd_und_section_ptr)
1451
/* ??? Do we really gain much from implementing this as well as the
1452
mach-o specific ones? */
1453
if (s->symbol.flags & BSF_WEAK)
1454
s->n_desc |= BFD_MACH_O_N_WEAK_REF;
1456
/* Undefined syms, become extern. */
1457
s->n_type |= BFD_MACH_O_N_EXT;
1458
S_SET_EXTERNAL (sp);
1460
else if (s->symbol.section == bfd_com_section_ptr)
1462
/* ... so do comm. */
1463
s->n_type |= BFD_MACH_O_N_EXT;
1464
S_SET_EXTERNAL (sp);
1468
if ((s->symbol.flags & BSF_WEAK)
1469
&& (sectype == BFD_MACH_O_S_COALESCED)
1470
&& (s->n_type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT)))
1471
s->n_desc |= BFD_MACH_O_N_WEAK_DEF;
1472
/* ??? we should do this - but then that reveals that the semantics of weak
1473
are different from what's supported in mach-o object files.
1475
as_bad (_("'%s' can't be a weak_definition."),
1479
if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
1481
/* Anything here that should be added that is non-standard. */
1482
s->n_desc &= ~BFD_MACH_O_REFERENCE_MASK;
1483
s->symbol.udata.i = SYM_MACHO_FIELDS_NOT_VALIDATED;
1485
else if (s->symbol.udata.i == SYM_MACHO_FIELDS_NOT_VALIDATED)
1487
/* Try to validate any combinations. */
1488
if (s->n_desc & BFD_MACH_O_N_WEAK_DEF)
1490
if (s->symbol.section == bfd_und_section_ptr)
1491
as_bad (_("'%s' can't be a weak_definition (since it is"
1492
" undefined)"), s->symbol.name);
1493
else if (sectype != BFD_MACH_O_S_COALESCED)
1494
as_bad (_("'%s' can't be a weak_definition (currently only supported"
1495
" in sections of type coalesced)"), s->symbol.name);
1496
else if (! (s->n_type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT)))
1497
as_bad (_("Non-global symbol: '%s' can't be a weak_definition."),
1503
as_bad (_("internal error: [%s] unexpected code [%lx] in frob symbol"),
1504
s->symbol.name, (unsigned long)s->symbol.udata.i);
1506
s->n_type &= ~BFD_MACH_O_N_TYPE;
1507
s->n_type |= base_type;
1509
if (s->symbol.flags & BSF_GLOBAL)
1510
s->n_type |= BFD_MACH_O_N_EXT;
1512
/* This cuts both ways - we promote some things to external above. */
1513
if (s->n_type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
1514
S_SET_EXTERNAL (sp);
1519
/* Support stabs for mach-o. */
1522
obj_mach_o_process_stab (int what, const char *string,
1523
int type, int other, int desc)
1526
bfd_mach_o_asymbol *s;
1531
symbolP = symbol_new ("", now_seg, frag_now_fix (), frag_now);
1532
/* Special stabd NULL name indicator. */
1533
S_SET_NAME (symbolP, NULL);
1538
symbolP = symbol_new (string, undefined_section, (valueT) 0,
1539
&zero_address_frag);
1540
pseudo_set (symbolP);
1544
as_bad(_("unrecognized stab type '%c'"), (char)what);
1549
s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (symbolP);
1552
/* For stabd, this will eventually get overwritten by the section number. */
1555
/* It's a debug symbol. */
1556
s->symbol.flags |= BSF_DEBUGGING;
1558
/* We've set it - so check it, if you can, but don't try to create the
1560
s->symbol.udata.i = SYM_MACHO_FIELDS_NOT_VALIDATED;
1563
/* This is a place to check for any errors that we can't detect until we know
1564
what remains undefined at the end of assembly. */
1567
obj_mach_o_check_before_writing (bfd *abfd ATTRIBUTE_UNUSED,
1569
void *unused ATTRIBUTE_UNUSED)
1572
struct frchain *frchp;
1573
segment_info_type *seginfo = seg_info (sec);
1575
if (seginfo == NULL)
1578
/* We are not allowed subtractions where either of the operands is
1579
undefined. So look through the frags for any fixes to check. */
1580
for (frchp = seginfo->frchainP; frchp != NULL; frchp = frchp->frch_next)
1581
for (fixP = frchp->fix_root; fixP != NULL; fixP = fixP->fx_next)
1583
if (fixP->fx_addsy != NULL
1584
&& fixP->fx_subsy != NULL
1585
&& (! S_IS_DEFINED (fixP->fx_addsy)
1586
|| ! S_IS_DEFINED (fixP->fx_subsy)))
1588
segT add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
1589
segT sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
1591
if (! S_IS_DEFINED (fixP->fx_addsy)
1592
&& S_IS_DEFINED (fixP->fx_subsy))
1594
as_bad_where (fixP->fx_file, fixP->fx_line,
1595
_("`%s' can't be undefined in `%s' - `%s' {%s section}"),
1596
S_GET_NAME (fixP->fx_addsy), S_GET_NAME (fixP->fx_addsy),
1597
S_GET_NAME (fixP->fx_subsy), segment_name (sub_symbol_segment));
1599
else if (! S_IS_DEFINED (fixP->fx_subsy)
1600
&& S_IS_DEFINED (fixP->fx_addsy))
1602
as_bad_where (fixP->fx_file, fixP->fx_line,
1603
_("`%s' can't be undefined in `%s' {%s section} - `%s'"),
1604
S_GET_NAME (fixP->fx_subsy), S_GET_NAME (fixP->fx_addsy),
1605
segment_name (add_symbol_segment), S_GET_NAME (fixP->fx_subsy));
1609
as_bad_where (fixP->fx_file, fixP->fx_line,
1610
_("`%s' and `%s' can't be undefined in `%s' - `%s'"),
1611
S_GET_NAME (fixP->fx_addsy), S_GET_NAME (fixP->fx_subsy),
1612
S_GET_NAME (fixP->fx_addsy), S_GET_NAME (fixP->fx_subsy));
1618
/* Do any checks that we can't complete without knowing what's undefined. */
1620
obj_mach_o_pre_output_hook (void)
1622
bfd_map_over_sections (stdoutput, obj_mach_o_check_before_writing, (char *) 0);
1625
/* Here we count up frags in each subsection (where a sub-section is defined
1626
as starting with a non-local symbol).
1627
Note that, if there are no non-local symbols in a section, all the frags will
1628
be attached as one anonymous subsection. */
1631
obj_mach_o_set_subsections (bfd *abfd ATTRIBUTE_UNUSED,
1633
void *unused ATTRIBUTE_UNUSED)
1635
segment_info_type *seginfo = seg_info (sec);
1636
symbolS *cur_subsection = NULL;
1637
struct obj_mach_o_symbol_data *cur_subsection_data = NULL;
1641
/* Protect against sections not created by gas. */
1642
if (seginfo == NULL)
1645
/* Attach every frag to a subsection. */
1646
for (chain = seginfo->frchainP; chain != NULL; chain = chain->frch_next)
1647
for (frag = chain->frch_root; frag != NULL; frag = frag->fr_next)
1649
if (frag->obj_frag_data.subsection == NULL)
1650
frag->obj_frag_data.subsection = cur_subsection;
1653
cur_subsection = frag->obj_frag_data.subsection;
1654
cur_subsection_data = symbol_get_obj (cur_subsection);
1655
cur_subsection_data->subsection_size = 0;
1657
if (cur_subsection_data != NULL)
1659
/* Update subsection size. */
1660
cur_subsection_data->subsection_size += frag->fr_fix;
1665
/* Handle mach-o subsections-via-symbols counting up frags belonging to each
1669
obj_mach_o_pre_relax_hook (void)
1671
bfd_map_over_sections (stdoutput, obj_mach_o_set_subsections, (char *) 0);
1674
/* Zerofill and GB Zerofill sections must be sorted to follow all other
1675
sections in their segments.
1677
The native 'as' leaves the sections physically in the order they appear in
1678
the source, and adjusts the section VMAs to meet the constraint.
1680
We follow this for now - if nothing else, it makes comparison easier.
1682
An alternative implementation would be to sort the sections as ld requires.
1683
It might be advantageous to implement such a scheme in the future (or even
1684
to make the style of section ordering user-selectable). */
1686
typedef struct obj_mach_o_set_vma_data
1690
unsigned zerofill_seen;
1691
unsigned gb_zerofill_seen;
1692
} obj_mach_o_set_vma_data;
1694
/* We do (possibly) three passes through to set the vma, so that:
1696
zerofill sections get VMAs after all others in their segment
1697
GB zerofill get VMAs last.
1699
As we go, we notice if we see any Zerofill or GB Zerofill sections, so that
1700
we can skip the additional passes if there's nothing to do. */
1703
obj_mach_o_set_section_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *v_p)
1705
bfd_mach_o_section *ms = bfd_mach_o_get_mach_o_section (sec);
1706
unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
1707
obj_mach_o_set_vma_data *p = (struct obj_mach_o_set_vma_data *)v_p;
1708
unsigned sectype = (ms->flags & BFD_MACH_O_SECTION_TYPE_MASK);
1712
if (sectype == BFD_MACH_O_S_ZEROFILL)
1715
p->zerofill_seen = zf;
1717
else if (sectype == BFD_MACH_O_S_GB_ZEROFILL)
1720
p->gb_zerofill_seen = zf;
1723
if (p->vma_pass != zf)
1726
/* We know the section size now - so make a vma for the section just
1728
ms->size = bfd_get_section_size (sec);
1730
/* Make sure that the align agrees, and set to the largest value chosen. */
1731
ms->align = ms->align > bfd_align ? ms->align : bfd_align;
1732
bfd_set_section_alignment (abfd, sec, ms->align);
1734
p->vma += (1 << ms->align) - 1;
1735
p->vma &= ~((1 << ms->align) - 1);
1737
bfd_set_section_vma (abfd, sec, p->vma);
1741
/* (potentially) three passes over the sections, setting VMA. We skip the
1742
{gb}zerofill passes if we didn't see any of the relevant sections. */
1744
void obj_mach_o_post_relax_hook (void)
1746
obj_mach_o_set_vma_data d;
1748
memset (&d, 0, sizeof (d));
1750
bfd_map_over_sections (stdoutput, obj_mach_o_set_section_vma, (char *) &d);
1751
if ((d.vma_pass = d.zerofill_seen) != 0)
1752
bfd_map_over_sections (stdoutput, obj_mach_o_set_section_vma, (char *) &d);
1753
if ((d.vma_pass = d.gb_zerofill_seen) != 0)
1754
bfd_map_over_sections (stdoutput, obj_mach_o_set_section_vma, (char *) &d);
1758
obj_mach_o_set_indirect_symbols (bfd *abfd, asection *sec,
1759
void *xxx ATTRIBUTE_UNUSED)
1761
bfd_vma sect_size = bfd_section_size (abfd, sec);
1762
bfd_mach_o_section *ms = bfd_mach_o_get_mach_o_section (sec);
1765
/* See if we have any indirect syms to consider. */
1766
if (indirect_syms == NULL)
1769
/* Process indirect symbols.
1770
Check for errors, if OK attach them as a flat array to the section
1771
for which they are defined. */
1773
switch (ms->flags & BFD_MACH_O_SECTION_TYPE_MASK)
1775
case BFD_MACH_O_S_SYMBOL_STUBS:
1776
case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
1779
case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
1781
unsigned int nactual = 0;
1783
obj_mach_o_indirect_sym *isym;
1784
obj_mach_o_indirect_sym *list = NULL;
1785
obj_mach_o_indirect_sym *list_tail = NULL;
1786
unsigned long eltsiz =
1787
bfd_mach_o_section_get_entry_size (abfd, ms);
1789
for (isym = indirect_syms; isym != NULL; isym = isym->next)
1791
if (isym->sect == sec)
1797
list_tail->next = isym;
1802
/* If none are in this section, stop here. */
1806
/* If we somehow added indirect symbols to a section with a zero
1807
entry size, we're dead ... */
1808
gas_assert (eltsiz != 0);
1810
ncalc = (unsigned int) (sect_size / eltsiz);
1811
if (nactual != ncalc)
1812
as_bad (_("the number of .indirect_symbols defined in section %s"
1813
" does not match the number expected (%d defined, %d"
1814
" expected)"), sec->name, nactual, ncalc);
1818
bfd_mach_o_asymbol *sym;
1821
nactual * sizeof (bfd_mach_o_asymbol *));
1823
if (ms->indirect_syms == NULL)
1825
as_fatal (_("internal error: failed to allocate %d indirect"
1826
"symbol pointers"), nactual);
1829
for (isym = list, n = 0; isym != NULL; isym = isym->next, n++)
1831
sym = (bfd_mach_o_asymbol *)symbol_get_bfdsym (isym->sym);
1832
/* Array is init to NULL & NULL signals a local symbol
1833
If the section is lazy-bound, we need to keep the
1834
reference to the symbol, since dyld can override.
1836
Absolute symbols are handled specially. */
1837
if (sym->symbol.section == bfd_abs_section_ptr)
1838
ms->indirect_syms[n] = sym;
1839
else if (S_IS_LOCAL (isym->sym) && ! lazy)
1845
/* If the symbols is external ... */
1846
else if (S_IS_EXTERNAL (isym->sym)
1847
|| (sym->n_type & BFD_MACH_O_N_EXT)
1848
|| ! S_IS_DEFINED (isym->sym)
1851
sym->n_desc &= ~LAZY;
1852
/* ... it can be lazy, if not defined or hidden. */
1853
if ((sym->n_type & BFD_MACH_O_N_TYPE)
1854
== BFD_MACH_O_N_UNDF
1855
&& ! (sym->n_type & BFD_MACH_O_N_PEXT)
1856
&& (sym->n_type & BFD_MACH_O_N_EXT))
1857
sym->n_desc |= lazy;
1858
ms->indirect_syms[n] = sym;
1871
/* The process of relocation could alter what's externally visible, thus we
1872
leave setting the indirect symbols until last. */
1875
obj_mach_o_frob_file_after_relocs (void)
1877
bfd_map_over_sections (stdoutput, obj_mach_o_set_indirect_symbols, (char *) 0);
1880
/* Reverse relocations order to make ld happy. */
1883
obj_mach_o_reorder_section_relocs (asection *sec, arelent **rels, unsigned int n)
1886
unsigned int max = n / 2;
1888
for (i = 0; i < max; i++)
1890
arelent *r = rels[i];
1891
rels[i] = rels[n - i - 1];
1892
rels[n - i - 1] = r;
1894
bfd_set_reloc (stdoutput, sec, rels, n);
1897
/* Relocation rules are different in frame sections. */
1900
obj_mach_o_is_frame_section (segT sec)
1903
l = strlen (segment_name (sec));
1904
if ((l == 9 && strncmp (".eh_frame", segment_name (sec), 9) == 0)
1905
|| (l == 12 && strncmp (".debug_frame", segment_name (sec), 12) == 0))
1910
/* Unless we're in a frame section, we need to force relocs to be generated for
1911
local subtractions. We might eliminate them later (if they are within the
1912
same sub-section) but we don't know that at the point that this decision is
1916
obj_mach_o_allow_local_subtract (expressionS * left ATTRIBUTE_UNUSED,
1917
expressionS * right ATTRIBUTE_UNUSED,
1920
/* Don't interfere if it's one of the GAS internal sections. */
1921
if (! SEG_NORMAL (seg))
1924
/* Allow in frame sections, otherwise emit a reloc. */
1925
return obj_mach_o_is_frame_section (seg);
1929
obj_mach_o_in_different_subsection (symbolS *a, symbolS *b)
1934
if (S_GET_SEGMENT (a) != S_GET_SEGMENT (b)
1935
|| !S_IS_DEFINED (a)
1936
|| !S_IS_DEFINED (b))
1938
/* Not in the same segment, or undefined symbol. */
1942
fa = symbol_get_frag (a);
1943
fb = symbol_get_frag (b);
1944
if (fa == NULL || fb == NULL)
1946
/* One of the symbols is not in a subsection. */
1950
return fa->obj_frag_data.subsection != fb->obj_frag_data.subsection;
1954
obj_mach_o_force_reloc_sub_same (fixS *fix, segT seg)
1956
if (! SEG_NORMAL (seg))
1958
return obj_mach_o_in_different_subsection (fix->fx_addsy, fix->fx_subsy);
1962
obj_mach_o_force_reloc_sub_local (fixS *fix, segT seg ATTRIBUTE_UNUSED)
1964
return obj_mach_o_in_different_subsection (fix->fx_addsy, fix->fx_subsy);
1968
obj_mach_o_force_reloc (fixS *fix)
1970
if (generic_force_reloc (fix))
1973
/* Force a reloc if the target is not in the same subsection.
1974
FIXME: handle (a - b) where a and b belongs to the same subsection ? */
1975
if (fix->fx_addsy != NULL)
1977
symbolS *subsec = fix->fx_frag->obj_frag_data.subsection;
1978
symbolS *targ = fix->fx_addsy;
1980
/* There might be no subsections at all. */
1984
if (S_GET_SEGMENT (targ) == absolute_section)
1987
return obj_mach_o_in_different_subsection (targ, subsec);
added
removed
binutils-2.23.52.20130611/gas/config/obj-macho.c
