+
+/* Determine the default n_type value for a symbol from its section. */
+
+static unsigned
+obj_mach_o_type_for_symbol (bfd_mach_o_asymbol *s)
+{
+ if (s->symbol.section == bfd_abs_section_ptr)
+ return BFD_MACH_O_N_ABS;
+ else if (s->symbol.section == bfd_com_section_ptr
+ || s->symbol.section == bfd_und_section_ptr)
+ return BFD_MACH_O_N_UNDF;
+ else
+ return BFD_MACH_O_N_SECT;
+}
+
+void
+obj_mach_o_frob_colon (const char *name)
+{
+ if (!bfd_is_local_label_name (stdoutput, name))
+ {
+ /* A non-local label will create a new subsection, so start a new
+ frag. */
+ frag_wane (frag_now);
+ frag_new (0);
+ }
+}
+
+/* We need to check the correspondence between some kinds of symbols and their
+ sections. Common and BSS vars will seen via the obj_macho_comm() function.
+
+ The earlier we can pick up a problem, the better the diagnostics will be.
+
+ However, when symbol type information is attached, the symbol section will
+ quite possibly be unknown. So we are stuck with checking (most of the)
+ validity at the time the file is written (unfortunately, then one doesn't
+ get line number information in the diagnostic). */
+
+/* Here we pick up the case where symbol qualifiers have been applied that
+ are possibly incompatible with the section etc. that the symbol is defined
+ in. */
+
+void obj_mach_o_frob_label (struct symbol *sp)
+{
+ bfd_mach_o_asymbol *s;
+ unsigned base_type;
+ bfd_mach_o_section *sec;
+ int sectype = -1;
+
+ if (!bfd_is_local_label_name (stdoutput, S_GET_NAME (sp)))
+ {
+ /* If this is a non-local label, it should have started a new sub-
+ section. */
+ gas_assert (frag_now->obj_frag_data.subsection == NULL);
+ frag_now->obj_frag_data.subsection = sp;
+ }
+
+ /* Leave local symbols alone. */
+
+ if (S_IS_LOCAL (sp))
+ return;
+
+ s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (sp);
+ /* Leave debug symbols alone. */
+ if ((s->n_type & BFD_MACH_O_N_STAB) != 0)
+ return;
+
+ /* This is the base symbol type, that we mask in. */
+ base_type = obj_mach_o_type_for_symbol (s);
+
+ sec = bfd_mach_o_get_mach_o_section (s->symbol.section);
+ if (sec != NULL)
+ sectype = sec->flags & BFD_MACH_O_SECTION_TYPE_MASK;
+
+ /* If there is a pre-existing qualifier, we can make some checks about
+ validity now. */
+
+ if(s->symbol.udata.i == SYM_MACHO_FIELDS_NOT_VALIDATED)
+ {
+ if ((s->n_desc & BFD_MACH_O_N_WEAK_DEF)
+ && sectype != BFD_MACH_O_S_COALESCED)
+ {
+ as_bad (_("'%s' can't be a weak_definition (currently only supported"
+ " in sections of type coalesced)"), s->symbol.name);
+ /* Don't cascade errors. */
+ s->symbol.udata.i = SYM_MACHO_FIELDS_UNSET;
+ }
+
+ /* Have we changed from an undefined to defined ref? */
+ s->n_desc &= ~(REFE | LAZY);
+ }
+
+ s->n_type &= ~BFD_MACH_O_N_TYPE;
+ s->n_type |= base_type;
+}
+
+/* This is the fall-back, we come here when we get to the end of the file and
+ the symbol is not defined - or there are combinations of qualifiers required
+ (e.g. global + weak_def). */
+
+int
+obj_mach_o_frob_symbol (struct symbol *sp)
+{
+ bfd_mach_o_asymbol *s;
+ unsigned base_type;
+ bfd_mach_o_section *sec;
+ int sectype = -1;
+
+ /* Leave local symbols alone. */
+ if (S_IS_LOCAL (sp))
+ return 0;
+
+ s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (sp);
+ /* Leave debug symbols alone. */
+ if ((s->n_type & BFD_MACH_O_N_STAB) != 0)
+ return 0;
+
+ base_type = obj_mach_o_type_for_symbol (s);
+ sec = bfd_mach_o_get_mach_o_section (s->symbol.section);
+ if (sec != NULL)
+ sectype = sec->flags & BFD_MACH_O_SECTION_TYPE_MASK;
+
+ if (s->symbol.section == bfd_und_section_ptr)
+ {
+ /* ??? Do we really gain much from implementing this as well as the
+ mach-o specific ones? */
+ if (s->symbol.flags & BSF_WEAK)
+ s->n_desc |= BFD_MACH_O_N_WEAK_REF;
+
+ /* Undefined syms, become extern. */
+ s->n_type |= BFD_MACH_O_N_EXT;
+ S_SET_EXTERNAL (sp);
+ }
+ else if (s->symbol.section == bfd_com_section_ptr)
+ {
+ /* ... so do comm. */
+ s->n_type |= BFD_MACH_O_N_EXT;
+ S_SET_EXTERNAL (sp);
+ }
+ else
+ {
+ if ((s->symbol.flags & BSF_WEAK)
+ && (sectype == BFD_MACH_O_S_COALESCED)
+ && (s->n_type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT)))
+ s->n_desc |= BFD_MACH_O_N_WEAK_DEF;
+/* ??? we should do this - but then that reveals that the semantics of weak
+ are different from what's supported in mach-o object files.
+ else
+ as_bad (_("'%s' can't be a weak_definition."),
+ s->symbol.name); */
+ }
+
+ if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
+ {
+ /* Anything here that should be added that is non-standard. */
+ s->n_desc &= ~BFD_MACH_O_REFERENCE_MASK;
+ }
+ else if (s->symbol.udata.i == SYM_MACHO_FIELDS_NOT_VALIDATED)
+ {
+ /* Try to validate any combinations. */
+ if (s->n_desc & BFD_MACH_O_N_WEAK_DEF)
+ {
+ if (s->symbol.section == bfd_und_section_ptr)
+ as_bad (_("'%s' can't be a weak_definition (since it is"
+ " undefined)"), s->symbol.name);
+ else if (sectype != BFD_MACH_O_S_COALESCED)
+ as_bad (_("'%s' can't be a weak_definition (currently only supported"
+ " in sections of type coalesced)"), s->symbol.name);
+ else if (! (s->n_type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT)))
+ as_bad (_("Non-global symbol: '%s' can't be a weak_definition."),
+ s->symbol.name);
+ }
+
+ }
+ else
+ as_bad (_("internal error: [%s] unexpected code [%lx] in frob symbol"),
+ s->symbol.name, (unsigned long)s->symbol.udata.i);
+
+ s->n_type &= ~BFD_MACH_O_N_TYPE;
+ s->n_type |= base_type;
+
+ if (s->symbol.flags & BSF_GLOBAL)
+ s->n_type |= BFD_MACH_O_N_EXT;
+
+ /* This cuts both ways - we promote some things to external above. */
+ if (s->n_type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
+ S_SET_EXTERNAL (sp);
+
+ return 0;
+}
+
+/* Support stabs for mach-o. */
+
+void
+obj_mach_o_process_stab (int what, const char *string,
+ int type, int other, int desc)
+{
+ symbolS *symbolP;
+ bfd_mach_o_asymbol *s;
+
+ switch (what)
+ {
+ case 'd':
+ symbolP = symbol_new ("", now_seg, frag_now_fix (), frag_now);
+ /* Special stabd NULL name indicator. */
+ S_SET_NAME (symbolP, NULL);
+ break;
+
+ case 'n':
+ case 's':
+ symbolP = symbol_new (string, undefined_section, (valueT) 0,
+ &zero_address_frag);
+ pseudo_set (symbolP);
+ break;
+
+ default:
+ as_bad(_("unrecognized stab type '%c'"), (char)what);
+ abort ();
+ break;
+ }
+
+ s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (symbolP);
+ s->n_type = type;
+ s->n_desc = desc;
+ /* For stabd, this will eventually get overwritten by the section number. */
+ s->n_sect = other;
+
+ /* It's a debug symbol. */
+ s->symbol.flags |= BSF_DEBUGGING;
+
+ /* We've set it - so check it, if you can, but don't try to create the
+ flags. */
+ s->symbol.udata.i = SYM_MACHO_FIELDS_NOT_VALIDATED;
+}
+
+/* This is a place to check for any errors that we can't detect until we know
+ what remains undefined at the end of assembly. */
+
+static void
+obj_mach_o_check_before_writing (bfd *abfd ATTRIBUTE_UNUSED,
+ asection *sec,
+ void *unused ATTRIBUTE_UNUSED)
+{
+ fixS *fixP;
+ struct frchain *frchp;
+ segment_info_type *seginfo = seg_info (sec);
+
+ if (seginfo == NULL)
+ return;
+
+ /* We are not allowed subtractions where either of the operands is
+ undefined. So look through the frags for any fixes to check. */
+ for (frchp = seginfo->frchainP; frchp != NULL; frchp = frchp->frch_next)
+ for (fixP = frchp->fix_root; fixP != NULL; fixP = fixP->fx_next)
+ {
+ if (fixP->fx_addsy != NULL
+ && fixP->fx_subsy != NULL
+ && (! S_IS_DEFINED (fixP->fx_addsy)
+ || ! S_IS_DEFINED (fixP->fx_subsy)))
+ {
+ segT add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
+ segT sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
+
+ if (! S_IS_DEFINED (fixP->fx_addsy)
+ && S_IS_DEFINED (fixP->fx_subsy))
+ {
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("`%s' can't be undefined in `%s' - `%s' {%s section}"),
+ S_GET_NAME (fixP->fx_addsy), S_GET_NAME (fixP->fx_addsy),
+ S_GET_NAME (fixP->fx_subsy), segment_name (sub_symbol_segment));
+ }
+ else if (! S_IS_DEFINED (fixP->fx_subsy)
+ && S_IS_DEFINED (fixP->fx_addsy))
+ {
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("`%s' can't be undefined in `%s' {%s section} - `%s'"),
+ S_GET_NAME (fixP->fx_subsy), S_GET_NAME (fixP->fx_addsy),
+ segment_name (add_symbol_segment), S_GET_NAME (fixP->fx_subsy));
+ }
+ else
+ {
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("`%s' and `%s' can't be undefined in `%s' - `%s'"),
+ S_GET_NAME (fixP->fx_addsy), S_GET_NAME (fixP->fx_subsy),
+ S_GET_NAME (fixP->fx_addsy), S_GET_NAME (fixP->fx_subsy));
+ }
+ }
+ }
+}
+
+/* Do any checks that we can't complete without knowing what's undefined. */
+void
+obj_mach_o_pre_output_hook (void)
+{
+ bfd_map_over_sections (stdoutput, obj_mach_o_check_before_writing, (char *) 0);
+}
+
+/* Here we count up frags in each subsection (where a sub-section is defined
+ as starting with a non-local symbol).
+ Note that, if there are no non-local symbols in a section, all the frags will
+ be attached as one anonymous subsection. */
+
+static void
+obj_mach_o_set_subsections (bfd *abfd ATTRIBUTE_UNUSED,
+ asection *sec,
+ void *unused ATTRIBUTE_UNUSED)
+{
+ segment_info_type *seginfo = seg_info (sec);
+ symbolS *cur_subsection = NULL;
+ struct obj_mach_o_symbol_data *cur_subsection_data = NULL;
+ fragS *frag;
+ frchainS *chain;
+
+ /* Protect against sections not created by gas. */
+ if (seginfo == NULL)
+ return;
+
+ /* Attach every frag to a subsection. */
+ for (chain = seginfo->frchainP; chain != NULL; chain = chain->frch_next)
+ for (frag = chain->frch_root; frag != NULL; frag = frag->fr_next)
+ {
+ if (frag->obj_frag_data.subsection == NULL)
+ frag->obj_frag_data.subsection = cur_subsection;
+ else
+ {
+ cur_subsection = frag->obj_frag_data.subsection;
+ cur_subsection_data = symbol_get_obj (cur_subsection);
+ cur_subsection_data->subsection_size = 0;
+ }
+ if (cur_subsection_data != NULL)
+ {
+ /* Update subsection size. */
+ cur_subsection_data->subsection_size += frag->fr_fix;
+ }
+ }
+}
+
+/* Handle mach-o subsections-via-symbols counting up frags belonging to each
+ sub-section. */
+
+void
+obj_mach_o_pre_relax_hook (void)
+{
+ bfd_map_over_sections (stdoutput, obj_mach_o_set_subsections, (char *) 0);
+}
+
+/* Zerofill and GB Zerofill sections must be sorted to follow all other
+ sections in their segments.
+
+ The native 'as' leaves the sections physically in the order they appear in
+ the source, and adjusts the section VMAs to meet the constraint.
+
+ We follow this for now - if nothing else, it makes comparison easier.
+
+ An alternative implementation would be to sort the sections as ld requires.
+ It might be advantageous to implement such a scheme in the future (or even
+ to make the style of section ordering user-selectable). */
+
+typedef struct obj_mach_o_set_vma_data
+{
+ bfd_vma vma;
+ unsigned vma_pass;
+ unsigned zerofill_seen;
+ unsigned gb_zerofill_seen;
+} obj_mach_o_set_vma_data;
+
+/* We do (possibly) three passes through to set the vma, so that:
+
+ zerofill sections get VMAs after all others in their segment
+ GB zerofill get VMAs last.
+
+ As we go, we notice if we see any Zerofill or GB Zerofill sections, so that
+ we can skip the additional passes if there's nothing to do. */
+
+static void
+obj_mach_o_set_section_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *v_p)
+{
+ bfd_mach_o_section *ms = bfd_mach_o_get_mach_o_section (sec);
+ unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
+ obj_mach_o_set_vma_data *p = (struct obj_mach_o_set_vma_data *)v_p;
+ unsigned sectype = (ms->flags & BFD_MACH_O_SECTION_TYPE_MASK);
+ unsigned zf;
+
+ zf = 0;
+ if (sectype == BFD_MACH_O_S_ZEROFILL)
+ {
+ zf = 1;
+ p->zerofill_seen = zf;
+ }
+ else if (sectype == BFD_MACH_O_S_GB_ZEROFILL)
+ {
+ zf = 2;
+ p->gb_zerofill_seen = zf;
+ }
+
+ if (p->vma_pass != zf)
+ return;
+
+ /* We know the section size now - so make a vma for the section just
+ based on order. */
+ ms->size = bfd_get_section_size (sec);
+
+ /* Make sure that the align agrees, and set to the largest value chosen. */
+ ms->align = ms->align > bfd_align ? ms->align : bfd_align;
+ bfd_set_section_alignment (abfd, sec, ms->align);
+
+ p->vma += (1 << ms->align) - 1;
+ p->vma &= ~((1 << ms->align) - 1);
+ ms->addr = p->vma;
+ bfd_set_section_vma (abfd, sec, p->vma);
+ p->vma += ms->size;
+}
+
+/* (potentially) three passes over the sections, setting VMA. We skip the
+ {gb}zerofill passes if we didn't see any of the relevant sections. */
+
+void obj_mach_o_post_relax_hook (void)
+{
+ obj_mach_o_set_vma_data d;
+
+ memset (&d, 0, sizeof (d));
+
+ bfd_map_over_sections (stdoutput, obj_mach_o_set_section_vma, (char *) &d);
+ if ((d.vma_pass = d.zerofill_seen) != 0)
+ bfd_map_over_sections (stdoutput, obj_mach_o_set_section_vma, (char *) &d);
+ if ((d.vma_pass = d.gb_zerofill_seen) != 0)
+ bfd_map_over_sections (stdoutput, obj_mach_o_set_section_vma, (char *) &d);
+}
+
+static void
+obj_mach_o_set_indirect_symbols (bfd *abfd, asection *sec,
+ void *xxx ATTRIBUTE_UNUSED)
+{
+ bfd_vma sect_size = bfd_section_size (abfd, sec);
+ bfd_mach_o_section *ms = bfd_mach_o_get_mach_o_section (sec);
+ unsigned lazy = 0;
+
+ /* See if we have any indirect syms to consider. */
+ if (indirect_syms == NULL)
+ return;
+
+ /* Process indirect symbols.
+ Check for errors, if OK attach them as a flat array to the section
+ for which they are defined. */
+
+ switch (ms->flags & BFD_MACH_O_SECTION_TYPE_MASK)
+ {
+ case BFD_MACH_O_S_SYMBOL_STUBS:
+ case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
+ lazy = LAZY;
+ /* Fall through. */
+ case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
+ {
+ unsigned int nactual = 0;
+ unsigned int ncalc;
+ obj_mach_o_indirect_sym *isym;
+ obj_mach_o_indirect_sym *list = NULL;
+ obj_mach_o_indirect_sym *list_tail = NULL;
+ unsigned long eltsiz =
+ bfd_mach_o_section_get_entry_size (abfd, ms);
+
+ for (isym = indirect_syms; isym != NULL; isym = isym->next)
+ {
+ if (isym->sect == sec)
+ {
+ nactual++;
+ if (list == NULL)
+ list = isym;
+ else
+ list_tail->next = isym;
+ list_tail = isym;
+ }
+ }
+
+ /* If none are in this section, stop here. */
+ if (nactual == 0)
+ break;
+
+ /* If we somehow added indirect symbols to a section with a zero
+ entry size, we're dead ... */
+ gas_assert (eltsiz != 0);
+
+ ncalc = (unsigned int) (sect_size / eltsiz);
+ if (nactual != ncalc)
+ as_bad (_("the number of .indirect_symbols defined in section %s"
+ " does not match the number expected (%d defined, %d"
+ " expected)"), sec->name, nactual, ncalc);
+ else
+ {
+ unsigned n;
+ bfd_mach_o_asymbol *sym;
+ ms->indirect_syms =
+ bfd_zalloc (abfd,
+ nactual * sizeof (bfd_mach_o_asymbol *));
+
+ if (ms->indirect_syms == NULL)
+ {
+ as_fatal (_("internal error: failed to allocate %d indirect"
+ "symbol pointers"), nactual);
+ }
+
+ for (isym = list, n = 0; isym != NULL; isym = isym->next, n++)
+ {
+ sym = (bfd_mach_o_asymbol *)symbol_get_bfdsym (isym->sym);
+ /* Array is init to NULL & NULL signals a local symbol
+ If the section is lazy-bound, we need to keep the
+ reference to the symbol, since dyld can override.
+
+ Absolute symbols are handled specially. */
+ if (sym->symbol.section == bfd_abs_section_ptr)
+ ms->indirect_syms[n] = sym;
+ else if (S_IS_LOCAL (isym->sym) && ! lazy)
+ ;
+ else
+ {
+ if (sym == NULL)
+ ;
+ /* If the symbols is external ... */
+ else if (S_IS_EXTERNAL (isym->sym)
+ || (sym->n_type & BFD_MACH_O_N_EXT)
+ || ! S_IS_DEFINED (isym->sym)
+ || lazy)
+ {
+ sym->n_desc &= ~LAZY;
+ /* ... it can be lazy, if not defined or hidden. */
+ if ((sym->n_type & BFD_MACH_O_N_TYPE)
+ == BFD_MACH_O_N_UNDF
+ && ! (sym->n_type & BFD_MACH_O_N_PEXT)
+ && (sym->n_type & BFD_MACH_O_N_EXT))
+ sym->n_desc |= lazy;
+ ms->indirect_syms[n] = sym;
+ }
+ }
+ }
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+/* The process of relocation could alter what's externally visible, thus we
+ leave setting the indirect symbols until last. */
+
+void
+obj_mach_o_frob_file_after_relocs (void)
+{
+ bfd_map_over_sections (stdoutput, obj_mach_o_set_indirect_symbols, (char *) 0);
+}
+
+/* Reverse relocations order to make ld happy. */
+
+void
+obj_mach_o_reorder_section_relocs (asection *sec, arelent **rels, unsigned int n)
+{
+ unsigned int i;
+ unsigned int max = n / 2;
+
+ for (i = 0; i < max; i++)
+ {
+ arelent *r = rels[i];
+ rels[i] = rels[n - i - 1];
+ rels[n - i - 1] = r;
+ }
+ bfd_set_reloc (stdoutput, sec, rels, n);
+}
+
+/* Relocation rules are different in frame sections. */
+
+static int
+obj_mach_o_is_frame_section (segT sec)
+{
+ int l;
+ l = strlen (segment_name (sec));
+ if ((l == 9 && strncmp (".eh_frame", segment_name (sec), 9) == 0)
+ || (l == 12 && strncmp (".debug_frame", segment_name (sec), 12) == 0))
+ return 1;
+ return 0;
+}
+
+/* Unless we're in a frame section, we need to force relocs to be generated for
+ local subtractions. We might eliminate them later (if they are within the
+ same sub-section) but we don't know that at the point that this decision is
+ being made. */
+
+int
+obj_mach_o_allow_local_subtract (expressionS * left ATTRIBUTE_UNUSED,
+ expressionS * right ATTRIBUTE_UNUSED,
+ segT seg)
+{
+ /* Don't interfere if it's one of the GAS internal sections. */
+ if (! SEG_NORMAL (seg))
+ return 1;
+
+ /* Allow in frame sections, otherwise emit a reloc. */
+ return obj_mach_o_is_frame_section (seg);
+}
+
+int
+obj_mach_o_in_different_subsection (symbolS *a, symbolS *b)
+{
+ fragS *fa;
+ fragS *fb;
+
+ if (S_GET_SEGMENT (a) != S_GET_SEGMENT (b)
+ || !S_IS_DEFINED (a)
+ || !S_IS_DEFINED (b))
+ {
+ /* Not in the same segment, or undefined symbol. */
+ return 1;
+ }
+
+ fa = symbol_get_frag (a);
+ fb = symbol_get_frag (b);
+ if (fa == NULL || fb == NULL)
+ {
+ /* One of the symbols is not in a subsection. */
+ return 1;
+ }
+
+ return fa->obj_frag_data.subsection != fb->obj_frag_data.subsection;
+}
+
+int
+obj_mach_o_force_reloc_sub_same (fixS *fix, segT seg)
+{
+ if (! SEG_NORMAL (seg))
+ return 1;
+ return obj_mach_o_in_different_subsection (fix->fx_addsy, fix->fx_subsy);
+}
+
+int
+obj_mach_o_force_reloc_sub_local (fixS *fix, segT seg ATTRIBUTE_UNUSED)
+{
+ return obj_mach_o_in_different_subsection (fix->fx_addsy, fix->fx_subsy);
+}
+
+int
+obj_mach_o_force_reloc (fixS *fix)
+{
+ if (generic_force_reloc (fix))
+ return 1;
+
+ /* Force a reloc if the target is not in the same subsection.
+ FIXME: handle (a - b) where a and b belongs to the same subsection ? */
+ if (fix->fx_addsy != NULL)
+ {
+ symbolS *subsec = fix->fx_frag->obj_frag_data.subsection;
+ symbolS *targ = fix->fx_addsy;
+
+ /* There might be no subsections at all. */
+ if (subsec == NULL)
+ return 0;
+
+ if (S_GET_SEGMENT (targ) == absolute_section)
+ return 0;
+
+ return obj_mach_o_in_different_subsection (targ, subsec);
+ }
+ return 0;
+}