| Line 1... |
Line 1... |
/* Mach-O object file format
|
/* Mach-O object file format
|
Copyright 2009 Free Software Foundation, Inc.
|
Copyright 2009, 2011, 2012 Free Software Foundation, Inc.
|
|
|
This file is part of GAS, the GNU Assembler.
|
This file is part of GAS, the GNU Assembler.
|
|
|
GAS is free software; you can redistribute it and/or modify
|
GAS is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as
|
it under the terms of the GNU General Public License as
|
| Line 16... |
Line 16... |
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GAS; see the file COPYING. If not, write to the Free
|
along with GAS; see the file COPYING. If not, write to the Free
|
Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
|
Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
|
02110-1301, USA. */
|
02110-1301, USA. */
|
|
|
|
/* Here we handle the mach-o directives that are common to all architectures.
|
|
|
|
Most significant are mach-o named sections and a variety of symbol type
|
|
decorations. */
|
|
|
|
/* Mach-O supports multiple, named segments each of which may contain
|
|
multiple named sections. Thus the concept of subsectioning is
|
|
handled by (say) having a __TEXT segment with appropriate flags from
|
|
which subsections are generated like __text, __const etc.
|
|
|
|
The well-known as short-hand section switch directives like .text, .data
|
|
etc. are mapped onto predefined segment/section pairs using facilites
|
|
supplied by the mach-o port of bfd.
|
|
|
|
A number of additional mach-o short-hand section switch directives are
|
|
also defined. */
|
|
|
#define OBJ_HEADER "obj-macho.h"
|
#define OBJ_HEADER "obj-macho.h"
|
|
|
#include "as.h"
|
#include "as.h"
|
#include "subsegs.h"
|
#include "subsegs.h"
|
#include "symbols.h"
|
#include "symbols.h"
|
#include "write.h"
|
#include "write.h"
|
#include "mach-o.h"
|
#include "mach-o.h"
|
#include "mach-o/loader.h"
|
#include "mach-o/loader.h"
|
|
#include "obj-macho.h"
|
|
|
static void
|
#include <string.h>
|
obj_mach_o_weak (int ignore ATTRIBUTE_UNUSED)
|
|
{
|
|
char *name;
|
|
int c;
|
|
symbolS *symbolP;
|
|
|
|
do
|
/* Forward decls. */
|
{
|
static segT obj_mach_o_segT_from_bfd_name (const char *, int);
|
/* Get symbol name. */
|
|
name = input_line_pointer;
|
|
c = get_symbol_end ();
|
|
symbolP = symbol_find_or_make (name);
|
|
S_SET_WEAK (symbolP);
|
|
*input_line_pointer = c;
|
|
SKIP_WHITESPACE ();
|
|
|
|
if (c != ',')
|
/* TODO: Implement "-dynamic"/"-static" command line options. */
|
break;
|
|
input_line_pointer++;
|
static int obj_mach_o_is_static;
|
SKIP_WHITESPACE ();
|
|
|
/* TODO: Implement the "-n" command line option to suppress the initial
|
|
switch to the text segment. */
|
|
|
|
static int obj_mach_o_start_with_text_section = 1;
|
|
|
|
/* Allow for special re-ordering on output. */
|
|
|
|
static int obj_mach_o_seen_objc_section;
|
|
|
|
/* Start-up: At present, just create the sections we want. */
|
|
void
|
|
mach_o_begin (void)
|
|
{
|
|
/* Mach-O only defines the .text section by default, and even this can
|
|
be suppressed by a flag. In the latter event, the first code MUST
|
|
be a section definition. */
|
|
if (obj_mach_o_start_with_text_section)
|
|
{
|
|
text_section = obj_mach_o_segT_from_bfd_name (TEXT_SECTION_NAME, 1);
|
|
subseg_set (text_section, 0);
|
|
if (obj_mach_o_is_static)
|
|
{
|
|
bfd_mach_o_section *mo_sec
|
|
= bfd_mach_o_get_mach_o_section (text_section);
|
|
mo_sec->flags &= ~BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS;
|
|
}
|
}
|
}
|
while (*input_line_pointer != '\n');
|
|
demand_empty_rest_of_line ();
|
|
}
|
}
|
|
|
/* Parse:
|
/* Remember the subsections_by_symbols state in case we need to reset
|
.section segname,sectname[,type[,attribute[,sizeof_stub]]]
|
the file flags. */
|
*/
|
|
|
|
static void
|
static int obj_mach_o_subsections_by_symbols;
|
obj_mach_o_section (int ignore ATTRIBUTE_UNUSED)
|
|
|
/* This will put at most 16 characters (terminated by a ',' or newline) from
|
|
the input stream into dest. If there are more than 16 chars before the
|
|
delimiter, a warning is given and the string is truncated. On completion of
|
|
this function, input_line_pointer will point to the char after the ',' or
|
|
to the newline.
|
|
|
|
It trims leading and trailing space. */
|
|
|
|
static int
|
|
collect_16char_name (char *dest, const char *msg, int require_comma)
|
{
|
{
|
char *p;
|
char c, *namstart;
|
char *segname;
|
|
char *sectname;
|
SKIP_WHITESPACE ();
|
char c;
|
namstart = input_line_pointer;
|
int sectype = BFD_MACH_O_S_REGULAR;
|
|
unsigned int secattr = 0;
|
while ( (c = *input_line_pointer) != ','
|
offsetT sizeof_stub = 0;
|
&& !is_end_of_line[(unsigned char) c])
|
const char *name;
|
input_line_pointer++;
|
flagword oldflags, flags;
|
|
asection *sec;
|
|
|
|
/* Parse segment name. */
|
|
if (!is_name_beginner (*input_line_pointer))
|
|
{
|
{
|
as_bad (_("missing segment name"));
|
int len = input_line_pointer - namstart; /* could be zero. */
|
ignore_rest_of_line ();
|
/* lose any trailing space. */
|
return;
|
while (len > 0 && namstart[len-1] == ' ')
|
|
len--;
|
|
if (len > 16)
|
|
{
|
|
*input_line_pointer = '\0'; /* make a temp string. */
|
|
as_bad (_("the %s name '%s' is too long (maximum 16 characters)"),
|
|
msg, namstart);
|
|
*input_line_pointer = c; /* restore for printing. */
|
|
len = 16;
|
|
}
|
|
if (len > 0)
|
|
memcpy (dest, namstart, len);
|
}
|
}
|
p = input_line_pointer;
|
|
c = get_symbol_end ();
|
|
segname = alloca (input_line_pointer - p + 1);
|
|
strcpy (segname, p);
|
|
*input_line_pointer = c;
|
|
|
|
if (*input_line_pointer != ',')
|
if (c != ',' && require_comma)
|
{
|
{
|
as_bad (_("missing comma after segment name"));
|
as_bad (_("expected a %s name followed by a `,'"), msg);
|
ignore_rest_of_line ();
|
return 1;
|
return;
|
|
}
|
}
|
input_line_pointer++;
|
|
|
|
/* Parse section name. */
|
return 0;
|
if (!is_name_beginner (*input_line_pointer))
|
|
{
|
|
as_bad (_("missing section name"));
|
|
ignore_rest_of_line ();
|
|
return;
|
|
}
|
}
|
p = input_line_pointer;
|
|
c = get_symbol_end ();
|
|
sectname = alloca (input_line_pointer - p + 1);
|
|
strcpy (sectname, p);
|
|
*input_line_pointer = c;
|
|
|
|
/* Parse type. */
|
static int
|
if (*input_line_pointer == ',')
|
obj_mach_o_get_section_names (char *seg, char *sec,
|
|
unsigned segl, unsigned secl)
|
{
|
{
|
input_line_pointer++;
|
/* Zero-length segment and section names are allowed. */
|
if (!is_name_beginner (*input_line_pointer))
|
/* Parse segment name. */
|
|
memset (seg, 0, segl);
|
|
if (collect_16char_name (seg, "segment", 1))
|
{
|
{
|
as_bad (_("missing section type name"));
|
|
ignore_rest_of_line ();
|
ignore_rest_of_line ();
|
return;
|
return 0;
|
}
|
}
|
p = input_line_pointer;
|
input_line_pointer++; /* Skip the terminating ',' */
|
c = get_symbol_end ();
|
|
|
|
sectype = bfd_mach_o_get_section_type_from_name (p);
|
/* Parse section name, which can be empty. */
|
if (sectype == -1)
|
memset (sec, 0, secl);
|
{
|
collect_16char_name (sec, "section", 0);
|
as_bad (_("unknown or invalid section type '%s'"), p);
|
return 1;
|
sectype = BFD_MACH_O_S_REGULAR;
|
|
}
|
}
|
*input_line_pointer = c;
|
|
|
|
/* Parse attributes. */
|
/* Build (or get) a section from the mach-o description - which includes
|
if (*input_line_pointer == ',')
|
optional definitions for type, attributes, alignment and stub size.
|
{
|
|
do
|
|
{
|
|
int attr;
|
|
|
|
input_line_pointer++;
|
BFD supplies default values for sections which have a canonical name. */
|
|
|
|
#define SECT_TYPE_SPECIFIED 0x0001
|
|
#define SECT_ATTR_SPECIFIED 0x0002
|
|
#define SECT_ALGN_SPECIFIED 0x0004
|
|
#define SECT_STUB_SPECIFIED 0x0008
|
|
|
if (!is_name_beginner (*input_line_pointer))
|
static segT
|
|
obj_mach_o_make_or_get_sect (char * segname, char * sectname,
|
|
unsigned int specified_mask,
|
|
unsigned int usectype, unsigned int usecattr,
|
|
unsigned int ualign, offsetT stub_size)
|
{
|
{
|
as_bad (_("missing section attribute identifier"));
|
unsigned int sectype, secattr, secalign;
|
ignore_rest_of_line ();
|
flagword oldflags, flags;
|
break;
|
const char *name;
|
}
|
segT sec;
|
p = input_line_pointer;
|
bfd_mach_o_section *msect;
|
c = get_symbol_end ();
|
const mach_o_section_name_xlat *xlat;
|
|
|
attr = bfd_mach_o_get_section_attribute_from_name (p);
|
/* This provides default bfd flags and default mach-o section type and
|
if (attr == -1)
|
attributes along with the canonical name. */
|
as_bad (_("unknown or invalid section attribute '%s'"), p);
|
xlat = bfd_mach_o_section_data_for_mach_sect (stdoutput, segname, sectname);
|
else
|
|
secattr |= attr;
|
|
|
|
*input_line_pointer = c;
|
/* TODO: more checking of whether overides are acually allowed. */
|
}
|
|
while (*input_line_pointer == '+');
|
|
|
|
/* Parse sizeof_stub. */
|
if (xlat != NULL)
|
if (*input_line_pointer == ',')
|
|
{
|
{
|
if (sectype != BFD_MACH_O_S_SYMBOL_STUBS)
|
name = xstrdup (xlat->bfd_name);
|
as_bad (_("unexpected sizeof_stub expression"));
|
sectype = xlat->macho_sectype;
|
|
if (specified_mask & SECT_TYPE_SPECIFIED)
|
sizeof_stub = get_absolute_expression ();
|
{
|
}
|
if ((sectype == BFD_MACH_O_S_ZEROFILL
|
else if (sectype == BFD_MACH_O_S_SYMBOL_STUBS)
|
|| sectype == BFD_MACH_O_S_GB_ZEROFILL)
|
as_bad (_("missing sizeof_stub expression"));
|
&& sectype != usectype)
|
|
as_bad (_("cannot overide zerofill section type for `%s,%s'"),
|
|
segname, sectname);
|
|
else
|
|
sectype = usectype;
|
}
|
}
|
|
secattr = xlat->macho_secattr;
|
|
secalign = xlat->sectalign;
|
|
flags = xlat->bfd_flags;
|
}
|
}
|
demand_empty_rest_of_line ();
|
else
|
|
|
bfd_mach_o_normalize_section_name (segname, sectname, &name, &flags);
|
|
if (name == NULL)
|
|
{
|
{
|
/* There is no normal BFD section name for this section. Create one.
|
/* There is no normal BFD section name for this section. Create one.
|
The name created doesn't really matter as it will never be written
|
The name created doesn't really matter as it will never be written
|
on disk. */
|
on disk. */
|
size_t seglen = strlen (segname);
|
size_t seglen = strlen (segname);
|
| Line 182... |
Line 214... |
memcpy (n, segname, seglen);
|
memcpy (n, segname, seglen);
|
n[seglen] = '.';
|
n[seglen] = '.';
|
memcpy (n + seglen + 1, sectname, sectlen);
|
memcpy (n + seglen + 1, sectname, sectlen);
|
n[seglen + 1 + sectlen] = 0;
|
n[seglen + 1 + sectlen] = 0;
|
name = n;
|
name = n;
|
|
if (specified_mask & SECT_TYPE_SPECIFIED)
|
|
sectype = usectype;
|
|
else
|
|
sectype = BFD_MACH_O_S_REGULAR;
|
|
secattr = BFD_MACH_O_S_ATTR_NONE;
|
|
secalign = 0;
|
|
flags = SEC_NO_FLAGS;
|
}
|
}
|
|
|
#ifdef md_flush_pending_output
|
/* For now, just use what the user provided. */
|
md_flush_pending_output ();
|
|
#endif
|
if (specified_mask & SECT_ATTR_SPECIFIED)
|
|
secattr = usecattr;
|
|
|
|
if (specified_mask & SECT_ALGN_SPECIFIED)
|
|
secalign = ualign;
|
|
|
/* Sub-segments don't exists as is on Mach-O. */
|
/* Sub-segments don't exists as is on Mach-O. */
|
sec = subseg_new (name, 0);
|
sec = subseg_new (name, 0);
|
|
|
oldflags = bfd_get_section_flags (stdoutput, sec);
|
oldflags = bfd_get_section_flags (stdoutput, sec);
|
|
msect = bfd_mach_o_get_mach_o_section (sec);
|
|
|
if (oldflags == SEC_NO_FLAGS)
|
if (oldflags == SEC_NO_FLAGS)
|
{
|
{
|
bfd_mach_o_section *msect;
|
/* In the absence of canonical information, try to determine CODE and
|
|
DEBUG section flags from the mach-o section data. */
|
|
if (flags == SEC_NO_FLAGS
|
|
&& (specified_mask & SECT_ATTR_SPECIFIED)
|
|
&& (secattr & BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS))
|
|
flags |= SEC_CODE;
|
|
|
|
if (flags == SEC_NO_FLAGS
|
|
&& (specified_mask & SECT_ATTR_SPECIFIED)
|
|
&& (secattr & BFD_MACH_O_S_ATTR_DEBUG))
|
|
flags |= SEC_DEBUGGING;
|
|
|
|
/* New, so just use the defaults or what's specified. */
|
if (! bfd_set_section_flags (stdoutput, sec, flags))
|
if (! bfd_set_section_flags (stdoutput, sec, flags))
|
as_warn (_("error setting flags for \"%s\": %s"),
|
as_warn (_("failed to set flags for \"%s\": %s"),
|
bfd_section_name (stdoutput, sec),
|
bfd_section_name (stdoutput, sec),
|
bfd_errmsg (bfd_get_error ()));
|
bfd_errmsg (bfd_get_error ()));
|
msect = bfd_mach_o_get_mach_o_section (sec);
|
|
strncpy (msect->segname, segname, sizeof (msect->segname));
|
strncpy (msect->segname, segname, sizeof (msect->segname));
|
msect->segname[16] = 0;
|
|
strncpy (msect->sectname, sectname, sizeof (msect->sectname));
|
strncpy (msect->sectname, sectname, sizeof (msect->sectname));
|
msect->sectname[16] = 0;
|
|
msect->flags = secattr | sectype;
|
msect->align = secalign;
|
msect->reserved2 = sizeof_stub;
|
msect->flags = sectype | secattr;
|
|
|
|
if (sectype == BFD_MACH_O_S_ZEROFILL
|
|
|| sectype == BFD_MACH_O_S_GB_ZEROFILL)
|
|
seg_info (sec)->bss = 1;
|
}
|
}
|
else if (flags != SEC_NO_FLAGS)
|
else if (flags != SEC_NO_FLAGS)
|
{
|
{
|
if (flags != oldflags)
|
if (flags != oldflags
|
|
|| msect->flags != (secattr | sectype))
|
as_warn (_("Ignoring changed section attributes for %s"), name);
|
as_warn (_("Ignoring changed section attributes for %s"), name);
|
}
|
}
|
|
|
|
if (specified_mask & SECT_STUB_SPECIFIED)
|
|
/* At present, the stub size is not supplied from the BFD tables. */
|
|
msect->reserved2 = stub_size;
|
|
|
|
return sec;
|
}
|
}
|
|
|
struct known_section
|
/* .section
|
{
|
|
const char *name;
|
|
unsigned int flags;
|
|
};
|
|
|
|
static const struct known_section known_sections[] =
|
The '.section' specification syntax looks like:
|
{
|
.section <segment> , <section> [, type [, attribs [, size]]]
|
/* 0 */ { NULL, 0},
|
|
/* 1 */ { ".cstring", BFD_MACH_O_S_CSTRING_LITERALS }
|
White space is allowed everywhere between elements.
|
};
|
|
|
<segment> and <section> may be from 0 to 16 chars in length - they may
|
|
contain spaces but leading and trailing space will be trimmed. It is
|
|
mandatory that they be present (or that zero-length names are indicated
|
|
by ",,").
|
|
|
|
There is only a single section type for any entry.
|
|
|
|
There may be multiple attributes, they are delimited by `+'.
|
|
|
|
Not all section types and attributes are accepted by the Darwin system
|
|
assemblers as user-specifiable - although, at present, we do here. */
|
|
|
static void
|
static void
|
obj_mach_o_known_section (int sect_index)
|
obj_mach_o_section (int ignore ATTRIBUTE_UNUSED)
|
{
|
{
|
const struct known_section *sect = &known_sections[sect_index];
|
unsigned int sectype = BFD_MACH_O_S_REGULAR;
|
asection *old_sec;
|
unsigned int specified_mask = 0;
|
segT sec;
|
unsigned int secattr = 0;
|
|
offsetT sizeof_stub = 0;
|
|
segT new_seg;
|
|
char segname[17];
|
|
char sectname[17];
|
|
|
#ifdef md_flush_pending_output
|
#ifdef md_flush_pending_output
|
md_flush_pending_output ();
|
md_flush_pending_output ();
|
#endif
|
#endif
|
|
|
old_sec = bfd_get_section_by_name (stdoutput, sect->name);
|
/* Get the User's segment annd section names. */
|
if (old_sec)
|
if (! obj_mach_o_get_section_names (segname, sectname, 17, 17))
|
|
return;
|
|
|
|
/* Parse section type, if present. */
|
|
if (*input_line_pointer == ',')
|
|
{
|
|
char *p;
|
|
char c;
|
|
char tmpc;
|
|
int len;
|
|
input_line_pointer++;
|
|
SKIP_WHITESPACE ();
|
|
p = input_line_pointer;
|
|
while ((c = *input_line_pointer) != ','
|
|
&& !is_end_of_line[(unsigned char) c])
|
|
input_line_pointer++;
|
|
|
|
len = input_line_pointer - p;
|
|
/* strip trailing spaces. */
|
|
while (len > 0 && p[len-1] == ' ')
|
|
len--;
|
|
tmpc = p[len];
|
|
|
|
/* Temporarily make a string from the token. */
|
|
p[len] = 0;
|
|
sectype = bfd_mach_o_get_section_type_from_name (stdoutput, p);
|
|
if (sectype > 255) /* Max Section ID == 255. */
|
{
|
{
|
/* Section already present. */
|
as_bad (_("unknown or invalid section type '%s'"), p);
|
sec = old_sec;
|
p[len] = tmpc;
|
subseg_set (sec, 0);
|
ignore_rest_of_line ();
|
|
return;
|
}
|
}
|
else
|
else
|
|
specified_mask |= SECT_TYPE_SPECIFIED;
|
|
/* Restore. */
|
|
p[len] = tmpc;
|
|
|
|
/* Parse attributes.
|
|
TODO: check validity of attributes for section type. */
|
|
if ((specified_mask & SECT_TYPE_SPECIFIED)
|
|
&& c == ',')
|
{
|
{
|
bfd_mach_o_section *msect;
|
do
|
|
{
|
|
int attr;
|
|
|
|
/* Skip initial `,' and subsequent `+'. */
|
|
input_line_pointer++;
|
|
SKIP_WHITESPACE ();
|
|
p = input_line_pointer;
|
|
while ((c = *input_line_pointer) != '+'
|
|
&& c != ','
|
|
&& !is_end_of_line[(unsigned char) c])
|
|
input_line_pointer++;
|
|
|
sec = subseg_force_new (sect->name, 0);
|
len = input_line_pointer - p;
|
|
/* strip trailing spaces. */
|
|
while (len > 0 && p[len-1] == ' ')
|
|
len--;
|
|
tmpc = p[len];
|
|
|
/* Set default flags. */
|
/* Temporarily make a string from the token. */
|
msect = bfd_mach_o_get_mach_o_section (sec);
|
p[len] ='\0';
|
msect->flags = sect->flags;
|
attr = bfd_mach_o_get_section_attribute_from_name (p);
|
|
if (attr == -1)
|
|
{
|
|
as_bad (_("unknown or invalid section attribute '%s'"), p);
|
|
p[len] = tmpc;
|
|
ignore_rest_of_line ();
|
|
return;
|
}
|
}
|
|
else
|
|
{
|
|
specified_mask |= SECT_ATTR_SPECIFIED;
|
|
secattr |= attr;
|
|
}
|
|
/* Restore. */
|
|
p[len] = tmpc;
|
}
|
}
|
|
while (*input_line_pointer == '+');
|
|
|
/* Called from read.c:s_comm after we've parsed .comm symbol, size.
|
/* Parse sizeof_stub. */
|
Parse a possible alignment value. */
|
if ((specified_mask & SECT_ATTR_SPECIFIED)
|
|
&& *input_line_pointer == ',')
|
|
{
|
|
if (sectype != BFD_MACH_O_S_SYMBOL_STUBS)
|
|
{
|
|
as_bad (_("unexpected section size information"));
|
|
ignore_rest_of_line ();
|
|
return;
|
|
}
|
|
|
static symbolS *
|
input_line_pointer++;
|
obj_mach_o_common_parse (int ignore ATTRIBUTE_UNUSED,
|
sizeof_stub = get_absolute_expression ();
|
symbolS *symbolP, addressT size)
|
specified_mask |= SECT_STUB_SPECIFIED;
|
|
}
|
|
else if ((specified_mask & SECT_ATTR_SPECIFIED)
|
|
&& sectype == BFD_MACH_O_S_SYMBOL_STUBS)
|
{
|
{
|
addressT align = 0;
|
as_bad (_("missing sizeof_stub expression"));
|
|
ignore_rest_of_line ();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
if (*input_line_pointer == ',')
|
new_seg = obj_mach_o_make_or_get_sect (segname, sectname, specified_mask,
|
|
sectype, secattr, 0 /*align */,
|
|
sizeof_stub);
|
|
if (new_seg != NULL)
|
{
|
{
|
align = parse_align (0);
|
subseg_set (new_seg, 0);
|
if (align == (addressT) -1)
|
demand_empty_rest_of_line ();
|
return NULL;
|
}
|
}
|
}
|
|
|
S_SET_VALUE (symbolP, size);
|
/* .zerofill segname, sectname [, symbolname, size [, align]]
|
S_SET_EXTERNAL (symbolP);
|
|
S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
|
|
|
|
symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
|
Zerofill switches, temporarily, to a sect of type 'zerofill'.
|
|
|
return symbolP;
|
If a variable name is given, it defines that in the section.
|
}
|
Otherwise it just creates the section if it doesn't exist. */
|
|
|
static void
|
static void
|
obj_mach_o_comm (int ignore ATTRIBUTE_UNUSED)
|
obj_mach_o_zerofill (int ignore ATTRIBUTE_UNUSED)
|
|
{
|
|
char segname[17];
|
|
char sectname[17];
|
|
segT old_seg = now_seg;
|
|
segT new_seg;
|
|
symbolS *sym = NULL;
|
|
unsigned int align = 0;
|
|
unsigned int specified_mask = 0;
|
|
offsetT size = 0;
|
|
|
|
#ifdef md_flush_pending_output
|
|
md_flush_pending_output ();
|
|
#endif
|
|
|
|
/* Get the User's segment annd section names. */
|
|
if (! obj_mach_o_get_section_names (segname, sectname, 17, 17))
|
|
return;
|
|
|
|
/* Parse variable definition, if present. */
|
|
if (*input_line_pointer == ',')
|
|
{
|
|
/* Parse symbol, size [.align]
|
|
We follow the method of s_common_internal, with the difference
|
|
that the symbol cannot be a duplicate-common. */
|
|
char *name;
|
|
char c;
|
|
char *p;
|
|
expressionS exp;
|
|
|
|
input_line_pointer++; /* Skip ',' */
|
|
SKIP_WHITESPACE ();
|
|
name = input_line_pointer;
|
|
c = get_symbol_end ();
|
|
/* Just after name is now '\0'. */
|
|
p = input_line_pointer;
|
|
*p = c;
|
|
|
|
if (name == p)
|
{
|
{
|
s_comm_internal (ignore, obj_mach_o_common_parse);
|
as_bad (_("expected symbol name"));
|
|
ignore_rest_of_line ();
|
|
goto done;
|
}
|
}
|
|
|
static void
|
SKIP_WHITESPACE ();
|
obj_mach_o_subsections_via_symbols (int arg ATTRIBUTE_UNUSED)
|
if (*input_line_pointer == ',')
|
|
input_line_pointer++;
|
|
|
|
expression_and_evaluate (&exp);
|
|
if (exp.X_op != O_constant
|
|
&& exp.X_op != O_absent)
|
{
|
{
|
/* Currently ignore it. */
|
as_bad (_("bad or irreducible absolute expression"));
|
demand_empty_rest_of_line ();
|
ignore_rest_of_line ();
|
|
goto done;
|
|
}
|
|
else if (exp.X_op == O_absent)
|
|
{
|
|
as_bad (_("missing size expression"));
|
|
ignore_rest_of_line ();
|
|
goto done;
|
}
|
}
|
|
|
const pseudo_typeS mach_o_pseudo_table[] =
|
size = exp.X_add_number;
|
|
size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
|
|
if (exp.X_add_number != size || !exp.X_unsigned)
|
{
|
{
|
{ "weak", obj_mach_o_weak, 0},
|
as_warn (_("size (%ld) out of range, ignored"),
|
{ "section", obj_mach_o_section, 0},
|
(long) exp.X_add_number);
|
{ "cstring", obj_mach_o_known_section, 1},
|
ignore_rest_of_line ();
|
{ "lcomm", s_lcomm, 1 },
|
goto done;
|
{ "comm", obj_mach_o_comm, 0 },
|
}
|
{ "subsections_via_symbols", obj_mach_o_subsections_via_symbols, 0 },
|
|
|
|
{NULL, NULL, 0}
|
*p = 0; /* Make the name into a c string for err messages. */
|
};
|
sym = symbol_find_or_make (name);
|
|
if (S_IS_DEFINED (sym) || symbol_equated_p (sym))
|
|
{
|
|
as_bad (_("symbol `%s' is already defined"), name);
|
|
*p = c;
|
|
ignore_rest_of_line ();
|
|
goto done;
|
|
}
|
|
|
|
size = S_GET_VALUE (sym);
|
|
if (size == 0)
|
|
size = exp.X_add_number;
|
|
else if (size != exp.X_add_number)
|
|
as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
|
|
name, (long) size, (long) exp.X_add_number);
|
|
|
|
*p = c; /* Restore the termination char. */
|
|
|
|
SKIP_WHITESPACE ();
|
|
if (*input_line_pointer == ',')
|
|
{
|
|
align = (unsigned int) parse_align (0);
|
|
if (align == (unsigned int) -1)
|
|
{
|
|
as_warn (_("align value not recognized, using size"));
|
|
align = size;
|
|
}
|
|
if (align > 15)
|
|
{
|
|
as_warn (_("Alignment (%lu) too large: 15 assumed."),
|
|
(unsigned long)align);
|
|
align = 15;
|
|
}
|
|
specified_mask |= SECT_ALGN_SPECIFIED;
|
|
}
|
|
}
|
|
/* else just a section definition. */
|
|
|
|
specified_mask |= SECT_TYPE_SPECIFIED;
|
|
new_seg = obj_mach_o_make_or_get_sect (segname, sectname, specified_mask,
|
|
BFD_MACH_O_S_ZEROFILL,
|
|
BFD_MACH_O_S_ATTR_NONE,
|
|
align, (offsetT) 0 /*stub size*/);
|
|
if (new_seg == NULL)
|
|
return;
|
|
|
|
/* In case the user specifies the bss section by mach-o name.
|
|
Create it on demand */
|
|
if (strcmp (new_seg->name, BSS_SECTION_NAME) == 0
|
|
&& bss_section == NULL)
|
|
bss_section = new_seg;
|
|
|
|
subseg_set (new_seg, 0);
|
|
|
|
if (sym != NULL)
|
|
{
|
|
char *pfrag;
|
|
|
|
if (align)
|
|
{
|
|
record_alignment (new_seg, align);
|
|
frag_align (align, 0, 0);
|
|
}
|
|
|
|
/* Detach from old frag. */
|
|
if (S_GET_SEGMENT (sym) == new_seg)
|
|
symbol_get_frag (sym)->fr_symbol = NULL;
|
|
|
|
symbol_set_frag (sym, frag_now);
|
|
pfrag = frag_var (rs_org, 1, 1, 0, sym, size, NULL);
|
|
*pfrag = 0;
|
|
|
|
S_SET_SEGMENT (sym, new_seg);
|
|
if (new_seg == bss_section)
|
|
S_CLEAR_EXTERNAL (sym);
|
|
}
|
|
|
|
done:
|
|
/* switch back to the section that was current before the .zerofill. */
|
|
subseg_set (old_seg, 0);
|
|
}
|
|
|
|
static segT
|
|
obj_mach_o_segT_from_bfd_name (const char *nam, int must_succeed)
|
|
{
|
|
const mach_o_section_name_xlat *xlat;
|
|
const char *segn;
|
|
segT sec;
|
|
|
|
/* BFD has tables of flags and default attributes for all the sections that
|
|
have a 'canonical' name. */
|
|
xlat = bfd_mach_o_section_data_for_bfd_name (stdoutput, nam, &segn);
|
|
if (xlat == NULL)
|
|
{
|
|
if (must_succeed)
|
|
as_fatal (_("BFD is out of sync with GAS, "
|
|
"unhandled well-known section type `%s'"), nam);
|
|
return NULL;
|
|
}
|
|
|
|
sec = bfd_get_section_by_name (stdoutput, nam);
|
|
if (sec == NULL)
|
|
{
|
|
bfd_mach_o_section *msect;
|
|
|
|
sec = subseg_force_new (xlat->bfd_name, 0);
|
|
|
|
/* Set default type, attributes and alignment. */
|
|
msect = bfd_mach_o_get_mach_o_section (sec);
|
|
msect->flags = xlat->macho_sectype | xlat->macho_secattr;
|
|
msect->align = xlat->sectalign;
|
|
|
|
if ((msect->flags & BFD_MACH_O_SECTION_TYPE_MASK)
|
|
== BFD_MACH_O_S_ZEROFILL)
|
|
seg_info (sec)->bss = 1;
|
|
}
|
|
|
|
return sec;
|
|
}
|
|
|
|
static const char * const known_sections[] =
|
|
{
|
|
/* 0 */ NULL,
|
|
/* __TEXT */
|
|
/* 1 */ ".const",
|
|
/* 2 */ ".static_const",
|
|
/* 3 */ ".cstring",
|
|
/* 4 */ ".literal4",
|
|
/* 5 */ ".literal8",
|
|
/* 6 */ ".literal16",
|
|
/* 7 */ ".constructor",
|
|
/* 8 */ ".destructor",
|
|
/* 9 */ ".eh_frame",
|
|
/* __DATA */
|
|
/* 10 */ ".const_data",
|
|
/* 11 */ ".static_data",
|
|
/* 12 */ ".mod_init_func",
|
|
/* 13 */ ".mod_term_func",
|
|
/* 14 */ ".dyld",
|
|
/* 15 */ ".cfstring"
|
|
};
|
|
|
|
/* Interface for a known non-optional section directive. */
|
|
|
|
static void
|
|
obj_mach_o_known_section (int sect_index)
|
|
{
|
|
segT section;
|
|
|
|
#ifdef md_flush_pending_output
|
|
md_flush_pending_output ();
|
|
#endif
|
|
|
|
section = obj_mach_o_segT_from_bfd_name (known_sections[sect_index], 1);
|
|
if (section != NULL)
|
|
subseg_set (section, 0);
|
|
|
|
/* else, we leave the section as it was; there was a fatal error anyway. */
|
|
}
|
|
|
|
static const char * const objc_sections[] =
|
|
{
|
|
/* 0 */ NULL,
|
|
/* 1 */ ".objc_class",
|
|
/* 2 */ ".objc_meta_class",
|
|
/* 3 */ ".objc_cat_cls_meth",
|
|
/* 4 */ ".objc_cat_inst_meth",
|
|
/* 5 */ ".objc_protocol",
|
|
/* 6 */ ".objc_string_object",
|
|
/* 7 */ ".objc_cls_meth",
|
|
/* 8 */ ".objc_inst_meth",
|
|
/* 9 */ ".objc_cls_refs",
|
|
/* 10 */ ".objc_message_refs",
|
|
/* 11 */ ".objc_symbols",
|
|
/* 12 */ ".objc_category",
|
|
/* 13 */ ".objc_class_vars",
|
|
/* 14 */ ".objc_instance_vars",
|
|
/* 15 */ ".objc_module_info",
|
|
/* 16 */ ".cstring", /* objc_class_names Alias for .cstring */
|
|
/* 17 */ ".cstring", /* Alias objc_meth_var_types for .cstring */
|
|
/* 18 */ ".cstring", /* objc_meth_var_names Alias for .cstring */
|
|
/* 19 */ ".objc_selector_strs",
|
|
/* 20 */ ".objc_image_info", /* extension. */
|
|
/* 21 */ ".objc_selector_fixup", /* extension. */
|
|
/* 22 */ ".objc1_class_ext", /* ObjC-1 extension. */
|
|
/* 23 */ ".objc1_property_list", /* ObjC-1 extension. */
|
|
/* 24 */ ".objc1_protocol_ext" /* ObjC-1 extension. */
|
|
};
|
|
|
|
/* This currently does the same as known_sections, but kept separate for
|
|
ease of maintenance. */
|
|
|
|
static void
|
|
obj_mach_o_objc_section (int sect_index)
|
|
{
|
|
segT section;
|
|
|
|
#ifdef md_flush_pending_output
|
|
md_flush_pending_output ();
|
|
#endif
|
|
|
|
section = obj_mach_o_segT_from_bfd_name (objc_sections[sect_index], 1);
|
|
if (section != NULL)
|
|
{
|
|
obj_mach_o_seen_objc_section = 1; /* We need to ensure that certain
|
|
sections are present and in the
|
|
right order. */
|
|
subseg_set (section, 0);
|
|
}
|
|
|
|
/* else, we leave the section as it was; there was a fatal error anyway. */
|
|
}
|
|
|
|
/* Debug section directives. */
|
|
|
|
static const char * const debug_sections[] =
|
|
{
|
|
/* 0 */ NULL,
|
|
/* __DWARF */
|
|
/* 1 */ ".debug_frame",
|
|
/* 2 */ ".debug_info",
|
|
/* 3 */ ".debug_abbrev",
|
|
/* 4 */ ".debug_aranges",
|
|
/* 5 */ ".debug_macinfo",
|
|
/* 6 */ ".debug_line",
|
|
/* 7 */ ".debug_loc",
|
|
/* 8 */ ".debug_pubnames",
|
|
/* 9 */ ".debug_pubtypes",
|
|
/* 10 */ ".debug_str",
|
|
/* 11 */ ".debug_ranges",
|
|
/* 12 */ ".debug_macro"
|
|
};
|
|
|
|
/* ??? Maybe these should be conditional on gdwarf-*.
|
|
It`s also likely that we will need to be able to set them from the cfi
|
|
code. */
|
|
|
|
static void
|
|
obj_mach_o_debug_section (int sect_index)
|
|
{
|
|
segT section;
|
|
|
|
#ifdef md_flush_pending_output
|
|
md_flush_pending_output ();
|
|
#endif
|
|
|
|
section = obj_mach_o_segT_from_bfd_name (debug_sections[sect_index], 1);
|
|
if (section != NULL)
|
|
subseg_set (section, 0);
|
|
|
|
/* else, we leave the section as it was; there was a fatal error anyway. */
|
|
}
|
|
|
|
/* This could be moved to the tc-xx files, but there is so little dependency
|
|
there, that the code might as well be shared. */
|
|
|
|
struct opt_tgt_sect
|
|
{
|
|
const char *name;
|
|
unsigned x86_val;
|
|
unsigned ppc_val;
|
|
};
|
|
|
|
/* The extensions here are for specific sections that are generated by GCC
|
|
and Darwin system tools, but don't have directives in the `system as'. */
|
|
|
|
static const struct opt_tgt_sect tgt_sections[] =
|
|
{
|
|
/* 0 */ { NULL, 0, 0},
|
|
/* 1 */ { ".lazy_symbol_pointer", 0, 0},
|
|
/* 2 */ { ".lazy_symbol_pointer2", 0, 0}, /* X86 - extension */
|
|
/* 3 */ { ".lazy_symbol_pointer3", 0, 0}, /* X86 - extension */
|
|
/* 4 */ { ".non_lazy_symbol_pointer", 0, 0},
|
|
/* 5 */ { ".non_lazy_symbol_pointer_x86", 0, 0}, /* X86 - extension */
|
|
/* 6 */ { ".symbol_stub", 16, 20},
|
|
/* 7 */ { ".symbol_stub1", 0, 16}, /* PPC - extension */
|
|
/* 8 */ { ".picsymbol_stub", 26, 36},
|
|
/* 9 */ { ".picsymbol_stub1", 0, 32}, /* PPC - extension */
|
|
/* 10 */ { ".picsymbol_stub2", 25, 0}, /* X86 - extension */
|
|
/* 11 */ { ".picsymbol_stub3", 5, 0}, /* X86 - extension */
|
|
};
|
|
|
|
/* Interface for an optional section directive. */
|
|
|
|
static void
|
|
obj_mach_o_opt_tgt_section (int sect_index)
|
|
{
|
|
const struct opt_tgt_sect *tgtsct = &tgt_sections[sect_index];
|
|
segT section;
|
|
|
|
#ifdef md_flush_pending_output
|
|
md_flush_pending_output ();
|
|
#endif
|
|
|
|
section = obj_mach_o_segT_from_bfd_name (tgtsct->name, 0);
|
|
if (section == NULL)
|
|
{
|
|
as_bad (_("%s is not used for the selected target"), tgtsct->name);
|
|
/* Leave the section as it is. */
|
|
}
|
|
else
|
|
{
|
|
bfd_mach_o_section *mo_sec = bfd_mach_o_get_mach_o_section (section);
|
|
subseg_set (section, 0);
|
|
#if defined (TC_I386)
|
|
mo_sec->reserved2 = tgtsct->x86_val;
|
|
#elif defined (TC_PPC)
|
|
mo_sec->reserved2 = tgtsct->ppc_val;
|
|
#else
|
|
mo_sec->reserved2 = 0;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/* We don't necessarily have the three 'base' sections on mach-o.
|
|
Normally, we would start up with only the 'text' section defined.
|
|
However, even that can be suppressed with (TODO) c/l option "-n".
|
|
Thus, we have to be able to create all three sections on-demand. */
|
|
|
|
static void
|
|
obj_mach_o_base_section (int sect_index)
|
|
{
|
|
segT section;
|
|
|
|
#ifdef md_flush_pending_output
|
|
md_flush_pending_output ();
|
|
#endif
|
|
|
|
/* We don't support numeric (or any other) qualifications on the
|
|
well-known section shorthands. */
|
|
demand_empty_rest_of_line ();
|
|
|
|
switch (sect_index)
|
|
{
|
|
/* Handle the three sections that are globally known within GAS.
|
|
For Mach-O, these are created on demand rather than at startup. */
|
|
case 1:
|
|
if (text_section == NULL)
|
|
text_section = obj_mach_o_segT_from_bfd_name (TEXT_SECTION_NAME, 1);
|
|
if (obj_mach_o_is_static)
|
|
{
|
|
bfd_mach_o_section *mo_sec
|
|
= bfd_mach_o_get_mach_o_section (text_section);
|
|
mo_sec->flags &= ~BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS;
|
|
}
|
|
section = text_section;
|
|
break;
|
|
case 2:
|
|
if (data_section == NULL)
|
|
data_section = obj_mach_o_segT_from_bfd_name (DATA_SECTION_NAME, 1);
|
|
section = data_section;
|
|
break;
|
|
case 3:
|
|
/* ??? maybe this achieves very little, as an addition. */
|
|
if (bss_section == NULL)
|
|
{
|
|
bss_section = obj_mach_o_segT_from_bfd_name (BSS_SECTION_NAME, 1);
|
|
seg_info (bss_section)->bss = 1;
|
|
}
|
|
section = bss_section;
|
|
break;
|
|
default:
|
|
as_fatal (_("internal error: base section index out of range"));
|
|
return;
|
|
break;
|
|
}
|
|
subseg_set (section, 0);
|
|
}
|
|
|
|
/* This finishes off parsing a .comm or .lcomm statement, which both can have
|
|
an (optional) alignment field. It also allows us to create the bss section
|
|
on demand. */
|
|
|
|
static symbolS *
|
|
obj_mach_o_common_parse (int is_local, symbolS *symbolP,
|
|
addressT size)
|
|
{
|
|
addressT align = 0;
|
|
bfd_mach_o_asymbol *s;
|
|
|
|
SKIP_WHITESPACE ();
|
|
|
|
/* Both comm and lcomm take an optional alignment, as a power
|
|
of two between 1 and 15. */
|
|
if (*input_line_pointer == ',')
|
|
{
|
|
/* We expect a power of 2. */
|
|
align = parse_align (0);
|
|
if (align == (addressT) -1)
|
|
return NULL;
|
|
if (align > 15)
|
|
{
|
|
as_warn (_("Alignment (%lu) too large: 15 assumed."),
|
|
(unsigned long)align);
|
|
align = 15;
|
|
}
|
|
}
|
|
|
|
s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (symbolP);
|
|
if (is_local)
|
|
{
|
|
/* Create the BSS section on demand. */
|
|
if (bss_section == NULL)
|
|
{
|
|
bss_section = obj_mach_o_segT_from_bfd_name (BSS_SECTION_NAME, 1);
|
|
seg_info (bss_section)->bss = 1;
|
|
}
|
|
bss_alloc (symbolP, size, align);
|
|
s->n_type = BFD_MACH_O_N_SECT;
|
|
S_CLEAR_EXTERNAL (symbolP);
|
|
}
|
|
else
|
|
{
|
|
S_SET_VALUE (symbolP, size);
|
|
S_SET_ALIGN (symbolP, align);
|
|
S_SET_EXTERNAL (symbolP);
|
|
S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
|
|
s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
|
|
}
|
|
|
|
/* This is a data object (whatever we choose that to mean). */
|
|
s->symbol.flags |= BSF_OBJECT;
|
|
|
|
/* We've set symbol qualifiers, so validate if you can. */
|
|
s->symbol.udata.i = SYM_MACHO_FIELDS_NOT_VALIDATED;
|
|
|
|
return symbolP;
|
|
}
|
|
|
|
static void
|
|
obj_mach_o_comm (int is_local)
|
|
{
|
|
s_comm_internal (is_local, obj_mach_o_common_parse);
|
|
}
|
|
|
|
/* Set properties that apply to the whole file. At present, the only
|
|
one defined, is subsections_via_symbols. */
|
|
|
|
typedef enum obj_mach_o_file_properties {
|
|
OBJ_MACH_O_FILE_PROP_NONE = 0,
|
|
OBJ_MACH_O_FILE_PROP_SUBSECTS_VIA_SYMS,
|
|
OBJ_MACH_O_FILE_PROP_MAX
|
|
} obj_mach_o_file_properties;
|
|
|
|
static void
|
|
obj_mach_o_fileprop (int prop)
|
|
{
|
|
if (prop < 0 || prop >= OBJ_MACH_O_FILE_PROP_MAX)
|
|
as_fatal (_("internal error: bad file property ID %d"), prop);
|
|
|
|
switch ((obj_mach_o_file_properties) prop)
|
|
{
|
|
case OBJ_MACH_O_FILE_PROP_SUBSECTS_VIA_SYMS:
|
|
obj_mach_o_subsections_by_symbols = 1;
|
|
if (!bfd_set_private_flags (stdoutput,
|
|
BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS))
|
|
as_bad (_("failed to set subsections by symbols"));
|
|
demand_empty_rest_of_line ();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Temporary markers for symbol reference data.
|
|
Lazy will remain in place. */
|
|
#define LAZY 0x01
|
|
#define REFE 0x02
|
|
|
|
/* We have a bunch of qualifiers that may be applied to symbols.
|
|
.globl is handled here so that we might make sure that conflicting qualifiers
|
|
are caught where possible. */
|
|
|
|
typedef enum obj_mach_o_symbol_type {
|
|
OBJ_MACH_O_SYM_UNK = 0,
|
|
OBJ_MACH_O_SYM_LOCAL = 1,
|
|
OBJ_MACH_O_SYM_GLOBL = 2,
|
|
OBJ_MACH_O_SYM_REFERENCE = 3,
|
|
OBJ_MACH_O_SYM_WEAK_REF = 4,
|
|
OBJ_MACH_O_SYM_LAZY_REF = 5,
|
|
OBJ_MACH_O_SYM_WEAK_DEF = 6,
|
|
OBJ_MACH_O_SYM_PRIV_EXT = 7,
|
|
OBJ_MACH_O_SYM_NO_DEAD_STRIP = 8,
|
|
OBJ_MACH_O_SYM_WEAK = 9
|
|
} obj_mach_o_symbol_type;
|
|
|
|
/* Set Mach-O-specific symbol qualifiers. */
|
|
|
|
static int
|
|
obj_mach_o_set_symbol_qualifier (symbolS *sym, int type)
|
|
{
|
|
int is_defined;
|
|
bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *) symbol_get_bfdsym (sym);
|
|
bfd_mach_o_section *sec;
|
|
int sectype = -1;
|
|
int err = 0;
|
|
|
|
/* If the symbol is defined, then we can do more rigorous checking on
|
|
the validity of the qualifiers. Otherwise, we are stuck with waiting
|
|
until it's defined - or until write the file.
|
|
|
|
In certain cases (e.g. when a symbol qualifier is intended to introduce
|
|
an undefined symbol in a stubs section) we should check that the current
|
|
section is appropriate to the qualifier. */
|
|
|
|
is_defined = s->symbol.section != bfd_und_section_ptr;
|
|
if (is_defined)
|
|
sec = bfd_mach_o_get_mach_o_section (s->symbol.section) ;
|
|
else
|
|
sec = bfd_mach_o_get_mach_o_section (now_seg) ;
|
|
|
|
if (sec != NULL)
|
|
sectype = sec->flags & BFD_MACH_O_SECTION_TYPE_MASK;
|
|
|
|
switch ((obj_mach_o_symbol_type) type)
|
|
{
|
|
case OBJ_MACH_O_SYM_LOCAL:
|
|
/* This is an extension over the system tools. */
|
|
if (s->n_type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
|
|
{
|
|
as_bad (_("'%s' previously declared as '%s'."), s->symbol.name,
|
|
(s->n_type & BFD_MACH_O_N_PEXT) ? "private extern"
|
|
: "global" );
|
|
err = 1;
|
|
}
|
|
else
|
|
{
|
|
s->n_type &= ~BFD_MACH_O_N_EXT;
|
|
S_CLEAR_EXTERNAL (sym);
|
|
}
|
|
break;
|
|
|
|
case OBJ_MACH_O_SYM_PRIV_EXT:
|
|
s->n_type |= BFD_MACH_O_N_PEXT ;
|
|
s->n_desc &= ~LAZY; /* The native tool switches this off too. */
|
|
/* We follow the system tools in marking PEXT as also global. */
|
|
/* Fall through. */
|
|
|
|
case OBJ_MACH_O_SYM_GLOBL:
|
|
/* It's not an error to define a symbol and then make it global. */
|
|
s->n_type |= BFD_MACH_O_N_EXT;
|
|
S_SET_EXTERNAL (sym);
|
|
break;
|
|
|
|
case OBJ_MACH_O_SYM_REFERENCE:
|
|
if (is_defined)
|
|
s->n_desc |= BFD_MACH_O_N_NO_DEAD_STRIP;
|
|
else
|
|
s->n_desc |= (REFE | BFD_MACH_O_N_NO_DEAD_STRIP);
|
|
break;
|
|
|
|
case OBJ_MACH_O_SYM_LAZY_REF:
|
|
if (is_defined)
|
|
s->n_desc |= BFD_MACH_O_N_NO_DEAD_STRIP;
|
|
else
|
|
s->n_desc |= (REFE | LAZY | BFD_MACH_O_N_NO_DEAD_STRIP);
|
|
break;
|
|
|
|
/* Force ld to retain the symbol - even if it appears unused. */
|
|
case OBJ_MACH_O_SYM_NO_DEAD_STRIP:
|
|
s->n_desc |= BFD_MACH_O_N_NO_DEAD_STRIP ;
|
|
break;
|
|
|
|
/* Mach-O's idea of weak ... */
|
|
case OBJ_MACH_O_SYM_WEAK_REF:
|
|
s->n_desc |= BFD_MACH_O_N_WEAK_REF ;
|
|
break;
|
|
|
|
case OBJ_MACH_O_SYM_WEAK_DEF:
|
|
if (is_defined && 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);
|
|
err = 1;
|
|
}
|
|
else
|
|
s->n_desc |= BFD_MACH_O_N_WEAK_DEF;
|
|
break;
|
|
|
|
case OBJ_MACH_O_SYM_WEAK:
|
|
/* A generic 'weak' - we try to figure out what it means at
|
|
symbol frob time. */
|
|
S_SET_WEAK (sym);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* We've seen some kind of qualifier - check validity if or when the entity
|
|
is defined. */
|
|
s->symbol.udata.i = SYM_MACHO_FIELDS_NOT_VALIDATED;
|
|
return err;
|
|
}
|
|
|
|
/* Respond to symbol qualifiers.
|
|
All of the form:
|
|
.<qualifier> symbol [, symbol]*
|
|
a list of symbols is an extension over the Darwin system as. */
|
|
|
|
static void
|
|
obj_mach_o_sym_qual (int ntype)
|
|
{
|
|
char *name;
|
|
char c;
|
|
symbolS *symbolP;
|
|
|
|
#ifdef md_flush_pending_output
|
|
md_flush_pending_output ();
|
|
#endif
|
|
|
|
do
|
|
{
|
|
name = input_line_pointer;
|
|
c = get_symbol_end ();
|
|
symbolP = symbol_find_or_make (name);
|
|
obj_mach_o_set_symbol_qualifier (symbolP, ntype);
|
|
*input_line_pointer = c;
|
|
SKIP_WHITESPACE ();
|
|
c = *input_line_pointer;
|
|
if (c == ',')
|
|
{
|
|
input_line_pointer++;
|
|
SKIP_WHITESPACE ();
|
|
if (is_end_of_line[(unsigned char) *input_line_pointer])
|
|
c = '\n';
|
|
}
|
|
}
|
|
while (c == ',');
|
|
|
|
demand_empty_rest_of_line ();
|
|
}
|
|
|
|
typedef struct obj_mach_o_indirect_sym
|
|
{
|
|
symbolS *sym;
|
|
segT sect;
|
|
struct obj_mach_o_indirect_sym *next;
|
|
} obj_mach_o_indirect_sym;
|
|
|
|
/* We store in order an maintain a pointer to the last one - to save reversing
|
|
later. */
|
|
obj_mach_o_indirect_sym *indirect_syms;
|
|
obj_mach_o_indirect_sym *indirect_syms_tail;
|
|
|
|
static void
|
|
obj_mach_o_indirect_symbol (int arg ATTRIBUTE_UNUSED)
|
|
{
|
|
bfd_mach_o_section *sec = bfd_mach_o_get_mach_o_section (now_seg);
|
|
|
|
#ifdef md_flush_pending_output
|
|
md_flush_pending_output ();
|
|
#endif
|
|
|
|
if (obj_mach_o_is_static)
|
|
as_bad (_("use of .indirect_symbols requires `-dynamic'"));
|
|
|
|
switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
|
|
{
|
|
case BFD_MACH_O_S_SYMBOL_STUBS:
|
|
case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
|
|
case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
|
|
{
|
|
obj_mach_o_indirect_sym *isym;
|
|
char *name = input_line_pointer;
|
|
char c = get_symbol_end ();
|
|
symbolS *sym = symbol_find_or_make (name);
|
|
unsigned int elsize =
|
|
bfd_mach_o_section_get_entry_size (stdoutput, sec);
|
|
|
|
if (elsize == 0)
|
|
{
|
|
as_bad (_("attempt to add an indirect_symbol to a stub or"
|
|
" reference section with a zero-sized element at %s"),
|
|
name);
|
|
*input_line_pointer = c;
|
|
ignore_rest_of_line ();
|
|
return;
|
|
}
|
|
*input_line_pointer = c;
|
|
|
|
/* The indirect symbols are validated after the symbol table is
|
|
frozen, we must make sure that if a local symbol is used as an
|
|
indirect, it is promoted to a 'real' one. Fetching the bfd sym
|
|
achieves this. */
|
|
symbol_get_bfdsym (sym);
|
|
isym = (obj_mach_o_indirect_sym *)
|
|
xmalloc (sizeof (obj_mach_o_indirect_sym));
|
|
|
|
/* Just record the data for now, we will validate it when we
|
|
compute the output in obj_mach_o_set_indirect_symbols. */
|
|
isym->sym = sym;
|
|
isym->sect = now_seg;
|
|
isym->next = NULL;
|
|
if (indirect_syms == NULL)
|
|
indirect_syms = isym;
|
|
else
|
|
indirect_syms_tail->next = isym;
|
|
indirect_syms_tail = isym;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
as_bad (_("an .indirect_symbol must be in a symbol pointer"
|
|
" or stub section."));
|
|
ignore_rest_of_line ();
|
|
return;
|
|
}
|
|
demand_empty_rest_of_line ();
|
|
}
|
|
|
|
const pseudo_typeS mach_o_pseudo_table[] =
|
|
{
|
|
/* Section directives. */
|
|
{ "comm", obj_mach_o_comm, 0 },
|
|
{ "lcomm", obj_mach_o_comm, 1 },
|
|
|
|
{ "text", obj_mach_o_base_section, 1},
|
|
{ "data", obj_mach_o_base_section, 2},
|
|
{ "bss", obj_mach_o_base_section, 3}, /* extension */
|
|
|
|
{ "const", obj_mach_o_known_section, 1},
|
|
{ "static_const", obj_mach_o_known_section, 2},
|
|
{ "cstring", obj_mach_o_known_section, 3},
|
|
{ "literal4", obj_mach_o_known_section, 4},
|
|
{ "literal8", obj_mach_o_known_section, 5},
|
|
{ "literal16", obj_mach_o_known_section, 6},
|
|
{ "constructor", obj_mach_o_known_section, 7},
|
|
{ "destructor", obj_mach_o_known_section, 8},
|
|
{ "eh_frame", obj_mach_o_known_section, 9},
|
|
|
|
{ "const_data", obj_mach_o_known_section, 10},
|
|
{ "static_data", obj_mach_o_known_section, 11},
|
|
{ "mod_init_func", obj_mach_o_known_section, 12},
|
|
{ "mod_term_func", obj_mach_o_known_section, 13},
|
|
{ "dyld", obj_mach_o_known_section, 14},
|
|
{ "cfstring", obj_mach_o_known_section, 15},
|
|
|
|
{ "objc_class", obj_mach_o_objc_section, 1},
|
|
{ "objc_meta_class", obj_mach_o_objc_section, 2},
|
|
{ "objc_cat_cls_meth", obj_mach_o_objc_section, 3},
|
|
{ "objc_cat_inst_meth", obj_mach_o_objc_section, 4},
|
|
{ "objc_protocol", obj_mach_o_objc_section, 5},
|
|
{ "objc_string_object", obj_mach_o_objc_section, 6},
|
|
{ "objc_cls_meth", obj_mach_o_objc_section, 7},
|
|
{ "objc_inst_meth", obj_mach_o_objc_section, 8},
|
|
{ "objc_cls_refs", obj_mach_o_objc_section, 9},
|
|
{ "objc_message_refs", obj_mach_o_objc_section, 10},
|
|
{ "objc_symbols", obj_mach_o_objc_section, 11},
|
|
{ "objc_category", obj_mach_o_objc_section, 12},
|
|
{ "objc_class_vars", obj_mach_o_objc_section, 13},
|
|
{ "objc_instance_vars", obj_mach_o_objc_section, 14},
|
|
{ "objc_module_info", obj_mach_o_objc_section, 15},
|
|
{ "objc_class_names", obj_mach_o_objc_section, 16}, /* Alias for .cstring */
|
|
{ "objc_meth_var_types", obj_mach_o_objc_section, 17}, /* Alias for .cstring */
|
|
{ "objc_meth_var_names", obj_mach_o_objc_section, 18}, /* Alias for .cstring */
|
|
{ "objc_selector_strs", obj_mach_o_objc_section, 19},
|
|
{ "objc_image_info", obj_mach_o_objc_section, 20}, /* extension. */
|
|
{ "objc_selector_fixup", obj_mach_o_objc_section, 21}, /* extension. */
|
|
{ "objc1_class_ext", obj_mach_o_objc_section, 22}, /* ObjC-1 extension. */
|
|
{ "objc1_property_list", obj_mach_o_objc_section, 23}, /* ObjC-1 extension. */
|
|
{ "objc1_protocol_ext", obj_mach_o_objc_section, 24}, /* ObjC-1 extension. */
|
|
|
|
{ "debug_frame", obj_mach_o_debug_section, 1}, /* extension. */
|
|
{ "debug_info", obj_mach_o_debug_section, 2}, /* extension. */
|
|
{ "debug_abbrev", obj_mach_o_debug_section, 3}, /* extension. */
|
|
{ "debug_aranges", obj_mach_o_debug_section, 4}, /* extension. */
|
|
{ "debug_macinfo", obj_mach_o_debug_section, 5}, /* extension. */
|
|
{ "debug_line", obj_mach_o_debug_section, 6}, /* extension. */
|
|
{ "debug_loc", obj_mach_o_debug_section, 7}, /* extension. */
|
|
{ "debug_pubnames", obj_mach_o_debug_section, 8}, /* extension. */
|
|
{ "debug_pubtypes", obj_mach_o_debug_section, 9}, /* extension. */
|
|
{ "debug_str", obj_mach_o_debug_section, 10}, /* extension. */
|
|
{ "debug_ranges", obj_mach_o_debug_section, 11}, /* extension. */
|
|
{ "debug_macro", obj_mach_o_debug_section, 12}, /* extension. */
|
|
|
|
{ "lazy_symbol_pointer", obj_mach_o_opt_tgt_section, 1},
|
|
{ "lazy_symbol_pointer2", obj_mach_o_opt_tgt_section, 2}, /* extension. */
|
|
{ "lazy_symbol_pointer3", obj_mach_o_opt_tgt_section, 3}, /* extension. */
|
|
{ "non_lazy_symbol_pointer", obj_mach_o_opt_tgt_section, 4},
|
|
{ "non_lazy_symbol_pointer_x86", obj_mach_o_opt_tgt_section, 5}, /* extension. */
|
|
{ "symbol_stub", obj_mach_o_opt_tgt_section, 6},
|
|
{ "symbol_stub1", obj_mach_o_opt_tgt_section, 7}, /* extension. */
|
|
{ "picsymbol_stub", obj_mach_o_opt_tgt_section, 8}, /* extension. */
|
|
{ "picsymbol_stub1", obj_mach_o_opt_tgt_section, 9}, /* extension. */
|
|
{ "picsymbol_stub2", obj_mach_o_opt_tgt_section, 4}, /* extension. */
|
|
{ "picsymbol_stub3", obj_mach_o_opt_tgt_section, 4}, /* extension. */
|
|
|
|
{ "section", obj_mach_o_section, 0},
|
|
{ "zerofill", obj_mach_o_zerofill, 0},
|
|
|
|
/* Symbol qualifiers. */
|
|
{"local", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_LOCAL},
|
|
{"globl", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_GLOBL},
|
|
{"reference", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_REFERENCE},
|
|
{"weak_reference", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_WEAK_REF},
|
|
{"lazy_reference", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_LAZY_REF},
|
|
{"weak_definition", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_WEAK_DEF},
|
|
{"private_extern", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_PRIV_EXT},
|
|
{"no_dead_strip", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_NO_DEAD_STRIP},
|
|
{"weak", obj_mach_o_sym_qual, OBJ_MACH_O_SYM_WEAK}, /* ext */
|
|
|
|
{ "indirect_symbol", obj_mach_o_indirect_symbol, 0},
|
|
|
|
/* File flags. */
|
|
{ "subsections_via_symbols", obj_mach_o_fileprop,
|
|
OBJ_MACH_O_FILE_PROP_SUBSECTS_VIA_SYMS},
|
|
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
/* 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);
|
|
|
|
/* 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;
|
|
s->symbol.udata.i = SYM_MACHO_FIELDS_NOT_VALIDATED;
|
|
}
|
|
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;
|
|
}
|
|
|
No newline at end of file
|
No newline at end of file
|
